In dieser Herausforderung besteht Ihre Aufgabe darin, eine Zeichenfolge zu entschlüsseln. Glücklicherweise ist der Algorithmus ziemlich einfach: Beim Lesen von links nach rechts muss jede gefundene Ziffer N (0 bis 9) durch das Zeichen ersetzt werden, das N + 1 Stellen davor ist.

Beispiel

Die Eingabezeichenfolge "Prog2am0in6"würde folgendermaßen dekodiert:

Daher ist die erwartete Ausgabe "Programming".

Erläuterungen und Regeln

• Die Eingabezeichenfolge enthält ausschließlich ASCII-Zeichen im Bereich von 32 bis 126. Sie können davon ausgehen, dass es niemals leer sein wird.
• Die ursprünglich entschlüsselte Zeichenfolge enthält garantiert keine Ziffer.
• Sobald ein Zeichen dekodiert wurde, kann es wiederum durch eine nachfolgende Ziffer referenziert werden. Zum Beispiel "alp2c1"sollte als dekodiert werden "alpaca".
• Referenzen werden niemals um die Zeichenfolge gewickelt: Es kann nur auf vorherige Zeichen verwiesen werden.
• Sie können entweder ein vollständiges Programm oder eine Funktion schreiben, die das Ergebnis entweder druckt oder ausgibt.
• Dies ist Codegolf, daher gewinnt die kürzeste Antwort in Bytes.
• Standardlücken sind verboten.

Testfälle

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.

Gelee , 9 7 Bytes

~ịṭṭµ@/

Probieren Sie es online!

Wie es funktioniert

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

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

Probieren Sie es online!

Dank Anders Tornblad 1 Byte gespeichert . Das erste Zeichen kann keine Ziffer sein, daher muss es nicht überprüft werden, damit wir es vor dem Überprüfen unserer Beendigungsbedingung vorab inkrementieren können.

Haskell, 55 Bytes

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

Anwendungsbeispiel: reverse.foldl(#)[] $ "Prog2am0in6 Puz0les7&1Cod74G4lf"-> "Programming Puzzles & Code Golf". Probieren Sie es online!

Reduzieren Sie die Zeichenfolge zu einer umgekehrten Kopie von sich selbst, wobei die Zahlen durch die entsprechenden Zeichen ersetzt werden. "umkehren", weil wir auf diese Weise beim Indizieren der Zahlen einen einfachen Zugriff auf den bisherigen String haben. Mach es wieder rückgängig.

C 46 Bytes

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

Probieren Sie es online!

C  52   49  48 Bytes

Vielen Dank an @ l4m2 für das Speichern eines Bytes!

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

Bearbeitet die Eingabezeichenfolge direkt.

Probieren Sie es online!

Alternative 50-Byte-Version:

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

Rekursive Version, 48 Bytes:

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

05AB1E , 11 Bytes

vydiÂyèëy}J

Probieren Sie es online!

Erläuterung

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 Byte

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

7 Bytes dank fɛnəˈtɛk eingespart.

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

Retina , 37 Bytes

Die Anzahl der Bytes setzt die Kodierung nach ISO 8859-1 voraus.

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

Probieren Sie es online!

Erläuterung

\d
$*«»

Ersetzen Sie jede Ziffer d durch d « s, gefolgt von einer ». Letzteres benötigen wir, um a) Positionen mit d = 0 und b) als Trennzeichen zwischen benachbarten Ziffern erkennen zu können.

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

Passen Sie +die Regex in der ersten Zeile wiederholt ( ) von rechts nach links an ( r) und ersetzen Sie dann die am weitesten links stehende Übereinstimmung ( 1) durch die Ersetzung in der zweiten Zeile.

Der reguläre Ausdruck selbst stimmt mit einer unserer jetzt unären Ziffern überein und zählt die Anzahl von «s in Gruppe 2. Der Lookbehind vergleicht dann d Zeichen mit, (?<-2>.)*bevor er das betreffende Zeichen in Gruppe 1 erfasst. Die Zeichenfolge von «s und »wird dann durch das erfasste Zeichen ersetzt .

MATL , 21 19 17 16 Bytes

"@t4Y2m?UQ$y]]&h

