Este desafio é criado em comemoração à minha primeira língua esotérica, Backhand !

O backhand é uma linguagem unidimensional com um fluxo de ponteiro não linear. O ponteiro move três etapas por vez, executando apenas a terceira instrução.

O programa 1..1..+..O..@adicionará 1 + 1 e a saída 2 antes de terminar. As instruções intermediárias são ignoradas, portanto, 1<>1()+{}O[]@é exatamente o mesmo programa.

Quando o ponteiro está prestes a sair do final da fita, ele inverte a direção e avança para o outro lado, assim [email protected]+.como o mesmo programa. Note que conta apenas a instrução final uma vez. Isso nos permite comprimir a maioria dos programas lineares, como1O+1@

Seu desafio aqui é escrever um programa ou função que use uma string e emitir as instruções que seriam executadas se o programa fosse interpretado como Backhand (você não precisa manipular nenhuma instrução real de Backhand). Você deve produzir apenas até que o ponteiro apareça no último caractere da string (nesse ponto a execução normalmente retornaria).

Mas espere , isso não é tudo! Quando o seu próprio programa é interpretado dessa maneira, o código resultante deve gerar um dos itens abaixo:

• (Mostly) works
• Turing complete
• 'Recreational' (as aspas podem ser 'ou ", mas não as duas)
• Perfectly okay
• Only a few bugs

Por exemplo, se o seu código-fonte for code 2 backhand, o programa ce cankb od2ahddeve exibir uma dessas frases.

Casos de teste:

"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)
"---!---!"       -> "-!-----!"

E um programa de referência escrito, é claro, Backhand ( isso pode ser um pouco complicado) Ok, acho que o corrigi).

Regras.

• As brechas padrão são proibidas
• A entrada do primeiro programa conterá apenas ASCII e novas linhas imprimíveis (ou seja, bytes 0x20- 0x7Ealém de 0x0A)
• Você pode escolher se o seu segundo programa é convertido do primeiro por bytes ou por caracteres UTF-8.
• Segundo programa:
  • O case não importa, portanto, sua saída pode ser pErFectLy OKayse você desejar.
  • Qualquer quantidade de espaço em branco à direita / à esquerda (nova linha, guias, espaços) também é aceitável.
  • O segundo programa deve ter o mesmo idioma que o primeiro, embora não necessariamente o mesmo formato (programa / função)
  • É um prazer incluir sugestões dos comentários sobre frases extras (desde que não sejam muito curtas)
• Como se trata de código-golfe , seu objetivo é obter a resposta mais curta para o seu idioma!
• Em duas semanas, concederei uma recompensa de 200 à resposta mais curta do Backhand.

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='') 

Experimente online!

O espaço único no final é necessário para que \nnunca seja impresso quando o programa é aplicado a si próprio.

Explicação

Parte 1:

Ungolfed:

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

A função produz isso quando atua em todo o 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)

Experimente online!

Saídas:

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

Uau, -25 bytes graças ao nwellnhof, melhorando drasticamente o primeiro programa

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

Experimente online!

Espero que mais pessoas aproveitem a recuperação assim. O programa Backhanded é

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

Que comenta apenas {"(Mostly) works"}.

05AB1E , 43 40 38 37 bytes

-2 bytes (40 → 38) graças a @Emigna .

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

Experimente online . (PS: alterne o idioma de 05AB1E (herdado) para 05AB1E para caso de teste 0123456789. A versão herdada é mais rápida, mas mostra resultados incorretos para entradas numéricas com zeros à esquerda.)

O programa 'backhanded' se tornará:

„ÃеÝ[N© I#N#

Qual será a saída perfectly okayem minúsculas completa.

Experimente online.

Programa base de explicação:

„€€Ã€           # 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

Programa de explicações '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

Passo a passo, acontece o seguinte:

1. „ÃеÝ: STACK torna-se ["perfectly okay"]
2. [: Iniciar loop infinito
3. (iteração do primeiro loop) N©: STACK torna-se["perfectly okay", 0]
4. (iteração do primeiro loop) I: STACK permanece ["perfectly okay", 0]porque não há entrada
5. (primeira iteração do loop) #: STACK se torna ["perfectly okay"]e o loop continua
6. (iteração do primeiro loop) N: STACK torna-se["perfectly okay", 0]
7. (primeira iteração do loop) #: STACK se torna ["perfectly okay"]e o loop continua
8. (iteração do segundo loop) N©: STACK torna-se["perfectly okay", 1]
9. (segunda iteração do loop) I: STACK permanece ["perfectly okay", 1]porque não há entrada
10. (segunda iteração do loop) #: STACK se torna ["perfectly okay"]e o loop é interrompido devido a 1(verdade)
11. Imprime implicitamente a parte superior da pilha em STDOUT: perfectly okay

Veja as etapas aqui com o depurador no TIO ativado.

Veja esta dica 05AB1E meu (seção Como usar o dicionário? ) Para entender por que „€€Ã€„Ѐ€µ'€Ýsão the pointed, dm onee, beene „ÃеÝé perfectly okay.

Versão antiga de 38 bytes:

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

Experimente online . (PS: alterne o idioma de 05AB1E (herdado) para 05AB1E para casos de teste 0123456789e @. A versão herdada é mais rápida, mas mostra resultados incorretos para entradas de número com zeros à esquerda ou entradas de caractere único.)

O programa 'backhanded' se tornará:

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

(Onde qsai do programa e faz todo o resto não funcionar.)

Experimente online.

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]

Experimente online!

JavaScript (ES6), 130 bytes

Tentativa precoce. Não é muito satisfatório.

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)

