चलो कुछ "deciph4r4ng" करते हैं

58

इस चुनौती में, आपका काम एक स्ट्रिंग को समझना है। सौभाग्य से, एल्गोरिथ्म बहुत सरल है: बाएं से दाएं पढ़ना, प्रत्येक सामना किए गए अंक एन (0 से 9) को उस चरित्र से प्रतिस्थापित किया जाना चाहिए जो एन + 1 स्थिति से पहले है।

उदाहरण

इनपुट स्ट्रिंग "Prog2am0in6"को इस तरह डिकोड किया जाएगा:

उदाहरण

इसलिए, अपेक्षित आउटपुट है "Programming"।

स्पष्टीकरण और नियम

  • इनपुट स्ट्रिंग में विशेष रूप से 32 - 126 की सीमा में ASCII वर्ण होंगे। आप मान सकते हैं कि यह कभी खाली नहीं होगा।
  • मूल डिक्रिप्ड स्ट्रिंग की गारंटी है कि इसमें कोई अंक नहीं है।
  • एक बार एक चरित्र को डिकोड किया गया है, यह बदले में बाद के अंक द्वारा संदर्भित किया जा सकता है। उदाहरण के लिए, के "alp2c1"रूप में डिकोड किया जाना चाहिए "alpaca"।
  • संदर्भ स्ट्रिंग के आसपास कभी नहीं लिपटेंगे: केवल पिछले वर्णों को संदर्भित किया जा सकता है।
  • आप या तो एक पूर्ण कार्यक्रम या एक फ़ंक्शन लिख सकते हैं, जो या तो प्रिंट करता है या परिणाम को आउटपुट करता है।
  • यह कोड गोल्फ है, इसलिए बाइट्स जीत में सबसे छोटा जवाब है।
  • मानक खामियों को मना किया जाता है।

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

Input : abcd
Output: abcd

Input : a000
Output: aaaa

Input : ban111
Output: banana

Input : Hel0o W2r5d!
Output: Hello World!

Input : this 222a19e52
Output: this is a test

Input : golfin5 3s24o0d4f3r3y3u
Output: golfing is good for you

Input : Prog2am0in6 Puz0les7&1Cod74G4lf
Output: Programming Puzzles & Code Golf

Input : Replicants 4re3lik448ny3oth8r5mac6in8.8T64y'r371it9376a1b5n1fit7or2a1h2z17d.
Output: Replicants are like any other machine. They're either a benefit or a hazard.
code-golf  string  cipher 
— Arnauld
स्रोत
क्या हम एकल वर्ण स्ट्रिंग्स की एक सरणी के रूप में इनपुट प्राप्त कर सकते हैं? क्या हम मान सकते हैं कि संख्या कभी भी 9 से अधिक नहीं होगी?
— f --n
@ f @n :tɪk इनपुट प्रारूप के बारे में: जब तक यह आपकी भाषा के लिए एकमात्र स्वीकार्य प्रारूप नहीं है, मैं कहूंगा। हम संख्याओं के बजाय एकल अंकों के साथ काम कर रहे हैं । तो हाँ: इसकी गारंटी है कि <= 9 लेकिन आप एक पंक्ति में कई अंकों का सामना कर सकते हैं।
— अरनुलद
चाहेंगे 1bbab(की उम्मीद उत्पादन के साथ एक मान्य इनपुट हो abbab)? दूसरे शब्दों में, क्या संदर्भ स्ट्रिंग के चारों ओर लपेट सकते हैं?
— ल्यूक
@ ल्यूक अच्छी बात है। नहीं, 1bbabमान्य नहीं है। मैंने उस बारे में एक स्पष्टीकरण जोड़ा है।
— अरनुलद

जवाबों:

11

जेली , ९ by बाइट्स

~ịṭṭµ@/

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

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

~ịṭṭµ@/  Main link. Argument: s

    µ    Combine the four links to the left into a chain (arity unknown).
     @   Swap the chains arguments. This makes it dyadic.
      /  Reduce s by the chain with swapped arguments. It will be called with
         right argument r (the result of the previous call, initially the first 
         character) and left argument c (the next character of s).
~            Bitwise NOT of c. This maps a digit 'd' to ~d = -(d+1), but all 
             non-digit characters 'D' to 0.
  ṭ          Tack; append c to r.
 ị           Index; select the character of the result to the right at the
             index from the result to the left. Indexing is 1-based and modular,
             so 0 is the last character, -1 the second to last, etc.
   ṭ         Tack; append the resulting character to r.
