Ce défi est créé pour célébrer mon premier langage ésotérique, le revers !

Le revers est un langage unidimensionnel avec un flux de pointeur non linéaire. Le pointeur se déplace de trois étapes à la fois, exécutant uniquement toutes les trois instructions.

Le programme 1..1..+..O..@ajoutera 1 + 1 et affichera 2 avant de se terminer. Les instructions intermédiaires sont ignorées, 1<>1()+{}O[]@tout comme le même programme.

Lorsque le pointeur est sur le point de descendre de la fin de la bande, il inverse la direction et avance dans l'autre sens, tout 1.@1.O+.comme le même programme. Notez qu'il ne compte l'instruction de fin qu'une seule fois. Cela nous permet de compresser la plupart des programmes linéaires, tels que1O+1@

Votre défi ici est d'écrire un programme ou une fonction qui prend une chaîne et de produire les instructions qui seraient exécutées si le programme était interprété comme Backhand (vous n'avez pas besoin de gérer de réelles instructions Backhand). Vous devez uniquement sortir jusqu'à ce que le pointeur atterrisse sur le dernier caractère de la chaîne (auquel cas l'exécution devrait normalement revenir en arrière).

Mais attendez , ce n'est pas tout! Lorsque votre programme lui-même est interprété de cette manière, le code résultant doit afficher l'un des éléments suivants:

• (Mostly) works
• Turing complete
• 'Recreational' (les guillemets peuvent être soit 'ou ", mais pas les deux)
• Perfectly okay
• Only a few bugs

Par exemple, si votre code source est code 2 backhand, le programme ce cankb od2ahddoit sortir l'une de ces phrases.

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

Et un programme de référence écrit, bien sûr, Backhand ( cela pourrait être un peu bogué, d' accord, je pense que je l'ai corrigé).

Règles.

• Les échappatoires standard sont interdites
• L'entrée du premier programme ne contiendra que des caractères ASCII et des sauts de ligne imprimables (c'est-à-dire des octets 0x20- 0x7Eainsi que 0x0A)
• Vous pouvez choisir si votre deuxième programme est converti à partir de votre premier octet ou par des caractères UTF-8.
• Deuxième programme:
  • La casse n'a pas d' importance, donc votre sortie pourrait l'être pErFectLy OKaysi vous le souhaitez.
  • Toute quantité d'espaces de fin / de début (nouvelle ligne, tabulations, espaces) est également correcte.
  • Le deuxième programme doit être la même langue que le premier, mais pas nécessairement le même format (programme / fonction)
  • Je suis heureux d'inclure des suggestions de commentaires sur des phrases supplémentaires (tant qu'elles ne sont pas trop courtes)
• Comme il s'agit de code-golf , votre objectif est d'obtenir la réponse la plus courte pour votre langue!
• Dans deux semaines, j'attribuerai une prime de 200 à la réponse de revers la plus courte.

R , 187 octets

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

Essayez-le en ligne!

L'espace unique à la fin est nécessaire pour que le \nne soit jamais imprimé lorsque le programme est appliqué à lui-même.

Explication

Partie 1:

Non 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
}

Partie 2:

La fonction produit ceci lorsqu'elle agit sur l'ensemble du programme:

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

Python 2 , 163 130 127 121 115 99 96 octets

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)

Essayez-le en ligne!

Les sorties:

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

Perl 6 , 101 86 octets

Wow, -25 octets grâce à nwellnhof en améliorant radicalement le premier programme

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

Essayez-le en ligne!

J'espère que plus de gens profiteront du rebond comme celui-ci. Le programme Backhanded est

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

Qui commente juste {"(Mostly) works"}.

05AB1E , 43 40 38 37 octets

-2 octets (40 → 38) grâce à @Emigna .

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

Essayez-le en ligne . (PS: basculez la langue de 05AB1E (hérité) à 05AB1E pour le cas de test 0123456789. La version héritée est plus rapide, mais elle affiche des résultats incorrects pour les entrées de nombres avec des zéros en tête.)

Le programme «en revers» deviendra:

„ÃеÝ[N© I#N#

Qui sortira perfectly okayen minuscules.

Essayez-le en ligne.

Explication du programme de 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

Explication du programme «en revers»:

„ÃÐµÝ           # 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

Pas à pas, les événements suivants se produisent:

1. „ÃеÝ: STACK devient ["perfectly okay"]
2. [: Démarrer la boucle infinie
3. (première itération de boucle) N©: STACK devient["perfectly okay", 0]
4. (première itération de boucle) I: STACK reste ["perfectly okay", 0]parce qu'il n'y a pas d'entrée
5. (première itération de boucle) #: STACK devient ["perfectly okay"]et la boucle continue
6. (première itération de boucle) N: STACK devient["perfectly okay", 0]
7. (première itération de boucle) #: STACK devient ["perfectly okay"]et la boucle continue
8. (deuxième itération de boucle) N©: STACK devient["perfectly okay", 1]
9. (deuxième itération de boucle) I: STACK reste ["perfectly okay", 1]parce qu'il n'y a pas d'entrée
10. (deuxième itération de boucle) #: STACK devient ["perfectly okay"], et la boucle se rompt à cause de 1(véridique)
11. Imprime implicitement le haut de la pile dans STDOUT: perfectly okay

Voir les étapes ici avec le débogueur sur TIO activé.

Voir cette astuce 05AB1E de la mine (section Comment utiliser le dictionnaire? ) Pour comprendre pourquoi „€€Ã€„Ѐ€µ'€Ýsont the pointed, dm oneet beenet „ÃеÝest perfectly okay.

Ancienne version de 38 octets:

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

Essayez-le en ligne . (PS: basculez la langue de 05AB1E (hérité) à 05AB1E pour les cas de test 0123456789et @. La version héritée est plus rapide, mais elle affiche des résultats incorrects pour les entrées de nombre avec des zéros en tête ou des entrées à caractère unique.)

Le programme «en revers» deviendra:

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

(Où qquitte le programme et fait tout le reste sans opération.)

Essayez-le en ligne.

Python 2 , 130 octets

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]

Essayez-le en ligne!

JavaScript (ES6), 130 octets

Tentative précoce. Pas très satisfaisant.

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)

Essayez-le en ligne!

Lorsque le code est traité par lui-même, les caractères suivants sont isolés:

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

qui donne:

f=>"Perfectly okay"//…

Gelée , 34 octets

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

Un programme complet ou un lien monadique acceptant une liste de caractères qui imprime ou donne (respectivement).

Essayez-le en ligne! Ou consultez la suite de tests .

Le code analysé par revers est alors:

Jȧ“N2s]Ỵ»ị@€

Un programme complet ou une impression de lien niladique ou donnant (respectivement) Turing complet .

Comment?

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)

le code analysé par revers est alors:

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)

Enchantements runiques , 294 octets

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

Essayez-le en ligne!

Version non compressée (et presque lisible):

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

Essayez-le en ligne!

C'est ... aussi proche que possible.

Pour le comprimer davantage, il faudrait trouver un moyen de gérer les différents points de permutation de boucle sans les faire entrer en collision avec d'autres éléments. La première ligne (qui est la seule partie qui doit être passée en entrée à elle-même) doit rester séparée: la chaîne entière ne peut pas tenir sur la deuxième ligne sans causer de problèmes ( _pour les espaces requis):

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

Cela ?ne peut pas être éloigné du !qui lui-même ne peut pas être éloigné du\ et aucun des messages autorisés n'autorise aucun de ces trois personnages à cette position.

L'alternative serait d'utiliser la redirection de flux, mais cela conduit à un problème sur la ligne inférieure:

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

Comme nous devons éviter le commutateur de boucle dans le programme principal.

Problèmes connus:

• Entrées extrêmement grandes. En raison des limites de la pile IP de Runic, le fait de pousser de très grandes chaînes d'entrée entraînera l'expiration de l'IP avant la fin. Cela peut être minimisé en générant des adresses IP supplémentaires et en les fusionnant (par exemple, il gère abcdefghijklmnopqrstuvwxyzmais pas l'intégralité de sa propre source). Et il y a une limite quel que soit le nombre de fusions. Peut gérer jusqu'à 58 octets d'entrée tels quels (en outre, l'augmentation du nombre d'adresses IP nécessite de trouver comment les fusionner sans utiliser plus d'espace). Peut contenir deux entrées IP supplémentaires sur la ligne de retour de boucle (à droite de Usur la ligne commençant \y<<dans la version non compressée, ou une à gauche sur la ligne au-dessus de y<<dans la version compressée) augmentant la longueur maximale d'entrée à 78.
• Les chaînes d'entrée avec des espaces doivent avoir des espaces échappés (par exemple 1\ \ 1\ \ +\ \ O\ \ @). Il s'agit d'une limitation de l'analyse syntaxique des entrées du langage.
• Impossible de fournir des entrées composées de chaînes qui ressemblent à des entiers commençant par un nombre quelconque de 0s (comme lorsqu'il est transformé en nombre sur la pile, le 0est perdu). Encore une fois, limitation de l'analyse syntaxique des entrées du langage.

Comment ça fonctionne

Entrée:

1. Combinez 4 pointeurs d'instructions
2. Lisez l'entrée, divisez en caractères, ajoutez une nouvelle ligne, inversez, entrez dans la boucle principale.

Boucle principale (tout ce qui éclate la pile est précédé d'un dup):

1. Imprimer le haut de la pile
2. Comparer à la nouvelle ligne. Vrai: changez de boucle et faites pivoter la pile deux fois vers la gauche.
3. Comparez avec @. Vrai: terminer. (Commande de fin exécutée)
4. Faire pivoter la pile vers la droite
5. Comparer à la nouvelle ligne. Vrai: terminer. (Commande la plus à droite exécutée)
6. Faire pivoter la pile vers la droite
7. Comparer à la nouvelle ligne. Vrai: changez de boucle et faites pivoter la pile trois fois vers la gauche.
8. Faire pivoter la pile vers la droite
9. Retour en haut de la boucle

Boucle secondaire:

• Identique à la boucle principale, seul le commutateur tourne à droite avec rotation à gauche