W tym wyzwaniu Twoim zadaniem jest rozszyfrowanie łańcucha. Na szczęście algorytm jest dość prosty: czytając od lewej do prawej, każda napotkana cyfra N (od 0 do 9) musi zostać zastąpiona znakiem, który przed nią ma pozycje N + 1 .

Przykład

Łańcuch wejściowy "Prog2am0in6"zostałby zdekodowany w ten sposób:

Dlatego oczekiwany wynik to "Programming".

Wyjaśnienia i zasady

• Łańcuch wejściowy będzie zawierał wyłącznie znaki ASCII w zakresie od 32 do 126. Możesz założyć, że nigdy nie będzie pusty.
• Oryginalny rozszyfrowany ciąg znaków nie może zawierać żadnej cyfry.
• Po zdekodowaniu znaku może on z kolei być oznaczony kolejną cyfrą. Na przykład "alp2c1"powinien zostać zdekodowany jako "alpaca".
• Odnośniki nigdy nie będą owijać się wokół łańcucha: można odwoływać się tylko do poprzednich znaków.
• Możesz napisać pełny program lub funkcję, która wydrukuje lub wyświetli wynik.
• To jest kod golfowy, więc wygrywa najkrótsza odpowiedź w bajtach.
• Standardowe luki są zabronione.

Przypadki testowe

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.

Galaretka , 9 7 bajtów

~ịṭṭµ@/

Wypróbuj online!

Jak to działa

~ịṭṭµ@/  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.    

Java 7, 81 80 bajtów

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];}

Wypróbuj online!

Zaoszczędzono 1 bajt dzięki Andersowi Tornbladowi . Pierwszy znak nie może być cyfrą, więc nie trzeba go sprawdzać, co oznacza, że ​​możemy zwiększyć wartość przed sprawdzeniem naszego warunku zakończenia.

Haskell, 55 bajtów

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

Przykład użycia: reverse.foldl(#)[] $ "Prog2am0in6 Puz0les7&1Cod74G4lf"-> "Programming Puzzles & Code Golf". Wypróbuj online!

Zredukuj ciąg znaków do jego odwrotnej kopii, zastępując liczby odpowiednimi znakami. „rewers”, ponieważ w ten sposób mamy do tej pory łatwy dostęp do ciągu podczas indeksowania liczb. Odwróć to jeszcze raz.

C, 46 bajtów

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

Wypróbuj online!

C,  52   49  48 bajtów

Dzięki @ l4m2 za uratowanie bajtu!

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

Edytuje bezpośrednio łańcuch wejściowy.

Wypróbuj online!

Alternatywna 50-bajtowa wersja:

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

Wersja rekurencyjna, 48 bajtów:

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

05AB1E , 11 bajtów

vydiÂyèëy}J

Wypróbuj online!

Wyjaśnienie

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

JavaScript (ES6), 59 53 bajtów

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

Zaoszczędzono 7 bajtów dzięki fəˈnɛ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."));

Siatkówka , 37 bajtów

Liczba bajtów zakłada kodowanie ISO 8859-1.

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

Wypróbuj online!

Wyjaśnienie

\d
$*«»

Zastąpić każdą cyfrę d o d « s, a następnie przez jeden ». Potrzebujemy tych ostatnich a), aby móc rozpoznać pozycje, w których d = 0 ib) jako separator między sąsiednimi cyframi.

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

Wielokrotnie ( +) dopasuj wyrażenie regularne w pierwszym wierszu od prawej do lewej ( r), a następnie zamień dopasowanie najbardziej lewe ( 1) z podstawieniem w drugim wierszu.

Wyrażenie regularne dopasowuje jedną z naszych obecnie jednoargumentowych cyfr i liczy liczbę «s w grupie 2. Lookbehind następnie dopasowuje znaki d(?<-2>.)* przed przechwyceniem przywoływanego znaku w grupie 1. Ciąg «s, a »następnie zastępowany jest znakiem przechwyconym .

MATL , 21 19 17 16 bajtów

"@t4Y2m?UQ$y]]&h

Wypróbuj w MATL Online!

Wyjaśnienie

        % 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

JavaScript (ES6), 51 bajtów

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łuży do przechowywania zastąpionych cyfr w celu radzenia sobie z cyframi odnoszącymi się do innych cyfr.