— डेनिस
स्रोत
13

जावा 7, 81 80 बाइट्स

void a(char[]a){for(int i=0;++i<a.length;)if(a[i]>47&a[i]<58)a[i]=a[i-a[i]+47];}

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

एंडर्स टोर्नलैड के लिए 1 बाइट धन्यवाद । पहला चरित्र एक अंक नहीं हो सकता है, इसलिए इसे जाँचने की आवश्यकता नहीं है, जिसका अर्थ है कि हम अपनी समाप्ति स्थिति की जांच करने से पहले पुनर्मूल्यांकन कर सकते हैं।

— प्रहार
स्रोत
2
चूँकि पहले चार अंकों में कभी अंक नहीं हो सकते, इसलिए आपको इसकी जाँच करने की आवश्यकता नहीं है। इसलिए, एक लूप की for(int i=0;++i<a.length;){बचत के बजाय , आपका लूप हो सकता है ।
— एंडर्स तोर्ब्लाड
12

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

o#c|c>'/',c<':'=o!!read[c]:o|1<2=c:o
reverse.foldl(#)[]

प्रयोग उदाहरण: reverse.foldl(#)[] $ "Prog2am0in6 Puz0les7&1Cod74G4lf"-> "Programming Puzzles & Code Golf"। इसे ऑनलाइन आज़माएं!

संबंधित वर्णों द्वारा प्रतिस्थापित संख्याओं के साथ स्ट्रिंग को स्वयं की रिवर्स प्रति में कम करें। "रिवर्स", क्योंकि इस तरह से संख्याओं को अनुक्रमित करते समय हम स्ट्रिंग तक आसानी से पहुंच पाते हैं। इसे फिर से उलट दें।

— nimi
स्रोत
1
वाह, मैंने यह सटीक समाधान लिखा है, लेकिन मैं इसे पोस्ट करने में धीमा था :) खैर, कम से कम अब मुझे पता है कि यह एक अच्छा था, +1
— लियो
11

सी, 46 बाइट्स

f(char*s){for(;*s++;)*s=s[(*s-52)/6?0:47-*s];}

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

सी,  52   49  48 बाइट्स

एक बाइट को बचाने के लिए @ l4m2 के लिए धन्यवाद!

f(char*s){for(;*s++;)*s>47&*s<58?*s=s[47-*s]:0;}

सीधे इनपुट स्ट्रिंग संपादित करता है।

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

वैकल्पिक 50-बाइट संस्करण:

f(char*s){for(;*s++;)*s=abs(*s-57)>9?*s:s[47-*s];}

पुनरावर्ती संस्करण, 48 बाइट्स:

f(char*s){*s>47&*s<58?*s=s[47-*s]:0;*s++&&f(s);}
— Steadybox
स्रोत
9

05AB1E , 11 बाइट्स

vydiÂyèëy}J

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

व्याख्या

v            # for each character y in input
 ydi         # if y is a digit
    Â        #    push a reversed copy of the string we've built up so far
     yè      #    push the character at index y in the reversed string
       ë     # else
        y    #    push y
         }   # end if
          J  # join stack to a single string
             # output top of the stack at the end of the loop
— Emigna
स्रोत
मुझे वास्तव में यह देखने की ज़रूरत है कि क्या आपने शुरू करने से पहले अधिक बार उत्तर दिया है।
— मैजिक ऑक्टोपस Urn
@carusocomputing: आप अभी भी मेरे द्वारा इस्तेमाल किए गए कुछ बेहतर चाल के बारे में सोच सकते हैं;)
— एमिग्ना
7

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

f=x=>/\d/.test(x)?f(x.replace(/\d/,(m,o)=>x[o+~m])):x

सहेजे गए 7 बाइट्स fednɛt .k के लिए धन्यवाद।

f=x=>/\d/.test(x)?f(x.replace(/\d/,(m,o)=>x[o+~m])):x

console.log(f("Prog2am0in6"));
console.log(f("abcd"));
console.log(f("a000"));
console.log(f("ban111"));
console.log(f("Hel0o W2r5d!"));
console.log(f("this 222a19e52"));
console.log(f("golfin5 3s24o0d4f3r3y3u"));
console.log(f("Prog2am0in6 Puz0les7&1Cod74G4lf"));
console.log(f("Replicants 4re3lik448ny3oth8r5mac6in8.8T64y'r371it9376a1b5n1fit7or2a1h2z17d."));
स्निपेट का विस्तार करें

