Quine / Reverse Quine

26

Écrivez un programme complet qui prend une entrée entière booléenne ou non négative. Il doit:

  • Produire son propre code source si la valeur d'entrée est fausse
  • Sortir son propre code source à l'envers si la valeur d'entrée est véridique

Votre programme ne peut pas être palindromique, ni lire son propre code source par aucun moyen.

C'est le code golf - le code le plus court en octets gagne.

code-golf  quine 
— Luc
source
6
Donc ... si ma langue n'a pas de booléens. Mais 0 est faux et les entiers positifs sont vrais. Puis-je supposer que l'entrée ne sera que 0 ou 1 (en tant que remplaçants pour les booléens - la langue donnera en fait toujours l'un de ces deux à la suite d'un opérateur conditionnel)? Ou dois-je prendre en charge des entiers, car je ne peux pas utiliser de booléens "réels"?
— Martin Ender

Réponses:

9

Gol> <> , 9 octets

'rd3*I?rH

Je me sens un peu gêné de poster ceci, car nous avons déjà des réponses> <>, Vitsy et Minkolang. Les seuls ajouts au quine standard sont I(lire l'entrée entière), ?(exécuter ensuite si vrai) et r(pile inverse).

Essayez-le en ligne .

— Sp3000
source
Joindre le club! : D Vous gagnez de toute façon. +1
— Addison Crump
1
8 octets:sP#Hr?I"
— Jo King
18

CJam, 17 16 octets

{`"_~"+Wq~g#%}_~

Testez-le ici.

Une modification assez simple du quine standard. Autres solutions pour 17 octets:

{`"_~"+q~{W%}&}_~
{`"_~"+q~!2*(%}_~

Si je peux supposer que l'entrée n'est que 0 ou 1 (en tant que remplaçant pour un booléen, pour lequel il n'y a pas de type dédié dans CJam), j'obtiens 15 en omettant g:

{`"_~"+Wq~#%}_~

Explication

{`"_~"+  e# Standard generalised quine framework. Leaves the source code on the stack. 
  W      e# Push a -1.
  q~     e# Read and evaluate input.
  g      e# signum, turning truthy values into 1 (leaving 0 unchanged).
  #      e# Power. -1^0 == 1, -1^1 == -1.
  %      e# Select every Nth element: a no-op for 1 and reverses the string for -1.
}_~
— Martin Ender
source
Puisque 0 et 1 sont des booléens de CJam, je ne pense pas que vous en ayez besoin g.
— Dennis
@ Dennis Ouais, je n'en étais pas vraiment sûr.
— Martin Ender
Étonnamment, j'ai en quelque sorte battu cela. oo Je ne serai pas surpris si vous le jouez plus. : D
— Addison Crump
9

Pyth, 17 octets

_WQjN*2]"_WQjN*2]

Une modification simple du quine Pyth standard.

— isaacg
source
Merde, j'attendais de poster ça depuis une heure après qu'il a été mis en bac à sable.
— lirtosiast du
7

> <>, 17 octets

Nécessite l'indicateur -v (+1 octet) pour pousser l'entrée sur la pile (ou pour que vous puissiez mettre l'entrée sur la pile au préalable sur l'interpréteur en ligne).

'rd3*$?rol?!;70.

Vous pouvez faire ce qui suit pour la même quantité d'octets (sans l'indicateur) si seules les entrées entières étaient autorisées (c'est-à-dire 0 pour la fausse, 1 pour la vérité).

'rd3*ic%?rol?!;80.

Essayez-le en ligne

Vrai / faux pour> <> ne sont rien respectivement 0 et 0.

— cole
source
6

Vitsy , 15 octets

... Je suis ... je bat CJam! (crie) Maman! Regardez, ma, je l'ai fait!

«rd3 * i86 * -) rl \ O

Explication:

«rd3 * i86 * - (rl \ O
Quine standard, mais avec une touche:

'Capturez le code source sous forme de chaîne
 rd3 * Créer le caractère 'en ASCII
     i86 * - Obtenez le caractère d'entrée en ASCII puis soustrayez-en 48. 
                    Si c'est zéro, l'instruction if sautera l'instruction suivante.
          (r Si l'élément supérieur de la pile est zéro, ne faites pas l'élément suivant.
                    Le point suivant ici est inversé.
            l \ O Imprimez la pile.

Version plus récente de Vitsy , 11 octets

v'rd3 *} v) rZ
v Capturez l'entrée en tant que variable.
 «Capturez la source jusqu'à en rencontrer une autre»
  r Inversez la pile.
   d3 * Poussez 'vers la pile.
      } Faites pivoter la pile vers la droite.
       v) Poussez la variable (entrée) dans la pile et vérifiez si elle n'est pas nulle.
         Si c'est le cas, inversez la pile.
          Z Sortez tout dans la pile.
— Addison Crump
source
2

Javascript (ES6), 42 octets

$=_=>'$='+(_?$:[...''+$].reverse().join``)

Ceci est une modification de ma Bling Quine . C'est aussi deux fois plus long.

— Mama Fun Roll
source
Cela produit-il réellement quelque chose? Les réponses qui ne fonctionnent que dans un REPL ne sont pas autorisées.
— feersum
1
@ETHproductions Cela appellerait la fonction, mais elle n'imprimerait toujours rien. De plus, ce ne serait plus une quine.
— Dennis
@Dennis Droite. Eh bien, je suppose que ce moyen prompt()est nécessaire, sauf si nous passons à Node.JS. Je crois que cela $=_=>(A=`$=${$};$(prompt())`,alert(_?A:[...A].reverse().join``));$(prompt())fonctionne correctement, bien qu'il soit peut-être possible de jouer plus bas.
— ETHproductions
1
"Votre programme ne peut en aucun cas [...] lire son propre code source." Cette solution entre-t-elle dans cette catégorie?
— ETHproductions
2

Burlesque, 40 octets

ri#Q2 SH ~- "ri#Q" \/ .+ j "<-" ps if sh

Explication:

Burlesque a des fonctionnalités avancées de manipulation de pile et de code. En fait, vous ne pouvez pas accéder au code source du programme mais vous pouvez accéder au code restant qui sera exécuté à l'avenir. Cela signifie #Qretournera tout le code qui le suit, c'est pourquoi nous devons tout ajouter #Qà ce code, ce que nous faisons ri#Q.

blsq ) #Q1 2++
12 -- this is the result of 1 2++
{1 2 ++} -- this is the result of #Q

++1 2est un code techniquement illégal car il est basé sur la pile. Mais nous pouvons manipuler le code pour le faire exécuter comme 1 2++:

blsq ) #Q<-#q++1 2 
12

Travailler avec ces intégrés est incroyablement délicat et personne ne les a encore utilisés pour quelque chose de productif, sauf pour les choses liées à la quine. Si vous inversez, ++1 2vous obtenez 2 1++ce qui produira 21et non 12. La raison pour laquelle le code ci-dessus produit 12est parce qu'il #Qinclut également le <-donc à la fin, nous finissons par exécuter beaucoup plus que juste 2 1++: p. On finit par exécuter 2 1++#q<-ce qui produit 12.

Nous pouvons réellement remplacer des choses dans notre code par exemple, ce code remplace toutes les occurrences de ?+lui-même par?*

blsq ) #Q(?+)(?*)r~5.-#q5 5?+
25

Usage:

$ echo "1" | blsq --stdin 'ri#Q2 SH ~- "ri#Q" \/ .+ j "<-" ps if sh'
hs fi sp "-<" j +. /\ "Q#ir" -~ HS 2Q#ir
$ echo "0" | blsq --stdin 'ri#Q2 SH ~- "ri#Q" \/ .+ j "<-" ps if sh'
ri#Q2 SH ~- "ri#Q" \/ .+ j "<-" ps if sh
— mroman
source
2

Haskell, 126 118 108 octets

main=readLn>>=putStr.([t,reverse t]!!);t=s++show s;s="main=readLn>>=putStr.([t,reverse t]!!);t=s++show s;s="

Attend 0ou 1en entrée.

— nimi
source
2

Minkolang 0,10 , 13 octets

"66*2-n,?r$O.

Essayez-le ici.

C'est exactement comme le Quine standard , sauf pour ces quatre caractères: n,?r. nprend un entier de l'entrée, l' ,inverse, donc ?saute rsi l'entrée est véridique. Sinon, rinverse la pile afin qu'elle soit sortie dans l'ordre inverse.

— El'endia Starman
source
1
Mon tonnerre est parti. : c
— Addison Crump
2

Python 2, 51 octets

s="print('s=%r;exec s'%s)[::1-2*0**input()]";exec s
— Sp3000
source
0

Java 10 (programme complet), 282 octets

interface N{static void main(String[]a){var s="interface N{static void main(String[]a){var s=%c%s%1$c;s=s.format(s,34,s);System.out.print(new Boolean(a[0])?new StringBuffer(s).reverse():s);}}";s=s.format(s,34,s);System.out.print(new Boolean(a[0])?new StringBuffer(s).reverse():s);}}

Essayez-le en ligne.

Java 10 (en tant que fonction lambda), 154 octets

b->{var s="b->{var s=%c%s%1$c;s=s.format(s,34,s);return b?new StringBuffer(s).reverse():s;}";s=s.format(s,34,s);return b?new StringBuffer(s).reverse():s;}

Essayez-le en ligne.

Explication:

interface N{                          // Class
  static void main(String[]a){        //  Mandatory main-method
    var s="interface N{static void main(String[]a){var s=%c%s%1$c;s=s.format(s,34,s);System.out.print(new Boolean(a[0])?new StringBuffer(s).reverse():s);}}";
                                      //   Unformatted source code
    s=s.format(s,34,s);               //   Format the source code (the quine-String)
    System.out.print(                 //   Print:
      new Boolean(a[0])?              //    If the input is true:
       new StringBuffer(s).reverse()  //     Print the quine-String reversed
      :                               //    Else:
       s);}}                          //     Print the quine-String as is

explication quine :

  • Le var scontient le code source non formaté
  • %s est utilisé pour mettre cette chaîne en elle-même avec s.format(...)
  • %c,, %1$cet 34sont utilisés pour formater les guillemets doubles
  • s.format(s,34,s) met tout cela ensemble

Et new StringBuffer(s).reverse()est ensuite utilisé pour inverser la chaîne de quine si nécessaire en fonction de l'entrée-booléen.

— Kevin Cruijssen
source
0

05AB1E , 21 octets

0"D34çý‚sè"D34çý‚sè

Essayez-le en ligne.

Modification du quine 0"D34çý"D34çý par défaut en ajoutant ‚sè.

Explication:

0                        # Push 0 to the stack
                         #  STACK: [0]
 "D34çý‚sè"             # Push the string 'D34çý‚sè' to the stack
                         #  STACK: [0, 'D34çý‚sè']
            D            # Duplicate this string
                         #  STACK: [0, 'D34çý‚sè', 'D34çý‚sè']
             34ç         # Push '"' to the stack
                         #  STACK: [0, 'D34çý‚sè', 'D34çý‚sè', '"']
                ý        # Join the stack with '"' delimiter
                         #  STACK: ['0"D34çý‚sè"D34çý‚sè']
                 Â       # Bifurcate (short for Duplicate & Reverse)
                         #  STACK: ['0"D34çý‚sè"D34çý‚sè', 'ès‚Âýç43D"ès‚Âýç43D"0']
                  ‚      # Pair them up:
                         #  STACK: [['0"D34çý‚sè"D34çý‚sè','ès‚Âýç43D"ès‚Âýç43D"0']]
                   s     # Swap to get the boolean input (0 or 1)
                         #  STACK: [['0"D34çý‚sè"D34çý‚sè','ès‚Âýç43D"ès‚Âýç43D"0'], 1]
                    è    # Index the input into the list
                         #  STACK: ['ès‚Âýç43D"ès‚Âýç43D"0']
                         # (Output the top of the stack implicitly)

PS: imprime automatiquement une nouvelle ligne de fin. Si cela doit également être inversé, il s'agit plutôt de 23 octets:

0"D34çý‚sè?"D34çý‚sè?

Essayez-le en ligne. ( ?est une impression explicite sans nouvelle ligne )

— Kevin Cruijssen
source
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.