Perl 5 , 34 bajtów

33 bajty kodu + -pflaga.

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

Wypróbuj online!

s/\d/.../ezamień pierwszą cyfrę ...zgodnie z kodem Perla. (przy ...czym substr$_,-$&-1+pos,1w tym przypadku. substr$_,-$&-1+pos,1zwraca podciąg $_długości 1w indeksie -$&-1+pos, gdzie $&jest numer tylko dopasowane, a posjest indeksem początku meczu. Musimy tylko redojeśli zastąpi się powiodła, aby zastąpić każdą cyfrę. (a wynik jest domyślnie wydrukowany dzięki -pfladze).

Stare podejście, 47 bajtów:

44 bajty kodu + -Fflaga.

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

Wypróbuj online!

Właściwie całkiem prosto. -FFlaga dzieli dane wejściowe każdego znaku na @F. map{...}@Fiteruje przez @F(tj. każdy znak wejścia). Jeśli znak jest cyfrą ( /\d/), wówczas zastępujemy go znakiem w indeksie $i-$_-1. Jest $ito bieżąca zmienna indeksu (którą zachowujemy, zwiększając każdy widziany znak).

JavaScript ES6, 61 59 bajtów

Dzięki @Luke za grę w golfa z 8 bajtów

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

Wypróbuj online!

05AB1E , 27 17 bajtów

vyDdiU)DRXèU`X}}J

Wypróbuj online!

vy             }  # For each character
  Dd              #   Push is_number
    i         }   #   If it is
     U            #     Save save it
      )DR         #     Wrap the (reversed) stack into an array
         Xè       #     Get the character at the saved index
           U`X    #     Flatten the whole stack
                J # Join 

CJam, 13 bajtów

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

Demo online.

To rozwiązanie wykorzystuje wbudowany w CJam operator „kopiuj n- ty element na stosie” $do implementacji dekodowania. Zaczyna się od odczytu danych wejściowych (za pomocą q), a następnie zapętlenia znaków z ciągu wejściowego i zrzucenia ich na stos (za pomocą {}/). Jednak wewnątrz korpusu pętli kopiuje również każdy znak po umieszczeniu go na stosie (z _) i sprawdza, czy jest to cyfra, patrząc na jego pozycję za #pomocą ciągu "0123456789", dogodnie reprezentowanego jako A,s.

Wynikiem tego wyszukiwania jest albo wartość liczbowa cyfry, albo, jeśli znak nie jest cyfrą, -1. Następnie )operator zwiększa tę wartość o jeden i $zastępuje ją znakiem prądu w wielu pozycjach poniżej górnej części stosu. Wreszcie, \;po prostu usuwa _ze stosu kopię bieżącego znaku wejściowego , ponieważ nie jest już potrzebny.

Befunge-98 , 45 43 bajtów

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

Wypróbuj online!

Pomysł:

1. Dla każdego znaku w ciągu wejściowym
   1. Zapisz to w wierszu 2
   2. Jeśli nie jest to liczba, po prostu ją wypisz
   3. W przeciwnym razie sprawdź poprawną wartość, przepisz ją, a następnie wyślij

::::            ; 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 ;

Nie byłem w stanie skrócić tej wersji, ale ta ma 44 bajty:

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

Pomyślałem, że podzielę się tym ze względu na zgrabną sztuczkę s- ale przechowywanie licznika na stosie prowadzi do poprawy o 1 znak

Python 2 , 59 bajtów

s=''
for c in input():s+=c['/'<c<':':]or s[~int(c)]
print s

Wypróbuj online!

Python 2, 75 71 bajtów

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

Wypróbuj online!

Edycja: Naprawiono dla wartości ascii między 32-47 ; Naprawiono podwójne dekodowanie (np. „Alp2c1” do „alpaca”)

PHP 7,1 67 59 bajtów

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

Pobiera dane wejściowe z STDIN; uruchom jako potok z -nRlub spróbuj online .

• _&$c=$s[$i++]zapętlić ciąg ( _&$cspowoduje coś, co nie jest "0"; więc jedynym znakiem, który może przerwać pętlę, jest pusty ciąg = koniec wejścia)
• $c^"0" przełączaj bity 5 i 6 w kodzie ascii
• <"\n" sprawdź, czy wynik to <chr (10)
• jeśli tak, to cyfra: wydrukuj poprzedni znak według indeksu (i skopiuj do bieżącego indeksu)
• w przeciwnym razie wydrukuj ten znak