— टॉम
स्रोत
.charAt (...) को 7 बाइट्स की बचत के लिए [...] से बदला जा सकता है
— ftnɛtɪk
x.charAt (...) x के बराबर है [...]
— fɛnɪt Aprk
@ f @n Itɪk हां, मुझे लगा कि मैंने पहले भी कोशिश की थी लेकिन यह एक त्रुटि थी। धन्यवाद!
— टॉम
1
o-m-1से बदला जा सकता है o+~m।
— नील
2
च को पुनरावर्ती कहा जाता है, क्योंकि प्रोग्राम की वर्ण गणना में f=भाग शामिल होना चाहिए , इसलिए यह 54 बाइट्स है, 52 नहीं।
— user5090812
5

रेटिना , 37 बाइट्स

बाइट गिनती आईएसओ 8859-1 एन्कोडिंग मानती है।

\d
$*«»
r1+`(?<=(.)(?<-2>.)*)(«)*»
$1

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

व्याख्या

\d
$*«»

प्रत्येक अंक d को d « s से बदलें , उसके बाद एक »। हमें उत्तरार्द्ध की आवश्यकता है) मान्यता प्राप्त पदों के लिए सक्षम होने में जहां घ = 0 और बी) आसन्न अंकों के बीच एक विभाजक के रूप में।

r1+`(?<=(.)(?<-2>.)*)(«)*»
$1

बार-बार +बाएं से पहली पंक्ति r( 1) से दूसरी लाइन पर प्रतिस्थापन के साथ (फिर) बाएं-सबसे मिलान ( ) की जगह पर रेगेक्स ( ) से मेल खाता है ।

रेगेक्स खुद हमारे अब के एक अंक से मेल खाता है और «समूह 2 में s की संख्या को गिनता है । लुकअप इसके बाद निर्दिष्ट वर्ण को कैप्चर करने से पहले d अक्षर से मेल खाता है (?<-2>.)*। s का स्ट्रिंग 1. s का स्ट्रिंग «और »फिर कैप्चर किए गए वर्ण से बदल दिया गया है ।

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

MATL , 21 19 17 16 बाइट्स

"@t4Y2m?UQ$y]]&h

MATL ऑनलाइन पर यह कोशिश करो !

व्याख्या

        % Implicitly grab input as a string
"       % For each character in the input
  @     % Push that character to the stack
  t     % Make a copy of it
  4Y2   % Push the pre-defined array '0123456789' to the stack
  m     % Check if the current character is part of this array (a digit)
  ?     % If it is
    UQ  % Convert it to a number and add 1 (N)
    $y  % Make a copy of the element N-deep in the stack. MATL uses one-based indexing
        % So 1$y is the element at the top of the stack, 2$y is the next one down, etc.
  ]     % End of if statement
        % Non-digit characters remain on the stack as-is
]       % End of for loop
&h      % Horizontally concatenate the entire stack to form a string
        % Implicitly display the result
— Suever
स्रोत
$yनए संस्करण में अच्छा उपयोग !
— लुइस मेंडू
@LuisMendo धन्यवाद! Yea स्टैक-आधारित भाषाएँ इस चुनौती के लिए एक अच्छी फिट हैं
— स्वेअर
@LuisMendo दुर्भाग्य से इसे और भी छोटा किया जा सकता था यदि Uकेवल अंकों के लिए काम किया जाता। दुर्भाग्य से 'e'Uपैदावार exp(1)अन्यथा मैं 4Y2सामान से छुटकारा पा सकता था
— स्वेर
उन ऑक्टेव चीजों में से एक और ...
— लुइस मेंडू
4

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

f=
s=>s.replace(/\d/g,(c,i)=>a[i]=a[i+=~c]||s[i],a=[])
<input oninput=o.textContent=f(this.value)><pre id=o>
स्निपेट का विस्तार करें

a अन्य अंकों की चर्चा करते हुए अंकों से निपटने के लिए प्रतिस्थापित अंकों को संग्रहीत करने के लिए उपयोग किया जाता है।

