एक ही लंबाई, अलग स्ट्रिंग

53

चुनौती

लंबाई एल के एक गैर-खाली स्ट्रिंग एस को देखते हुए पूरी तरह से मुद्रण योग्य एएससीआईआई चार्ट से मिलकर बनता है, लंबाई एल के एक और स्ट्रिंग का उत्पादन होता है जिसमें पूरी तरह से प्रिंट करने योग्य एएससीआईआई चार्ट होते हैं, लेकिन एस के बराबर नहीं है ।

इस चुनौती के प्रयोजनों के लिए, एक मुद्रण योग्य ASCII चार्ट U + 0020 और U + 007E, समावेशी के बीच एक है; कि से, है करने के लिए (स्थान) ~(टिल्ड)। नया अंक और टैब शामिल नहीं हैं।

उदाहरण के लिए, "abcde"कुछ मान्य आउटपुट दिए जा सकते हैं:

  • "11111"
  • "abcdf"
  • "edcba"

लेकिन ये अमान्य होंगे:

  • "abcde"
  • "bcde"
  • "abcde0"

परीक्षण के मामलों

"asdf"
"1111"
"       "
"~~~~~"
"abcba"
"1"
" "
"~"
" ~"
"~ "
"  0"
"!@#$%^&*()ABCDEFGhijklmnop1234567890"
" !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~"

नियम

  • आप मान सकते हैं कि इनपुट में पूरी तरह से मुद्रण योग्य ASCII वर्ण शामिल हैं।
  • आप यह नहीं मान सकते हैं कि इनपुट में सभी 95 मुद्रण योग्य वर्ण नहीं हैं।
  • आप मान सकते हैं कि इनपुट में कम से कम एक वर्ण है और 256 वर्ण से कम लंबा है।
  • आउटपुट में पूरी तरह से मुद्रण योग्य ASCII वर्ण भी शामिल होना चाहिए। उदाहरण के लिए, आप इनपुट के लिए बाइट \ x7F का उत्पादन नहीं कर सकते "~"।
  • आउटपुट संभावना 1 वाले इनपुट से अलग होना चाहिए; यह है कि, आप इनपुट से भिन्न होने तक यादृच्छिक स्ट्रिंग्स उत्पन्न कर सकते हैं, लेकिन आप एल यादृच्छिक अक्षरों का उत्पादन नहीं कर सकते हैं और आशा है कि यह अलग है।
  • आउटपुट में न्यूलाइन्स को अस्वीकृत कर दिया जाता है, लेकिन आप एक अनुगामी न्यूलाइन को आउटपुट कर सकते हैं जिसे स्ट्रिंग की ओर नहीं गिना जाता है।

स्कोरिंग

यह कोड-गोल्फ है , इसलिए प्रत्येक भाषा में बाइट्स में सबसे छोटा कोड जीत जाता है।

code-golf  string 
— ETHproductions
स्रोत
ध्यान दें कि "धनात्मक" खाली स्ट्रिंग को बाहर करता है। अतिरिक्त स्पष्टता के लिए, शायद "सकारात्मक" को "नॉनज़रो" से बदल दें?
— कैलक्यूलेटरफलिन
5
@ कैक्यूलरफलाइन लेकिन इसमें नकारात्मक-लंबाई के तार शामिल होंगे
— ETHproductions
1
... वे मौजूद नहीं हैं।
— कैलक्यूलेटरफैलिन
@CalculatorFeline अब बेहतर है?
— ETHproductions
3
एक और सरल लेकिन तुच्छ चुनौती नहीं।
— वीजुन झोउ

जवाबों:

34

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

lambda s:`s`[:len(s)]

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

इनपुट स्ट्रिंग के स्ट्रिंग प्रतिनिधित्व को लेता है और इसे इनपुट स्ट्रिंग की लंबाई तक काट देता है। एक विशिष्ट स्ट्रिंग के लिए, यह इसे 'उद्धरण में रखता है और अंत में काट देता है:

abc  ->   'abc'  ->  'ab
     rep        chop

ध्यान दें कि नई स्ट्रिंग के साथ शुरू होता है '। आइए दिखाते हैं कि आउटपुट हमेशा इनपुट से अलग होता है।

  • यदि इनपुट नहीं है ', तो आउटपुट के साथ शुरू होता है 'और इनपुट नहीं होता है।

  • यदि इनपुट में एक 'और लेकिन नहीं है ", तो पायथन "बाहरी उद्धरणों के लिए उपयोग करेगा , पहला वर्ण "जो इनपुट स्ट्रिंग में नहीं है।

  • इनपुट दोनों है, तो 'और ", तो बाहरी उद्धरण हैं 'और प्रत्येक 'के रूप में बच रहा है \'। जहां भी "इनपुट में पहला दिखाई देता है, उसे 'आउटपुट में प्रारंभिक द्वारा और किसी भी संभावित भागने से सही स्थानांतरित किया जाता है। इसका मतलब है कि यह "आउटपुट में संबंधित स्थिति के साथ मेल नहीं खा सकता है ।

अंत में, ध्यान दें कि इनपुट को उद्धृत करते हुए और संभवतः बचने वाले वर्ण हमेशा वर्णों की संख्या बढ़ाते हैं, इसलिए आउटपुट को रौंदने से इनपुट के समान लंबाई हो जाती है।

ध्यान दें कि यह महत्वपूर्ण था कि पायथन "दूसरे मामले में अनुकूल रूप से स्विच करता है । यदि ऐसा नहीं होता, तो यह तीन-वर्ण इनपुट पर विफल होता '\'। या, फ़िक्स शो स्ट्रिंग के किसी भी उपसर्ग का उपयोग करके '। इसलिए, यह विधि अधिकांश भाषाओं के लिए काम नहीं करेगी।

— XNOR
स्रोत
के len(s)बजाय 'अनुक्रमणिका तिल के लिए तर्क क्या है -2?
— जूलियन वुल्फ
1
@ जूलियनवुल्फ दोनों के इनपुट के लिए 'और ", 2 से अधिक वर्ण जोड़े गए होंगे क्योंकि उद्धरणों से बचने की आवश्यकता है।
— एंडर्स केसरग
समझ में आता है; उस पर विचार नहीं किया था। धन्यवाद!
— जूलियन वुल्फ
आप 16 वर्णों तक नीचे जाने के [2:]बजाय उपयोग कर सकते हैं [:len(s)]।
— xbarbie
@xbarbie हमेशा वही लंबाई नहीं देती है, अगर बचने वाले किरदारों की जरूरत होती है।
— xnor
15

जावास्क्रिप्ट (ईएस 6), 37 33 36 29 26 18 21 19 बाइट्स

s=>s.slice(1)+ +!+s

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

-4 बाइट्स ETHProductions के लिए धन्यवाद

-7 + -5 + -2 बाइट्स कैलक्यूलेटरफलाइन के लिए धन्यवाद

रिक हिचकॉक को -3 बाइट्स धन्यवाद

पहले वर्ण को अंत में ले जाता है और इसे 0 पर सेट करता है यदि यह संख्यात्मक और गैर-शून्य है, और 1 अन्यथा।

व्याख्या

s=>                    anonymous function with parameter s
                 +s    convert s to a number
                !      not (converts to boolean; relevant: 0->true,1->false)
               +       convert !+s back to number (true->1, false->0)
   s.slice(1)+         prefix the rest of the string
              ␣        needed to avoid the +s combining

सबूत

क्योंकि दूसरा चर पहले बन जाता है, तीसरा चर दूसरा बन जाता है, आदि सभी वर्ण समान होने चाहिए। अंतिम शेष चार केवल एक 0 या 1 हो सकता है, इसलिए दोहराया गया वर्ण 0 या 1 होना चाहिए। लेकिन 0 के किसी भी स्ट्रिंग के अंत में एक 1 का उत्पादन होता है, और इसके विपरीत; इसलिए, ऐसा इनपुट बनाना असंभव है जो इसके आउटपुट के बराबर हो। -ETHProductions

