Hagamos algo de "deciph4r4ng"

58

En este desafío, su tarea es descifrar una cadena. Afortunadamente, el algoritmo es bastante simple: leyendo de izquierda a derecha, cada dígito encontrado N (0 a 9) debe ser reemplazado por el carácter que es N + 1 posiciones antes.

Ejemplo

La cadena de entrada "Prog2am0in6"se decodificaría de esta manera:

ejemplo

Por lo tanto, la salida esperada es "Programming".

Aclaraciones y reglas.

  • La cadena de entrada contendrá caracteres ASCII en el rango 32 - 126 exclusivamente. Puede suponer que nunca estará vacío.
  • Se garantiza que la cadena descifrada original no contendrá ningún dígito.
  • Una vez que un personaje ha sido decodificado, a su vez puede ser referenciado por un dígito posterior. Por ejemplo, "alp2c1"debe decodificarse como "alpaca".
  • Las referencias nunca se ajustarán a la cadena: solo se puede hacer referencia a los caracteres anteriores.
  • Puede escribir un programa completo o una función, que imprime o genera el resultado.
  • Este es el código de golf, por lo que gana la respuesta más corta en bytes.
  • Las lagunas estándar están prohibidas.

Casos de prueba

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.
Arnauld
fuente
¿Podemos recibir la entrada como una matriz de cadenas de caracteres individuales? ¿Podemos suponer que el número nunca será mayor que 9?
fəˈnɛtɪk
@ fəˈnɛtɪk Con respecto al formato de entrada: diría que no, a menos que este sea el único formato aceptable para su idioma. Estamos tratando con dígitos individuales en lugar de números. Entonces sí: se garantiza que sea <= 9 pero puede encontrar varios dígitos seguidos.
Arnauld
¿ 1bbabSería una entrada válida (con salida esperada de abbab)? En otras palabras, ¿pueden las referencias envolver la cadena?
Lucas
@Luke Buen punto. No, 1bbabno es valido. He agregado una aclaración sobre eso.
Arnauld

Respuestas:

11

Jalea , 9 7 bytes

~ịṭṭµ@/

Pruébalo en línea!

Cómo funciona

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

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

Pruébalo en línea!

Guardado 1 byte gracias a Anders Tornblad . El primer carácter no puede ser un dígito, por lo que no es necesario verificarlo, lo que significa que podemos preincrementar antes de verificar nuestra condición de terminación.

Meter
fuente
2
Como el primer carácter nunca podría contener un dígito, no tiene que verificarlo. Por lo tanto, su bucle puede ser for(int i=0;++i<a.length;){en su lugar, ahorrando un carácter.
Anders Tornblad
12

Haskell, 55 bytes

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

Ejemplo de uso: reverse.foldl(#)[] $ "Prog2am0in6 Puz0les7&1Cod74G4lf"-> "Programming Puzzles & Code Golf". Pruébalo en línea!

Reduzca la cadena a una copia inversa de sí misma con los números reemplazados por los caracteres correspondientes. "revertir", porque de esta manera tenemos fácil acceso a la cadena hasta el momento al indexar los números. Invierta de nuevo.

nimi
fuente
1
Wow, he escrito esta solución exacta pero tardé en publicarla :) Bueno, al menos ahora sé que fue buena, +1
Leo
11

C, 46 bytes

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

Pruébalo en línea!


C,  52   49  48 bytes

¡Gracias a @ l4m2 por guardar un byte!

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

Edita la cadena de entrada directamente.

Pruébalo en línea!

Versión alternativa de 50 bytes:

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

Versión recursiva, 48 bytes:

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

05AB1E , 11 bytes

vydiÂyèëy}J

Pruébalo en línea!

Explicación

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
fuente
Realmente necesito verificar si ya has respondido con más frecuencia antes de comenzar.
Magic Octopus Urn
@carusocomputing: Todavía podrías pensar en un truco mejor que el que he usado;)
Emigna
7

JavaScript (ES6), 59 53 bytes

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

Guardado 7 bytes gracias a 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."));

Tom
fuente
.charAt (...) se puede reemplazar con [...] un ahorro de 7 bytes
fəˈnɛtɪk
x.charAt (...) es equivalente a x [...]
fəˈnɛtɪk
@ fəˈnɛtɪk Sí, pensé que lo había intentado antes pero arrojó un error. ¡Gracias!
Tom
1
o-m-1puede ser reemplazado con o+~m.
Neil
2
Debido a que f se llama de forma recursiva, el recuento de caracteres del programa debe incluir la f=parte, por lo que son 54 bytes, no 52.
user5090812
5

Retina , 37 bytes

El recuento de bytes asume la codificación ISO 8859-1.

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

Pruébalo en línea!

Explicación

\d
$*«»

Reemplace cada dígito d con d « s, seguido de uno ». Necesitamos el último a) para poder reconocer posiciones donde d = 0 yb) como separador entre dígitos adyacentes.

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

Repetidamente ( +) coincida con la expresión regular en la primera línea de derecha a izquierda ( r) y luego reemplace la coincidencia más a la izquierda ( 1) con la sustitución en la segunda línea.