— नील
स्रोत
`` `s => s.replace (a = / \ d / g, (c, i) => a [i] = a [i + = ~ c] || s [i])` ``
— l4m2
3

पर्ल 5 , 34 बाइट्स

कोड + -pध्वज के 33 बाइट्स ।

s/\d/substr$_,-$&-1+pos,1/e&&redo

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

s/\d/.../e...पर्ल कोड के रूप में मूल्यांकन करके पहले अंक को बदलें । ( उस स्थिति में ...होने के साथ , सूचकांक में लंबाई के विकल्प को लौटाता है , जहां संख्या अभी-अभी मेल खाती है, और मैच के शुरू होने का सूचकांक है। हमें यह जानने की जरूरत है कि क्या प्रत्येक अंक को बदलने के लिए प्रतिस्थापन सफल था। (और परिणाम स्पष्ट रूप से ध्वज के लिए धन्यवाद मुद्रित किया गया है)।substr$_,-$&-1+pos,1substr$_,-$&-1+pos,1$_1-$&-1+pos$&posredo-p

पुराना तरीका, 47 बाइट्स:

कोड + -Fध्वज के 44 बाइट्स ।

map{$F[$i]=$F[$i-$_-1]if/\d/;++$i}@F;print@F

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

वास्तव में काफी आगे सीधे। -Fध्वज प्रत्येक वर्ण में इनपुट को विभाजित करता है @F। map{...}@Fके माध्यम से iterates @F(यानी। इनपुट के हर चरित्र)। यदि वर्ण यदि एक अंक ( /\d/) है, तो हम इसे सूचकांक में वर्ण द्वारा प्रतिस्थापित करते हैं $i-$_-1। $iवर्तमान सूचकांक चर रहा है (कि हम हर किरदार देखा पर incrementing द्वारा बनाए रखने के)।

— बापू
स्रोत
3

जावास्क्रिप्ट ईएस 6, 61 59 बाइट्स

धन्यवाद @ बाइट 8 बाइट से गोल्फिंग के लिए

x=>[...x].map((p,i,a)=>a[i]=/\d/.test(p)?a[i-1-p]:p).join``

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

— fənɛtɪk
स्रोत
x.split``यह भी हो सकता है [...x], [0-9]हो सकता है \d, एक साथ 6B बचत
— ल्यूक
वर्तमान में कहीं न कहीं एक त्रुटि है जो पहले ठीक करने जा रही है
— fɛnɪt Aprk
x=>[...x].map((p,i,a)=>+p+1?a[i-1-p]:p).join``46 बाइट्स के लिए
— ल्यूक
रिक्त स्थान + "" के लिए विफल रहता है 0 देता है जो इसे पिछले चरित्र को हथियाने का कारण बनता है
— fɛnɪtɪk
x=>[...x].map((p,i,a)=>a[i]=1+p>9?a[i-1-p]:p).join``
— l4m2
2

सीजेएम, 13 बाइट्स

q{_A,s#)$\;}/

ऑनलाइन डेमो।

यह समाधान डिकोडिंग को लागू करने के लिए CJam की अंतर्निहित "कॉपी n -th स्टैक पर ऑपरेटर" $का उपयोग करता है। यह इनपुट को पढ़ने के साथ शुरू होता है (साथ q) और फिर इनपुट स्ट्रिंग से वर्णों पर लूपिंग और उन्हें स्टैक (साथ {}/) पर डंप करना । हालाँकि, लूप बॉडी के अंदर यह प्रत्येक वर्ण को डुप्लिकेट करने के बाद भी इसे स्टैक (साथ _) पर रखा गया है और जाँचता है कि क्या यह इसके साथ अपनी स्थिति को देखकर एक अंक है।# स्ट्रिंग में"0123456789" , आसानी से प्रतिनिधित्व किया A,s।

इस लुकअप का परिणाम या तो अंक का संख्यात्मक मान है, या, यदि चरित्र एक अंक नहीं है, -1। )ऑपरेटर तो एक के बाद कि मूल्य वृद्धि कर देता है, और $ढेर के शीर्ष से नीचे है कि कई स्थानों पर चरित्र वर्तमान के साथ यह बदल देता है। अंत में, \;हम वर्तमान इनपुट चरित्र की प्रति निकालते हैं, जिसे हमने _स्टैक से बनाया है , क्योंकि इसकी अब आवश्यकता नहीं है।

— इल्मरी करोनें
स्रोत
2

बेफुंज -98 , 45 43 बाइट्स

::::#@~\1p:1g::'9`!\'/`*j;'/--1g\1p\1g#;,1+

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

विचार:

  1. इनपुट स्ट्रिंग में प्रत्येक वर्ण के लिए,
    1. इसे पंक्ति 2 में लिखें
    2. यदि यह एक संख्या नहीं है, तो बस इसे आउटपुट करें
    3. अन्यथा, सही मूल्य देखें, इसे फिर से लिखें, फिर इसे आउटपुट करें
::::            ; There's a counter on the stack, duplicate it 4 times  ;
    #@~         ; Get the next char of input, exiting if there is none  ;
       \1p      ; At the location (counter, 1), write the input char    ;
          :1g   ; Re-obtain the char. Stack is now [counter * 4, input] ;

::                ; Stack: [counter * 4, input * 3]      ;
  '9`!\'/`*       ; If !(input > '9') and (input > '/')  ;
                  ; IE If ('0' <= input && input <= '9') ;
           j;...; ; Then execute the ...                 ;

; Stack: [counter * 4, input] ;
; The ... branch:             ;

'/-             ; input -> int. (input -= '/')             ;
   -            ; counter - int(input) - 1                 ;
                ; Stack: [counter * 3, lookupPosition ]    ;
    1g          ; Get the char that we want to find        ;
      \1p\1g#   ; Overwrite the current char (not the old) ;

; Both branches: ;
,1+             ; Print the number and increment the counter ;

मैं इस संस्करण को छोटा नहीं कर पाया, लेकिन यह 44 बाइट्स है:

s #@~\3p:3g::'9`!\'/`*j;'/--3g#;:10g3p,1+:::

सोचा था कि मैं इसे साफ-सुथरी चाल के कारण साझा करूंगा s- लेकिन स्टैक पर काउंटर जमा करने से उस 1 चार्ट में सुधार होता है

— जस्टिन
स्रोत
2

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

s='';j=-1
for i in input():s+=s[j-int(i)]if'/'<i<':'else i;j+=1
print s

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

संपादित करें: 32-47 के बीच एएससीआई मूल्यों के लिए निश्चित ; डबल डिकोडिंग के लिए निश्चित (उदा। "Alp2c1" से "अल्पाका")

— गणित के दीवाने
स्रोत
1
@ अरनुलद नोप। क्षमा करें, मैंने युक्ति को पर्याप्त रूप से नहीं पढ़ा है। शीघ्र ही संशोधित
— गणित नशेड़ी
ऐसा लगता है कि कोई बग है। के लिए 'Prog2am0in6 Puz0les7&1Cod74G4lf'अपने कार्यक्रम के निशान Programming Puzzles &7Code1Golf! मैंने दोनों TIO लिंक साझा करने की कोशिश की!
— कीर्तन प्रभाकरन 14
@ कीर्तनप्रभाकर धन्यवाद! 0 बाइट की कीमत पर तय! (मेरा वैकल्पिक समाधान हालांकि कटौती नहीं किया)
— गणित नशेड़ी
एक महान दृष्टिकोण!
— कीर्तन प्रभाकरन
क्या आप '' / '<i <': '' समझा सकते हैं। मुझे पता है कि यह परीक्षण है अगर यह एक संख्या है लेकिन यह कैसे काम करता है?
— मटीस कश्मीर
2

PHP 7.1 67 59 बाइट्स

while(_&$c=$argn[$i++])$t.=($c^"0")<"
"?$t[~+$c]:$c;echo$t;

एसटीडीआईएन से इनपुट लेता है; पाइप के साथ चलाएं -nRया इसे ऑनलाइन आज़माएं ।

  • _&$c=$s[$i++]स्ट्रिंग के माध्यम से लूप ( _&$cपरिणामस्वरूप ऐसा कुछ होगा जो नहीं है "0"; इसलिए केवल एक ही चरित्र लूप को तोड़ सकता है इनपुट का खाली स्ट्रिंग = अंत)
  • $c^"0" Ascii कोड में बिट्स 5 और 6 को टॉगल करें
  • <"\n" जाँच करें कि क्या परिणाम <chr (10) है
  • यदि ऐसा है, तो यह एक अंक है: पिछले चरित्र को सूचकांक से प्रिंट करें (और वर्तमान सूचकांक पर कॉपी करें)
  • इस चरित्र को प्रिंट करें

12% की बचत के लिए @Christoph धन्यवाद

— टाइटस
स्रोत
1
मुझे पता है कि यह एक पुराना उत्तर है लेकिन: नकारात्मक स्ट्रिंग ऑफसेट! (और वह $s=$argn...?)for(;_&$c=$argn[$i++];)$t.=($c^"0")<"\n"?$t[~+$c]:$c;echo$t;
— क्रिस्टोफ़
2

विम मैक्रो / कीस्ट्रोक्स, 49 बाइट्स

^M वापसी चरित्र का प्रतिनिधित्व करें (0x0A, 1 बाइट)।

qqqqq/[0-9]^Myl:exe 'norm '.(@"+1).'h'^Mylnphx@qq@q

व्याख्या

qqq                                                     clear register q
   qq                                                   record into q
     /[0-9]^M                                           move the cursor to the next digit
             yl                                         yank the digit
               :exe 'norm '.(@"+1).'h'^M                move the cursor left that number of characters plus one
                                        yl              yank the char
                                          n             go back to the digit
                                           p            paste the char 
                                            hx          delete the digit
                                              @q        recursive call
                                                q       stop recording
                                                 @q     run the macro
— TheFamilyFroot
स्रोत
2

एपीएल (डायलॉग क्लासिक) , 25 23 बाइट्स

-2 बाइट्स @FrownyFrog की बदौलत 

((⊂⌷⊢)⍣≡⍳∘≢-11|⎕d∘⍳)⊃¨⊂

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

का उपयोग करता है ⎕io←1

( ⍵नीचे मूल्यांकन में एक मध्यवर्ती मूल्य के लिए खड़ा है)

⎕d स्ट्रिंग है '0123456789'

⎕d⍳⍵(इस मामले में 1 आधारित) के सूचकांकों पाता ⍵है में वर्ण ⎕d; एक गैर-अंक के लिए सूचकांक 11 है

11|⍵ मोडुलो है - 11 एस 0 एस बन जाते हैं

≢⍵ की लंबाई है ⍵

⍳≢⍵है 1 2 ...जब तक≢⍵

इसलिए, (⍳≢⍵)-11|⎕d⍳⍵हमें सूचकांकों की एक वेक्टर i प्रदान करता है जहां हमें परिणामी वर्ण प्राप्त करने के लिए देखना चाहिए; हालाँकि उन कुछ सूचकांकों को अन्य (छोटे) सूचकांकों के लिए पुनर्निर्देशित किया जा सकता है। सकर्मक क्लोजर (यानी प्रभावी सूचकांकों) की गणना करने के लिए, हम वेक्टर को अपने आप में ( ⊂⌷⊢, समतुल्य (⊂i)⌷iया बराबर i[i]) ट्रेन में अनुक्रमित करते हैं और तब तक दोहराते हैं जब तक कि यह स्थिर नहीं हो ⍣≡जाता (इसे निश्चित बिंदु ऑपरेटर के रूप में जाना जाता है )।

अंत में हम मूल स्ट्रिंग में इंडेक्स करते हैं: (...)⊃¨⊂

— NGN
स्रोत
ट्रेन के रूप में कैसा लगेगा?
— FrownyFrog
@FrownyFrog वास्तव में, छोटा
— ngn
1

जाप , 24 बाइट्स

£Xn >J?U=UhYUgJ+Y-X):PÃU

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

स्पष्टीकरण:

£Xn >J?U=UhYUgJ+Y-X):PÃU
£                     Ã    Iterate through the input (implicit U) 
                             X becomes the iterative item, Y becomes the index
 Xn                          Try parseInt(X)
    >J                       > -1
                               In this case, this checks if X is a digit
      ?                      If true:
       U=                      Set U to 
         UhY                     U with the char at index Y set to:     
            UgJ+Y-X               The index at -1+Y-X
                   ):        Else:
                     P         variable P (just a no-op in this case)
                       U   Finally, return U
