गिनती और वर्तनी

26

एक प्रोग्राम लिखें जो इसके इनपुट को एक स्ट्रिंग के रूप में लेता है जो निम्न गुणों के साथ एक स्ट्रिंग को आउटपुट करता है।

  • यदि स्ट्रिंग में एक वर्ण अपरकेस अक्षर (ASCII 41-5A) है, तो चरित्र को प्रत्येक अक्षर को स्ट्रिंग से बदल दिया जाता है और ऊपरी पत्र में मूल पत्र शामिल होता है। उदाहरण के लिए, यदि इनपुट स्ट्रिंग है I, तो आउटपुट होगा ABCDEFGHI।
  • इसी तरह, यदि कोई चरित्र लोअरकेस अक्षर (ASCII 61-7A) है, तो चरित्र को उसी तरह से बदल दिया जाता है। iद्वारा प्रतिस्थापित किया जाएगा abcdefghi।
  • यदि कोई वर्ण एक संख्या (ASCII 30-39) है, तो वर्ण को हर संख्या से बदल दिया जाता है जो संख्या से शुरू होती है 0और संख्या तक होती है।
  • यदि इनपुट में अलग-अलग वर्ण होते हैं, तो प्रतिस्थापन अनुक्रम एक साथ समाप्‍त होते हैं।
  • अन्य सभी वर्ण संशोधन के बिना मुद्रित होते हैं।

नमूना इनपुट (रिक्त लाइनों द्वारा अलग)

AbC123

pi=3.14159

Hello, World!

नमूना आउटपुट

AabABC010120123

abcdefghijklmnopabcdefghi=0123.0101234010123450123456789

ABCDEFGHabcdeabcdefghijklabcdefghijklabcdefghijklmno, ABCDEFGHIJKLMNOPQRSTUVWabcdefghijklmnoabcdefghijklmnopqrabcdefghijklabcd!

यह कोड गोल्फ, फेलस है। मानक नियम लागू होते हैं। बाइट्स में सबसे छोटा कोड जीतता है।

लीडरबोर्ड देखने के लिए, "शो कोड स्निपेट" पर क्लिक करें, नीचे स्क्रॉल करें और "sn रन कोड स्निपेट" पर क्लिक करें। ऑप्टिमाइज़र द्वारा बनाया गया स्निपेट।

कोड स्निपेट दिखाएं

code-golf  string 
— आर्कटुरस
स्रोत
10
अगली कड़ी के लिए आइडिया: इस परिवर्तन को पूर्ववत करें।
— ETHproductions
2
@ETHproductions शायद, हालांकि यहाँ रास्ता मुझे बेहतर लगता है क्योंकि यह कोई भी इनपुट ले सकता है; क्या होगा अगर रिवर्स में इनपुट थे Hello, World!?
— आर्कटिकस
क्या हमें इनपुट स्ट्रिंग में NUL (ascii 0x00) वर्णों का समर्थन करना है?
— ०४:३३
@ ऐसे मामले में, कोड को या तो एक त्रुटि प्रिंट करना चाहिए या, एक मजेदार मोड़ के लिए, उपरोक्त परिवर्तन करना चाहिए। Ie, f (f (इनपुट)) == इनपुट मुझे विश्वास नहीं है कि किसी भी अल्फ़ान्यूमेरिकल इनपुट के लिए इस संबंध की अवज्ञा करना संभव है।
— जेक
1
यह पूरी तरह से सच है - मैं यह धारणा बनाता हूं कि "यदि कोई स्ट्रिंग परिवर्तन के परिणाम को पार कर सकती है, तो उसे उल्टा कर दें। अन्यथा, परिवर्तन लागू करें।" - यह आपकी चुनौती है, आप अपने द्वारा चुने गए किसी भी नियम को निर्दिष्ट कर सकते हैं (ए) वे सुसंगत हैं और (बी) वे सत्यापन योग्य हैं और हल करने के लिए गणित की पूरी नई शाखा की आवश्यकता नहीं है। साइड नोट: इरेडिकेटिंग (बी) दिलचस्प होगा; आप कभी नहीं जानते हैं कि जब कोई व्यक्ति एनपी समस्या के लिए बहुपद समय एल्गोरिथ्म के साथ आने से कंप्यूटर विज्ञान में क्रांति लाएगा - जो वास्तव में यहाँ पर उचित है, तो जब तक यह 4 बाइट बचाता है।
— जेक

