Este desafío se crea para celebrar mi primer lenguaje esotérico, ¡ Revés !

El revés es un lenguaje unidimensional con un flujo de puntero no lineal. El puntero se mueve tres pasos a la vez, solo ejecuta cada tercera instrucción.

El programa 1..1..+..O..@agregará 1 + 1 y la salida 2 antes de finalizar. Se omiten las instrucciones intermedias, así que1<>1()+{}O[]@ es exactamente el mismo programa.

Cuando el puntero está a punto de salir del final de la cinta, en su lugar invierte la dirección y avanza hacia el otro lado, por lo que 1.@1.O+. es el mismo programa. Tenga en cuenta que solo cuenta la instrucción final una vez. Esto nos permite comprimir la mayoría de los programas lineales, como1O+1@

Su desafío aquí es escribir un programa o función que tome una cadena y muestre las instrucciones que se ejecutarían si el programa se interpretara como Revés (no necesita manejar ninguna instrucción real de Revés). Solo debe generar hasta que el puntero caiga en el último carácter de la cadena (en cuyo punto la ejecución normalmente iría hacia atrás).

¡Pero espera , eso no es todo! Cuando su propio programa se interpreta de esta manera, el código resultante debería generar uno de los siguientes:

• (Mostly) works
• Turing complete
• 'Recreational' (las comillas pueden ser 'o ", pero no ambas)
• Perfectly okay
• Only a few bugs

Por ejemplo, si su código fuente es code 2 backhand, entonces el programace cankb od2ahd debería generar una de estas frases.

Casos de prueba:

"1  1  +  O  @"  -> "11+O@"
"1O+1@"          -> "11+O@"
"HoreWll dlo!"   -> "Hello World!"
"abcdefghijklmnopqrstuvwxyz" -> "adgjmpsvyxurolifcbehknqtwz"
"0123456789"     -> "0369"  (not "0369630369")
"@"              -> "@"
"io"             -> "io"  (Cat program in Backhand)
"!?O"            -> "!?O" (Outputs random bits forever in Backhand)
"---!---!"       -> "-!-----!"

Y un programa de referencia escrito en, por supuesto, Revés ( esto podría ser un poco defectuoso Ok, creo que lo he solucionado).

Reglas.

• Las lagunas estándar están prohibidas
• La entrada del primer programa contendrá solo ASCII imprimible y nuevas líneas (es decir, bytes 0x20, 0x7Easí como 0x0A)
• Puede elegir si su segundo programa se convierte del primero en bytes o en caracteres UTF-8.
• Segundo programa:
  • El caso no importa, por lo que su salida podría ser pErFectLy OKaysi lo desea.
  • Cualquier cantidad de espacios en blanco al inicio / final (nueva línea, tabulaciones, espacios) también está bien.
  • El segundo programa debe ser el mismo idioma que el primero, aunque no necesariamente el mismo formato (programa / función)
  • Me complace incluir sugerencias de los comentarios sobre frases adicionales (siempre que no sean demasiado cortas)
• Como se trata de código de golf , ¡su objetivo es obtener la respuesta más breve para su idioma!
• En dos semanas, otorgaré una recompensa de 200 a la respuesta de revés más corta.

R , 187 bytes

 # c  a  t  (  '  P  e  r  f  e  c  t  l  y     o  k  a  y  '  )  #
g=function(x,n=nchar(x),i=c(1:n,(n-1):1,2:n),j=seq(1,3*n-2,3),k=i[j][1:which(i[j]==n)[1]])cat(substring(x,k,k),sep='') 

Pruébalo en línea!

El espacio único al final es necesario para que \nnunca se imprima cuando el programa se aplica a sí mismo.

Explicación

Parte 1:

Sin golf:

 # c  a  t  (  '  P  e  r  f  e  c  t  l  y     o  k  a  y  '  )  #
g <- function(x) {
  n <- nchar(x)                      # number of characters in string
  i <- c(1:n, (n - 1):1, 2:n)        # index: 1 to n, n-1 back to 1, 2 to n
  j <- seq(1, 3 * n - 2, 3)          # every third element of i
  k <- i[j][1:which(i[j] == n)[1]]   # the elements of i at indices j, up to the first appearance of n
  cat(substring(x, k, k), sep = "")  # extract from x the characters at indices k, and paste them together
}

Parte 2:

La función produce esto cuando actúa en todo el programa:

cat('Perfectly okay')#=ni(ncr)=1,-:2)=q,n,,i]:i(j=[]assi(k)e' 

Python 2 , 163 130 127 121 115 99 96 bytes

i=input() ###
print(i+i[-2:0:-1]+i)[:len(i)*(len(i)%3%2or 3):3]  

#'p lr+yi  n'ottk(ca'eyPf'er)

Pruébalo en línea!

Salidas:

int #rt+-01i:n)l(%2 : 
print('Perfect' + # 33o3ie*(l)]:2i(i
#(p=iu)#pni[:-+[ei(n)%r)]
'ly okay')

Perl 6 , 101 86 bytes

Wow, -25 bytes gracias a nwellnhof al mejorar drásticamente el primer programa

##
{S:g/(.).?.?/$0/}o{.comb%3-1??.chop~.flip~S/.//!!$_} #
#}{ "" s( kM ro os wt  l )y.

Pruébalo en línea!

Espero que más personas aprovechen el rebote de esta manera. El programa Backhanded es

#{g.?//{o%1.o.iS/!}
{"(Mostly) works"}#_!.~l~h?-bco0?.(:
#S/).$}.m3?cpfp//$ #        .

Lo que comenta solo {"(Mostly) works"}.

05AB1E , 43 40 38 37 bytes

-2 bytes (40 → 38) gracias a @Emigna .

„€€Ã€„Ѐ€µ'€Ý)\[ûDN3*©è  ?®IgD#<ÖNĀ*#

Pruébalo en línea . (PD: cambie el idioma de 05AB1E (heredado) a 05AB1E para el caso de prueba 0123456789. La versión heredada es más rápida, pero muestra resultados incorrectos para entradas numéricas con ceros a la izquierda).

El programa 'backhanded' se convertirá en:

„ÃеÝ[N© I#N#

Lo que saldrá perfectly okayen minúscula completa.

Pruébalo en línea.

Explicación del programa base:

„€€Ã€           # Push the string "the pointed"
„Ѐ€µ           # Push the string "dm one"
'€Ý            '# Push the string "been"
     )          # Wrap the entire stack in a list
      \         # And remove that list from the stack again
[               # Start an infinite loop
 û              #  Palindromize the string at the top of the stack
                #   i.e. "1O+1@" becomes "1O+1@1+O1" the first iteration,
                #        and "1O+1@1+O1O+1@1+O1" the next iteration, etc.
  D             #  Duplicate the palindromized string
 N3*            #  0-indexed index of the loop multiplied by 3
    ©           #  Save it in the register (without popping)
     è?         #  Index into the string and print the character
  Ig            #  If the length of the input is exactly 1:
     #          #   Stop the infinite loop
 ®  D <Ö        #  If the value from the register is divisible by the length - 1
          *     #  And
        NĀ      #  The 0-indexed index of the loop is NOT 0:
           #    #   Stop the infinite loop

Explicación del programa 'backhanded':

„ÃÐµÝ           # Push the string "perfectly okay"
     [          # Start an infinite loop
      N©        #  Push the index, and store it in the register (without popping)
          I     #  Push the input (none given, so nothing happens)
           #    #  If the top of the stack is 1, stop the infinite loop
            N   #  Push the index again
             #  #  If the top of the stack is 1, stop the infinite loop

Paso a paso sucede lo siguiente:

1. „ÃеÝ: STACK se convierte ["perfectly okay"]
2. [: Iniciar bucle infinito
3. (primera iteración del bucle) N©: STACK se convierte["perfectly okay", 0]
4. (primera iteración del bucle) I: STACK permanece ["perfectly okay", 0]porque no hay entrada
5. (primera iteración del bucle) #: STACK se convierte ["perfectly okay"]y el bucle continúa
6. (primera iteración del bucle) N: STACK se convierte["perfectly okay", 0]
7. (primera iteración del bucle) #: STACK se convierte ["perfectly okay"]y el bucle continúa
8. (segunda iteración del bucle) N©: STACK se convierte["perfectly okay", 1]
9. (segunda iteración del bucle) I: STACK permanece ["perfectly okay", 1]porque no hay entrada
10. (segunda iteración del bucle) #: STACK se convierte ["perfectly okay"]y el bucle se rompe debido a la 1(verdad)
11. Imprime implícitamente la parte superior de la pila en STDOUT: perfectly okay

Vea los pasos aquí con el depurador en TIO habilitado.

Ver este consejo 05AB1E mío (sección Cómo usar el diccionario? ) Para entender por qué „€€Ã€„Ѐ€µ'€Ýson the pointed, dm oney beene „ÃеÝes perfectly okay.

Versión antigua de 38 bytes:

„€€Ã€„Ѐ€µ'€Ý)\ giqë¬?[ûDN>3*©è?®Ig<Ö#

Pruébalo en línea . (PD: cambie el idioma de 05AB1E (heredado) a 05AB1E para casos de prueba 0123456789y @. La versión heredada es más rápida, pero muestra resultados incorrectos para entradas numéricas con ceros iniciales o entradas de un solo carácter).

El programa 'backhanded' se convertirá en:

„ÃÐµÝ q?D3èIÖ<®©>û¬i\€€„€€€€')gë[N*?g#

(Donde qsale del programa y hace que todo lo demás no funcione).

Pruébalo en línea.

Python 2 , 130 bytes

p='r'#i  n  t  '  P  e  r  f  e  c  t  l  y     o  k  a  y  '  # 
s=input();S=s+s[-2:0:-1]+s
print S[:len(~-len(s)%3and S or s):3]

Pruébalo en línea!

JavaScript (ES6), 130 bytes

Intento temprano No muy satisfactorio

f  =/*>  "  P  e  r  f  e  c  t  l  y     o  k  a*/y=>""+/**/(g=p=>(c=y[p])?m++%3?g(p+d):y[p+1]?c+g(p+d):c:g(p-d-d,d=-d))(m=0,d=1)

Pruébalo en línea!

Cuando el código se procesa solo, se aíslan los siguientes caracteres:

f  =/*>  "  P  e  r  f  e  c  t  l  y     o  k  a*/y=>""+/**/…
^  ^  ^  ^  ^  ^  ^  ^  ^  ^  ^  ^  ^  ^  ^  ^  ^  ^  ^  ^  ^

lo que da:

f=>"Perfectly okay"//…

Jalea , 34 bytes

JŒḄȧ`ȯ“”NNŒḄ2¡3s@”]ȧZỴḢḢ»`Qị⁸ȧ@11€

Un programa completo o enlace monádico que acepta una lista de caracteres que imprime o produce (respectivamente).

Pruébalo en línea! O vea el conjunto de pruebas .

El código analizado de revés es entonces:

Jȧ“N2s]Ỵ»ị@€

Un programa completo o un enlace niladic imprimiendo o produciendo (respectivamente) Turing completo .

¿Cómo?

JŒḄȧ`ȯ“”NNŒḄ2¡3s@”]ȧZỴḢḢ»`Qị⁸ȧ@11€ - Main Link: list of characters   e.g. 'abcd'
J                                  - range of length                      [1,2,3,4]
 ŒḄ                                - bounce                         [1,2,3,4,3,2,1]
    `                              - use as both arguments of:
   ȧ                               -   logical AND [x AND x = x]
      “”                           - literal empty list of characters
     ȯ                             - logical OR [when x is truthy: x OR y = x]
        N                          - negate  }
         N                         - negate  } together a no-op
             ¡                     - repeat this...
            2                      - ... two times:
          ŒḄ                       -   bounce                       [1,2,3,4,3,2,1,2,3,4,3,2,1,2,3,4,3,2,1,2,3,4,3,2,1]
              3                    - literal three
               s@                  - split into (threes)            [[1,2,3],[4,3,2],[1,2,3],[4,3,2],[1,2,3],[4,3,2],[1,2,3],[4,3,2],[1]]
                 ”]                - literal ']' character
                   ȧ               - logical AND [']' is truthy so a no-op]
                    Z              - transpose                      [[1,4,1,4,1,4,1,4,1],[2,3,2,3,2,3,2,3],[3,2,3,2,3,2,3,2]]
                     Ỵ             - split at new lines [no newline characters exist in this list of ints so effectively wrap in a list]
                      Ḣ            - head [undo that wrap]
                       Ḣ           - head [get the first of the transposed split indices]
                                   -                                [1,4,1,4,1,4,1,4,1]
                         `         - use as both arguments of:
                        »          -   maximum [max(x, x) = x]
                          Q        - de-duplicate                   [1,4]
                            ⁸      - chain's left argument (the input)
                           ị       - index into it                  "ad"
                               11€ - literal eleven for €ach (of input)
                             ȧ@    - logical AND with swapped args [[11,11,...,11] is truthy]
                                   -                                "ad"
                                   - (as a full program implicit print)

el código analizado de revés es entonces:

Jȧ“N2s]Ỵ»ị@€ - Main Link: no arguments
J            - range of length (of an implicit 0, treated as [0]) -> [1]
  “N2s]Ỵ»    - compression of "Turing complete"
 ȧ           - logical AND [[1] is truthy] -> "Turing complete"
           € - for each character in the list of characters:
          @  -   with swapped arguments (an implicit 0 is on the right, so f(0, "Turing complete"))
         ị   -     index into
             - (as a full program implicit print)

Encantamientos rúnicos , 294 bytes

>; "  O  n  l  y     a     F  e  w     B  u  g  s  "  @
                                  /{\!?   =ka:{;!?=ka\
v   R                         R {{R:ak=?!\:$:'@=?!;{:/
v/?!/:$:'@=?!;}:ak= ?!;}:ak=?!\}\        }
y\=ka:L                      }{ /        }
\iuakrU      y<<              !  }}}L {{{L

Pruébalo en línea!

Versión sin comprimir (y casi legible):

>; "  O  n  l  y     a     F  e  w     B  u  g  s  "  @
                               ;           /                                 \
/y<<         R                         R {{R:ak=?!\:$:'@=?!;{:ak=?!\{:ak=?!\{/
RiuakrR:ak=?!/:$:'@=?!;}:ak= ?!/}:ak=?!\}\        }                ;
\y<<  U                               }{ /        }
      \                                !          L                     }}}L

Pruébalo en línea!

Esto ... es lo más cerca que puedo llegar.

Comprimirlo aún más requeriría encontrar una manera de manejar los diversos puntos de intercambio de bucles sin que colisionen con otras cosas. Se requiere que la primera línea (que es la única parte que se debe pasar como entrada a sí misma) permanezca separada: la cadena completa no puede caber en la segunda línea sin causar problemas ( _para los espacios requeridos):

Needed string:
>; "  O  n  l  y  _  a  _  F  e  w  _  B  u  g  s
Best fit:
>; "  O  n  l  y  _  a  _  F  e  w/{_\!?   =ka:{;!?=ka\
Collision:                             ↑

Eso ?no se puede alejar de lo !que en sí mismo no se puede alejar de \y ninguno de los mensajes permitidos permite ninguno de estos tres caracteres en esta posición.

La alternativa sería utilizar la redirección de flujo, pero eso lleva a un problema en la línea inferior:

Last usable character:
            ↓
>"Only a Few Bugs"@
/.../
ur         }{L
              ↑
Earliest available free space:

Como tenemos que evitar el cambio de bucle en el programa principal.

Problemas conocidos:

• Entradas extremadamente grandes. Debido a los límites de la pila de IP de Runic, presionar cadenas de entrada muy grandes hará que la IP caduque antes de completarse. Esto puede minimizarse generando direcciones IP adicionales y fusionándolas (por ejemplo, maneja abcdefghijklmnopqrstuvwxyzpero no la totalidad de su propia fuente). Y hay un límite independientemente de cuántas fusiones ocurran. Puede manejar hasta 58 bytes de entrada tal como está (además, aumentar la cantidad de IP requiere descubrir cómo fusionarlas sin usar más espacio). Puede caber dos entradas IP más en la línea de retorno de bucle (a la derecha del Uinicio de la línea\y<< en la versión sin comprimir, o una izquierda en la línea sobre ely<< versión comprimida) elevando la longitud máxima de entrada a 78.
• Las cadenas de entrada con espacios deben tener los espacios escapados (p. Ej. 1\ \ 1\ \ +\ \ O\ \ @ ). Esta es una limitación del análisis de entrada del idioma.
• No se pueden suministrar entradas que consisten en cadenas que parecen números enteros que comienzan con cualquier número de 0s (como cuando se convierte en un número en la pila, 0se pierde). Nuevamente, limitación del análisis de entrada del idioma.

Cómo funciona

Entrada:

1. Combina 4 punteros de instrucciones
2. Lea la entrada, divida en caracteres, agregue una nueva línea, invierta, ingrese el bucle principal.

Bucle principal (todo lo que aparece en la pila está precedido por un dup):

1. Imprime la parte superior de la pila
2. Comparar con nueva línea. Verdadero: cambie los bucles y gire la pila hacia la izquierda dos veces.
3. Comparar a @. Verdadero: terminar. (Terminar comando ejecutado)
4. Girar la pila hacia la derecha
5. Comparar con nueva línea. Verdadero: terminar. (Comando más a la derecha ejecutado)
6. Girar la pila hacia la derecha
7. Comparar con nueva línea. Verdadero: cambie los bucles y gire la pila tres veces a la izquierda.
8. Girar la pila hacia la derecha
9. Regresar al inicio del ciclo

Bucle secundario:

• Idéntico al bucle principal, solo cambie la rotación a la derecha con la rotación a la izquierda