पूर्व संस्करणों और स्पष्टीकरण के लिए संपादन देखें।

f=
s=>s.slice(1)+ +!+s

console.log(f("000"))
console.log(f("111"))
console.log(f("001"))
console.log(f("110"))
console.log(f("~"))
console.log(f("111111111111111111111111111111111111111111111111111"))
console.log(f("Hello world!"))
console.log(f("23"))
console.log(f(" "))
console.log(f("1x"))
स्निपेट का विस्तार करें

— स्टीफन एस
स्रोत
13

जेली , 3 बाइट्स

~Ṿṁ

आउटपुट अंकों, अल्पविराम और हाइपेन-माइनस वर्णों की एक स्ट्रिंग है, जिसका पहला वर्ण इनपुट स्ट्रिंग के पहले चरित्र से अलग होगा।

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

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

~Ṿṁ  Main link. Argument: s (string)

~    Map bitwise NOT over the characters c in s.
     This attempts to cast c to int and then apply bitwise NOT, mapping
     '0', ..., '9' to 0, ..., 9 (before ~), then -1, ..., -10 (after ~).
     For non-digits, the attempt fails, mapping c to 0.
 Ṿ   Uneval, yielding a comma-separated string of integers in [-10, ..., 0].
     The first character will be '-' if s starts with a digit and '0' if not.
  ṁ  Mold; truncate the result to the length of s.
— डेनिस
स्रोत
6

हास्केल , 20 बाइट्स

map$head.show.(<'M')

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

की एक स्ट्रिंग में कनवर्ट करता है Fऔर T। क्या मायने रखता है कि चरित्र Fऔर Tएक-दूसरे में परिवर्तित हो जाते हैं। यह जाँच करके किया जाता है कि क्या चरित्र Mप्राप्त करने की तुलना में कम है Trueया False, फिर स्ट्रिंग प्रतिनिधित्व का पहला चरित्र ले रहा है।

हास्केल , 23 बाइट्स

q '~'=' '
q _='~'
map q

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

हर चरित्र को बदल देता है ~, ~एक स्थान को छोड़कर ।

— XNOR
स्रोत
में अंतरिक्ष का महत्व क्या है q '~'? इसे क्यों नहीं हटाया जा सकता?
— साइओस 6'17
@Cyoce Haskell 'पहचानकर्ताओं में एक चरित्र के रूप में अनुमति देता है , इसलिए के q'~'=' 'रूप में पार्स किया जाएगा q' ~ '=' '(एक शाब्दिक त्रुटि की रिपोर्ट क्योंकि अंतिम 'बेजोड़ है।)
— भजन जोहान्स
5

व्हॉट्सएप, 59 बाइट्स

दृश्यमान प्रतिनिधित्व

NSSNSSSTSSSSSNSNSSNSSNSTNTSTTTTSSTNTTSNSNSTSSSNSSSNTNSSNSNN

यह क्या करता है:

प्रत्येक वर्ण के लिए यह पढ़ता है कि यह एक स्थान प्रिंट करता है, जब यह एक स्थान को छोड़कर, तब यह एक @ प्रिंट करता है।

disassembly:

loop:
    push 32
     dup
      dup
       dup
        ichr
       get
       sub
      jn not_32
     dup
      add
not_32:
     pchr
    jmp loop