La expresión regular en sí coincide con uno de nuestros dígitos ahora unarios y cuenta el número de «s en el grupo 2. Luego, la mirada atrás coincide con los caracteres d(?<-2>.)* antes de capturar el carácter mencionado en el grupo 1. La cadena de «sy »luego se reemplaza con el carácter capturado. .

Martin Ender
fuente
5

MATL , 21 19 17 16 bytes

"@t4Y2m?UQ$y]]&h

¡Pruébalo en MATL Online!

Explicación

        % 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
fuente
Buen uso de $yen la nueva versión!
Luis Mendo
@LuisMendo ¡Gracias! Sí, los idiomas basados ​​en la pila son una buena
opción
@LuisMendo Lamentablemente, esto podría haberse acortado aún más si Usolo funcionara por dígitos. Por desgracia, 'e'Ulos rendimientos de exp(1)lo contrario podría haber librado de la 4Y2materia
Suever
Otra de esas cosas de Octave ...
Luis Mendo
4

JavaScript (ES6), 51 bytes

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 se utiliza para almacenar los dígitos reemplazados para tratar con dígitos que se refieren a otros dígitos.

Neil
fuente
`` `s => s.replace (a = / \ d / g, (c, i) => a [i] = a [i + = ~ c] || s [i])` ``
l4m2
3

Perl 5 , 34 bytes

33 bytes de código + -pbandera.

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

Pruébalo en línea!