Experimente online!

Quando o código é processado por si só, os seguintes caracteres são isolados:

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

que dá:

f=>"Perfectly okay"//…

Geléia , 34 bytes

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

Um programa completo ou link monádico que aceita uma lista de caracteres que imprime ou produz (respectivamente).

Experimente online! Ou veja a suíte de testes .

O código analisado com backhand é então:

Jȧ“N2s]Ỵ»ị@€

Um programa completo ou link niládico imprimindo ou produzindo (respectivamente) Turing completo .

Quão?

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)

o código analisado em retrocesso é então:

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)

Encantos 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

Experimente online!

Versão não compactada (e quase legível):

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

Experimente Online!

Isso é o mais perto que posso chegar.

A compressão adicional exigiria descobrir uma maneira de lidar com os vários pontos de troca de loop sem que eles colidissem com outras coisas. A primeira linha (que é a única parte que precisa ser passada como entrada para si mesma) é requerida para permanecer separada: a sequência inteira não pode caber na segunda linha sem causar problemas ( _para os espaços necessários):

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

Isso ?não pode ser movido para longe do !qual ele próprio não pode ser movido para fora \e nenhuma das mensagens permitidas permite que nenhum desses três caracteres esteja nessa posição.

A alternativa seria usar o redirecionamento de fluxo, mas isso leva a um problema na linha inferior:

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

Como temos que evitar a troca de loop no programa principal.

Problemas conhecidos:

• Insumos extremamente grandes. Devido aos limites da pilha IP da Runic, pressionar cadeias de entrada muito grandes fará com que o IP expire antes de concluir. Isso pode ser minimizado gerando IPs adicionais e mesclando-os (por exemplo, ele manipula, abcdefghijklmnopqrstuvwxyzmas não a totalidade de sua própria fonte). E há um limite, independentemente de quantas mesclagens ocorrerem. Pode lidar com até 58 bytes de entrada como está (além disso, aumentar o número de IPs exige descobrir como fazer a mesclagem sem usar mais espaço). Pode caber mais duas entradas IP na linha de retorno de loop (à direita da Ulinha iniciando \y<<na versão descompactada ou uma esquerda na linha acima da y<<na versão compactada) aumentando o comprimento máximo de entrada para 78.
• Seqüências de entrada com espaços precisam ter espaços vazios (por exemplo 1\ \ 1\ \ +\ \ O\ \ @). Essa é uma limitação da análise de entrada do idioma.
• Não é possível fornecer entradas que consistem em seqüências de caracteres que se parecem com números inteiros começando com qualquer número de 0s (como quando se transforma em um número na pilha, o valor 0é perdido). Mais uma vez, limitação da análise de entrada do idioma.

Como funciona

Entrada:

1. Combine 4 indicadores de instruções
2. Leia a entrada, divida em caracteres, adicione uma nova linha, inverta, insira o loop principal.

Loop principal (qualquer coisa que apareça na pilha é precedida por um dup):

1. Imprimir a parte superior da pilha
2. Compare com a nova linha. Verdadeiro: alterne loops e gire a pilha para a esquerda duas vezes.
3. Compare com @. Verdadeiro: finalize. (Comando Terminar executado)
4. Girar a pilha para a direita
5. Compare com a nova linha. Verdadeiro: finalize. (Comando mais à direita executado)
6. Girar a pilha para a direita
7. Compare com a nova linha. Verdadeiro: alterne loops e gire a pilha três vezes para a esquerda.
8. Girar a pilha para a direita
9. Voltar ao topo do loop

Loop secundário:

• Idêntico ao loop principal, alterne apenas para a direita e para a esquerda