— CensoredUsername
स्रोत
व्हॉट्सएप में समाधान देखने के लिए हमेशा अच्छा होता है। खासकर जब आप सामान्य रूप से वास्तव में इसे देखने में असमर्थ होते हैं । +1
— जोशिया विंसलो
अच्छा जवाब! मैंने संरचना के साथ कुछ कम करने की कोशिश की, लेकिन कुछ भी नहीं मिला। लेकिन आप गोल्फ बदलकर 2 बाइट्स कर सकते हैं SSSTSSSSSN (push 32)करने के लिए SSSTSSTN (push 9)और TSSS (add)करने के लिए TSSN (multiply)। यह 9 के ऊपर एक यूनिकोड मान वाले प्रत्येक वर्ण के लिए एक टैब प्रिंट करेगा, और एक यूनिकोड मान वाले प्रत्येक वर्ण के लिए Q(9 * 9 = 81) 0..9। इसे ऑनलाइन कच्चे 57 बाइट्स में आज़माएँ
— केविन क्रूज़सेन
ऊपर मेरी टिप्पणी पर ध्यान न दें। चुनौती के लिए एक टैब को मुद्रण योग्य ASCII वर्ण के रूप में नहीं माना जाता है ..
— केविन क्रूज़सेन
5

MATL , 6 5 बाइट्स

Qo!V!

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

व्याख्या

Q     % Implicitly input a string. Add 1 to each code point.
o     % Parity: 0 if odd, 1 if even. Note that '0' has ASCII code 48, so after
      % having added 1 it now gives 1. Similarly. '1' has ASCII code 49, so it
      % now gives 0. All other chars give 0 or 1. 
!V!   % Convert each number to the corresponding char. Implicitly display
— लुइस मेंडो
स्रोत
CJam में वह 5 है: l'0f=(यदि वह ऐसा करता है जो मुझे लगता है कि वह करता है)
— मार्टिन एंडर
@MartinEnder हाँ, यह ठीक है कि :-) मैंने अभी एक स्पष्टीकरण जोड़ा है
— लुइस मेंडू
5

हास्केल , 19 बाइट्स

एक अनाम फ़ंक्शन, जो लेता है और वापस लौटता है String। के रूप में उपयोग करें (map$(!!1).show.succ) "1111"।

map$(!!1).show.succ

इसे ऑनलाइन आज़माएं! (@ Xnor के परीक्षण दोहन का उपयोग करना।)

  • इनपुट स्ट्रिंग में प्रत्येक वर्ण के लिए, वर्ण को बढ़ाता है, फिर उस वर्ण को शाब्दिक स्वरूप में परिवर्तित करता है, फिर शाब्दिक के दूसरे वर्ण को लेता है, जो कि शुरुआती 'उद्धरण के ठीक बाद का वर्ण है ।
  • लगभग सभी मुद्रण योग्य वर्णों के लिए, इसका परिणाम केवल बढ़े हुए चरित्र में होता है। अपवाद &और हैं ~, जो बदले में देते हैं \, क्योंकि उनके उत्तराधिकारी 'और \DELचरित्र शाब्दिक रूप से बच जाते हैं।
— अर्जन जोहान्सन
स्रोत
निश्चित headरूप से (!!1)एक अतिरिक्त बाइट के लिए इस्तेमाल किया जा सकता है
— जूलियन वुल्फ
नहीं, headहै (!!0), नहीं (!!1)। यह चरित्र पर विफल होता '।
— अर्जन जोहान्सन
ठीक है। मैं सिर्फ अजगर जवाब पढ़ रहा हूं और यह भूल गया कि आमतौर पर उद्धरण विशेष उपचार की आवश्यकता होती है।
— जूलियन वुल्फ
4

05AB1E , 5 बाइट्स

žQDÀ‡

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

व्याख्या

अगले चार मुद्रण योग्य एससीआई चार के साथ हर जगह को बदल देता है, टिल्ड से अंतरिक्ष में लपेटता है।

žQ     # push a string of printable acsii chars (space to tilde)
  D    # duplicate
   À   # rotate left
    ‡  # translate
— Emigna
स्रोत
4

वी , 7 बाइट्स

íÁ/a
g?

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें!

यह कैसे काम करता है?