जवाबों:

11

पायथ, 19 बाइट्स

sXzsJ+rBG1jkUTs._MJ

इसे ऑनलाइन आज़माएँ: प्रदर्शन या टेस्ट सूट

व्याख्या

sXzsJ+rBG1jkUTs._MJ
      rBG1            the list ["abc...xyz", "ABC...XYZ"]
     +    jkUT        appends the string "0123456789"
    J                 save this list of 3 strings in J
   sJ                 join the strings in J
               ._MJ   create all prefixes of the strings in J
              s       and combine them to one list
 XzsJ         s._MJ   translate the input string, chars from sJ
                      get translated to the correct prefix,
                      chars that don't appear in sJ don't get translated
s                     join all resulting translation strings
— Jakube
स्रोत
8

पायथन 2.7, 100 98 96 बाइट्स

a=[]
for c in raw_input():d=ord(c);a+=range(max(d&96|1,48),d)*c.isalnum()+[d]
print bytearray(a)
— xsot
स्रोत
7

TeaScript , 24 बाइट्स 26 28

TeaScript गोल्फिंग के लिए जावास्क्रिप्ट है

xl(#(i=lN()1)h(ii(l)+1))

काफी कम

इसे ऑनलाइन आज़माएं

व्याख्या

x.l(#            // Loops through each character of the string

     (i=l.N()1)  // Determines whether a character is alphanumeric
                 // Will return A-Z, a-z or 0-9 depending on result
                 // Assigns to variable i

     .h(         // Get characters up to...
        i.i      // where the character is in "i"
     ) + 1       // Increased by one
)
— Downgoat
स्रोत
6

रूबी, 137 87 82 76 67 55 बाइट्स

Ungolfed, लेकिन आप पैटर्न देख सकते हैं।

$><<gets.gsub(/[a-z0-9]/i){[*" 0Aa"[$&.ord/32]..$&]*""}

संपादित करें: केवल एक regex के लिए नीचे गोल्फ।

संपादन 2: में बहुत सारे अतिरिक्त स्थान थे।

संपादित करें 3: 12 बाइट्स के लिए गोल्फ खेलने के लिए धन्यवाद!

— पीटर लेनकेफी
स्रोत
1
$><<gets.gsub(/[a-z0-9]/i){[*" 0Aa"[$&.ord/32]..$&]*""}
— मैनटवर्क
@manatwork लानत है कि चालाक है!
— पीटर लेनकेफी
4

पायथन 2, 145 140 133 103 102 बाइट्स

लिस्ट कॉम्प्रिहेंशन का उपयोग कर एक नहीं-तो-चिकना गुमनाम फ़ंक्शन। मुझे लगता है कि तर्क बहुत छोटा होना चाहिए, मैं कोशिश करूँगा और कुछ पता लगाऊंगा।

lambda k:''.join([c,`map(chr,range(48+17*(c>'@')+32*(c>'`'),ord(c)+1))`[2::5]][c.isalnum()]for c in k)

उपयोग करने के लिए एक नाम दिया जाना चाहिए, अर्थात f=...

— Kade
स्रोत
@ ओह ओह, हाहा! कोई चिंता नहीं है :)
— केडी
4

हास्केल, 95 91 86 60 बाइट्स

c#(a:o:r)|c<a||c>o=c#r|1<2=[a..c]
c#_=[c]
f=((#"AZaz09")=<<)

उपयोग उदाहरण: f "pi=3.14159"->"abcdefghijklmnopabcdefghi=0123.0101234010123450123456789"

यह कैसे काम करता है: इनपुट स्ट्रिंग में प्रत्येक चार सी को कॉपी करें जब तक कि सी किसी भी A/ Z, a/ zया 0/ के बीच में नहीं है 9और यदि ऐसा है तो सूची ले लें [<first char in pair> ... <c>]।

संपादित करें: @Zgarb ने कई बाइट्स बचाए। धन्यवाद!

— nimi
स्रोत
मुझे लगता है कि आप पूरी तरह से परिभाषित c#_=[c]और छोड़ सकते हैं t।
— जर्गब
@ ज़र्ब: हाँ वास्तव में और फिर sभी शानदार है। आपका बहुत बहुत धन्यवाद!
— नीमी
4

जावास्क्रिप्ट (ईएस 6), 143 138 बाइट्स

कौन से वर्णों का उपयोग करना है यह जांचने के लिए स्ट्रिंग तुलनाओं का उपयोग करता है।

s=>s.replace(/[A-Z0-9]/gi,c=>(a=btoa`Ó]·ã»óÖq×£Y§¢«²Û¯Ã³`,(c>'Z'?a:a.toUpperCase()).split``.filter(x=>x<=c&(x>'9'|c<'A')).join``))

ऑनलाइन डेमो। फ़ायरफ़ॉक्स और क्रोम में परीक्षण किया गया।

संपादित करें: के a='0123456789abcdefghijklmnopqrstuvwxyz'साथ प्रतिस्थापित करके 5 बाइट्स सहेजे गए

a=btoa`Ó]·ã»óÖq×£Y§¢«²Û¯Ã³`
— intrepidcoder
स्रोत
3

PHP, 146 बाइट्स

golfed 

function f($n,&$l){for(;$c=$n[$r],$b=0,$d=ord($c);$r++,$b?:$l.=$c)foreach([58=>48,91=>65,123=>97] as $m=>$i)while($d<$m&&$d>=$i)$b=$l.=chr($i++);}

संशोधन 1: ऑर्ड पर्वतमाला को सीधे फॉर्च्यूनर में डालें। वेतन वृद्धि की सीमा सीमा अधिकतम हो जाती है और बदल $d<=$mजाती है $d<$m। का उपयोग कर forपुनरावृति करने के बजाय वर्ण foreachऔर str_split। सभी {}को कोड में ले जाकर हटाया गयाfor

Ungolfed 

function f($input,&$output){
foreach (str_split($input) as $char){
  $ord = ord($char);
  $ords = [57=>48,90=>65,122=>97];
  $b = 0;
  foreach ($ords as $max=>$min){
     while ($ord<=$max&&$ord>=$min){
         $b = $max;
         $output .= chr($min);
         $min++;
     }
  }
  $b ?: $output.=$char;
}
};

$output = NULL;
$input = "pi=3.141592";
f($input,$output);
echo $output;

स्पष्टीकरण: सरणी में विभाजित स्ट्रिंग। यदि एएससीआई मूल्य एक सीमा (एज़, एज़, 0-9 के लिए) में गिरता है, तो रेंज के मिनट से चार के एससीआई मूल्य पर एक वेतन वृद्धि करें, प्रत्येक मूल्य को तब तक जोड़ते रहें जब तक आप चार्ट की एससीआई मूल्य तक नहीं पहुँच जाते।

मैं पारित कर दिया &$varउत्पादन में एक के बजाय संदर्भ द्वारा किया जाता हैreturn

— ईख
स्रोत
श्रेणियों की सरणी को धारण करने के लिए चर $ z की कोई आवश्यकता नहीं है, आप सरणी शाब्दिक को सीधे रख सकते हैं foreach।
— मैनटवर्क
उपयोग करने की कोशिश की range()? pastebin.com/k2tqFEgD
— मैनटवर्क
@ मैनटवर्क, मैंने घोषणा करने से बदल दिया $zऔर कुछ अन्य बदलाव किए। range()शायद बेहतर होगा। मैं बाद में रेंज के साथ कुछ कोशिश कर सकता हूं।
— रीड
उपयोग करते हुए range, मुझे मिला function f($n,&$l){$o=['a'=>'z','A'=>'Z','0'=>'9'];foreach(str_split($n) as $c){$b=0;foreach($o as $m=>$x)!($c>$m&&$c<=$x)?:$b=$l.=implode(range($m,$c));$b?:$l.=$c;}}, जो कि 166 था।
— रीड
1
हां, आपके द्वारा फिर से उपयोग किए जाने वाले 146 वर्णों को फिर से लिखना range()कम फायदेमंद है। लेकिन वह 166 बहुत लंबा है यहां तक ​​कि: सरणी शाब्दिक के लिए $ o वापस आ गया है, asकीवर्ड के आसपास अतिरिक्त स्थान हैं , के join()लिए अन्य नाम है implode()। (पहले से लिंक किए गए पास्टबिन कोड की जांच की। रेंज एंडपॉइंट्स को स्टोर करने की एक और संभावना दिखाता है।) अपने 146 अक्षरों के समाधान के बारे में, आप असाइनमेंट को ord()कॉल के अंदर $ c में स्थानांतरित कर सकते हैं $d=ord($c=$n[$r]):।
— 9
2

पायथन, 143 बाइट्स

lambda s:''.join(map(chr,sum(map(lambda a,r=range:r(65,a+1)if 64<a<97else r(97,a+1)if 96<a<123else r(48,a+1)if 47<a<58else[a],map(ord,s)),[])))

इसे ऑनलाइन आज़माएं

— मै जाऊं
स्रोत
2
आप 4 बाइट्स को बचाने के लिए z = रेंज का उपयोग कर सकते हैं।
— आर्कटिकस
1
बहुत यकीन है कि आप एक टैब के साथ डबल स्पेस इंडेंट को बदल सकते हैं, जो आपको कुछ बाइट्स बचाएगी
— फंड मोनिका का मुकदमा
2

पर्ल 6, 101 बाइट्स

यहाँ इस पर पहला पास है:

sub MAIN($_ is copy){
  s:g/<[0..9]>/{(0..$/).join}/;
  s:g/<[a..z]>/{('a'..~$/).join}/;
  s:g/<[A..Z]>/{('A'..~$/).join}/;
  .say
}
sub MAIN($_ is copy){s:g/<[0..9]>/{(0..$/).join}/;s:g/<[a..z]>/{('a'..~$/).join}/;s:g/<[A..Z]>/{('A'..~$/).join}/;.say}

119

हटाने के लिए उपयोग कर .transरहा $_है is copy।

sub MAIN($_){
  .trans(
    /\d/       => {(0..$/).join},
    /<[a..z]>/ => {('a'..~$/).join},
    /<[A..Z]>/ => {('A'..~$/).join}
  ).say
}
sub MAIN($_){.trans(/\d/=>{(0..$/).join},/<[a..z]>/=>{('a'..~$/).join},/<[A..Z]>/=>{('A'..~$/).join}).say}

106

पर कार्रवाई @*ARGSएक को परिभाषित करने की बजाय सीधे MAINउप।
(अन्यथा पिछले उदाहरण के समान)

@*ARGS[0].trans(/\d/=>{(0..$/).join},/<[a..z]>/=>{('a'..~$/).join},/<[A..Z]>/=>{('A'..~$/).join}).say

101

— ब्रैड गिल्बर्ट b2gills
स्रोत
2

स्काला, 111 91 बाइट्स

val f=(_:String).flatMap(x=>if(x.isDigit)('0'to x)else if(x.isUpper)('A'to x)else('a'to x))
— मार्टिन सीलर
स्रोत
इसके लिए विफल रहता है pi=3.14159। क्या समाधान val f=(_:String).flatMap(x:String=>if(x.isDigit)('0'to x)else if(x.isUpper)('A'to x)else if(x.isLower)('a'to x)else x.toString)128 वर्णों का हो सकता है?
— लियोनार्डो
2

जूलिया, 102 98 90 84 बाइट्स

s->join([(i=Int(c);join(map(Char,(64<c<91?65:96<c<123?97:47<c<58?48:i):i)))for c=s])

यह एक अनाम फ़ंक्शन बनाता है जो एक स्ट्रिंग को स्वीकार करता है और एक स्ट्रिंग लौटाता है।

Ungolfed:

function f(s::AbstractString)
    # For each character in the input, get the codepoint and construct
    # a range of codepoints from the appropriate starting character to
    # the current character, convert these to characters, and join them
    # into a string
    x = [(i = Int(c);
          join(map(Char, (isupper(c) ? 65 :
                          islower(c) ? 97 :
                          isdigit(c) ? 48 : i):i))
         ) for c in s]

    # Join the array of strings into a single string
    return join(x)
end
— एलेक्स ए।
स्रोत
2

पॉवरशेल, 155 बाइट्स

($args-split''|%{$b=$_;switch([int][char]$_){{$_-in(65..90)}{[char[]](65..$_)}{$_-in(97..122)}{[char[]](97..$_)}{$_-in(48..57)}{0..$b}default{$b}}})-join''

तकनीकी रूप से एक-लाइनर, और पावरशेल उन सभी के बारे में है ;-)

इनपुट को विभाजित करता ForEach-Objectहै, जो एक लूप में आता है, कास्ट वर्ण के पूर्णांक मान पर स्विच करता है, फिर char[]उपयुक्त सीमाओं के नए उत्पन्न करता है। ध्यान दें कि हमें अस्थायी चर सेट करने के लिए बाइट्स खर्च करने होंगे $bक्योंकि $_स्विच स्टेटमेंट में इनपुट डालने का मतलब है कि हम सिर्फ इस्तेमाल नहीं कर सकते हैं $_या हमें फंकी आउटपुट मिलेगा।

EDIT - मुझे यह इंगित करना चाहिए कि यह त्रुटि को दूर करेगा क्योंकि पहली वस्तु को खिलाया %{...}जाना एक अशक्त वस्तु है। चूंकि STDERR को डिफ़ॉल्ट रूप से अनदेखा किया जाता है , यह कोई समस्या नहीं होनी चाहिए। यदि यह एक समस्या है, तो सबसे पहले बदलकर ($args-split''-ne''|...अशक्त वस्तु को समाप्त कर दें।

— AdmBorkBork
स्रोत
2

जावास्क्रिप्ट (ईएस 6), 340 258 273 271 बाइट्स

a=s=>{s=s.split``;Q=x=>x.toUpperCase();A="ABCDEFGHIJKLMNOPQRSTUVWXYZ";D="0123456789";f="";for(i=0;i<s.length;i++){j=s[i];c="to"+(Q(j)==j?"Upper":"Lower")+"Case";j=Q(j);if(q=A.search(j)+1)f+=g=A.slice(0,q)[c]();else if(q=D.search(j)+1)f+=g=D.slice(0,q);else f+=j}return f}
— कोनोर ओ ब्रायन
स्रोत
आप लूप के बदले ("")और विभाजन के लिए टेम्पलेट स्ट्रिंग `` का उपयोग कर सकते हैं f=i=""। आप कुछ और बाइट्स बचाने में सक्षम हो सकते हैं।
— intrepidcoder
@intrepidcoder पहला काम करेगा। मैं दूसरे पर जाँच कर रहा हूँ।
— कॉनर ओ'ब्रायन
2

सी (269 बाइट्स)

(स्पष्टता के लिए लाइन ब्रेक जोड़ा गया)

#include<stdio.h>
#define F(x,y,z)if(c>=T[0][x]&&c<=T[1][y]){z}
#define L(x,y)for(i=0;i<x;++i){y}
main(){int c,i,n;char o,*T[]={"0Aa","9Zz"};while((c=getchar())!=EOF)
{F(0,2,L(3,F(i,i,o=T[0][i],n=++c-o;L(n,putchar(o++));break;))else putchar(c);)}}

Ungolfed

#include<stdio.h>
int main(void)
{
  int c, i, n;
  char output;
  char *char_table[] = {"0Aa", "9Zz"};

  while ((c = getchar()) != EOF) {
    if (c < '0' || c > 'z') {
      putchar(c);
    } else {
      for (i = 0; i < 3; ++i) {
        if (c >= char_table[0][i] && c <= char_table[1][i]) {
          output = char_table[0][1];
          n = c - output;
          break;
        }
      }
      for (i = 0; i <= n; ++i) {
        putchar(output);
        ++output;
      }
    }
  }
  return(0);
}
— musarithmia
स्रोत
2

पर्ल 5 , 66 61 (51 बाइट्स + 1) 52

सशर्त ऑपरेटरों के साथ रेगीक्स को मिलाकर इस मामले में अच्छा काम किया। किसी सरणी में श्रेणियों को संयोजित करने के लिए मानचित्र का उपयोग कर
शामिल होने के साथ ।

say map{(/\d/?0:/[A-Z]/?A:/[a-z]/?a:$_)..$_}split//

परीक्षा

$ echo "A0C1.a3c_2!" |perl -M5.010 -n count_and_spell_up.pl
A0ABC01.a0123abc_012!

व्याख्या

say                # print output
  map{             # loop through the array that's at the end of the other mustache. 
                   # outputs an array. 
     (
        /\d/?0            # if $_ is a digit then 0
          :/[A-Z]/?A      # else, if it's an uppercase character then A
             :/[a-z]/?a   # else, if it's a lowercase character then a
               :$_        # else the current character
     )..$_         # generate a sequenced string of characters 
                   # that ends with the magic variable $_ 
                   # ($_ is currently a character from the array)
  }split//     # split the magic variable $_ (currently the input string)
               # to an array of characters
— LukStorms
स्रोत
1

जावास्क्रिप्ट (ईएस 7), 125 बाइट्स

स्ट्रिंग्स को एन्कोडिंग पर ध्यान देने वाले पहले से ही दो जेएस उत्तर थे, इसलिए मैंने उपयोग करके अधिक एल्गोरिदमिक दृष्टिकोण के लिए जाने का फैसला किया String.fromCharCode():

x=>x.replace(/[^\W_]/g,z=>(c=z.charCodeAt(),f=c<65?48:c<97?65:97,String.fromCharCode(...[for(i of Array(c-f).keys())i+f])+z))

इस पद्धति का उपयोग करने का एक बोनस यह है कि यह किसी भी प्रकार के चार कोड लेता है, इसलिए joinसूची को आवश्यक नहीं है। यह किसी भी अन्य तकनीक से कम निकला, इसलिए मैं परिणाम से खुश हूं।

— ETHproductions
स्रोत
1

MUMPS, 131 बाइट्स

u(l,h) i l'>a,a'>h f j=l:1:a s o=o_$C(j),f=0
    q
t(s) f i=1:1:$L(s) s a=$A(s,i),f=1 d u(48,57),u(65,90),u(97,122) s:f o=o_$C(a)
    q o

मैंने MUMPS के डायनामिक स्कोपिंग की बदौलत यहां कुछ अच्छे बाइट्स सहेजने का प्रबंधन किया । यहाँ एक लगभग-समान ungolfed संस्करण है, जो मुझे यकीन है कि सिंटैक्स हाइलाइट करना पसंद करेगा, अगर केवल MUMPS Prettify मॉड्यूल के लिए समर्थन उपलब्ध था ।

convert(str) ;
    new asciiCode,flag,i,output
    for i=1:1:$LENGTH(str) do
    . set asciiCode=$ASCII(str,i)
    . set flag=1
    . do helper(48,57)
    . do helper(65,90)
    . do helper(97,122)
    . if 'flag do
    . . set output=output_$CHAR(asciiCode)
    quit
helper(low,high) ;
    if low'>asciiCode,asciiCode'>high do
    . for code=low:1:asciiCode do
    . . set output=output_$CHAR(code)
    . . set flag=0
    quit
— senshin
स्रोत
1

पर्ल 6, 78 77 बाइट्स

@*ARGS[0].trans(/\d/=>{[~] 0..$/},/<:L>/=>{[~] samecase("a",~$/)..~$/}).say
— हॉटकी
स्रोत
मुझे पता था कि इसे 'a'..'z'और 'A'..'Z'मामलों को मिलाकर छोटा किया जा सकता है , मुझे और कोशिश करनी चाहिए।
— ब्रैड गिल्बर्ट
मैं <!-- language-all: lang-perl6 -->बस इसके बाद जोड़ने की सलाह देता हूं ## Perl 6ताकि यह सही ढंग से उजागर हो। (इस उत्तर पर परिवर्तन पहले से ही लंबित है)
— ब्रैड गिल्बर्ट b2gills 18
आप बदल सकते हैं {[~](0..$/)}करने के लिए {[~] 0..$/}जो एक बाइट बचत होगी।
— ब्रैड गिलबर्ट ने
0

गणितज्ञ, 102 बाइट्स

FromCharacterCode@Flatten[Which[64<#<91,65,96<#<123,97,47<#<58,48,1>0,#]~Range~#&/@ToCharacterCode@#]&

ओह अच्छा...

— LegionMammal978
स्रोत
0

CJam, 32 31 बाइट्स

q_'[,_el^A,s+26/ff{_@#)<}:s\.e|

CJam दुभाषिया में इसे ऑनलाइन आज़माएं ।

यह काम किस प्रकार करता है

q_    e# Push two copies of the user input.
'[,   e# Push the string of all ASCII characters up to Z.
_el   e# Push a copy and convert it to lowercase.
^     e# Perform symmetric difference this keeps only letters.
A,s+  e# Append the string "0123456789".
26/   e# Split the result into chunks of length 26.
ff{   e# For each character from input: For each chunk:
  _@  e#   Copy the chunk and rotate the character on top of it.
  #   e#   Push the index of the character in the string (-1 for not found).
  )<  e#   Increment and keep that many characters from the left of the chunk.
      e#   This pushes "" for index -1.
}
:s    e# Flatten the resulting arrays of strings.
      e# The results will be empty strings iff the character wan't alphanumeric.
\     e# Swap the result with the input string.
.e|   e# Perform vectorized logical OR.
— डेनिस
स्रोत
0

पायथन 2, 135 117 बाइट्स

s=''
for c in raw_input():
 b=ord(c);e=b+1
 if c.isalnum():
  b=max(b&96,47)+1
 for i in range(b,e):s+=chr(i)
print s
— TFeld
स्रोत
0

PHP - 291 बाइट्स

स्ट्रिंग को पास करें GET["s"]।

<?php $s=$_GET["s"];$m="array_map";echo implode($m(function($v){$i="in_array";$l="implode";$r="range";global$m;$a=ord($v);if($i($a,$r(48,57)))$v=$l($m("chr",$r(48,$a)));if($i($a,$r(65,90)))$v=$l($m("chr",$r(65,$a)));if($i($a,$r(97,122)))$v=$l($m("chr",$r(97,$a)));return$v;},str_split($s)));
— अपरिभाषित
स्रोत
0

सी #, 251 201 184 157 154 बाइट्स

using System;class c{static void Main(string[] i){foreach(var c in i[0])for(var x=c>64&c<91?'A':c>96&c<123?'a':c>47&c<58?'0':c;x<=c;)Console.Write(x++);}}

संपादित करें: हड़ताल! PowerShell से छोटा;)

— स्टीफ़न शिंकेल
स्रोत
1
क्या आप कर सकते हैं string[]i?
— आउटगॉल्फ
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.