— ओलिवर
स्रोत
1

जावास्क्रिप्ट ईएस 6, 54 बाइट्स

f=r=>[...r].reduce((a,s,i)=>a+(/\d/.test(s)?a[i+~s]:s))


f=r=>[...r].reduce((a,s,i)=>a+(/\d/.test(s)?a[i+~s]:s))

console.log(f("Prog2am0in6"));
console.log(f("abcd"));
console.log(f("a000"));
console.log(f("ban111"));
console.log(f("Hel0o W2r5d!"));
console.log(f("this 222a19e52"));
console.log(f("golfin5 3s24o0d4f3r3y3u"));
console.log(f("Prog2am0in6 Puz0les7&1Cod74G4lf"));
console.log(f("Replicants 4re3lik448ny3oth8r5mac6in8.8T64y'r371it9376a1b5n1fit7or2a1h2z17d."));
स्निपेट का विस्तार करें

— ogur
स्रोत
1
PPCG में आपका स्वागत है! यदि आपको पुनरावर्ती कॉल के लिए अपने फ़ंक्शन नाम की आवश्यकता नहीं है, तो अनाम फ़ंक्शन मान्य हैं, इसलिए आप दो बाइट्स को बचा सकते हैं f=।
— मार्टिन एंडर
1

> <> (मछली), 108 बाइट्स (= 9 x 12 ग्रिड)