मुद्रण योग्य ASCII से मिलकर सभी तारों पर विचार करें। प्रत्येक तार को या तो 1) वर्णमाला वर्ण होते हैं, या 2) कोई वर्णमाला वर्ण नहीं होता है।

तो जिस तरह से यह कार्यक्रम काम करता है, वह पहले एक गैर-वर्णनात्मक चरित्र को रूपांतरित करके 'a'और फिर इनपुट स्ट्रिंग पर ROT13 का प्रदर्शन करता है।

í       " Substitute:
 Á      "   A non-alphabetic character ([^a-zA-Z])
  /     "   with
   a    "   the letter 'a'
g?      " Perform ROT13 on...
        "   (Implicit) the current line.
— DJMcMayhem
स्रोत
यह टूट जाता है यदि आपके पास 9अकेले की तरह एक संख्या है , जहां इसे बढ़ाना स्ट्रिंग में एक और चरित्र जोड़ता है
— nmjcman101
@ nmjcman101 आह, यह एक अच्छी बात है। मैं वापस लौट चुके हैं
— DJMcMayhem
मुझे ROT13 की बात पसंद है, हालांकि, मुझे नहीं पता था कि V (im) ऐसा कर सकता है
— nmjcman101
4

सी (जीसीसी) , 22 बाइट्स

f(char*s){*s=65+*s%2;}

एक स्ट्रिंग पॉइंटर लेता है और जगह में पहले चार को नियंत्रित करता है।

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

— डेनिस
स्रोत
1
छोटा: *s=159-*s। हमेशा अंतिम बिट को बदलता है, इसलिए कभी भी समान चरित्र नहीं देता है। ध्यान दें कि159 = ' ' + '~'
— celtschk
मुझे लगता है कि आपका मतलब 158 = '' + '~' है। 159-32 = 127, जो एक दायरे से बाहर का चरित्र होगा। लेकिन अच्छा विचार है।
— कॉम्पुट्रोनियम
@celtschk इनवॉइस काम नहीं कर सकता है, क्योंकि प्रिंट करने योग्य क्रैकरैक्टर्स की एक विषम राशि (95) है, इसलिए उनमें से कम से कम एक खुद को मैप करेगा।
— डेनिस
@ कॉमपोरोनियम: उफ़, आप सही कह रहे हैं, मुझे ~गलत का चरित्र कोड मिला है।
— celtschk
4

सी (जीसीसी) , 20 बाइट्स

सॉ डेनिस का जवाब, एक 2 बाइट आवश्यक सुधार के बारे में सोचा।

f(char*s){*s^=*s/3;}

इसे ऑनलाइन आज़माएं! (डेनिस द्वारा पाद लेख।)

मूल की तरह, स्ट्रिंग के पहले वर्ण को जगह में संशोधित करता है, लेकिन इसे इसके मान के साथ विभाजित करता है 3 (छोटी संख्या जो काम करती है। 2 एकल वर्ण पर विफल रहता है 'U'जो 127 देता है, मुद्रण योग्य नहीं है।)

— अर्जन जोहान्सन
स्रोत
4

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

lambda s:`s<'T'`[0]+s[1:]

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

एंडर्स केसेर्ग ने पहले चरित्र को Trueया उससे निकालकर एक बाइट को बचाया False।

— XNOR
स्रोत
मैं '?'एक 2 अंकों के चारकोड में बदलने का सुझाव दूंगा, लेकिन पायथन उन भाषाओं में से एक नहीं है, जहां आप ऐसा कर सकते हैं :(
— कैलक्यूलेटरफलाइन
एक बाइट को बचाने वाले वेरिएंट (लेकिन पायथन 3 संगतता को छोड़ते हुए): lambda s:`+(s<'1')`+s[1:]याlambda s:`s<'T'`[0]+s[1:]
— एंडर्स केसोर्ग
3

ऑक्टेव , 19 18 बाइट्स

@(s)['',(s<66)+65]

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

स्पष्टीकरण:

@(s)                 % Anonymous function taking a string s as input
         s<66        % A boolean vector with `1` for all characters below ASCII-66.
        (s<66)+65    % Add 65 to this, so that all elements that are 32-65 are now 66.
                     % All other elements are 65 
    ['',         ]   % Implicitly convert the list of 65 and 66 to the letters A and B
— स्टीवी ग्रिफिन
स्रोत
3

CJam , 5 बाइट्स

l)iA%

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

