Questa sfida è stata creata per celebrare il mio primo linguaggio esoterico, Backhand !

Il rovescio è un linguaggio unidimensionale con un flusso di puntatore non lineare. Il puntatore si sposta di tre passaggi alla volta, eseguendo solo ogni terza istruzione.

Il programma 1..1..+..O..@aggiungerà 1 + 1 e l'uscita 2 prima di terminare. Le istruzioni intermedie vengono saltate, quindi 1<>1()+{}O[]@è esattamente lo stesso programma.

Quando il puntatore sta per uscire dalla fine del nastro, inverte invece la direzione e si sposta dall'altra parte, così 1.@1.O+.è lo stesso programma. Nota che conta l'istruzione finale una sola volta. Questo ci consente di comprimere la maggior parte dei programmi lineari, come ad esempio1O+1@

La tua sfida qui è scrivere un programma o una funzione che prendano una stringa e produrre le istruzioni che verrebbero eseguite se il programma fosse interpretato come Backhand (non è necessario gestire alcuna istruzione Backhand effettiva). Devi solo emettere fino a quando il puntatore non si ferma sull'ultimo carattere della stringa (a quel punto l'esecuzione normalmente andrebbe indietro).

Ma aspetta , non è tutto! Quando il programma stesso viene interpretato in questo modo, il codice risultante dovrebbe generare uno dei seguenti:

• (Mostly) works
• Turing complete
• 'Recreational' (le virgolette possono essere o 'o ", ma non entrambe)
• Perfectly okay
• Only a few bugs

Ad esempio, se il codice sorgente è code 2 backhand, il programma ce cankb od2ahddovrebbe generare una di queste frasi.

Casi test:

"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 un programma di riferimento scritto in Backhand ( questo potrebbe essere un po 'difettoso Okay, penso di averlo corretto).

Regole.

• Sono vietate le scappatoie standard
• L'input del primo programma conterrà solo ASCII e newline stampabili (ovvero byte 0x20- 0x7Eoltre a 0x0A)
• Puoi scegliere se convertire il tuo secondo programma dal tuo primo byte o byte UTF-8.
• Secondo programma:
  • Il caso non ha importanza, quindi l'output potrebbe essere pErFectLy OKayse lo desideri.
  • Anche qualsiasi quantità di spazio bianco finale / iniziale (newline, tab, spazi) va bene.
  • Il secondo programma dovrebbe avere la stessa lingua del primo, sebbene non necessariamente lo stesso formato (programma / funzione)
  • Sono felice di includere suggerimenti dai commenti su frasi extra (purché non siano troppo brevi)
• Poiché si tratta di code-golf , il tuo obiettivo è quello di ottenere la risposta più breve per la tua lingua!
• Tra due settimane, assegnerò un premio di 200 alla risposta più corta al rovescio.

R , 187 byte

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

Provalo online!

Lo spazio singolo alla fine è necessario in modo che \nnon venga mai stampato quando il programma viene applicato a se stesso.

Spiegazione

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:

La funzione produce questo quando agisce sull'intero programma:

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

Pitone 2 , 163 130 127 121 115 99 96 byte

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)

Provalo online!

Uscite:

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

Perl 6 , 101 86 byte

Caspita, -25 byte grazie a nwellnhof migliorando drasticamente il primo programma

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

Provalo online!

Spero che più persone traggano vantaggio dal rimbalzo in questo modo. Il programma Backhanded è

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

Che commenta solo {"(Mostly) works"}.

05AB1E , 43 40 38 37 byte

-2 byte (40 → 38) grazie a @Emigna .

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

Provalo online . (PS: cambia la lingua da 05AB1E (legacy) a 05AB1E per il test case 0123456789. La versione legacy è più veloce, ma mostra risultati errati per input numerici con zeri iniziali.)

Il programma "rovescio" diventerà:

„ÃеÝ[N© I#N#

Che produrrà perfectly okayin minuscolo.

Provalo online.

Spiegazione del programma di 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

Spiegazione del programma "rovescio":

„ÃÐµÝ           # 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 dopo passo si verifica quanto segue:

1. „ÃеÝ: STACK diventa ["perfectly okay"]
2. [: Avvia un ciclo infinito
3. (prima ripetizione del ciclo) N©: STACK diventa["perfectly okay", 0]
4. (iterazione del primo loop) I: STACK rimane ["perfectly okay", 0]perché non c'è input
5. (prima ripetizione del ciclo) #: STACK diventa ["perfectly okay"]e il ciclo continua
6. (prima ripetizione del ciclo) N: STACK diventa["perfectly okay", 0]
7. (prima ripetizione del ciclo) #: STACK diventa ["perfectly okay"]e il ciclo continua
8. (iterazione del secondo ciclo) N©: STACK diventa["perfectly okay", 1]
9. (iterazione del secondo loop) I: STACK rimane ["perfectly okay", 1]perché non c'è input
10. (iterazione del secondo ciclo) #: STACK diventa ["perfectly okay"]e il ciclo si interrompe a causa della 1(verità)
11. Stampa implicitamente la parte superiore dello stack su STDOUT: perfectly okay

Vedere i passaggi qui con il debugger su TIO abilitato.

Vedere questo suggerimento 05AB1E mio (sezione Come utilizzare il dizionario? ) Per capire il motivo per cui „€€Ã€„Ѐ€µ'€Ýsono the pointed, dm onee beened „ÃеÝè perfectly okay.

Vecchia versione a 38 byte:

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

Provalo online . (PS: cambia la lingua da 05AB1E (legacy) a 05AB1E per i casi di test 0123456789e @. La versione legacy è più veloce, ma mostra risultati errati per input numerici con zeri iniziali o input a carattere singolo.)

Il programma "rovescio" diventerà:

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

(Dove qesce il programma e rende tutto il resto non operativo.)

Provalo online.

Python 2 , 130 byte

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]

Provalo online!

JavaScript (ES6), 130 byte

Tentativo precoce. Non molto soddisfacente.

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)

Provalo online!

Quando il codice viene elaborato da solo, i seguenti caratteri vengono isolati:

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

che dà:

f=>"Perfectly okay"//…

Gelatina , 34 byte

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

Un programma completo o un collegamento monadico che accetta un elenco di caratteri che stampa o restituisce (rispettivamente).

Provalo online! Oppure vedi la suite di test .

Il codice analizzato a rovescio è quindi:

Jȧ“N2s]Ỵ»ị@€

Un programma completo o un collegamento niladico che stampa o cede (rispettivamente) Turing completato .

Come?

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)

il codice analizzato a rovescio è quindi:

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)

Incantesimi runici , 294 byte

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

Provalo online!

Versione non compressa (e quasi leggibile):

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

Provalo online!

Questo ... è il più vicino possibile.

Comprimerlo ulteriormente richiederebbe un modo per gestire i vari punti di scambio loop senza farli scontrare con altre cose. La prima riga (che è l'unica parte deve essere passata come input a se stessa) deve rimanere separata: l'intera stringa non può adattarsi alla seconda riga senza causare problemi ( _per gli spazi richiesti):

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

Questo ?non può essere allontanato dal !quale di per sé non può essere allontanato dal\ e nessuno dei messaggi consentiti consente uno di questi tre caratteri in questa posizione.

L'alternativa sarebbe utilizzare il reindirizzamento del flusso, ma ciò porta a un problema nella riga inferiore:

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

Come dobbiamo evitare l'interruttore di loop nel programma principale.

Problemi noti:

• Ingressi estremamente grandi. A causa dei limiti dello stack IP di Runic, spingendo stringhe di input molto grandi, l'IP scadrà prima del completamento. Ciò può essere ridotto al minimo generando ulteriori IP e unendoli (ad esempio, gestisce abcdefghijklmnopqrstuvwxyzma non l'intera fonte). E c'è un limite indipendentemente da quante fusioni si verificano. Può gestire fino a 58 byte di input così com'è (inoltre, per aumentare il numero di IP è necessario capire come farli unire senza utilizzare più spazio). Può contenere altre due voci IP sulla linea loop-return (a destra della Ulinea che inizia \y<<nella versione non compressa o una a sinistra sulla linea sopra la y<<nella versione compressa) aumentando la lunghezza massima di ingresso a 78.
• Le stringhe di input con spazi devono avere gli spazi di escape (ad es 1\ \ 1\ \ +\ \ O\ \ @.). Questa è una limitazione dell'analisi dell'input della lingua.
• Non è possibile fornire input costituiti da stringhe che sembrano numeri interi che iniziano con un numero qualsiasi di 0s (come quando si trasforma in un numero nello stack, 0viene perso). Ancora una volta, limitazione dell'analisi dell'input della lingua.

Come funziona

Iscrizione:

1. Combina 4 puntatori di istruzioni
2. Leggere l'input, dividere i caratteri, aggiungere una nuova riga, invertire, inserire il ciclo principale.

Ciclo principale (tutto ciò che apre lo stack è preceduto da un dup):

1. Stampa la parte superiore della pila
2. Confronta con newline. Vero: cambia loop e ruota lo stack a sinistra due volte.
3. Paragonare a @ . Vero: termina. (Termina comando eseguito)
4. Ruota la pila a destra
5. Confronta con newline. Vero: termina. (Comando più a destra eseguito)
6. Ruota la pila a destra
7. Confronta con newline. Vero: cambia loop e ruota lo stack a sinistra tre volte.
8. Ruota la pila a destra
9. Ritorna all'inizio del ciclo

Circuito secondario:

• Identico al circuito principale, solo l'interruttore ruota a destra con ruota a sinistra