Dzięki @Christoph za oszczędność 12%

Makro / klawisze Vima, 49 bajtów

^M reprezentują znak powrotu (0x0A, 1 bajt).

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

Wyjaśnienie

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

APL (Dyalog Classic) , 25 23 bajtów

-2 bajty dzięki @FrownyFrog

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

Wypróbuj online!

wykorzystuje ⎕io←1

( ⍵poniżej oznacza wartość pośrednią w ocenie)

⎕d jest ciąg '0123456789'

⎕d⍳⍵znajduje (w tym przypadku w oparciu o 1) indeksy ⍵znaków ⎕d; dla wartości niezerowych indeks wynosi 11

11|⍵ jest modulo - 11 to 0

≢⍵ jest długością ⍵

⍳≢⍵jest 1 2 ...do≢⍵

więc (⍳≢⍵)-11|⎕d⍳⍵daje nam wektor i indeksów, w których powinniśmy szukać, aby uzyskać wynikowe znaki; jednak niektóre z tych indeksów mogą przekierowywać na jeszcze inne (mniejsze) indeksy. Aby obliczyć zamknięcie przechodnie (tj. Indeksy efektywne), indeksujemy wektor do siebie ( ⊂⌷⊢pociąg równoważny (⊂i)⌷ilub i[i]) i powtarzamy go, aż się ustabilizuje ( ⍣≡jest znany jako operator punktu stałego ).

na koniec indeksujemy do oryginalnego ciągu: (...)⊃¨⊂

Python 2 , 83 80 bajtów

r=input()
for i in r:
 if'/'<i<':':r=r.replace(i,r[r.find(i)+~int(i)],1)
print r

Wypróbuj online!

• zapisano 3 bajty, ale sprawdzanie ascii zamiast cyfry! Dzięki math_junkie!

Japt , 24 bajty

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

Wypróbuj online!

Wyjaśnienie:

£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

Rubin, 56 46 bajtów

->s{i=0;s[i]=s[i+~s[i].to_i]while i=s=~/\d/;s}

Wypróbuj online!

Python 2 , 58 bajtów

lambda s:reduce(lambda t,c:t+(c+t)['/'<c<':'and~int(c)],s)

Jest to w zasadzie port mojej odpowiedzi Jelly, a także cyfry z odpowiedzi Python @ xnor.

Wypróbuj online!

Röda , 51 bajtów

f a{x=0;a|{|y|a[x]=a[x+47-ord(y)]if[y=~`\d`];x++}_}

Wypróbuj online!

JavaScript ES6, 54 bajty

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."));

> <> (Ryba), 108 bajtów (= siatka 9 x 12)

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

Spróbuj tutaj, aby zobaczyć pływające ryby.

• Dołącz -1 do stosu wejściowego, a następnie odwróć stos.
• Pętla: jeśli najwyższa wartość to -1, to koniec (przełączyliśmy wszystkie znaki). Inaczej:
• Umieść najwyższą postać w rejestrze; sprawdź, czy mieści się w zakresie od „0” do „9”. W takim razie:
  • obróć stos o odpowiednią liczbę miejsc
  • uzyskaj wskazaną postać
  • obróć z powrotem i zamień cyfrę na znak z rejestru
• Wynik; wznowić pętlę.

Kod maszynowy 8086, 35 bajtów

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

ok, 39 bajtów

{x{x[y 0]:x@-/y}/(!#x),'0|{x*11>x}x-47}

Wypróbuj online!

Japt v2.0a0, 16 bajtów

r\d@=hYUgY-°X¹gY

Spróbuj

Wyjaśnienie

                     :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

J , 20 bajtów

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

Wypróbuj online

                  ,.  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

Podziękowania dla ngn za inspirację.

22 bajty

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

To jest port odpowiedzi Jelly.

                    |. 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.

W obu rozwiązaniach wersja używana przez TIO interpretuje pojedynczy .jako liczbę 0, więc ostatni test kończy się niepowodzeniem. Starsze wersje (≤7) wydają się działać poprawnie.

Wypróbuj online!