अंतिम वर्ण को उसके कोड बिंदु में परिवर्तित करता है और उस मोडुलो को लेता है 10. यह अंतिम स्थिति में गैर-अंक वर्णों के लिए स्पष्ट रूप से भिन्न है। लेकिन अंक कोड बिंदु 48 पर शुरू होते हैं, इसलिए उन मॉड 10 को लेने से उन्हें चक्रीय रूप से छोड़ दिया जाएगा और इसलिए अंतिम वर्ण हमेशा बदल जाता है।

— मार्टिन एंडर
स्रोत
3

क्यूबिक्स , 10 बाइट्स

..@|i?2%)O

इसे ऑनलाइन आज़माएं! या यह देखो!

प्रत्येक चार्ट के लिए, 1यदि चार्ट में एक समान कोड बिंदु है, तो प्रिंट करता है, 2अन्यथा; 1एक विषम कोड बिंदु और 2एक सम है, इसलिए आउटपुट इनपुट के बराबर नहीं होगा।

व्याख्या

यह कोड निम्नलिखित क्यूब नेट से मेल खाता है:

    . .
    @ |
i ? 2 % ) O . .
. . . . . . . .
    . .
    . .

IP (इंस्ट्रक्शन पॉइंटर) सुदूर-पूर्व मुख के शीर्ष-बाएँ कोने पर शुरू होता है, पूर्व की ओर। यह निर्देशों की इस श्रृंखला का अनुसरण करता है:

i     Grab a char-code from STDIN and push it to the stack (-1 if there is no more input).
?     If the top item is negative, turn left and hit @ which ends the program.
      If it's positive (any printable ASCII char), turn right. The IP runs through a bunch
        of no-ops, then hits:
)     Increment the top item.
|     Mirror the IP's direction horizontally (turns it around).
)     Increment the top item again. The IP then wraps around again until it hits:
?     The top item is positive, so turn right.
2     Push a 2 to the stack.
%     Push the modulus of the top two items (0 for even char-code, 1 for odd).
)     Increment the result (now 1 for even char-code, 2 for odd).
O     Output as a number. The IP wraps back around to the i and the process starts again.
— ETHproductions
स्रोत
3

ऐलिस , 9 बाइट्स

#oi/
t i@

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

व्याख्या

यह विचार मार्टिन एंडर के सीजेएम प्रस्तुत से लिया गया था। पहले वर्ण को एक कोड बिंदु के रूप में लिया जाता है, मॉड 10 को कम किया जाता है, और आउटपुट के अंत में ले जाया जाता है। चूँकि वास्तव में एक वर्ण को बदल दिया गया था, वर्णों की अनुमति देने से एक ही तार वापस नहीं मिल सकता है।

#   skip next command
o   (skipped)
i   push first byte onto stack
    STACK: [97]
/   reflect to SE, switch to ordinal mode (implicit reflect to SW)
i   push remaining input onto stack as string (implicit reflect to NW)
    STACK: [97, "sdf"]
o   output top of stack (implicit reflect to SW)
    STACK: [97]
t   implicitly convert code point to decimal string, and extract last character
    (implicit reflect to NE)
    STACK: ["9", "7"]
o   output this last digit (implicit reflect to SE)
i   push empty string, since there is no more input to take (implicit reflect to NE)
/   reflect to S, switch to cardinal mode
@   terminate
— Nitrodon
स्रोत
tमॉड 10 के लिए उपयोग करना वास्तव में चालाक है, अच्छा है। :)
— मार्टिन एंडर
3