Probieren Sie es bei MATL Online!

Erläuterung

        % 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 Byte

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 wird zum Speichern der ersetzten Ziffern verwendet, um mit Ziffern umzugehen, die sich auf andere Ziffern beziehen.

Perl 5 , 34 Bytes

33 Byte Code + -pFlag.

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

Probieren Sie es online!

s/\d/.../eErsetzen Sie die erste Ziffer durch den ...als Perl-Code ausgewerteten. (mit ...wobei substr$_,-$&-1+pos,1in diesem Fall. substr$_,-$&-1+pos,1gibt die Teilkette von $_der Länge 1bei Index -$&-1+pos, in dem $&die Zahl ist nur angepasst, und posist der Index des Beginns des Spiels. Wir müssen nur , redowenn der Ersatz erfolgreich war , um jede Stelle zu ersetzen. (und das Ergebnis wird dank -pflag implizit gedruckt ).

Alter Ansatz, 47 Bytes:

44 Byte Code + -FFlag.

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

Probieren Sie es online!

Eigentlich ganz einfach. -Fflag teilt die Eingaben für jedes Zeichen in @F. map{...}@Fiteriert durch @F(dh jedes Zeichen der Eingabe). Wenn das Zeichen eine Ziffer ( /\d/) ist, ersetzen wir es durch das Zeichen am Index $i-$_-1. Dies $iist die aktuelle Indexvariable (die wir pflegen, indem wir sie bei jedem angezeigten Zeichen erhöhen).

JavaScript ES6, 61 59 Bytes

Vielen Dank an @Luke für das Golfen mit 8 Bytes

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

Probieren Sie es online!

05AB1E , 27 17 Bytes

vyDdiU)DRXèU`X}}J

Probieren Sie es 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 Bytes

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

Online-Demo.

Diese Lösung verwendet den in CJam integrierten Operator "copy n- th item on the stack" $, um die Decodierung zu implementieren. Es beginnt damit, die Eingabe (mit q) zu lesen und dann die Zeichen aus der Eingabezeichenfolge in einer Schleife auf dem Stapel (mit {}/) abzulegen . Innerhalb des Schleifenkörpers dupliziert es jedoch auch jedes Zeichen, nachdem es auf den Stapel (mit _) gelegt wurde, und prüft, ob es sich um eine Ziffer handelt, indem es seine Position #in der Zeichenfolge nachschaut "0123456789", die zweckmäßigerweise als dargestellt wird A,s.

Das Ergebnis dieser Suche ist entweder der numerische Wert der Ziffer oder, falls das Zeichen keine Ziffer ist, -1. Der )Operator erhöht diesen Wert dann um eins und $ersetzt ihn durch den aktuellen Zeichenwert an so vielen Stellen unter dem oberen Rand des Stapels. Zum Schluss wird \;nur die Kopie des aktuellen Eingabezeichens _vom Stapel entfernt, da es nicht mehr benötigt wird.

Befunge-98 , 45 43 Bytes

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

Probieren Sie es online!

Die Idee:

1. Für jedes Zeichen in der Eingabezeichenfolge
   1. Schreiben Sie es in Zeile 2
   2. Wenn es sich nicht um eine Zahl handelt, geben Sie sie einfach aus
   3. Suchen Sie andernfalls den richtigen Wert, schreiben Sie ihn neu und geben Sie ihn aus

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

Ich konnte diese Version nicht kürzer bekommen, aber diese ist 44 Bytes:

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

Ich dachte, ich teile es wegen des netten Tricks mit s- aber das Speichern des Zählers auf dem Stapel führt zu dieser 1-Zeichen-Verbesserung

Python 2 , 59 Bytes

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

Probieren Sie es online!

Python 2, 75 71 Bytes

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

Probieren Sie es online!

Bearbeiten: Korrigiert für ASCII-Werte zwischen 32 und 47 ; Behoben für Doppeldecodierung (zB "alp2c1" bis "alpaca")

PHP 7.1 67 59 Bytes

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

Übernimmt die Eingabe von STDIN; Laufen Sie als Pipe mit -nRoder probieren Sie es online aus .

• _&$c=$s[$i++]Durchschleifen eines Strings ( _&$cführt zu etwas, was nicht "0"der Fall ist; das einzige Zeichen, das die Schleife unterbrechen kann, ist der leere String = Ende der Eingabe)
• $c^"0" Schalten Sie die Bits 5 und 6 im ASCII-Code um
• <"\n" überprüfe ob das Ergebnis <chr (10) ist
• In diesem Fall handelt es sich um eine Ziffer: Vorheriges Zeichen nach Index drucken (und in den aktuellen Index kopieren)
• Andernfalls wird dieses Zeichen gedruckt

Danke @Christoph für das Sparen von 12%

Vim Makro / Tastenanschläge, 49 Bytes

^M Stellen Sie das Rückgabezeichen dar (0x0A, 1 Byte).

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

Erläuterung

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 Bytes

-2 Bytes dank @FrownyFrog

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

Probieren Sie es online!

Verwendet ⎕io←1

( ⍵unten steht für einen Zwischenwert in der Bewertung)

⎕d ist die Zeichenfolge '0123456789'

⎕d⍳⍵findet die (in diesem Fall auf 1 basierenden) Indizes der ⍵Zeichen in ⎕d; für eine Nicht-Ziffer ist der Index 11

11|⍵ ist modulo - die 11er werden zu 0er

≢⍵ ist die Länge von ⍵

⍳≢⍵ist 1 2 ...bis≢⍵

so, (⍳≢⍵)-11|⎕d⍳⍵gibt uns einen Vektor i der Indizes , wo wir die sich ergebenden Zeichen zu bekommen aussehen sollte; Einige dieser Indizes können jedoch auf andere (kleinere) Indizes umgeleitet werden. Um den transitiven Abschluss (dh die effektiven Indizes) zu berechnen, indizieren wir den Vektor in sich selbst ( ⊂⌷⊢einen Zug, der (⊂i)⌷ioder entspricht i[i]) und wiederholen diesen Vorgang, bis er sich stabilisiert ( ⍣≡wird als Festkommaoperator bezeichnet ).

Zum Schluss indexieren wir die ursprüngliche Zeichenfolge: (...)⊃¨⊂

Python 2 , 83 80 Bytes

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

Probieren Sie es online!

• 3 Bytes gespeichert, aber das Prüfen von ASCII anstelle von ist eine Ziffer! Danke an math_junkie!

Japt , 24 Bytes

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

Probieren Sie es online!

Erläuterung:

£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

Ruby, 56 46 Bytes

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

Probieren Sie es online!

Python 2 , 58 Bytes

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

Dies ist im Wesentlichen ein Port meiner Jelly-Antwort sowie die Ziffernüberprüfung aus der Python-Antwort von @ xnor.

Probieren Sie es online!

Röda , 51 Bytes

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

Probieren Sie es online!

JavaScript ES6, 54 Byte

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

> <> (Fisch), 108 Bytes (= 9 x 12 Raster)

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

Versuchen Sie es hier , um die Fische herumschwimmen zu sehen.

• Hänge -1 an den Eingabestapel an und kehre den Stapel um.
• Schleife: Wenn der Höchstwert -1 ist, endet die Schleife (wir haben alle Zeichen durchlaufen). Andernfalls:
• Setze das oberste Zeichen in das Register. Überprüfen Sie, ob der Wert zwischen "0" und "9" liegt. Wenn ja:
  • Drehen Sie den Stapel um die entsprechende Anzahl von Stellen
  • Erhalte den Charakter, auf den gezeigt wird
  • zurückdrehen und die Zahl durch das Zeichen aus dem Register ersetzen
• Ausgabe; Wiederaufnahme der Schleife.

8086 Maschinencode, 35 Bytes

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 bytes

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

Probieren Sie es online!

Japt v2.0a0, 16 Bytes

r\d@=hYUgY-°X¹gY

Versuch es

Erläuterung

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

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

Probieren Sie es online aus

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

Dank für die Inspiration.

22 Bytes

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

Dies ist ein Port der Jelly-Antwort.

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

In beiden Lösungen interpretiert die von TIO verwendete Version eine einzelne .als die Zahl 0, sodass der letzte Test fehlschlägt. Ältere Versionen (≤7) scheinen korrekt zu funktionieren.

Probieren Sie es online!