01-r>:0(\
"/"&::;?/
)?\v    \
":/v!?(":
")\ :>:"0
 !?\
${/  \ -1
&>\ ~{:&$
\ \ :"0"=
/\- 1}$/?
:v&//}~/~
 \o}\&$/

मछली को तैरते हुए देखने के लिए इसे यहाँ आज़माएँ ।

  • इनपुट स्टैक के लिए -1 संलग्न करें फिर स्टैक को उल्टा करें।
  • लूप: अगर टॉप वैल्यू -1 है तो एंड (हमने सभी पात्रों के माध्यम से साइकिल चला दी है)। अन्यथा:
  • रजिस्टर में शीर्ष चरित्र रखो; यह देखने के लिए जांचें कि क्या यह "0" से "9" की सीमा में है। यदि ऐसा है तो:
    • स्टैक को उचित स्थानों पर घुमाएं
    • चरित्र को इंगित किया जा रहा है
    • वापस घुमाएं और रजिस्टर से वर्ण के साथ संख्या को बदलें
  • आउटपुट; लूप फिर से शुरू करें।
— Théophile
स्रोत
1

8086 मशीन कोड, 35 बाइट्स

00000000  be 82 00 ac 98 50 2c 30  3c 09 77 0c 4e 89 f7 4e  |.....P,0<.w.N..N|
00000010  29 c6 58 ac aa 89 fe 50  5a b4 02 cd 21 80 fa 0d  |).X....PZ...!...|
00000020  75 e1 c3                                          |u..|
00000023
— user5434231
स्रोत
1