s/\d/.../ereemplace el primer dígito por ...evaluado como código Perl. (al ...estar substr$_,-$&-1+pos,1en ese caso. substr$_,-$&-1+pos,1devuelve la subcadena de $_longitud 1en el índice -$&-1+pos, donde $&está el número que coincide y poses el índice del inicio de la coincidencia. Solo necesitamos redosi el reemplazo fue exitoso para reemplazar cada dígito. (y el resultado se imprime implícitamente gracias a -pflag).


Enfoque anterior, 47 bytes:

44 bytes de código + -Fbandera.

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

Pruébalo en línea!

Muy sencillo en realidad. -FLa bandera divide las entradas en cada carácter @F. map{...}@Fitera a través @F(es decir, cada carácter de la entrada). Si el carácter es un dígito ( /\d/), lo reemplazamos por el carácter en el índice $i-$_-1. El $ies la variable de índice actual (que mantenemos al incrementar en cada carácter visto).

Dada
fuente
3

JavaScript ES6, 61 59 bytes

Gracias @Luke por jugar 8 bytes

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

Pruébalo en línea!

fəˈnɛtɪk
fuente
x.split``también podría ser [...x], [0-9]podría ser \d, juntos ahorrando 6B
Lucas
Actualmente tiene un error en algún lugar por lo que va a arreglar eso primero
fənɛtɪk
x=>[...x].map((p,i,a)=>+p+1?a[i-1-p]:p).join``por 46 bytes
Lucas
Falla para espacios + "" da 0, lo que hace que tome el carácter anterior
fəˈnɛtɪk
x=>[...x].map((p,i,a)=>a[i]=1+p>9?a[i-1-p]:p).join``
l4m2
3

05AB1E , 27 17 bytes

vyDdiU)DRXèU`X}}J

Pruébalo en línea!

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 
Riley
fuente
2

CJam, 13 bytes

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

Demo en línea.

Esta solución utiliza la "copia de Cjam incorporada n -ésimo en la pila" operador $para implementar la decodificación. Comienza leyendo la entrada (con q) y luego recorriendo los caracteres de la cadena de entrada y volcándolos en la pila (con {}/). Sin embargo, dentro del cuerpo del bucle también duplica cada carácter después de que se ha colocado en la pila (con _) y comprueba si es un dígito buscando su posición #en la cadena "0123456789", convenientemente representada como A,s.

El resultado de esta búsqueda es el valor numérico del dígito o, si el carácter no es un dígito, -1. El )operario incrementos de valor que por uno, y $lo reemplaza con la corriente carácter a que muchos puestos por debajo de la parte superior de la pila. Finalmente, \;solo elimina la copia del carácter de entrada actual que hicimos _de la pila, ya que ya no es necesario.

Ilmari Karonen
fuente
2

Befunge-98 , 45 43 bytes

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

Pruébalo en línea!

La idea:

  1. Para cada carácter en la cadena de entrada,
    1. Escríbelo en la línea 2
    2. Si no es un número, simplemente envíelo
    3. De lo contrario, busque el valor correcto, vuelva a escribirlo y luego déle salida
::::            ; 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 ;

No pude acortar esta versión, pero esta tiene 44 bytes:

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

Pensé que lo compartiría por el buen truco con s, pero almacenar el contador en la pila conduce a esa mejora de 1 personaje.

Justin
fuente
2

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

Pruébalo en línea!

Editar: arreglado para valores ascii entre 32-47 ; Se corrigió la doble decodificación (por ejemplo, "alp2c1" a "alpaca")

adicto a las matemáticas
fuente
1
@Arnauld Nope. Lo siento, no leí las especificaciones lo suficientemente cerca. Se modificará en breve
drogadicto de matemáticas
Parece que hay un error. para 'Prog2am0in6 Puz0les7&1Cod74G4lf'su programa imprime Programming Puzzles &7Code1Golf! ¡Lo intenté con ambos enlaces TIO compartidos!
Keerthana Prabhakaran
@KeerthanaPrabhakaran ¡Gracias! ¡Arreglado a un costo de 0 bytes! (Sin embargo, mi solución alternativa no hizo el corte)
adicto a las matemáticas
¡Ese es un gran enfoque!
Keerthana Prabhakaran
¿Puedes explicar '/' <i <':'. Sé que está probando si es un número, pero ¿cómo funciona?
Matias K
2

PHP 7.1 67 59 bytes

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

Toma entrada de STDIN; ejecutar como tubería -nRo probarlo en línea .

  • _&$c=$s[$i++]recorrer la cadena ( _&$cdará como resultado algo que no es "0"; por lo tanto, el único carácter que puede romper el ciclo es la cadena vacía = final de la entrada)
  • $c^"0" alternar los bits 5 y 6 en el código ASCII
  • <"\n" compruebe si el resultado es <chr (10)
  • si es así, es un dígito: imprima el carácter anterior por índice (y copie al índice actual)
  • más imprime este personaje

Gracias @Christoph por ahorrar 12%

Titus
fuente
1
Sé que esta es una respuesta antigua, pero: ¡compensaciones de cadena negativas! (y eso $s=$argn...?)for(;_&$c=$argn[$i++];)$t.=($c^"0")<"\n"?$t[~+$c]:$c;echo$t;
Christoph
2

Vim macro / pulsaciones de teclas, 49 bytes

^M representa el carácter de retorno (0x0A, 1 byte).

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

Explicación

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
fuente
2

APL (Dyalog Classic) , 25 23 bytes

-2 bytes gracias a @FrownyFrog

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

Pruébalo en línea!

usos ⎕io←1

(a continuación representa un valor intermedio en la evaluación)

⎕d es la cuerda '0123456789'

⎕d⍳⍵encuentra los índices (basados ​​en 1 en este caso) de los caracteres de 's en ⎕d; para un no dígito el índice es 11

11|⍵ es módulo: los 11 se convierten en 0

≢⍵ es la longitud de

⍳≢⍵es 1 2 ...hasta≢⍵

entonces, (⍳≢⍵)-11|⎕d⍳⍵nos da un vector i de los índices donde deberíamos buscar para obtener los caracteres resultantes; sin embargo, algunos de esos índices pueden redirigir a otros índices (más pequeños). Para calcular el cierre transitivo (es decir, los índices efectivos), indexamos el vector en sí mismo ( ⊂⌷⊢un tren equivalente (⊂i)⌷iao i[i]) y lo repetimos hasta que se estabiliza ( ⍣≡se conoce como el operador de punto fijo ).

finalmente indexamos en la cadena original: (...)⊃¨⊂

ngn
fuente
¿Cómo se vería como un tren?
FrownyFrog
@FrownyFrog de hecho, más corto
ngn
1

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

Pruébalo en línea!

  • ¡guardado 3 bytes pero verificando ascii en lugar de es dígito! Gracias a math_junkie!
Keerthana Prabhakaran
fuente
1

Japt , 24 bytes

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

Pruébalo en línea!

Explicación:

£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
Oliver
fuente
1

Python 2 , 58 bytes

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

Esto es esencialmente un puerto de mi respuesta Jelly, más la verificación de dígitos de la respuesta Python de @ xnor.

Pruébalo en línea!

Dennis
fuente
1

JavaScript ES6, 54 bytes

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
fuente
1
Bienvenido a PPCG! Si no necesita el nombre de su función para llamadas recursivas, las funciones sin nombre son válidas, por lo que puede guardar dos bytes en el f=.
Martin Ender
1

> <> (Pez), 108 bytes (= cuadrícula 9 x 12)

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

Pruébalo aquí para ver a los peces nadando.

  • Agregue -1 a la pila de entrada y luego invierta la pila.
  • Bucle: si el valor superior es -1, finalice (hemos recorrido todos los caracteres). De otra manera:
  • Ponga el personaje superior en el registro; verifique si está en el rango "0" a "9". Si es así:
    • rotar la pila el número apropiado de lugares
    • conseguir que se señale al personaje
    • gire hacia atrás y reemplace el número con el carácter del registro
  • Salida; reanudar el bucle.
Teófilo
fuente
1

Código de máquina 8086, 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
usuario5434231
fuente
1

Japt v2.0a0, 16 bytes

r\d@=hYUgY-°X¹gY

Intentalo


Explicación

                     :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
Lanudo
fuente
1

J , 20 bytes

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

Pruébalo en línea

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

Crédito a ngn por la inspiración.

22 bytes

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

Este es un puerto de la respuesta 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.

En ambas soluciones, la versión que utiliza TIO interpreta un solo .como el número 0, por lo que la última prueba falla. Las versiones anteriores (≤7) parecen funcionar correctamente.

Pruébalo en línea!

FrownyFrog
fuente