पुष्य , 1 बाइट

Q

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

यह दिए गए स्ट्रिंग को ASCII वर्ण कोड की सूची में परिवर्तित करता है, उन्हें (मॉड्यूलर अनुक्रमण) अपरकेस वर्णमाला में अनुक्रमित करता है, फिर परिणाम प्रिंट करता है। अनिवार्य रूप से, प्रत्येक वर्ण nको मैप किया जाता है chr(ord(n) % 26 + 65)। आप इस कार्यक्रम का उपयोग यह देखने के लिए कर सकते हैं कि मैपिंग कैसे काम करती है।

उत्पादन:

  • हमेशा इनपुट के समान लंबाई होगी, क्योंकि पात्रों को सीधे नए में मैप किया जाता है।
  • हमेशा केवल मुद्रण योग्य ASCII वर्ण शामिल होंगे (क्योंकि इसमें केवल बड़े अक्षर शामिल हैं)
  • हमेशा इनपुट के लिए अलग होगा, क्योंकि ऐसा कोई संभावित इनपुट चरित्र नहीं है , nजैसे कि chr(ord(n) % 26 + 65) == nयह सच है xकि ऐसा पूर्णांक होना चाहिए 26x = 65, जिसके लिए कोई समाधान नहीं है।

1 बाइट

q

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

इस उत्तर यह करने के लिए नक्शे सिवाय इसके कि बिल्कुल वैसा ही है, लोअरकेस बजाय वर्णमाला वर्ण अपरकेस वर्णमाला अक्षर। के रूप में वहाँ कोई संभव इनपुट चरित्र है यह अभी भी मान्य है nऐसा है कि chr(ord(n) % 26 + 97) == n।

— FlipTack
स्रोत
2

ब्रेन-फ्लैक , 53 बाइट्स

के लिए +1 शामिल है -c

([(((()()()()){}){}){}()]({}())){{}(<({}[()()])>)}{}

यह पहले वर्ण को कम कर देगा जब तक कि यह एक स्थान नहीं है, उस स्थिति में यह पहले चरित्र को बढ़ाएगा।

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

([(((()()()()){}){}){}()]      )                     # Push: input + 1 != 33 on top of...
                         ({}())                      #    input + 1
                                {{}(<          >)}{} # If (input + 1 != 33)
                                     ({}[()()])      #   Push: (input + 1) - 2
— रिले
स्रोत
2

जेली , 4 बाइट्स

^1Ṿ€

एक अंक स्ट्रिंग आउटपुट। कोई आउटपुट कैरेक्टर संबंधित इनपुट कैरेक्टर के बराबर नहीं होगा।

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

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

^1Ṿ€  Main link. Argument: s (string)

^1    XOR each character c in with 1.
      This attempts to cast c to int, mapping '0', ..., '9' to 0, ..., 9.
      For non-digits, the attempt fails, mapping c to 0.
      After XORing with 1, we get 1, 0, 3, 2, 5, 4, 7, 6, 9, 8 for '0', ..., '9', 
      and 1 for all non-digits.
  Ṿ€  Uneval each; mapping 0, ..., 9 to '0', ..., '9'. This yields a character
      array, which is Jelly's string type.
      Note that no character is mapped to itself.
— डेनिस
स्रोत
2

PHP, 30 27

<?=strtr($a=$argn,$a,$a^1);

हर चार चार्ट के बराबर पहले चार के साथ परिवर्तन करता है जिसमें कम से कम महत्वपूर्ण बिट फ़्लिप होता है।