Japt v2.0a0, 16 बाइट्स

r\d@=hYUgY-°X¹gY

कोशिश करो

व्याख्या

                     :Implicit input of string U
r                    :Replace
 \d                  :  RegEx /\d/g
   @                 :  Pass each match X at index Y through a function
     hY              :    Set the character at index Y in U
       UgY-°X        :    To the character at index Y-++X
    =        ¹       :    Reassign to U
              gY     :    Get the character at index Y
— झबरा
स्रोत
1

जे , 20 बाइट्स

{~[:{~^:_#\-2+_1".,.

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

                  ,.  Each character on a separate row
              _1".    Convert to numbers, replacing non-numbers with -1
                         (it becomes one row again)
            2+        Add 2.
         #\           Prefix lengths (range 1..length)
           -          Subtract
  [:{~^:_             Index into itself as long as it changes the result
{~                    Index into the original string

प्रेरणा के लिए उदासीनता का श्रेय।

22 बाइट्स

(],,{~1{._1-_1".[)/@|.

यह जेली उत्तर का एक बंदरगाह है।

                    |. The string backwards, because reduce is right-to-left.
            _1".[      The next character as a number (d), -1 if it's not a number,
                          and a space character produces an empty array.
         _1-           -1-d
      1{.              Take 1. If we have a nothing
                          at this point, that makes it a 0.
   ,                   Prepend the next character to the result of the previous call.
    {~                 Select the character. 0 is the first, _2 is second to last.
 ],                    Append the result.

दोनों समाधानों में जो संस्करण TIO का उपयोग करता है वह एकल की व्याख्या करता है . 0 की संख्या के रूप में , इसलिए अंतिम परीक्षण विफल हो जाता है। पुराने संस्करण ()7) सही ढंग से काम करने लगते हैं।

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

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