— क्रिस्टोफ
स्रोत
"~" काम करता है ?.
— कैलक्यूलेटरफलिन
यह वास्तव में पहले चार्ट के कम से कम महत्वपूर्ण बिट को फ्लिप नहीं करता है; यह इसे एक पूर्णांक में परिवर्तित करता है और कम से कम महत्वपूर्ण बिट को प्रवाहित करता है । तो हां, @CalculatorFeline, ~काम करता है, आउटपुट करता है 1।
— ETHproductions
ओह। करता है !$aया ~$aकाम करता है ?
— कैलकुलेटरफैनल
@ETHproductions मैंने बिस्तर पर जाने से कुछ समय पहले अंतिम संपादन किया था और इसे अपडेट करने का समय नहीं था। बेशक आपका अधिकार पहले पूर्णांक में परिवर्तित हो जाता है और इसलिए हो सकता है कि वह पहले चार को भी न बदले लेकिन शायद दूसरा उदाहरण "12" "13" हो जाता है।
— क्रिस्टोफ
@CalculatorFeline दुखद रूप से दोनों विफल हो !$aजाता "12"है "12"क्योंकि falseएक रिक्त स्ट्रिंग में परिवर्तित हो जाता है ताकि कुछ भी प्रतिस्थापित न हो और ~$aसब कुछ unprintables में बदल जाए क्योंकि ~"12"पहले int में परिवर्तित नहीं होता है, लेकिन सचमुच स्ट्रिंग में सभी बिट्स को फ़्लिप करता है।
— क्रिस्टोफ़
2

ब्रेकीलॉग , 9 बाइट्स

{¬Ṣ|∧Ịh}ᵐ

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

व्याख्या

यह सभी वर्णों को एक स्थान द्वारा प्रतिस्थापित करता है, उन स्थानों को छोड़कर, जिनके साथ यह प्रतिस्थापित करता है "0"।

{      }ᵐ      Map on each char of the Input
 ¬Ṣ              The Input char is not " ", and the Output char is " "
   |             Or
    ∧Ịh          The Output char is "0"
— Fatalize
स्रोत
2

PHP <7.1, 31 बाइट्स

for(;~$c=$argn[$i++];)echo$c^1;

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

— जार्ग हुल्सरमन
स्रोत
कृपया 66 बाइट समाधान निकालें क्योंकि यह अमान्य है।
— कैलक्यूलेटरफलाइन
"1", "10", "101" आदि के लिए विफल रहता है। आप केवल स्ट्रिंग की लंबाई पर निर्भर नहीं कर सकते।
— कैलक्यूलेटरफैलिन
@CalculatorFeline "1" आउटपुट "0", "10" आउटपुट "01", "101" आउटपुट "010"। समस्या कहां है?
— क्रिस्टोफ
@ कलकटरफ़लाइन "1" => 0, "10" => 01, "101" => 010 यह कहाँ विफल हो जाता है?
— जार्ज ह्यूल्समैन
1
PHP 7.1 पैदावार A non-numeric value encountered। और आप ~इसके बजाय उपयोग कर सकते हैं a&।
— टाइटस
2

गोल्फस्क्रिप्ट, 3 बाइट्स

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

)5%

अंतिम वर्ण का ASCII मान modulo 5 लें, और अंतिम वर्ण को परिणाम के साथ बदलें। यह स्पष्ट रूप से गैर-अंक वर्णों के लिए काम करता है, लेकिन यदि अंतिम वर्ण एक अंक है, तो यह भी बदलता है ("0" mod 5 = 3, "1" mod 5 = 4, आदि)।

यह समान लंबाई रखते हुए भी 7 या 9 के साथ काम करेगा।

इसके अलावा, याय! मेरे पास एक गोल्फस्क्रिप्ट समाधान है जो यहां सबसे अच्छा समाधान है!

— जोशिया विंसलो
स्रोत
2

फंकी , 26 22 बाइट्स

s=>s::gsub("."a=>1&~a)

गणना ~aकरता है कि गैर-अंकों के लिए जो NaN लौटाएगा। फिर 1&इसे 0 या 1 तक सीमित करता है, अंक 0 के लिए, यह होगा 1, और इसके लिए 1होगा 0। तो यह तार हमेशा अनोखा होता है।

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

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