Golf vous un quine pour un grand bien!

204

En utilisant votre langue de choix, le golf a quine .

Un quine est un programme informatique non vide qui ne prend aucune entrée et produit une copie de son propre code source en tant que sortie unique.

Pas de triche - cela signifie que vous ne pouvez pas simplement lire le fichier source et l'imprimer. En outre, dans de nombreuses langues, un fichier vide est également un quine: ce n'est pas non plus considéré comme un quine légitime.

No error quines - il existe déjà un défi distinct pour les quines d'erreur.

Points pour:

  • Plus petit code (en octets)
  • La solution la plus obscure / obscure
  • Utilisation de langages ésotériques / obscurs
  • Utiliser avec succès des langues difficiles à jouer au golf

L'extrait de pile suivant peut être utilisé pour obtenir un aperçu rapide du score actuel dans chaque langue, et ainsi savoir quelles langues ont des réponses existantes et quel type de cible vous devez battre:

Afficher l'extrait de code

code-golf  quine 
— Rafe Kettler
source
4
Ne voulez-vous pas dire, "Golf vous un quine pour plus grand bien!"?
— Mateen Ulhaq
50
@muntoo c'est un jeu sur "Apprenez-vous un Haskell pour le plus grand bien".
— Rafe Kettler

Réponses:

106

Hexagone , longueur de côté 17 16, 816 705 octets

180963109168843880558244491673953327577233938129339173058720504081484022549811402058271303887670710274969455065557883702369807148960608553223879503892017157337685576056512546932243594316638247597075423507937943819812664454190530214807032600083287129465751195839469777849740055584043374711363571711078781297231590606019313065042667406784753422844".".>.@.#.#.#.#.#.#.#.>.(...........................<.".......".".>./.4.Q.;.+.<.#.>...........................<.".....".".>.#.#.>.N.2.'.\.>.............=.=......._.<.".....".".>.>.;.'.=.:.\.>.......................<."...".".>.\.'.%.'.<.#.>..............._.....<."...".".>.#.#.>.<.#.>...............=.=.<.".".".>.#.\.'.R./.>.................<.".!.........../.>.

Essayez-le en ligne!

Voici à quoi cela ressemble déplié:

                1 8 0 9 6 3 1 0 9 1 6 8 8 4 3 8
               8 0 5 5 8 2 4 4 4 9 1 6 7 3 9 5 3
              3 2 7 5 7 7 2 3 3 9 3 8 1 2 9 3 3 9
             1 7 3 0 5 8 7 2 0 5 0 4 0 8 1 4 8 4 0
            2 2 5 4 9 8 1 1 4 0 2 0 5 8 2 7 1 3 0 3
           8 8 7 6 7 0 7 1 0 2 7 4 9 6 9 4 5 5 0 6 5
          5 5 7 8 8 3 7 0 2 3 6 9 8 0 7 1 4 8 9 6 0 6
         0 8 5 5 3 2 2 3 8 7 9 5 0 3 8 9 2 0 1 7 1 5 7
        3 3 7 6 8 5 5 7 6 0 5 6 5 1 2 5 4 6 9 3 2 2 4 3
       5 9 4 3 1 6 6 3 8 2 4 7 5 9 7 0 7 5 4 2 3 5 0 7 9
      3 7 9 4 3 8 1 9 8 1 2 6 6 4 4 5 4 1 9 0 5 3 0 2 1 4
     8 0 7 0 3 2 6 0 0 0 8 3 2 8 7 1 2 9 4 6 5 7 5 1 1 9 5
    8 3 9 4 6 9 7 7 7 8 4 9 7 4 0 0 5 5 5 8 4 0 4 3 3 7 4 7
   1 1 3 6 3 5 7 1 7 1 1 0 7 8 7 8 1 2 9 7 2 3 1 5 9 0 6 0 6
  0 1 9 3 1 3 0 6 5 0 4 2 6 6 7 4 0 6 7 8 4 7 5 3 4 2 2 8 4 4
 " . " . > . @ . # . # . # . # . # . # . # . > . ( . . . . . .
  . . . . . . . . . . . . . . . . . . . . . < . " . . . . . .
   . " . " . > . / . 4 . Q . ; . + . < . # . > . . . . . . .
    . . . . . . . . . . . . . . . . . . . . < . " . . . . .
     " . " . > . # . # . > . N . 2 . ' . \ . > . . . . . .
      . . . . . . . = . = . . . . . . . _ . < . " . . . .
       . " . " . > . > . ; . ' . = . : . \ . > . . . . .
        . . . . . . . . . . . . . . . . . . < . " . . .
         " . " . > . \ . ' . % . ' . < . # . > . . . .
          . . . . . . . . . . . _ . . . . . < . " . .
           . " . " . > . # . # . > . < . # . > . . .
            . . . . . . . . . . . . = . = . < . " .
             " . " . > . # . \ . ' . R . / . > . .
              . . . . . . . . . . . . . . . < . "
               . ! . . . . . . . . . . . / . > .
                . . . . . . . . . . . . . . . .

Ah bon, c’était plutôt une montagne russe émue ... j’ai arrêté de compter le nombre de fois où j’ai alterné "haha, c’est de la folie" et "attends, si je fais ça, c’est plutôt faisable". Les contraintes imposées au code par les règles de mise en page d'Hexagony étaient ... sévères.

Il serait peut-être possible de réduire la longueur des côtés de 1 ou 2 sans changer l'approche générale, mais cela va être dur (seules les cellules avec #sont actuellement inutilisées et disponibles pour le décodeur). Pour le moment, je n'ai également absolument aucune idée de la façon dont une approche plus efficace, mais je suis sûre qu'il en existe une. Je réfléchirai à cela au cours des prochains jours et j'essaierai peut-être de jouer d'un côté, avant d'ajouter une explication et le reste.

Au moins, j'ai prouvé que c'était possible ...

Quelques scripts CJam pour ma propre référence future:

— Martin Ender
source
51
Cher Pete, qu'est-ce que c'est?
— Conor O'Brien
2
Combien de temps a-t-il fallu pour faire cela?
— Adnan
3
@AandN Je joue avec les concepts d'un "modèle" général depuis hier (cela n'impliquait aucun test réel ... il suffisait de taper des éléments sur une grille 7x7 pour voir si cela fonctionnerait ... J'ai probablement abandonné une demi-douzaine d'approches déjà là). Le codage a ensuite pris ce soir ... peut-être 3 heures, je dirais.
— Martin Ender
10
Les mots ne peuvent expliquer à quel point je suis étonné lorsque je vois ceci en action avec Esoteric IDE, étape par étape ... Pour qui voudra peut-être comprendre cela, cet hexagone code la partie "décodeur" en un entier qui est imprimé avec !, puis En miroir /sur la 2ème dernière ligne, il entre dans le décodeur pour imprimer le code du décodeur afin de compléter le cycle. Cela a une utilisation miraculeuse <et >qui lit le très grand entier multiligne et construit la zone de stockage du décodeur. J'aimerais vraiment savoir quelles "dizaines d'approches" sont envisagées?
— Sunny Pun
3
Explication? ---
— MD XF
77

MySQL, 167 caractères

SELECT REPLACE(@v:='SELECT REPLACE(@v:=\'2\',1+1,REPLACE(REPLACE(@v,\'\\\\\',\'\\\\\\\\\'),\'\\\'\',\'\\\\\\\'\'));',1+1,REPLACE(REPLACE(@v,'\\','\\\\'),'\'','\\\''));

C'est vrai. :-)

J'ai vraiment écrit celui-ci moi-même. Il a été initialement publié sur mon site .

— TehShrike
source
72

GolfScript, 2 octets

1

(remarque: fin de ligne nouvelle) Ceci place le numéro 1 dans la pile. À la fin du programme, GolfScript imprime tous les éléments de la pile (sans espaces), puis imprime une nouvelle ligne.

C'est un vrai quine (comme indiqué dans la question), car il exécute le code; il ne se contente pas de "lire le fichier source et de l'imprimer" (contrairement à la soumission PHP).

Pour un autre exemple, voici un programme GolfScript à imprimer 12345678:

9,(;
  1. 9: poussez 9 à la pile
  2. ,: consomme le 9 comme argument, place le tableau [0 1 2 3 4 5 6 7 8]dans la pile
  3. (: consomme le tableau en argument, pousse le tableau [1 2 3 4 5 6 7 8]et l'élément 0vers la pile
  4. ;: élimine le premier élément de la pile

La pile contient maintenant le tableau [1 2 3 4 5 6 7 8]. Ceci est écrit dans la sortie standard sans espace entre les éléments, suivi d'un saut de ligne.

— Chris Jester-Young
source
18
Ou PowerShell, ou PHP :-)
— Joey, le
6
Vous n'êtes pas remonté dans le temps pour donner à l'inventeur l'idée d'inventer GolfScript, n'est-ce pas?
— Mateen Ulhaq
78
Techniquement, 1n'est pas un Quine dans GolfScript: il sort 1\n, où \ndésigne un saut de ligne. Cependant, le programme de deux personnages 1\n est une quine.
— Ilmari Karonen
17
Le programme à un caractère est \nprobablement aussi?
— Lynn
10
@Pseudonym a quine est littéralement un programme qui imprime sa propre source. Je ne pense pas qu'il y ait de restrictions arbitraires sur la "structure".
— Hugo Zink
71

Brain-Flak , 9.8e580 1.3e562 9.3e516 12818 11024 4452 4332 4240 4200 4180 3852 3656 3616 3540 2485 + 3 = 2488 octets

S'inscrit maintenant dans l'univers observable!

(())(()()())(())(())(()()())(())(())(()()())(())(()()()()())(()())(()()()()())(())(()()())(())(()()()()())(())(())(())(())(()()()()())(())(())(()()())(())(())(()()())(())(()()()()())(()())(()()()()())(())(()()())(())(()()()()())(())(())(())(())(())(())(()())(())(())(())(()())(()()()())(())(()()()()())(()())(()())(()())(()()())(())(()())(())(()()()()())(()())(()()()()())(())(())(())(())(())(()())(())(())(())(()()()()())(())(())(()()()()())(())(())(()()()()())(())(())(()())(())(()())(())(()())(())(()())(())(()())(()())(()())(()())(()())(()())(()())(()())(())(()()()()())(())(())(()()())(())(())(()()())(())(()()()()())(()())(()()()()())(())(()()())(())(())(()()())(()())(())(()()()()())(())(())(()()())(())(())(()()())(())(()()()()())(()())(()()()()())(())(())(())(()()())(())(())(()()())(())(())(()()())(())(()()()()())(()())(()()()()())(()()())(())(()()())(())(())(())(()())(()()())(()())(())(()()()()())(()())(())(()()())(())(()()()()())(())(())(())(()()())(())(())(())(()())(())(()())(()()()())(())(())(()()()()())(()())(()())(())(()()())(())(())(())(())(()()())(()())(())(())(()()()()())(())(())(()()()()())(())(())(()()()()())(())(())(()())(())(()())(())(()())(())(()())(()())(()())(()())(())(()()()()())(()())(())(()()())(())(()()()()())(()()()()())(())(()()())(())(())(()())(())(()()()()())(())(()()()()())(())(())(())(()()()()())(())(())(()())(())(()())(())(()())(())(()())(())(()())(()())(()())(()())(())(()()()()())(()())(())(()()())(())(())(()())(())(()()()()())(()())(()()()()())(())(()()())(())(())(()()()()())(())(()()()()())(())(())(())(()())(())(()()()()())(())(())(()())(())(()())(())(()())(()())(()())(()())(())(()()()()())(()())(())(()()()()())(())(()()())(())(())(()())(())(()()()()())(()())(()()()()())(())(()()())(())(())(())(()())(()()()())(())(())(()())(())(()()()()())(())(())(()()()()())(())(())(()()()()())(())(())(()())(())(()())(())(()())(())(()())(())(()())(()())(()())(()())(()())(()())(())(()()())(())(())(()())(())(()()()()())(()())(()()()()())(()()())(())(())(()())(())(())(()()()()())(()()()())(()())(()())(()()())(())(()())(())(()()()()())(()())(()()()()())(())(())(())(()()()())(()()()())(()())([[]]){({}()<(([{}]())<{({}())<>(((((()()()()()){}){}){}())[()])<>{({}())<>{}({}(((()()()){}())){}{})<>{({}())<>({}(((()()()()()){})){}{}())<>{{}<>({}(((()()()()){}){}){})(<>)}}<>(({})[()()])<>}}{}<>({}(<()>)<><{({}<>)<>}<>>){({}<>)<>}{}(<>)<>{({}<>)<>}{}(((((((()()()()()){}){}){}))()))>){({}()<((({}[()])()))>)}{}<>{({}<>)<>}{}>)}{}<>{({}<>)<>}<>

Essayez-le en ligne!

Explication

Cette Quine fonctionne comme la plupart des Quines dans les langues ésotériques; il comporte deux parties: un codeur et un décodeur. Le codeur est composé de toutes les parenthèses au début et le décodeur est la partie la plus complexe à la fin.

Une façon naïve de coder le programme serait de mettre la valeur ASCII de chaque caractère du décodeur dans la pile. Ce n’est pas une très bonne idée car Brain-Flak n’utilise que 8 caractères ( ()<>[]{}), vous payez donc quelques octets pour encoder très peu d’informations. Une idée plus intelligente, utilisée jusqu'à présent, consiste à affecter chacune des 8 accolades à un nombre beaucoup plus petit (1 à 8) et à les convertir en valeurs ASCII avec notre décodeur. C’est bien parce que coder un caractère ne coûte pas plus de 18 octets, par opposition à l’ancien 252.

Cependant ce programme ne fait ni l'un ni l'autre. Il repose sur le fait que les programmes Brain-Flak sont tous équilibrés pour coder les 8 accolades avec des nombres allant jusqu'à 5. Ils les codent comme suit.

(       -> 2
<       -> 3
[       -> 4
{       -> 5
),>,],} -> 1

Toutes les accolades proches sont affectées à 1, car nous pouvons utiliser le contexte pour déterminer laquelle d'entre elles doit être utilisée dans un scénario particulier. Cela peut sembler une tâche ardue pour un programme Brain-Flak, mais ce n’est vraiment pas le cas. Prenons par exemple les encodages suivants avec les accolades ouvertes décodées et les accolades fermantes remplacées par un .:

(.
((..
<([.{...

J'espère que vous pouvez voir que l'algorithme est assez simple, nous lisons de gauche à droite, chaque fois que nous rencontrons une accolade ouverte, nous poussons son accolade proche vers une pile imaginaire et lorsque nous rencontrons un, .nous sautons la valeur supérieure et le plaçons à la place du .. Ce nouvel encodage nous épargne un nombre énorme d’octets dans l’encodeur tout en nous perdant une poignée d’octets dans le décodeur.

Explication de bas niveau

Travaux en cours

— Sriotchilisme O'Zaic
source
25
Je pense que vous gagnez pour la solution la plus longue à un défi de code-golf ...
— Mego
18
Je viens de faire le plus grand golf en solo de l’histoire de PPCG Nope. 9.8e580 est quand même impressionnant.
— Dennis
19
+1 pour s'intégrer dans l'univers observable. De plus, avec TIO Nexus, le lien permanent doit correspondre à la réponse. tio.run/nexus/…
— Dennis
3
... très gros golf ...
— Lemon destructible
3
Je pense que vous gagnez pour la plupart des octets coupés
— Christopher
68

Prelude , 5 157 4 514 2 348 1761 1537 664 569 535 423 241 214 184 178 175 169 148 142 136 133 octets

Merci à Sp3000 pour la sauvegarde de 3 octets.

C’est plutôt long ... (bon, c’est encore long ... au moins, il bat le plus petit Brainfuck C # connu sur ce défi maintenant) mais c’est le premier quine que j’ai découvert moi-même (mes soumissions de Lua et Julia ne sont vraiment que des traductions de quine standard dans d’autres langues) et pour autant que je sache, personne n’a encore écrit de quine dans Prelude. C’est pourquoi je suis assez fier de cela. :)

7( -^^^2+8+2-!( 6+ !
  ((#^#(1- )#)8(1-)8)#)4337435843475142584337433447514237963742423434123534455634423547524558455296969647344257)

Ce grand nombre de chiffres n’est qu’un encodage du code principal, c’est pourquoi le nombre est si long.

Les chiffres encodant le code ont été générés avec ce script CJam .

Cela nécessite un interpréteur conforme aux normes, qui imprime les caractères (en utilisant les valeurs comme codes de caractères). Donc, si vous utilisez l'interpréteur Python, vous devez le définir NUMERIC_OUTPUT = False.

Explication

Tout d’abord, quelques mots sur Prelude: chaque ligne de Prelude est une "voix" distincte qui manipule sa propre pile. Ces piles sont initialisées à un nombre infini de 0. Le programme est exécuté colonne par colonne, toutes les commandes de la colonne étant exécutées "simultanément" en fonction des états précédents de la pile. Les chiffres sont poussés individuellement sur la pile, donc 42pousseront a 4, puis a 2. Il n'y a aucun moyen de pousser directement des nombres plus importants, vous devrez les additionner. Les valeurs peuvent être copiées à partir de piles adjacentes avec vet ^. Les boucles de style Brainfuck peuvent être introduites avec des parenthèses. Voir le lien dans le titre pour plus d'informations.

Voici l’idée de base de la quine: d’abord, nous plaçons des charges de chiffres sur la pile qui code le cœur de la quine. Ledit noyau prend ensuite ces chiffres, les décode pour s’imprimer lui-même, puis imprime les chiffres tels qu’ils apparaissent dans le code (et le fin )).

Ceci est légèrement compliqué par le fait que je devais diviser le noyau sur plusieurs lignes. À l'origine, j'avais l'encodage au début, mais j'avais ensuite besoin de remplir les autres lignes avec le même nombre d'espaces. C'est pourquoi les scores initiaux étaient tous si grands. Maintenant, j'ai mis l'encodage à la fin, mais cela signifie que je dois d'abord ignorer le cœur, puis appuyer sur les chiffres, puis revenir au début et imprimer.

L'encodage

Puisque le code n'a que deux voix, et que la contiguïté est cyclique ^et vest synonyme. C’est bien parce que vle code de caractères est de loin le plus gros. En évitant de le faire en utilisant toujours, cela ^facilite le codage. Maintenant, tous les codes de caractère sont compris entre 10 et 94 inclus. Cela signifie que je peux encoder chaque caractère avec exactement deux chiffres décimaux. Il y a cependant un problème: certains caractères, notamment le saut de ligne, ont un zéro dans leur représentation décimale. C'est un problème car les zéros ne se distinguent pas facilement du bas de la pile. Heureusement, il existe une solution simple à ce problème: nous avons compensé les codes de caractères par 2une plage allant de 12 à 96 inclus, qui tient toujours bien dans les deux chiffres décimaux. Maintenant, de tous les caractères qui peuvent apparaître dans le programme Prelude,0a un 0 dans sa représentation (50), mais nous n’avons vraiment pas besoin 0du tout. C'est donc l'encodage que j'utilise, poussant chaque chiffre individuellement.

Cependant, comme nous travaillons avec une pile, les représentations sont inversées. Donc, si vous regardez la fin de l'encodage:

...9647344257

Diviser en paires et inverser, puis soustraire deux, puis rechercher les codes de caractère:

57 42 34 47 96
55 40 32 45 94
 7  (     -  ^

où 32est correspond à des espaces. Le noyau effectue exactement cette transformation, puis imprime les caractères.

Le noyau

Voyons donc comment ces chiffres sont réellement traités. Premièrement, il est important de noter que les parenthèses ne doivent pas nécessairement se trouver sur la même ligne dans Prelude. Il ne peut y avoir qu'une seule parenthèse par colonne, il n'y a donc aucune ambiguïté entre les parenthèses. En particulier, la position verticale de la parenthèse fermante est toujours sans importance - la pile vérifiée pour déterminer si la boucle se termine (ou est entièrement ignorée) sera toujours celle qui possède le (.

Nous voulons exécuter le code exactement deux fois - la première fois, nous sautons le noyau et nous transmettons tous les chiffres à la fin, la deuxième fois, nous le lançons. En fait, après avoir exécuté le noyau, nous repasserons tous ces chiffres, mais comme la boucle se termine après, cela n'a aucune importance. Cela donne le squelette suivant:

7(
  (                   )43... encoding ...57)

Premièrement, nous poussons une 7voix sur la première voix - si nous ne le faisons pas, nous n'entrerons jamais dans la boucle (pour le squelette, il est seulement important que ce soit non nul ... pourquoi c'est précisément ce que 7nous verrons plus tard) . Ensuite, nous entrons dans la boucle principale. Maintenant, la deuxième voix contient une autre boucle. Lors de la première passe, cette boucle sera ignorée car la deuxième pile est vide / ne contient que des 0. Nous sautons donc directement au codage et plaçons tous ces chiffres dans la pile. Le 7nous avons poussé sur la première pile est toujours là, donc la boucle se répète.

Cette fois, il y a aussi un 7sur la deuxième pile, nous entrons donc en boucle sur la deuxième voix. La boucle sur la deuxième voix est conçue de telle sorte que la pile est à nouveau vide, de sorte qu'elle ne s'exécute qu'une fois. Cela épuisera également la première pile ... Donc, lorsque nous quittons la boucle sur la deuxième voix, nous repassons tous les chiffres, mais maintenant 7, la pile de la première pile a été supprimée. La boucle principale se termine et le programme se termine.

Ensuite, regardons la première boucle du noyau actuel. Faire les choses en même temps qu'un (ou )est assez intéressant. J'ai marqué le corps de la boucle ici avec =:

-^^^2+8+2-!
(#^#(1- )#)
 ==========

Cela signifie que la colonne contenant (n'est pas considérée comme faisant partie de la boucle (les caractères ne sont exécutés qu'une seule fois et même si la boucle est ignorée). Mais la colonne contenant le ) fait partie de la boucle et est exécutée une fois à chaque itération.

Nous commençons donc avec un simple -, qui transforme le 7premier pile en un -7... encore, plus à ce sujet plus tard. Quant à la boucle actuelle ...

La boucle continue tant que la pile de chiffres n’a pas été vidée. Il traite deux chiffres à la fois. Le but de cette boucle est de décoder le codage, d’imprimer le caractère et de décaler simultanément la pile de chiffres vers la première voix. Donc cette partie d'abord:

^^^
#^#

La première colonne déplace le 1 chiffre vers la première voix. La deuxième colonne copie les 10 chiffres de la première voix tout en recopiant le 1 chiffre dans la deuxième voix. La troisième colonne ramène cette copie à la première voix. Cela signifie que la première voix a maintenant deux fois le chiffre 1 et les deux chiffres entre 10. La deuxième voix n'a qu'une autre copie du code à 10 chiffres. Cela signifie que nous pouvons travailler avec les valeurs au sommet des piles et nous assurer qu'il reste deux copies sur la première pile pour plus tard.

Maintenant, nous récupérons le code de caractère à partir des deux chiffres:

2+8+2-!
(1- )#

Le bas est une petite boucle qui décrémente à peine les 10 chiffres. Pour chaque itération, nous voulons ajouter 10 au sommet. Rappelez-vous que le premier 2ne fait pas partie de la boucle, donc le corps de la boucle est en fait +8+2ce qui ajoute 10 (en utilisant le 2poussé précédemment) et le poussé un autre 2. Donc, quand nous avons fini avec la boucle, la première pile a réellement la base- 10 valeur et un autre 2. Nous soustrayons ce 2 avec -pour tenir compte du décalage dans l'encodage et pour imprimer le caractère avec !. Le #juste élimine le zéro à la fin de la boucle inférieure.

Une fois cette boucle terminée, la deuxième pile est vide et la première pile contient tous les chiffres dans l'ordre inverse (et un -7en bas). Le reste est assez simple:

( 6+ !
8(1-)8)#

Il s’agit de la deuxième boucle du noyau, qui affiche maintenant tous les chiffres. Pour ce faire, nous avons besoin de 48 à chaque chiffre pour obtenir le code de caractère correct. Nous faisons cela avec une simple boucle qui exécute des 8temps et ajoute à 6chaque fois. Le résultat est imprimé avec !et 8la fin est pour la prochaine itération.

Alors qu'en est-il -7? Oui, 48 - 7 = 41qui est le code de caractère de ). La magie!

Enfin, lorsque nous avons terminé avec cette boucle, nous éliminons le bouton que 8nous venons de pousser #afin de nous assurer de laisser la boucle externe sur la deuxième voix. Nous repoussons tous les chiffres et le programme se termine.

— Martin Ender
source
1
— Robert Fraser
19
Martin, tu dois arrêter quelque part.
— seequ
3
J'adore le fait que plus de 5 000 octets ont été joués, plus un remerciement à Sp3000 pour avoir économisé 3 d'entre eux.
— Kamil Drakari
2
@ KamilDrakari C'étaient les 3 derniers octets cependant, donc c'est assez grave. ;)
— Martin Ender
57

Hexagone , longueur de côté 11, 314 octets

164248894991581511673077637999211259627125600306858995725520485910920851569759793601722945695269172442124287874075294735023125483.....!/:;.........)%'=a':\....................\...................\..................\.................\................\...............\..............\..$@.........\$><>'?2='%.<\:;_;4Q

Essayez-le en ligne!

Ancienne version:

Hexagone , longueur de côté 11, 330 octets

362003511553420961423766261426252539048636523959468260999944549820033581478284471415809677091006384959302453627348235790194699306179..../:{;+'=1P'%'a{:..\.....................\...................\..................\.................\................\...............\..............\.............\!$><........\..@>{?2'%<......:;;4Q/

Essayez-le en ligne!

Encoder: Essayez-le en ligne!

Le programme est à peu près équivalent à ce code Python: Essayez-le en ligne!

Code déplié:

           3 6 2 0 0 3 5 1 1 5 5
          3 4 2 0 9 6 1 4 2 3 7 6
         6 2 6 1 4 2 6 2 5 2 5 3 9
        0 4 8 6 3 6 5 2 3 9 5 9 4 6
       8 2 6 0 9 9 9 9 4 4 5 4 9 8 2
      0 0 3 3 5 8 1 4 7 8 2 8 4 4 7 1
     4 1 5 8 0 9 6 7 7 0 9 1 0 0 6 3 8
    4 9 5 9 3 0 2 4 5 3 6 2 7 3 4 8 2 3
   5 7 9 0 1 9 4 6 9 9 3 0 6 1 7 9 . . .
  . / : { ; + ' = 1 P ' % ' a { : . . \ .
 . . . . . . . . . . . . . . . . . . . . \
  . . . . . . . . . . . . . . . . . . . \ 
   . . . . . . . . . . . . . . . . . . \  
    . . . . . . . . . . . . . . . . . \   
     . . . . . . . . . . . . . . . . \    
      . . . . . . . . . . . . . . . \     
       . . . . . . . . . . . . . . \      
        . . . . . . . . . . . . . \       
         ! $ > < . . . . . . . . \        
          . . @ > { ? 2 ' % < . .         
           . . . . : ; ; 4 Q / .

Deux .s prend 1 bit. Tous les autres caractères prennent 1 bit et un chiffre base 97.

Explication

Cliquez sur les images pour les agrandir. Chaque partie de l'explication a un code Python correspondant pour aider à la compréhension.

Partie de données

Au lieu de la structure complexe utilisée dans certaines autres réponses (avec <, entre "autres), je laisse simplement l’adresse IP passer par la moitié inférieure.

Les données

Premièrement, l’IP passe par un grand nombre de chiffres, de no-op's ( .) et de mirrors ( \). Chaque chiffre s’ajoute au numéro en mémoire, de sorte que la valeur en mémoire est égale au nombre au début du programme.

mem = 362003511...99306179

! l'imprime,

stdout.write(str(mem))

et $saute à travers la suivante >.

À partir du <. Si la valeur de la mémoire memest falsy ( <= 0c'est-à-dire que la condition mem > 0n'est pas remplie), nous avons imprimé le programme et devons quitter. L'IP suivrait le chemin supérieur.

Sortie

(laissez l'IP parcourir le monde pendant environ 33 commandes avant d'appuyer sur @(ce qui termine le programme) car le placer n'importe où ailleurs implique des octets supplémentaires)

Si c'est le cas, nous suivons le chemin inférieur, sommes redirigés quelques fois et exécutons quelques commandes supplémentaires avant de passer à une autre condition.

# Python                    # Hexagony
# go to memory cell (a)     # {
a = 2                       # ?2
# go to memory cell (b)     # '
b = mem % a                 # %

Maintenant, la mémoire ressemble à ceci:

Mem1

Si la valeur est la vérité:

if b > 0:

le code suivant est exécuté:

# Python                    # Hexagony
b = ord('Q')                # Q
b = b*10+4                  # 4
# Note: now b == ord('.')+256*3
stdout.write(chr(b%256))    # ;
stdout.write(chr(b%256))    # ;

Voir l' explication détaillée de la Q4à la réponse HelloWorld Hexagony de MartinEnder . En bref, ce code s'imprime .deux fois.

Au départ, j'avais prévu que cela soit imprimé .une fois. Lorsque j'ai proposé ceci (imprimé .deux fois) et que je l'ai mis en œuvre, environ 10 chiffres ont été enregistrés.

Ensuite,

b = mem // a                # :

Voici un fait important que j'ai réalisé et qui m'a permis d'économiser environ 14 chiffres: vous n'avez pas besoin d'être là où vous avez commencé.

Pour comprendre ce que je dis, établissons une analogie avec BF. (sautez ceci si vous avez déjà compris)

Compte tenu du code

while a != 0:
    b, a = a * 2, 0
    a, b = b, 0
    print(a)

En supposant que nous laissions ala valeur de la cellule en cours et bcelle de la bonne cellule, une traduction directe en BF est la suivante:

[             # while a != 0:
    [->++<]       # b, a = a * 2, 0
    >[-<+>]       # a, b = b, 0
    <.            # print(a)
]

Notez cependant que nous n’avons pas besoin d’être au même poste tout le temps du programme. Nous pouvons laisser la valeur de ace que nous sommes au début de chaque itération, alors nous avons ce code:

[             # while a != 0:
    [->++<]       # b, a = a * 2, 0
                  # implicitly let (a) be at the position of (b) now
    .             # print(a)
]

qui est plus courte de plusieurs octets.

De plus, le comportement d’emboîtement des coins m’évite également d’avoir un \miroir. Sans celui-ci, je ne pourrais pas insérer les chiffres (+2 chiffres pour \lui - même et +2 chiffres pour un non apparié .à sa droite, sans oublier le drapeaux)

(détails:

  • L'adresse IP entre dans le coin inférieur gauche et se dirige vers la gauche
  • Il se déforme dans le coin droit, toujours à gauche
  • Il rencontre un \qui le reflète, maintenant il se dirige vers le haut
  • Il va dans le coin et se déformer à nouveau dans le coin inférieur gauche

)

Si la valeur (de l'opération 2 du mod 2 ci-dessus) est falsy (zéro), alors nous suivons ce chemin:

# Python                 # Hexagony   # Memory visualization after execution
b = mem // a             # :          # click here
base = ord('a') # 97     # a
y = b % base             # '%
offset = 33              # P1
z = y + offset           # ='+
stdout.write(chr(z))     # ;          # click here
mem = b // base          # {:         # click here

Je ne vais pas expliquer trop en détail ici, mais l'offset n'est pas vraiment 33, mais correspond au 33mod 256. Et chra un implicite % 256.

— utilisateur202729
source
3
Homme, c'est beaucoup de no-ops
— Jo King
26
J'ai ri de "Pour comprendre ce que je dis, établissons une analogie avec [BrainFuck]". Seulement sur PPCG ... :)
— Lynn
2
J'ai fait défiler 3 fois jusqu'au début de la réponse pour le remonter, seulement pour découvrir que je l'avais déjà fait ...
— NieDzejkob
2
310 octets en profitant du nouvel espace en raccourcissant le nombre
— Jo King
2
308 octets en prenant encore plus d’espace
— Jo King
46

Vim, 11 octets

q"iq"qP<Esc>hqP
  • iq"qP<Esc>: Insère manuellement une copie du texte devant être en dehors de l'enregistrement.
  • q"et hqP: enregistrez l’intérieur directement dans le ""registre sans nom afin qu’il puisse être collé au milieu. Le hest le seul repositionnement requis; si vous le mettez dans la macro, il sera collé dans le résultat.

Modifier

Une note à propos de l'enregistrement avec q": Le registre non nommé ""est une chose amusante. Ce n'est pas vraiment un véritable registre comme les autres, car le texte n'y est pas stocké. C'est en fait un pointeur sur un autre registre (généralement "-pour les suppressions sans nouvelle ligne, "0pour les virements ou "1pour les suppressions avec une nouvelle ligne). q"enfreint les règles; il écrit en fait à "0. Si votre ""pointait déjà vers un autre registre que "0, q"écrasera "0mais laissera ""inchangé. Lorsque vous démarrez un nouveau Vim, il ""pointe automatiquement sur "0, de sorte que tout va bien dans ce cas.

Fondamentalement, Vim est bizarre et buggy.

— udioica
source
attends pourquoi ça ne marche pas pour moi
— Lemon destructible
@DestructibleWatermelon Je ne peux pas le dire avec certitude, mais une explication est la plus probable. J'aurais probablement dû l'avoir dans la rédaction avant, car cela peut déstabiliser les gens. Lire la modification.
— dimanche
vous devriez probablement dire quelque chose sur la façon dont presser you quelque chose avant de courir peut aider
— Lemon destructible
Pourquoi n'utilisez-vous pas ␛pour montrer en appuyant sur la touche <Échap>? Partie de ce bloc Unicode «Images de contrôle»
— mbomb007
4
@ mbomb007 La <Esc>notation est standard dans Vim mappings ( :help <>) et c'est ce que vimgolf.com utilise. Tout vimgolfer expérimenté sera habitué à le lire. Pour ce qui est de l’unicode, je dois plisser les yeux pour lire les petites lettres, qui obscurcissent la méthode utilisée pour les taper et rechercher le fichier d’aide.
— dimanche
44

Cubix , 20 octets

3434Qu$v@!<"OOw\o;/"

J'ai presque le \o/ ...

Net :

    3 4
    3 4
Q u $ v @ ! < "
O O w \ o ; / "
    . .
    . .

Essayez-le en ligne

Essayez-le ici !

Notes complémentaires

Histoire de fond

Après avoir été impressionné par la lecture de cette excellente réponse de @ ais523, j'ai commencé à penser à continuer à jouer au golf dans la quine. Après tout, il y avait pas mal de no-ops là-dedans, et ça ne semblait pas très compressé. Cependant, comme la technique utilisée par sa réponse (et la mienne également) exige que le code couvre toutes les lignes, une sauvegarde d’au moins 12 octets est nécessaire. Il y avait une remarque dans son explication qui m'a vraiment fait réfléchir:

En ce qui concerne le golf plus loin, il faudrait [...] une autre manière de représenter la face supérieure du cube [...]

Puis, tout à coup, alors que je me levais et que je partais chercher quelque chose à boire, je fus frappé: que se passe-t-il si le programme n'utilise pas de codes de caractères, mais plutôt des chiffres pour représenter la face supérieure? Ceci est particulièrement court si le numéro que nous imprimons a 2 chiffres. Cubix a 3 instructions d' un octet pour pousser un nombre à deux chiffres: N, Set Qqui poussent 10, 32et 34respectivement, ce qui devrait être assez Golfy, je pensais.

La première complication avec cette idée est que la face supérieure est maintenant remplie de chiffres inutiles, de sorte que nous ne pouvons plus l'utiliser. La deuxième complication est que la face supérieure a une taille qui est la taille du cube au carré, et qu'elle devait avoir une taille égale, sinon un nombre finirait également sur la position de départ du pointeur d'instruction, ce qui conduirait à une pile polluée. À cause de ces complications, mon code devait tenir sur un cube de taille 2 (pouvant contenir «seulement» 24 octets, je devais donc jouer au moins 21 octets). De plus, comme les faces supérieure et inférieure sont inutilisables, je n'avais que 16 octets effectifs.

J'ai donc commencé par choisir le nombre qui deviendrait la moitié de la face supérieure. J'ai commencé avec N(10), mais cela n'a pas fonctionné à cause de l'approche que je prenais pour tout imprimer. Quoi qu'il en soit, j'ai recommencé à l’origine et utilisé S(32) pour une raison quelconque. Cela a abouti à une bonne quine, du moins le pensais-je. Tout a très bien fonctionné, mais les citations manquaient. Ensuite, je me suis dit que le Q(34) serait vraiment utile. Après tout, 34 est le code de caractère de la citation double, ce qui nous permet de la conserver sur la pile, en sauvegardant (2, dans la présentation que j’avais alors utilisée) de précieux octets. Après avoir un peu modifié la route IP, tout ce qui restait était un exercice pour remplir les blancs.

Comment ça fonctionne

Le code peut être divisé en 5 parties. Je vais les examiner un par un. Notez que nous encodons les faces médianes dans l'ordre inverse, car le modèle de pile est le premier entré dernier sorti.

Étape 1: impression de la face supérieure

Les instructions non pertinentes ont été remplacées par no-ops ( .). La propriété intellectuelle commence la troisième ligne, à l'extrême gauche, en direction est. La pile est (évidemment) vide.

    . .
    . .
Q u . . . . . .
O O . . . . . .
    . .
    . .

L’IP se termine à la position la plus à gauche de la quatrième ligne, en direction de l’ouest, sur le point de revenir à la position la plus à droite de la même ligne. Les instructions exécutées sont (sans le caractère de flux de contrôle):

QOO
Q   # Push 34 (double quotes) to the stack
 OO # Output twice as number (the top face)

La pile ne contient que 34, représentant le dernier caractère de la source.

Étape 2: Encoder la quatrième ligne

Ce bit fait bien ce que vous attendez: encoder la quatrième ligne. L'adresse IP commence par la citation double à la fin de cette ligne, et va vers l'ouest en poussant les codes de caractère de chaque caractère sur lequel elle atterrit jusqu'à ce qu'elle trouve une citation double correspondante. Ce guillemet double correspond également au dernier caractère de la quatrième ligne, car l'adresse IP est renvoyée à la ligne lorsqu'elle atteint le bord gauche.

En réalité, l’IP a bougé d’une position vers la gauche et la pile contient maintenant la représentation de la quatrième ligne en codes de caractères et en ordre inverse.

Étape 3: Poussez une autre citation

Nous devons pousser un autre devis, et quel meilleur moyen que de le recycler Qau début du programme en l’abordant de la droite? Cela a l'avantage supplémentaire que l'adresse IP s'exécute directement dans la citation qui code la troisième ligne.

Voici la version Internet pour cette étape. Les intructions non pertinentes ont à nouveau été remplacées par no-ops, les no-ops exécutées ont été remplacés par hashtags ( #) à des fins d'illustration et l'adresse IP commence au dernier caractère de la quatrième ligne.

    . .
    . .
Q u $ . . . . .
. . w \ . . / .
    . #
    . #

La propriété intellectuelle se termine sur la troisième ligne à la première instruction, sur le point de se terminer à la fin de cette ligne car elle est orientée vers l’ouest. Les instructions suivantes (à l'exclusion du flux de contrôle) sont exécutées:

$uQ
$u  # Don't do anthing
  Q # Push the double quote

Cette double citation représente celle qui se trouve à la fin de la troisième ligne.

Étape 4: Encodage de la troisième ligne

Cela fonctionne exactement comme à l’étape 2, alors regardez-y pour une explication.

Étape 5: Imprimez la pile

La pile contient maintenant les quatrième et troisième lignes, dans l'ordre inverse, de sorte que tout ce que nous avons à faire maintenant, c'est de l'imprimer. L’IP commence à l’avant-dernière instruction de la troisième ligne en direction de l’ouest. Voici la partie pertinente du cube (encore une fois, les parties non pertinentes ont été remplacées par des no-ops).

    . .
    . .
. . . v @ ! < .
. . . \ o ; / .
    . .
    . .

C'est une boucle, comme vous l'avez peut-être vu / attendu. Le corps principal est:

o;
o  # Print top of stack as character
 ; # Delete top of stack

La boucle se termine si l'élément supérieur est 0, ce qui ne se produit que lorsque la pile est vide. Si la boucle se termine, la @est exécutée, mettant fin au programme.

— Luke
source
J'aimerai pouvoir continuer à voter plus
— MickyT
Les primes sont toujours les bienvenues ;-)
— Luke
42

Javascript ES6 - 21 octets

$=_=>`$=${$};$()`;$()

J'appelle cette quine "The Bling Quine".

Parfois, il faut jouer au golf avec style.

— Maman Fun Roll
source
Est-ce que !$=_=>`!$=${$}()`()vous économisez 2 octets?
— Downgoat
Invalid assignment left hand side. Souhaite que cela fonctionne :(
— Mama Fun Roll
1
@ TùxCräftîñg éliminer les parenthèses autour des littéraux de modèle ne fonctionne que sur les fonctions prototypes natives, comme Array.prototype.join.
— Mama Fun Roll
2
Hmm, pas sûr. Je l'ai écrit il y a plus d'un an (il était alors considéré comme valide) et je n'ai pas suivi de près les modifications des règles Quine. Toutefois, l'ajout alertou console.logaprès la fonction de flèche et le renvoi entre parenthèses de la chaîne de modèle fonctionneraient.
— Mama Fun Roll
3
De plus, si vous exécutez ceci dans la console, cela écrase $ (fonction jQuery) sur ce site, et la fonction upvote ne fonctionnera plus. :)
— Steven Palinkas
41

Brainf * ck (755 caractères)

Ceci est basé sur une technique développée par Erik Bosman (ejbosman à cs.vu.nl). Notez que la "Quine ESultanik's!" le texte est réellement nécessaire pour que ce soit une quine!

->++>+++>+>+>++>>+>+>+++>>+>+>++>+++>+++>+>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>+>+>++>>>+++>>>>>+++>+>>>>>>>>>>>>>>>>>>>>>>+++>>>>>>>++>+++>+++>+>>+++>>>+++>+>+++>+>++>+++>>>+>+>+>+>++>+++>+>+>>+++>>>>>>>+>+>>>+>+>++>+++>+++>+>>+++>+++>+>+++>+>++>+++>++>>+>+>++>+++>+>+>>+++>>>+++>+>>>++>+++>+++>+>>+++>>>+++>+>+++>+>>+++>>+++>>>+++++++++++++++>+++++++++++++>++++++>+++++++++++++++>++++++++++>+++>+++>++++>++++++++++++++>+++>++++++++++>++++>++++++>++>+++++>+++++++++++++++>++++++++>++++>++++++++++++>+++++++++++++++>>++++>++++++++++++++>+++>+++>++++>++++++>+++>+++++++++>++++>+>++++>++++++++++>++++>++++++++>++>++++++++++>+>+++++++++++++++>+++++++++++++
ESultanik's Quine!
+[[>>+[>]+>+[<]<-]>>[>]<+<+++[<]<<+]>>+[>]+++[++++++++++>++[-<++++++++++++++++>]<.<-<]
— ESultanik
source
13
C'est une façon intelligente de le faire.
— Peter Olson
13
Comment ça marche?
— fier haskeller
3
@proudhaskeller IIRC, la partie précédente ESultanik's Quine!configure la mémoire en tant que pile de codage ESultanik's Quine!et de suite, avec deux octets de mémoire pour chaque caractère (valeur ASCII décalée à partir de 0x1F). Le dernier bit de code parcourt la mémoire, reproduisant d’abord par programmation les ++>+++…codes pour chaque caractère, puis imprimant les caractères.
— ESultanik
4
@CatsAreFluffy Ils sont nécessaires pour que ce soit une quine! S'il est vrai qu'ils pourraient être supprimés, il faudrait également modifier le code précédent pour conserver la propriété quine.
— ESultanik
1
C'est vrai. De plus, les nouvelles lignes sont nécessaires.
— CalculatriceFeline
36

Hexagone , longueur de côté 15 14 13 12, 616 533 456 383 octets

Après plusieurs jours de golf minutieux, de réorganisation des boucles et de tout recommencer, j’ai finalement réussi à le réduire à 12 hexagones.

1845711724004994017660745324800783542810548755533855003470320302321248615173041097895645488030498537186418612923408209003405383437728326777573965676397524751468186829816614632962096935858"">./<$;-<.....>,.........==.........<"......."">'....>+'\.>.........==........<"......"">:>)<$=<..>..............$..<"...."">\'Q4;="/@>...............<"....."">P='%<.>.............<"..!'<.\=6,'/>

Essayez-le en ligne!

Déplié:

            1 8 4 5 7 1 1 7 2 4 0 0
           4 9 9 4 0 1 7 6 6 0 7 4 5
          3 2 4 8 0 0 7 8 3 5 4 2 8 1
         0 5 4 8 7 5 5 5 3 3 8 5 5 0 0
        3 4 7 0 3 2 0 3 0 2 3 2 1 2 4 8
       6 1 5 1 7 3 0 4 1 0 9 7 8 9 5 6 4
      5 4 8 8 0 3 0 4 9 8 5 3 7 1 8 6 4 1
     8 6 1 2 9 2 3 4 0 8 2 0 9 0 0 3 4 0 5
    3 8 3 4 3 7 7 2 8 3 2 6 7 7 7 5 7 3 9 6
   5 6 7 6 3 9 7 5 2 4 7 5 1 4 6 8 1 8 6 8 2
  9 8 1 6 6 1 4 6 3 2 9 6 2 0 9 6 9 3 5 8 5 8
 " " > . / < $ ; - < . . . . . > , . . . . . .
  . . . = = . . . . . . . . . < " . . . . . .
   . " " > ' . . . . > + ' \ . > . . . . . .
    . . . = = . . . . . . . . < " . . . . .
     . " " > : > ) < $ = < . . > . . . . .
      . . . . . . . . . $ . . < " . . . .
       " " > \ ' Q 4 ; = " / @ > . . . .
        . . . . . . . . . . . < " . . .
         . . " " > P = ' % < . > . . .
          . . . . . . . . . . < " . .
           ! ' < . \ = 6 , ' / > . .
            . . . . . . . . . . . .

Bien que cela ne ressemble pas au code Hexagony le plus sophistiqué, le type d’encodage que j’ai utilisé est optimisé pour les longues périodes de non-fonctionnement, ce que vous auriez autrement évité.

Explication

Cela bat la réponse Hexagony précédente en encodant le no-ops ( .) d'une manière différente. Alors que cette réponse permet de gagner de la place en transformant tous les autres caractères en un ., le mien code le nombre de non-ops. Cela signifie également que la source n'a pas besoin d'être si restreinte.

Ici , j'utilise une base 80 codage, où les numéros ci - dessous indiquent 16 séries de pas d'habitation, et les numéros entre 16 et 79 représentent la gamme 32 ( !) à 95 ( _) (je suis juste de réaliser maintenant je tous les joué au golf _s de ma code lol). Quelques pseudocodes Pythonic:

i = absurdly long number
print(i)
base = 80
n = i%base
while n:
    if n < 16:
        print("."*(16-n))
    else:
        print(ASCII(n+16))
    i = i//base
    n = i%base

Le numéro est encodé dans la première moitié de l'hexagone, avec tous les 

" " > 
 " " > 
  ... etc

sur le côté gauche et le

 > ,
< "
 >
< "
... etc

sur le côté droit redirige le pointeur pour coder le nombre dans une cellule. Ceci est tiré de la réponse de Martin Ender (merci), car je ne pouvais pas trouver un moyen plus efficace.

Il entre ensuite dans la section inférieure par le biais de ->:

       " " > \ ' Q 4 ; = " / @ > . . . .
        . . . . . . . . . . . < " . . .
         . . " " > P = ' % < . > . . .
          . . . . . . . . . . < " . .
     ->    ! ' < . \ = 6 , ' / > . .

!imprime le numéro et 'navigue vers la bonne cellule de mémoire avant de commencer la boucle. P='%mods le nombre actuel par 80. Si le résultat est 0, montez à la fin @, sinon descendez et créez une cellule à côté du résultat mod avec la valeur -16.

   . " " > ' . . . . > + ' \ . > . . . . . .
    . . . = = . . . . . . . . < " . . . . .
     . " " > : > ) < $ = < . . > . . . . .
      . . . . . . . . . $ . . < " . . . .
       " " > \ ' Q 4 ; = " / @ > . . . .
                      /
                     /

Définissez la cellule sur (valeur mod + -16). Si cette valeur est négative, montez à l'embranchement >+'\, sinon descendez.

Si la valeur est positive:

 " " > . / < $ ; - < . . . . . > , . . . . . .
  . . . = = . . . . . . . . . < " . . . . . .
   . " " > ' . . . . > + ' \ . > . . . . . .

Le pointeur se termine à la position ;-<qui définit la cellule sur (valeur mod - -16) et l’imprime.

La la valeur est négative:

   . " " > ' . . . . > + ' \ . > . . . . . .
    . . . = = . . . . . . . . < " . . . . .
     . " " > : > ) < $ = < . . > . . . . .

Descendez dans la > ) <section qui commence la boucle. Ici c'est isolé:

     . . > ) < $ = < . .
      . . . . . . . . .
       \ ' Q 4 ; = " /

Qui exécute le code 'Q4;="=qui affiche un .(merci encore à Martin Ender, qui a écrit un programme pour trouver les combinaisons lettre-nombre pour les caractères) et revient à la cellule de départ. Il incrémente ensuite ( )) la cellule de valeur mod et boucle à nouveau jusqu'à ce que la valeur mod soit positive.

Lorsque cela est fait, il se déplace vers le haut et rejoint l'autre section à:

 " " > . / < $ ; - < . . .
            \
             \

Le pointeur revient ensuite au début de la boucle plus grande

 " " > . / <--
  . . . = =
   . " " > ' 
    . . . = = 
     . " " > :
      . . . . .
       " " > \ ' . .
        . . . . . . .
         . . " " > P = ' % < . > . . .

Ceci exécute ='=:'ce qui divise le nombre actuel par 80 et navigue vers la cellule correcte.

Ancienne version (longueur 13)

343492224739614249922260393321622160373961419962223434213460086222642247615159528192623434203460066247203920342162343419346017616112622045226041621962343418346002622192616220391962343417346001406218603959366061583947623434"">/':=<$;'<.....>(......................<"......"">....'...>=\..>.....................<"....."">....>)<.-...>...........==......<"...."">.."...'.../>.................<"..."">\Q4;3=/.@.>...............<".."".>c)='%<..>..!'<.\1*='/.\""

Essayez-le en ligne!

Je peux très certainement jouer au golf d'un autre côté, mais je vais devoir le laisser jusqu'à demain car il se fait tard. Il s'avère que je suis impatient et que je ne peux pas attendre jusqu'à demain. Peut-être qu'un autre côté peut être joué au golf? :( ahhhhhhhhh je l'ai fait!

J'ai même joué quelques chiffres supplémentaires avec un encodage en base 77, mais cela n'a pas vraiment d'importance, car le décompte est identique.

— Jo King
source
13
Ceci est incroyable. L'idée de cet encodage hybride de durée d'exécution est vraiment géniale. :) Rappelez-moi de vous donner une prime si j'oublie.
— Martin Ender
35

PostScript, 20 caractères

Court et légitime. 20 caractères, y compris le retour à la ligne.

(dup == =)
dup == =
— KirarinSnow
source
33

Cubix , 45 octets

.....>...R$R....W..^".<R.!'.\)!'"R@>>o;?/o'u"

Vous pouvez tester ce code ici .

Ce programme est assez difficile à suivre, mais pour avoir une chance de le faire, nous devons commencer par l’étendre en un cube, comme le fait l’interpréteur Cubix:

      . . .
      . . >
      . . .
R $ R . . . . W . . ^ "
. < R . ! ' . \ ) ! ' "
R @ > > o ; ? / o ' u "
      . . .
      . . .
      . . .

Il s’agit d’une quine de style Befunge, qui fonctionne en exploitant l’emballage pour rendre les littéraux de chaîne «encapsulants» du code exécutable (avec un seul "repère, le code est à la fois à l’intérieur et à l’extérieur du guillemet, ce qui devient possible lorsque vous avez programmes non linéaires et non planaires). Notez que cela correspond à notre définition d'un quine approprié, car deux des guillemets doubles ne se codent pas, mais sont calculés ultérieurement via l'utilisation de l'arithmétique.

Contrairement à Befunge, cependant, nous utilisons quatre chaînes ici plutôt qu'une. Voici comment ils sont poussés sur la pile;

  1. Le programme commence en haut à gauche et va vers la droite; il tourne à droite deux fois ( R), ce qui le fait aller à gauche le long de la troisième et dernière ligne entourant tout le cube. La citation double correspond elle-même, nous repoussons donc toute la troisième ligne dans la pile. Ensuite, l'exécution continue après la double citation.

  2. La ucommande effectue un demi-tour à droite. La prochaine étape est la suivante '", à partir de la ligne médiane. Cela pousse un "sur la pile. Tout en continuant de rouler, nous avons frappé le <côté gauche du cube et avons rebondi. En approchant de cette direction, nous voyons une "commande en clair , pas '", de sorte que la deuxième ligne entière est poussée sur la pile en arrière au-dessus de la troisième ligne et le guillemet double.

  3. Nous commençons par pousser un !sur la pile ( '!) et l'incrémenter ( )); cela produit une double citation sans avoir besoin d'une double citation dans notre code source (ce qui terminerait la chaîne). Un miroir ( \) reflète la direction d'exécution vers le nord; alors la Wcommande évite à gauche. Cela nous laisse aller vers le haut sur la septième colonne, qui, puisqu'il s'agit d'un cube, passe à gauche dans la troisième rangée, puis à la troisième colonne. Nous avons frappé un R, tourner à droite et aller à gauche le long de la rangée supérieure; puis le $saute le Rvia par lequel nous sommes entrés dans le programme, donc l'exécution passe "à la fin de la ligne et nous capturons la première ligne dans une chaîne de la même manière que nous l'avons fait pour les deuxième et troisième.

  4. La ^commande nous envoie vers le nord dans la onzième colonne, ce qui correspond (pour le wrapping des cubes) au sud dans la cinquième. La seule chose que nous rencontrons est !(ignorer si non nul; le sommet de la pile est en fait non nul), ce qui ignore la ocommande, ce qui rend la cinquième colonne entièrement vide. Nous revenons donc à la ucommande, qui encore une fois fait demi-tour, mais cette fois, nous nous retrouvons dans la dernière colonne au sud, qui passe à la quatrième colonne au nord. Nous avons cependant fait une double citation pendant le demi-tour. Nous avons donc capturé la quatrième colonne entière dans une chaîne, de bas en haut. Contrairement à la plupart des guillemets doubles du programme, celui-ci ne se ferme pas lui-même; au lieu de cela, il est fermé par le "dans le coin supérieur droit, ce qui signifie que nous capturons la chaîne de neuf caractères ...>......

Donc, la disposition de la pile est maintenant, de haut en bas: quatrième colonne; rangée supérieure; "; rangée du milieu; "; rangée du bas. Chacun de ceux-ci est représenté sur la pile avec le premier caractère le plus proche du haut de la pile (Cubix pousse les chaînes dans le sens inverse de l'ordre, comme Befunge, mais chaque fois que l'IP se déplaçait dans le sens opposé à celui de lecture, donc il s’est effectivement inversé deux fois). On peut noter que le contenu de la pile est presque identique au programme original (car la quatrième colonne et la face nord / supérieure du cube contiennent les mêmes caractères dans le même ordre; évidemment, il a été conçu comme ça intentionnellement).

L'étape suivante consiste à imprimer le contenu de la pile. Après tous les efforts, la propriété intellectuelle se dirige vers le nord sur la quatrième colonne. Elle >entre donc dans une boucle étroite >>o;?(c.-à-d. "Tournez vers l'est, tournez vers l'est, la sortie sous forme de caractère, sautez à droite si positif"). Comme la septième ligne est pleine de NOP, le ?va revenir à la première >, de sorte que tout le contenu de la pile ?est repoussé ( c'est un no-op sur une pile vide). Nous avons presque imprimé le programme en entier! Malheureusement, ce n'est pas encore tout à fait fait; il nous manque la double citation à la fin.

Une fois la boucle terminée, nous réfléchissons sur la ligne centrale en direction de l'ouest, via une paire de miroirs. (Nous avons utilisé "l'autre côté" du \miroir plus tôt; maintenant nous utilisons le côté sud-ouest. Le /miroir n'a pas été utilisé auparavant.) Nous rencontrons '!donc nous poussons un point d'exclamation (c'est-à-dire 33; nous utilisons ASCII et Cubix ne fait pas la distinction entre les entiers et les caractères) sur la pile. (Il s'agit commodément de la même chose !que celle utilisée oprécédemment pour ignorer la commande.) Nous rencontrons une paire de Rcommandes et les utilisons pour faire un demi-tour "manuel" (la deuxième Rcommande a été utilisée plus tôt pour atteindre la première rangée, il semblait donc tout à fait naturel d’adapter une autre Rcommande à côté.Wcommande, pour contourner à gauche. Le pas de côté se bloque directement dans la >commande de la deuxième ligne, renvoyant l'exécution exactement là où elle était. Nous allons donc à nouveau à gauche, mais cette fois, nous allons vers le sud. La prochaine commande à exécuter est le )(incrémentation du point d'exclamation en guillemet double), suivie d'un o(pour le sortir). Enfin, l’exécution reprend la huitième ligne dans la deuxième colonne, où il trouve un moyen @de quitter le programme.

Je m'excuse pour l'apostrophe égarée sur la troisième ligne. Cela ne fait rien dans cette version du programme; cela faisait partie d'une idée antérieure que j'avais mais qui s'est avérée inutile. Cependant, une fois que j'avais un quine de travail, je voulais juste le soumettre plutôt que de le déranger davantage, d'autant plus que le supprimer ne changerait pas le nombre d'octets. En ce qui concerne le golf plus loin, cela ne me surprendrait pas si cela était possible à 3 × 3 en n'utilisant que les cinq premières lignes, mais je ne vois pas de façon évidente de le faire, et il faudrait regroupement encore plus étroit de tous les flux de contrôle avec un autre moyen de représenter la face supérieure du cube (ou modification de l'algorithme pour qu'il puisse continuer à utiliser la quatrième colonne, même si elle comportait maintenant dix ou onze caractères) .

Beau travail, c'est un score vraiment impressionnant. J'adore la façon dont vous avez encodé la face supérieure. :)
— Martin Ender
C'est juste incroyable! Si cela peut vous aider, une autre façon de pousser "est Q.
— ETHproductions
1
Hou la la! Je n'ai jamais pensé voir un cubix quine!
— FlipTack
3
Je n'ai pas eu le temps de lire l'explication hier, mais maintenant que j'ai ... Juste ... WOW. Je ne peux pas croire combien de personnages sont utilisés à deux voire trois fins complètement différentes. C’est probablement le programme Cubix le plus cool que j’ai jamais vu.
— ETHproductions
Bonne explication.
— Robert Fraser
33

Python 2, 30 octets

_='_=%r;print _%%_';print _%_

Tiré d'ici

— hallvabo
source
1
+1, vous avez battu ma solution similaire alors je l'ai supprimée. Il est à noter que cela ne fonctionne que dans Python 2.
— nyuszika7h
2
Cela semble bizarre avec le nom de la variable en tant que _, mais se lit mieux si vous l'assignez à n'importe quelle lettre, c'est-à-dire s:s='s=%r;print s%%s';print s%s
— Ehtesh Choudhury
5
Si cette solution n'est pas votre propre création, vous devriez en faire un wiki de communauté. En outre, le lien est mort.
— mbomb007
1
Je suis un peu en retard à la fête, mais quelqu'un peut-il expliquer comment cela fonctionne?
— MadTux
9
Cela nécessite un saut de ligne de fin pour être valide. En l'état, le code source ne correspond pas à la sortie.
— Dennis
32

Vim, 17 , 14 frappes

Quelqu'un a voté au hasard pour ça, alors je me suis rappelé que ça existe. Quand je l'ai relu, j'ai pensé "Hé, je peux faire mieux que ça!", Alors j'ai joué au golf deux octets. Ce n'est toujours pas le plus court, mais au moins c'est une amélioration.

Pendant longtemps, je me demandais si un vim quine était possible. D'une part, cela doit être possible, car vim est complètement terminé. Mais après avoir recherché un vim quine pendant très longtemps, je n’ai pas pu en trouver un. J'ai fait trouve ce défi PPCG , mais il est fermé et non Quines exactement au sujet littérales. J'ai donc décidé d'en faire un, car je ne pouvais pas en trouver un.

Je suis vraiment fier de cette réponse, à cause de deux premières :

  1. Ceci est la première quine que j'ai jamais faite, et

  2. Pour autant que je sache, c’est le premier vim-quine au monde au monde à être publié! Je peux me tromper, alors si vous en connaissez un, faites-le-moi savoir.

Donc, après cette longue introduction, le voici:

qqX"qpAq@q<esc>q@q

Essayez-le en ligne!

Notez que lorsque vous tapez ceci, la <esc>frappe est affichée sous la forme ^[. C’est toujours exact, puisque ^[représente 0x1B, qui est une évasion en ASCII , et la façon dont vim représente en interne la<esc> clé.

Notez également que les tests peuvent échouer si vous chargez une session vim existante. J'ai écrit des conseils répondent en expliquant que ici , si vous voulez plus d' informations, mais , fondamentalement , vous devez lancer vim avec

vim -u NONE -N -i NONE

ou tapez qqqavant d'exécuter ceci.

Explication:

qq                  " Start recording into register 'q'
  X                 " Delete one character before the cursor (Once we play this back, it will delete the '@')
   "qp              " Paste register 'q'
      Aq@q<esc>     " Append 'q@q' to this line
               q    " Stop recording
                @q  " Playback register 'q'

Sur une note de côté, cette réponse est probablement un record du monde pour la plupart des «q» dans une réponse PPCG, ou quelque chose du genre.

— DJMcMayhem
source
1
2i2i<esc>est si proche. Je pense que je peux faire quelque chose pour que cela fonctionne.
— Zwei
@ Zwei je sais, c'est proche ça fait mal! En fait, <Esc>c'est implicite dans V, donc ça marche . Malheureusement, il ajoute également une nouvelle ligne, c'est pourquoi je ne l'ai pas encore publiée.
— DJMcMayhem
q"iq"qbP<Esc>qbPAprès avoir mis cela sur Reddit , j’ai enquêté sur le vimgolfing ici et décidé de créer un compte. C'est la réponse que j'ai posté là-bas.
— dimanche
2
@udioica Pouvez-vous poster cela comme une réponse?
— DJMcMayhem
28

Lost , 120 116 98 96 76 70 66 octets

Edit: oui, moins de 100

Edit: enregistré un tas d'octets en basculant vers tous les /s sur la ligne du bas

:2+52*95*2+>::1?:[:[[[[@^%?>([ "
////////////////////////////////

Essayez-le en ligne! + vérification c'est déterministe pour tous les états possibles

Lost est un langage 2D dans lequel la position et la direction de départ sont complètement aléatoires. Cela signifie qu'il doit y avoir beaucoup de vérifications d'erreur à chaque étape pour s'assurer que vous avez le bon pointeur d'instruction, et ce n'est pas celui qui vient de s'égarer au hasard.

Explication:

Tous les /points de la ligne du bas sont là pour s’assurer que tous les pointeurs apparaissant dans une direction verticale ou sur la ligne du bas soient acheminés dans la bonne direction. De là, ils se retrouvent à plusieurs endroits différents, mais tous finissent par aller droit au but.

 ^%?>
 ////

Ce qui efface tous les nombres non nuls de la pile. Cet ([après efface également les 0 supplémentaires.

En milieu de dégagement, il frappe le %, ce qui désactive la 'sécurité', ce qui permet au programme de se terminer lorsqu'il le frappe @(sans cela, le programme pourrait se terminer immédiatement si un pointeur commençait à la@ ).

À partir de là, le langage 2D est assez simple, en encerclant un littéral de chaîne ( ") autour de la première ligne, poussant un "caractère en dupliquant un espace ( :2+) puis un newline ( 52*). Pour la deuxième ligne, il crée un /caractère ( 95*2+) et le duplique comme un groupe ( >::1?:[:[[[[), avant de se terminer par @et d'imprimer la pile implicitement. Cela ?1consiste à empêcher le processus de créer trop de 0 si le pointeur entre tôt, sans avoir à les effacer plus tard.

J'ai économisé 20 octets ici en faisant la même ligne avec le même caractère, ce qui signifie que je pouvais passer directement du processus de duper à la fin @.

Explication sur le processus de duper:

[est un personnage appelé "porte". Si le pointeur touche le côté plat d'un [ou d'une ], il réfléchit, sinon il le traverse. Chaque fois que le pointeur interagit avec une porte, il passe au type opposé. En utilisant cette connaissance, nous pouvons construire une formule simple pour combien de fois une instruction sera exécutée dans un >:[bloc.

Ajoutez la quantité initiale d'instructions. Pour chacun [, ajoutez 2 fois le nombre d'instructions à gauche de celle-ci. Pour l'exemple >::::[:[[[, nous commençons avec 5 comme montant initial. La première porte a 4 instructions de duplication, nous ajoutons donc 4 * 2 = 8 à 5 pour obtenir 13. Les trois autres portes ont 5 dupes à leur gauche, nous ajoutons donc 3 * (5 * 2) = 30 à 13 pour obtenir 43 instructions dupe exécutées et avoir 44 >s sur la pile. Le même processus peut être appliqué à d'autres instructions, telles que( pour pousser une grande quantité d'éléments de la pile vers l'étendue, ou comme utilisé ici, pour supprimer des éléments de la pile.

Un truc que j’ai utilisé ici pour éviter de tromper trop de 0 est le 1?. Si le caractère est 0, le ?ne saute pas le 1, ce qui signifie qu'il duplique 1 pour le reste de la dupe. Cela rend beaucoup plus facile d'effacer la pile plus tard.

— Jo King
source
25

Ce sont les deux quines Ruby les plus courtes de SO :

_="_=%p;puts _%%_";puts _%_

et

puts <<2*2,2
puts <<2*2,2
2

Ne me demandez pas comment fonctionne le second ...

— Nakilon
source
8
Le second utilise heredoc, <<2commence une chaîne sur la ligne suivante et *2répète la chaîne
— Ming-Tang le
Pourquoi avez-vous besoin du 2?
— CalculatriceFeline
1
@CalculatorFeline C'est le terminateur de la chaîne heredoc (qui doit apparaître sur sa propre ligne). Il ne faut pas que ce soit un 2: tio.run/##KypNqvz/v6C0pFjBxsZAy0jHgAuFY8D1/z8A
— Martin Ender
25

Fission , 6 octets

Il semble que ce soit maintenant la quine "correcte" la plus courte parmi ces réponses. 

'!+OR"

Explication

Le flux de contrôle commence Ravec un seul (1,0)atome allant de droite . Il est possible de "basculer entre les modes d’impression puis d’enrouler la ligne, d’imprimer '!+ORavant d’appuyer de "nouveau sur cette touche et de quitter le mode d’impression.

Cela laisse le "lui - même à imprimer. Le plus court chemin est '"O(où '"définit la masse de l'atome sur le code du caractère de "et Oimprime le caractère et détruit l'atome), mais si nous le faisions, cela "interférerait avec le mode d'impression. Donc, au lieu de cela, nous définissons la valeur de l'atome sur '!(moins un "), puis incrémentons avec +, puis imprimons le résultat avec O.

Des alternatives

Voici quelques alternatives, qui sont plus longues, mais peut-être que leurs techniques inspirent quelqu'un à trouver une version plus courte les utilisant (ou peut-être qu'elles seront plus utiles dans certains quines généralisés).

8 octets utilisant Jump

' |R@JO"

Encore une fois, le code commence à R. Les @échanges de masse et d'énergie à donner (0,1). Par conséquent, l' Jatome saute par-dessus la Odroite sur le ". Ensuite, comme précédemment, tous sauf le "sont imprimés en mode chaîne. Ensuite, l'atome frappe |pour inverser sa direction, puis passe à l' '"Oimpression ". L'espace est un peu gênant, mais il semble nécessaire, car sinon ', l'atome le traiterait |comme un personnage plutôt que comme un miroir.

8 octets utilisant deux atomes

"'L;R@JO

Cela a deux atomes, partant de gauche à Ldroite R. L'atome de gauche obtient sa valeur définie par '"laquelle est immédiatement imprimé avec O(et l'atome détruit). Pour l’atome de droite, nous échangeons à nouveau la masse et l’énergie, nous sautons par dessus Opour imprimer le reste du code en mode impression. Ensuite, sa valeur est définie par 'Lmais peu importe, car l’atome est ensuite rejeté ;.

— Martin Ender
source
Techniquement non valide en raison de l'absence de séparation code / données dans la source.
— CalculatriceFeline
4
@CalculatorFeline '!+encode ".
— Martin Ender
Je ne suis pas familier avec Fission, mais cela |R@JO"'fonctionnerait-il ou auriez-vous toujours besoin de cet espace après le '?
— MildlyMilquetoast
1
@MistahFiggins Je pense que oui, mais plus important encore, vous imprimeriez le 'premier.
— Martin Ender
24

JavaScript inter-navigateur (41 caractères)

Il fonctionne dans les 5 premiers navigateurs Web (IE> = 8, Mozilla Firefox, Google Chrome, Safari, Opera). Entrez-le dans la console du développeur dans l'un de ceux-ci:

eval(I="'eval(I='+JSON.stringify(I)+')'")

Ce n'est pas "tricher" - contrairement à la quine à un octet de Chris Jester-Young, qui pourrait facilement être modifiée pour utiliser la alert()fonction (coûtant 14 caractères):

alert(eval(I="'alert(eval(I='+JSON.stringify(I)+'))'"))

Ou converti en bookmarklet (coûtant 22 caractères):

javascript:eval(I="'javascript:eval(I='+JSON.stringify(I)+')'")
— Veuillez vous lever
source
24

C, 64 60 octets

main(s){printf(s="main(s){printf(s=%c%s%1$c,34,s);}",34,s);}

Jusqu'ici, c'est la plus courte quine connue. Il y a une prime prolongée si vous en trouvez une plus courte.

Cela fonctionne dans GCC , Clang et TCC dans un environnement POSIX . Il invoque une quantité excessive de comportement indéfini avec tous.

Juste pour le plaisir, voici une prise en pension qui contient tous les C Quines que je connais. N'hésitez pas à bifurquer / PR si vous en trouvez ou en écrivez un autre qui ajoute quelque chose de nouveau et de créatif par rapport aux existants.

Notez que cela ne fonctionne que dans un environnement ASCII . Cela fonctionne pour EBCDIC , mais requiert toujours POSIX . Bonne chance quand même pour trouver un environnement POSIX / EBCDIC: P

Comment ça fonctionne:

  1. main(s) les abus main 'arguments, en déclarant une variable pratiquement non typée s. (Notez que ce sn'est pas réellement non typé, mais puisque les compilateurs listés le convertissent automatiquement si nécessaire, il pourrait aussi bien être *.)
  2. printf(s="..." ensembles s la chaîne fournie et passe le premier argument à printf.
  3. sest réglé sur main(s){printf(s=%c%s%1$c,34,s);}.
  4. Le %cest réglé sur ASCII 34, ". Cela rend la quine possible. sRessemble maintenant à ceci:
    main(s){printf(s="%s%1$c,34,s);} .
  5. Le %sest réglé sur slui-même, ce qui est possible grâce à # 2. sRessemble maintenant à ceci:
    main(s){printf(s="main(s){printf(s=%c%s%1$c,34,s);}%1$c,34,s);} .
  6. Le %1$cest réglé sur ASCII 34 ", printf« s premier ** argument. Cela sressemble maintenant à ceci:
    main(s){printf(s="main(s){printf(s=%c%s%1$c,34,s);}",34,s);}
    ... qui se trouve être le code source original.

* Exemple grâce à @Pavel
** premier argument après le spécificateur de format - dans ce cas, s. Il est impossible de référencer le spécificateur de format.

Je pense qu'il est impossible que cela soit plus court avec la même approche. Si printfle spécificateur de format était accessible via $, cela fonctionnerait pour 52 octets:

main(){printf("main(){printf(%c%0$s%1$c,34);}",34);}
— MD XF
source
Bien que cela ne devrait certainement pas compter comme concurrent, le vainqueur du «pire abus des règles» du concours international de code C obscurci de 1994 , 1994_smr.c , est nettement plus court.
— Ray
@Ray Ce n'est pas permis. Ce n'est pas une quine appropriée par aucune définition. Les règles de quien ont été modifiées à cause de ce programme: P
— MD XF
Je suis tout à fait d’accord, mais c’est un hack assez intéressant pour que cela vaille la peine de mentionner chaque fois que quelqu'un mentionne une plus petite quine connue, ne serait-ce que pour des raisons historiques.
— Ray
4
sest de type int, pas une "variable non typée".
— Feersum
2
Ces compilateurs autorisent apparemment tous la conversion implicite d'un pointeur vers un int. s=3ne fonctionnerait évidemment pas parce que vous devez passer la chaîne deux fois printf.
— Feersum
24

Java, 528 octets:

Une solution Java avec une approche originale:

import java.math.*;class a{public static void main(String[]a){BigInteger b=new BigInteger("90ygts9hiey66o0uh2kqadro71r14x0ucr5v33k1pe27jqk7mywnd5m54uypfrnt6r8aks1g5e080mua80mgw3bybkp904cxfcf4whcz9ckkecz8kr3huuui5gbr27vpsw9vc0m36tadcg7uxsl8p9hfnphqgksttq1wlolm2c3he9fdd25v0gsqfcx9vl4002dil6a00bh7kqn0301cvq3ghdu7fhwf231r43aes2a6018svioyy0lz1gpm3ma5yrspbh2j85dhwdn5sem4d9nyswvx4wmx25ulwnd3drwatvbn6a4jb000gbh8e2lshp",36);int i=0;for(byte c:b.toByteArray()){if(++i==92)System.out.print(b.toString(36));System.out.print((char)c);}}}

sous forme lisible:

import java.math.*;
class a
{
    public static void main (String [] a)
    {
        BigInteger b=new BigInteger ("90ygts9hiey66o0uh2kqadro71r14x0ucr5v33k1pe27jqk7mywnd5m54uypfrnt6r8aks1g5e080mua80mgw3bybkp904cxfcf4whcz9ckkecz8kr3huuui5gbr27vpsw9vc0m36tadcg7uxsl8p9hfnphqgksttq1wlolm2c3he9fdd25v0gsqfcx9vl4002dil6a00bh7kqn0301cvq3ghdu7fhwf231r43aes2a6018svioyy0lz1gpm3ma5yrspbh2j85dhwdn5sem4d9nyswvx4wmx25ulwnd3drwatvbn6a4jb000gbh8e2lshp", 36); 
        int i=0; 
        for (byte c:b.toByteArray ())
        {
            if (++i==92) 
                System.out.print (b.toString (36)); 
            System.out.print ((char) c);
        }
    }
}
— Utilisateur inconnu
source
Comment ça marche?
— Loovjo
1
@ Loovjo: similaire à d'autres solutions qui coupent le code en deux parties et insèrent la chaîne entière qui représente le code à l'intérieur, mais le code complet n'est pas simplement une chaîne, mais est codé sous la forme du nombre long en base 36 (26 caractères alphabétiques + 10). chiffres).
— Utilisateur inconnu
1
Cela pourrait être raccourci si vous mettez if(++i==92),
— tuskiomi
2
@tuskiomi: Merci, raccourci pour deux caractères
— utilisateur inconnu
1
@userunknown En fait, a*le tableau ne se terminant pas en Java, il s'agit d'un C. Quelques autres parties du golf :, import java.math.*;class a{public static void main(String[]a){BigInteger b=new BigInteger("abc",36);int i=0;for(int c:b.toByteArray())System.out.printf("%s%c",++i==92?b.toString(36):"",c);}}où abcserait le nombre magique nouvellement calculé, String. Dans java 8+, il est également possible de passer class a{public static void mainà interface a{static void main, et dans Java 10+, il est également possible de changer import java.math.*;et BigInteger b=new BigInteger(de var b=new java.math.BigInteger(.
— Kevin Cruijssen
23

Poulet , 7

chicken

Non, ce n'est pas directement répercuté :)

— Timtech
source
Bon sang, vous m'avez battu :)
— Taconut
Ce n'est pas un écho, c'est la corde chicken!
— Erik l'Outgolfer
Pas de séparation code / données et donc invalide.
— CalculatriceFeline
10
@CalculatorFeline Avez-vous lu les règles?
— Timtech
1
@JoKing Je ne pense pas que cela soit invalide, car les règles du challenge interdisent uniquement les quines de longueur nulle et de tricherie (lire votre propre fichier source). La seule chose qui interdit les quines inappropriées est une échappatoire standard - sauf que les échappatoires standard ne sont généralement pas considérées comme s'appliquant aux réponses antérieures.
— pppery
23

Retina , 20 14 9 7 octets

Avant de commencer, je voudrais mentionner la solution triviale d’un fichier qui en contient un 0. Dans ce cas, Retina essaiera de compter les 0s dans l'entrée vide, ce qui donnera également le résultat 0. Je ne considérerais pas cela comme une bonne quine.

Alors voici un bon:

>\`
>\`

Essayez-le en ligne!

Alternativement, nous pourrions utiliser ;au lieu de >.

Explication

Le programme consiste en un seul remplacement que nous imprimons deux fois.

Dans la première ligne, le `sépare la configuration de l'expression régulière, de sorte que l'expression régulière est vide. Par conséquent, la chaîne vide (c’est-à-dire l’entrée inexistante) est remplacée par la deuxième ligne, mot pour mot.

Pour imprimer le résultat deux fois, nous l’emballons en deux étapes de sortie. La partie interne \imprime le résultat avec un saut de ligne de fin et la partie externe,> , l'imprime sans un.

Si vous connaissez un peu Retina, vous vous demandez peut-être ce qu'il est advenu de la sortie implicite de Retina. La sortie implicite de Retina fonctionne en encapsulant la dernière étape d'un programme dans une étape de sortie. Cependant, Retina ne le fait pas si l'étape finale est déjà une étape de sortie. La raison en est que , dans un programme normal , il est plus utile de pouvoir remplacer l'étage de sortie implicite avec un spécial comme \ou ;pour un seul octet ( au lieu d'avoir à se débarrasser de celui implicite avec le .drapeau ainsi). Malheureusement, ce comportement finit par nous coûter deux octets pour le quine.

— Martin Ender
source
20

Javascript (36 caractères)

(function a(){alert("("+a+")()")})()

C’est, AFAICT, la plus courte quine javascript publiée à ce jour.

— Peter Olson
source
1
C'est impressionnant. Tu devrais expliquer comment ça marche pour moi 8- |
— TehShrike
3
@TehShrike Indice: vous pouvez afficher le contenu d'une fonction en le contraignant à une chaîne. Par exemple, si vous avez une fonction a, vous pouvez accéder à son contenu en appelant a.toString.
— Peter Olson
7
Pour être pédant, cependant, il ne s'agit que d'une quine si votre implémentation JavaScript renforce la fonction aexactement de la même manière que ce qui a été écrit ci-dessus. Cependant, la sortie de ce code sera probablement une quine sur toute implémentation de JavaScript.
— Ilmari Karonen
1
Voici le même Quine, 1 octet plus courte: !function a(){alert("!"+a+"()")}().
— Ismael Miguel
1
(a=()=>alert(($ a))))()
— Dennis C
19

GolfScript, 8 octets

J'ai toujours pensé que la plus courte (vraie) GolfScript était de 9 octets:

{'.~'}.~

Le saut de ligne de fin est nécessaire car GolfScript imprime un saut de ligne de fin par défaut.

Mais je viens de trouver une séquence de 8 octets, qui fonctionne exactement autour de cette restriction de saut de ligne:

":n`":n`

Essayez-le en ligne!

Le problème, c'est que GolfScript n'imprime pas de saut de ligne final, mais qu'il en imprime le contenu nà la fin du programme. C'est juste que ncontient un saut de ligne pour commencer. Donc, l'idée est de remplacer cela par la chaîne":n`" , puis de la hiérarchiser, de sorte que la copie sur la pile s'imprime avec des guillemets et la copie stockée dans les nimpressions sans.

Comme l'a souligné Thomas Kwa, le CJam quine à 7 octets peut également être adapté à une solution à 8 octets:

".p"
.p

Encore une fois, nous avons besoin du saut de ligne de fuite.

— Martin Ender
source
6
Golfscript est bizarre.
— CalculatriceFeline
19

Labyrinth , 124 110 53 octets

Merci à Sp3000 d’avoir joué 9 octets au golf, ce qui m’a permis de jouer 7 autres fois.

44660535853919556129637653276602333!
1
:_98
/8 %
@9_.

Essayez-le en ligne!

Explication

Labyrinth 101:

  • Labyrinth est un langage 2D basé sur des piles. La pile étant sans fond et remplie de zéros, le fait de sauter d'une pile vide n'est pas une erreur.
  • L'exécution commence par le premier caractère valide (ici en haut à gauche). Au niveau de chaque jonction, où il existe deux chemins ou plus que le pointeur d'instruction (IP) peut emprunter, le haut de la pile est vérifié pour déterminer la prochaine étape. Le négatif est à gauche, le zéro à l'avant et le positif à droite.
  • Les chiffres dans le code source ne poussent pas le nombre correspondant - au lieu de cela, ils apparaissent en haut de la pile et poussent n*10 + <digit>. Cela permet de constituer facilement de grands nombres. Pour commencer un nouveau numéro, utilisez la commande _qui pousse zéro.
  • " sont des no-ops.

Tout d'abord, je vais vous expliquer une version légèrement plus simple qui est un octet plus long, mais un peu moins magique:

395852936437949826992796242020587432!
"
:_96
/6 %
@9_.

Essayez-le en ligne!

L'idée principale est de coder le corps principal de la source en un seul nombre, en utilisant une base importante. Ce numéro peut ensuite facilement être imprimé avant d'être décodé pour imprimer le reste du code source. Le décodage est simplement l’application répétée de divmod base, où imprimer le modet continuer à travailler avec lediv jusqu’à zéro.

En évitant {}, le code de caractère le plus élevé dont nous aurons besoin est _(95) de sorte que la base 96 soit suffisante (en gardant la base basse, le nombre au début est plus court). Nous voulons donc encoder ceci:

!
"
:_96
/6 %
@9_.

En transformant ces caractères en leurs points de code et en traitant le résultat comme un nombre base 96 (le chiffre le moins significatif correspondant à !et le plus significatif au ., car c'est dans cet ordre que nous allons désassembler le nombre), nous obtenons

234785020242697299628949734639258593

Maintenant, le code commence par un truc plutôt cool (si je puis dire) qui nous permet d’imprimer l’encodage et de conserver une autre copie pour le décodage avec très peu de temps système: nous insérons le numéro dans le code à l’inverse. J'ai calculé le résultat avec ce script CJam. Passons au code actuel. Voici le début:

395852936437949826992796242020587432!
"

L’IP commence dans le coin supérieur gauche et se dirige vers l’est. Tandis qu’il passe sur ces chiffres, il construit simplement ce nombre en haut de la pile. Le nombre lui-même n'a aucune signification, car c'est l'inverse de ce que nous voulons. Quand l'IP frappe le! , ce nombre apparaît dans la pile et est imprimé. C'est tout ce qu'il y a à reproduire l'encodage dans la sortie.

Mais maintenant, la propriété intellectuelle est dans l'impasse. Cela signifie qu’il fait demi-tour et revient maintenant dans l’ouest (sans exécuter à !nouveau). Cette fois -ci , commodément, l'IP lit le numéro de l' arrière vers l' avant, de sorte que maintenant le nombre au - dessus de la pile n'encode le reste de la source.

Lorsque l'adresse IP frappe à nouveau dans le coin supérieur gauche, il ne s'agit pas d'une impasse, car l'adresse IP peut prendre un virage à gauche. Elle le fait et se déplace maintenant vers le sud. Le "est un non-op, dont nous avons besoin ici pour séparer le nombre de la boucle principale du code. En parlant de ça:

...
"
:_96
/6 %
@9_.

Tant que le sommet de la pile n'est pas encore à zéro, l'adresse IP traversera ce code plutôt dense dans la boucle suivante:

"
>>>v
^< v
 ^<<

Ou disposé linéairement:

:_96%._96/

Cela s’explique par la sémantique du flux de contrôle de Labyrinth. Lorsqu'il y a au moins trois voisins dans la cellule actuelle, l'IP tourne à gauche sur une valeur de pile négative, continue sur un zéro et tourne à droite sur une valeur de pile positive. Si la direction choisie n'est pas possible parce qu'il y a un mur, l'IP prendra la direction opposée (c'est pourquoi il y a deux virages à gauche dans le code bien que le haut de la pile ne soit jamais négatif).

Le code de la boucle elle-même est en fait assez simple (sa compression la plus importante n’est pas et c’est là que la contribution principale de Sp3000 est):

:    # Duplicate the remaining encoding number N.
_96  # Push 96, the base.
%.   # Take modulo and print as a character.
_96  # Push 96 again.
/    # Divide N by 96 to move to the next digit.

Une fois le Nzéro atteint, le flux de contrôle change. Maintenant, l'IP aimerait aller tout droit après /(c'est-à-dire l'ouest), mais il y a un mur là-bas. Donc au lieu de cela si tourne autour (est), exécute à 6nouveau. Cela rend le haut de la pile positif, donc l’IP tourne à droite (sud) et exécute le fichier 9. Le sommet de la pile est maintenant 69, mais tout ce qui nous importe, c’est que c’est positif. L'IP prend un autre tournant à droite (ouest) et se déplace sur celui @qui termine le code.

En somme, assez simple.

Bon, maintenant, comment pouvons-nous éliminer cet octet supplémentaire? Il est clair que ce non-fonctionnement semble inutile, mais nous avons besoin de cette ligne supplémentaire: si la boucle était adjacente au numéro, l'adresse IP s'y déplacerait immédiatement immédiatement au lieu de parcourir le nombre entier. Alors pouvons-nous faire quelque chose d'utile avec ce no-op.

Eh bien, en principe, nous pouvons l'utiliser pour ajouter le dernier chiffre à l'encodage. Il n’est pas nécessaire que l’encodage soit entièrement sur la première ligne, !il permet simplement d’ imprimer tout ce qui se trouve là.

Il y a un problème cependant, nous ne pouvons pas simplement faire ceci:

95852936437949826992796242020587432!
3
:_96
/6 %
@9_.

Le problème est que maintenant nous avons changé le "en a 3, ce qui modifie également le nombre réel que nous voulons avoir. Et bien sûr, ce nombre ne se termine pas par 3. Puisque le nombre est complètement déterminé par le code à partir de, !nous ne pouvons pas faire grand chose à ce sujet.

Mais peut-être pouvons-nous choisir un autre chiffre? Nous ne nous soucions pas vraiment de savoir s'il y a un 3endroit à cet endroit tant que nous obtenons un nombre qui code correctement la source. Eh bien, malheureusement, aucun des 10 chiffres ne donne un codage dont le chiffre le moins significatif correspond à celui choisi. Heureusement, il y a une marge de manœuvre dans le reste du code, ce qui nous permet d'essayer quelques encodages supplémentaires sans augmenter le nombre d'octets. J'ai trouvé trois options:

  1. Nous pouvons changer @pour /. Dans ce cas, nous pouvons utiliser n'importe quel chiffre 1357et obtenir un codage correspondant. Cependant, cela signifierait que le programme se termine alors par une erreur, qui est autorisée mais qui ne semble pas très propre.
  2. Les espaces ne sont pas les seuls personnages "muraux". Chaque caractère non utilisé est, notamment toutes les lettres. Si nous utilisons une lettre majuscule, nous n'avons même pas besoin d'augmenter la base pour l'adapter (car ces points de code sont situés en dessous _). 26 choix offrent de nombreuses possibilités. Par exemple, pour Atout travail de chiffre impair. C’est un peu plus agréable, mais cela n’apparaît toujours pas très élégant, car vous n’utiliseriez jamais une lettre dans un code réel.
  3. Nous pouvons utiliser une plus grande base. Tant que nous n'augmentons pas la base de manière significative, le nombre de chiffres décimaux dans l'encodage restera le même (spécifiquement, toute base allant jusqu'à 104 convient, bien que les bases au-delà de 99 nécessitent en réalité des caractères supplémentaires dans le code lui-même). Heureusement, la base 98 offre une solution unique: lorsque nous utilisons le chiffre 1, le codage se termine également par 1. C'est la seule solution parmi les bases 96, 97, 98, 99, donc c'est vraiment très chanceux. Et c'est ainsi que nous nous retrouvons avec le code en haut de cette réponse.
— Martin Ender
source
19

Lost , 293 262 249 octets

>:2+52*:6*:(84*+75*):>:::::[[[[[[[:[(52*)>::::[[[[[[:[84*+@>%?!<((((((((((([[[[[[[[[[[[[[ "
\#<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<\

Essayez-le en ligne!

Explication

Tout ce projet a été un mouvement ascendant et descendant. Je n'arrêtais pas de penser que c'était impossible, puis j'ai eu une idée folle qui pourrait bien marcher.

Pourquoi une quine perdue est-elle si difficile?

Comme vous le savez peut-être, Lost est un langage de programmation 2D dans lequel l'emplacement et la direction de départ sont entièrement aléatoires. Cela rend l’écriture d’un programme perdu aussi difficile que l’écriture d’un code durci par les radiations. Vous devez tenir compte de tous les lieux et directions possibles.

Cela étant dit, il existe des moyens standard de faire les choses. Par exemple, voici la méthode standard pour imprimer une chaîne.

>%?"Stringv"(@
^<<<<<<<<<<<<<

Cela a un flux de collecte au bas qui saisit le plus d'ips et les tire à l'emplacement de départ. Une fois qu'ils ont atteint leur point de départ (en haut à gauche), nous les désinfectons avec une boucle supprimant toutes les valeurs de la pile, puis activons la sécurité en poussant la chaîne et en sortant. (la sécurité est un concept propre à Lost, chaque programme doit toucher %avant de quitter, cela évite la possibilité que le programme se termine au démarrage). Maintenant, mon idée serait d’étendre cette forme à un quine à part entière.

La première chose à faire était de retravailler un peu la boucle, la boucle existante étant spécifique au format String.

>%?!<"Stringv"(@
^<<<<<<<<<<<<<<<
^<<<<<<<<<<<<<<<

Nous devons ajouter un deuxième flux pour éviter la possibilité de !sauter par-dessus le flux et de créer une boucle.

Maintenant, nous voulons mélanger cela avec le format standard Quine. Puisque Lost est basé beaucoup sur Klein, j'ai essentiellement emprunté le Klien Quine à Martin Ender .

:2+@>%?!< "
<<<<^<<<<<<
<<<<^<<<<<<

Ceci imprime assez facilement la première ligne de la quine. Il ne nous reste plus qu'à coder en dur les flux. C'est plus facile à dire qu'à faire. J'ai essayé environ quatre méthodes différentes de le faire. Je vais juste décrire celle qui a fonctionné.

L'idée ici est d'utiliser les portes pour obtenir le nombre de flèches souhaité. Une porte est un type de miroir spécial qui change à chaque frappe. [reflète les ips venant de gauche et ]de droite. Quand ils sont touchés par une adresse IP de l'un ou l'autre de ces côtés, l'orientation du commutateur. Nous pouvons créer une ligne de ces portes et un réflecteur statique pour effectuer une opération à plusieurs reprises.

>:[[[

Va effectuer :trois fois. De cette façon, si nous poussons a <dans la pile avant la main, nous pouvons en faire beaucoup avec moins d'octets. Nous en fabriquons deux, une pour chaque ligne, et entre elles, nous établissons une nouvelle ligne. Toutefois, la seconde ne doit aller que jusqu'à ce qu'elle recouvre la !raison pour laquelle nous l' avons ajoutée, tout le reste peut être laissé vide, ce qui nous épargne quelques octets. Ok, nous devons maintenant ajouter les flèches verticales à nos flux. C’est là que l’optimisation de la clé entre en jeu. Au lieu de rediriger directement tous les ips sur le "début" du programme, nous les redirigerons tout à fait à gauche, car nous savons déjà que les ips commençant par l’extrême gauche doiventtravail (ou du moins fonctionnera dans la version finale), nous pouvons également simplement rediriger les autres ips. Cela le rend non seulement moins cher en octets, mais je pense que cette optimisation est ce qui rend le quine possible.

Cependant, il reste quelques problèmes, le plus important étant que les ips commencent après que le fichier >ait été poussé, mais avant que nous ne commencions à en faire des copies. Ces ips entreront dans le copieur et feront une série de copies de 0. Cela est grave car notre mécanisme d'effacement de la pile utilise des zéros pour déterminer le bas de la pile, laissant ainsi tout un tas de zéros au bas. Nous devons ajouter une méthode d'assainissement de pile plus forte. Puisqu'il n'y a aucun moyen de savoir si la pile est vide, nous devrons simplement essayer de détruire autant d'éléments que possible sur la pile. Ici, nous allons à nouveau utiliser la méthode de la porte décrite précédemment. Nous ajouterons ((((((((((([[[[[[[[[[[[[[à la fin de la première ligne juste après le désinfectant pour supprimer les zéros.

Maintenant, il y a un autre problème, puisque nous avons redirigé nos flux vers le haut à gauche, les ips commençant par le %et descendant ayant déjà désactivé la sécurité et quitté prématurément. Nous devons donc désactiver la sécurité. Pour ce faire, nous ajoutons a #au flux, de cette manière, les ips traversant le flux seront désactivés, mais pas les ips déjà désinfectés. Le #doit également être codé en dur dans la première ligne.

Ça y est, espérons que vous comprenez comment cela fonctionne maintenant.

— Sriotchilisme O'Zaic
source
: / tant de fautes de frappe et de liens manquants
— ASCII seulement
17

Yup , 1165 879 606 561 540 522 498 + 7 = 505 octets

Requiert le -cheatdrapeau pour permettre la définition des alias.

022222120211111102222122021121202222212021112202222110222212202112110222221202122212022222102222212021222120222221022222102222210222221202222110222211022222210222221022222210222212202222221022221102211110222221022221220222212202112120221111022212202211210222212022222102211120222122022111202222120212212021221202222221022111102221210222122022222102222120212212022221102211110222122022221102222120212212022112120221111022212202112120222212=%;0e-=<;0<-=>;:0~--=1;1>=2;0%{{>0<~{~>~<<}>>>]}>]}${<#}%{@}

Essayez-le en ligne!

Explication

Cela comporte deux parties (comme avec la plupart des quines). Les données:

022222120211111102222122021121202222212021112202222110222212202112110222221202122212022222102222212021222120222221022222102222210222221202222110222211022222210222221022222210222212202222221022221102211110222221022221220222212202112120221111022212202211210222212022222102211120222122022111202222120212212021221202222221022111102221210222122022222102222120212212022221102211110222122022221102222120212212022112120221111022212202112120222212

Et le décodeur:

=%;0e-=<;0<-=>;:0~--=1;1>=2;0%{{>0<~{~>~<<}>>>]}>]}${<#}%{@}

Les données sont simplement un codage binaire du décodeur (ou plutôt son inverse). Chacun 0commence un nouveau caractère et les 1s et 2s sont respectivement les 0- et - 1bits.

Notez que 0est une commande standard Yup qui pousse un zéro, alors que 1et 2ne sont pas définis à ce stade. Cependant, nous affectons la totalité de la partie de données à la commande %afin que le 1et 2puisse rester indéfini jusqu'à ce qu'il %soit réellement utilisé.

Ensuite, nous définissons quelques commandes supplémentaires:

0e-=<;
0<-=>;
:0~--=1;
1>=2;

<décrémente le haut de la pile, l’ >incrémente. 1(de manière peu intuitive) double le sommet de la pile. 2le double et puis l'incrémente. Grâce à ces définitions, quelque chose comme 0221111laissera en fait un 48 (110000 en binaire) sur la pile.

Les 32 octets restants font le décodage réel en deux parties. Nous devons d’abord reconstruire la chaîne de données.

0%                ` Push a zero and then the data.
{                 ` For each value...
  {               `   Until that value is zero...
    >0<~{~>~<<}>  `   divmod 2. The div is the input to the next iteration,
                  `   the mod gives us the next bit.
    >>]           `   Increment twice (gives 2 or 3) and put at the bottom
                  `   of the stack.
  }
  >]              ` Increment the 0 and put it at the bottom as well.
}
$                 ` Reverse the entire stack.
{<#}              ` Decrement and print each number.

Et enfin, nous repoussons les données et imprimons chaque valeur sous forme de caractère:

%{@}

Pour référence future, voici un script CJam pour coder les données.

— Martin Ender
source
17

Fueue , 423 octets

Fueue est un esolang basé sur une file d'attente dans lequel le programme en cours est la file d'attente.

)$$4255%%1(~):[)$$24%%0:<[~:)~)]~[$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<]](H-):~:[)[):~[)~:~~([:~)*[):~[$1(+48]):~+]-:~~)10)~~]/]+:5):]~:](106328966328112328136317639696111819119696281563139628116326221310190661962811611211962861109696289611619628116111612896281115421063633063961111116163963011632811111819159628151213262722151522061361613096119619190661966311961128966130281807072220060611612811961019070723232022060611

Essayez-le en ligne!

Comment ça fonctionne

Cette explication peut ou peut ne pas être échappée de la main. D'autre part, je ne sais pas comment l'expliquer de manière beaucoup plus courte, j'espère que les gens pourront suivre.

Aide-mémoire Fueue

Voir l' article du wiki esolang pour plus de détails, y compris les quelques fonctionnalités non utilisées dans ce programme.

  • Le programme initial est l'état initial de la file d'attente, qui peut contenir les éléments suivants:

    • Les littéraux entiers (non négatifs uniquement dans la source, mais les négatifs peuvent être calculés), en les exécutant imprime un caractère.
    • Blocs imbriqués délimités par des crochets, inertes (conservés intacts sauf si une fonction agit sur eux).
    • Fonctions, leurs arguments sont les éléments qui les suivent immédiatement dans la file d'attente:
      • +*/-%: arithmétique entière ( -est unaire, %négation logique). Inerte si pas d'arguments numériques.
      • ()<: mettre l'élément entre crochets, supprimer les crochets du bloc, ajouter le dernier élément au bloc. Les deux derniers sont inertes sauf s’ils sont suivis d’un bloc.
      • ~:: échange, dupliquer.
      • $: copie (prend nombre + élément). Inerte avant non-nombre.
      • H: arrêter le programme.

    Notez que []nid, ()ne le faites pas - ces derniers sont simplement des fonctions séparées.

Syntaxe de trace d'exécution

Les espaces sont facultatifs dans Fueue, sauf entre les chiffres. Dans les traces d'exécution suivantes, il sera utilisé pour suggérer la structure du programme, en particulier:

  • Lorsqu'une fonction s'exécute, ses arguments et ses arguments sont définis à partir des éléments entourés d'espaces. Si certains des arguments sont compliqués, il peut également y avoir un espace entre eux.
  • De nombreuses traces d'exécution sont divisées en un "blob de délai" sur la gauche, séparé d'une partie à droite qui effectue la manipulation substantielle des données. Voir la section suivante.

Les accolades {}(non utilisées dans Fueue) sont utilisées dans les traces pour représenter le résultat entier d'expressions mathématiques. Cela inclut les nombres négatifs, comme Fueue n'a que des littéraux non négatifs - -est la fonction de négation.

Différents noms métavariables ...sont utilisés pour désigner les valeurs et les abréviations.

Tactique dilatoire

Intuitivement, l'exécution tourne autour de la file d'attente, modifiant partiellement ce qu'elle traverse. Les résultats d'une fonction ne peuvent plus être utilisés avant le cycle suivant. Différentes parties du programme évoluent efficacement en parallèle tant qu'elles n'interagissent pas.

En conséquence, une grande partie du code est consacrée à la synchronisation, en particulier au retardement de l'exécution de parties du programme jusqu'au moment opportun. Il y a beaucoup d'options pour jouer au golf, ce qui a tendance à transformer ces parties en blobs illisibles qui ne peuvent être compris qu'en traçant leur cycle d'exécution par cycle.

Ces tactiques ne seront pas toujours mentionnées individuellement ci-dessous:

  • )[A]retards Apour un cycle. (Probablement la méthode la plus facile et la plus lisible.)
  • ~efpermute les éléments eet fretarde également leur exécution. (Probablement le moins lisible, mais souvent le plus court pour les retards mineurs.)
  • $1eretarde un seul élément e.
  • -et %sont utiles pour retarder des nombres (ces derniers pour 0et 1.)
  • Lors du retard de plusieurs éléments égaux dans une ligne, :ou $peut être utilisé pour les créer à partir d'un seul.
  • (nles enveloppes nentre parenthèses peuvent être supprimées ultérieurement. Ceci est particulièrement vital pour les calculs numériques, car les nombres sont trop instables pour être même copiés sans les mettre d'abord dans un bloc.

Structure générale

Le reste de l'explication est divisé en sept parties, chacune correspondant à une section du programme en cours. Les cycles les plus longs, après lesquels la plupart d’entre eux se répètent, seront appelés "itérations" pour les distinguer des "cycles" de passages uniques dans toute la file.

Voici comment le programme initial est divisé entre eux:

A:  )$$4255%%1(~
B:  ):[)$$24%%0:<[~:)~)]~[$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<]]
C:  
D:  (H-
E:  
F:  
G:  ):~:[)[):~[)~:~~([:~)*[):~[$1(+48]):~+]-:~~)10)~~]/]+:5):]~:](106328966328112328136317639696111819119696281563139628116326221310190661962811611211962861109696289611619628116111612896281115421063633063961111116163963011632811111819159628151213262722151522061361613096119619190661966311961128966130281807072220060611612811961019070723232022060611

Le grand chiffre à la fin du programme code le reste en inverse, deux chiffres par caractère, avec 30 soustractions de chaque valeur ASCII (donc, par exemple, 10code a (.)

À un niveau supérieur, vous pouvez penser que les données de ce programme (à commencer par le bignum) vont de droite à gauche, alors que le contrôle coule de gauche à droite. Cependant, à un niveau inférieur, Fueue brouille constamment la distinction entre code et données.

  • La section G décode le bignum en chiffres ASCII (par exemple, digit en 0tant qu’entier 48), en séparant d’abord les chiffres les moins significatifs. Il produit un chiffre tous les 15 cycles.
  • La section F contient les valeurs numériques ASCII produites (chacune dans un bloc) jusqu'à ce que la section E puisse les consommer.
  • La section E traite les chiffres produits deux à la fois, en les associant dans des blocs du formulaire [x[y]]et en imprimant également le caractère codé de chaque paire.
  • La section D consiste en un bloc profondément imbriqué, construit progressivement à partir des [x[y]]blocs, de sorte qu'une fois qu'il contient tous les chiffres, il peut être exécuté pour les imprimer tous, puis arrêter l'ensemble du programme.
  • La section C traite de la construction de la section D et recrée également la section E.
  • La section B recrée la section C ainsi que elle-même tous les 30 cycles.
  • La section A compte à rebours les cycles jusqu'à la dernière itération des autres sections. Ensuite, il abandonne la section B et exécute la section D.

Section A

La section A traite de la planification de la fin du programme. Il faut 4258 cycles pour réduire à une seule fonction d'échange ~, qui effectue ensuite un ajustement à la section B qui arrête sa boucle principale et commence à exécuter la section D à la place.

)$ $4255% %1 (~
)$%%%...%% %0 [~]
)$%%%...% %1 [~]
⋮
)$ %0 [~]
) $1[~]
)[~]
~
  • Une $fonction crée 4255 copies de ce qui suit %tandis que le (retour à la ligne est mis ~entre crochets.
  • Chaque cycle, le dernier %est utilisé pour faire basculer le nombre suivant entre 0et 1.
  • Lorsque tous les %s sont utilisés, le $1crée une copie du [~](effectivement un NOP), et au cycle suivant le )supprime les crochets.

Section B

La section B gère la régénération et une nouvelle itération de la section C tous les 30 cycles.

) : [)$$24%%0:<[~:)~)]~[$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<]]
) [)$$24%%0:<[~:)~)]~[$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<]]            [BkB]
)$ $24%     %0  :<  [~:)~)]    ~ [$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<] [BkB]
)$ %...%%% %1   < < [~:)~)] [BkB]   [$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<]
)$ %...%% %0      < [~:)~)[BkB]] [$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<]
)$ %...% %1         [~:)~)[BkB][$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<]]
⋮
) $1 [~:)~)[BkB][$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<]]
) [~:)~)[BkB][$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<]]                    (1)
~:) ~)[BkB]                 [$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<]
) : [BkB]                 ) [$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<]      (2)
) [BkB] [BkB]               $11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<
  • Un :duplique le gros bloc suivant (une copie abrégée [BkB]), puis )supprime les crochets de la première copie.
  • $$24%%0 met en place un compte à rebours similaire à celui de la section A.
  • Tandis que ce compte à rebours :<décale , se transforme en <<et ~échange deux blocs, plaçant le code d’une nouvelle section C en dernier.
  • Les deux <fonctions regroupent les deux derniers blocs dans le premier - ceci est redondant dans les itérations normales, mais permettra à la ~section A de faire son travail à la fin.
  • (1) Lorsque le compte à rebours est terminé, le )supprime les crochets extérieurs. Next se ~:)transforme en ):et bascule ~)a )au début du code de la section C.
  • (2) La section B est maintenant revenue à son cycle initial, alors que a )est sur le point de supprimer les crochets pour commencer à exécuter une nouvelle itération de la section C.

Dans la dernière itération, le ~from de la section A apparaît au point (1) ci-dessus:

~ ) [~:)~)[BkB][$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<]]                  (1)
[~:)~)[BkB][$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<]]              )

Ils ~basculent à )travers le bloc et dans la section C, empêchant la section B d’être réexécutée.

Section C

La section C gère la fusion de nouvelles paires de caractères numériques dans le bloc de la section D, ainsi que la création de nouvelles itérations de la section E.

L'illustration ci-dessous montre une itération typique avec xet yreprésentant les codes ASCII des chiffres. À la toute première itération, les éléments "D" et "E" entrants sont les éléments initiaux [H]et, à la -place, aucune section précédente E n’ayant été exécutée pour produire des paires de caractères numériques.

C                                               D             E
$11~ )  ~<[[+$4--498+*-:~-10)):])<~]  [)))~]  < [)))~[...]]   [x[y]]
~~~ ~~~ ~~~ ~~) [[+$4--498+*-:~-10)):])<~]  < [)))~] [)))~[...][x[y]]]
~~~ ~~~     )  ~ [[+$4--498+*-:~-10)):])<~] [)))~[)))~[...][x[y]]]]
~~~       ~ )   [)))~[....]]                                  [[+$4--498+*-:~-10)):])<~]
                                              ~~[)))~[....]] )[[+$4--498+*-:~-10)):])<~]
                                                [)))~[....]]  ~[+$4--498+*-:~-10)):])<~
  • Ceci utilise une méthode de synchronisation différente que j'ai découverte pour cette réponse. Lorsque vous avez plusieurs fonctions d'échange ~dans une ligne, celle-ci sera réduite d'environ 2/3 à chaque cycle (car on ~échange deux suivantes), mais parfois avec un reste de ~s qui fait des ravages, manipule soigneusement ce qui suit.
  • $11~produit une telle ligne. La prochaine ~échange un à <travers le bloc suivant. Un autre <à la fin ajoute un nouveau bloc de paires de chiffres (les chiffres x et y sous forme de codes ASCII) dans le bloc de la section D.
  • Au cycle suivant, la ~ligne a un ~~reste qui remplace ~le suivant ). L'autre <ajoute la section D à un [)))~]bloc.
  • Ensuite, le commutateur ~lui-même permute le bloc suivant avec le nouveau code de section E dans le bloc de section D. Ensuite, un nouveau reste ~bascule a )travers, et finalement le dernier ~~de la ~rangée échange l'un d'entre eux contre la section E, tout comme il )a supprimé ses crochets.

Lors de la dernière itération, les sections A ~ont remplacé les )sections B par les sections C. Toutefois, la section C est si courte qu'elle a déjà disparu et )se termine au début de la section D.

Section D

La section D traite de l’impression du grand chiffre final et de l’arrêt du programme. Pendant la majeure partie du programme, les sections B – G coopèrent pour la construction.

    (H -
    [H]-
    ⋮
    [)))~[H-]]                  After one iteration of section C
    ⋮
    [)))~[)))~[H-][49[49]]]]    Second iteration, after E has also run
    ⋮
)   [)))~[...]]     [49[48]]    Final printing starts as ) is swapped in
    ))) ~[...][49[48]]
    )) )[49[48]] [...]
    )) 49 [48][...]             Print first 1
    ) )[48] [...]
    ) 48 [...]                  Print 0
    )[...]                      Recurse to inner block
    ...
    ⋮
    )[H-]                       Innermost block reached
    H -                         Program halts
  • Dans le premier cycle du programme, un (encapsule la fonction d’arrêt Hentre parenthèses. A -suit, il sera utilisé comme élément factice pour la première itération au lieu d’une paire de chiffres.
  • La première paire de chiffres réels incorporée [49[49]]correspond au dernier 11dans le chiffre.
  • La toute dernière paire de chiffres [49[48]](correspondant 10au début du chiffre) n'est pas réellement incorporée dans le bloc, mais cela ne fait aucune différence car )[A[B]]et )[A][B]sont équivalents, les deux se transformant en A[B].

Après l'itération finale, la )permutation vers la droite de la section B arrive et le bloc de la section D est débloqué. Au )))~début de chaque sous-bloc, vous vous assurez que toutes les pièces sont exécutées dans le bon ordre. Enfin, le bloc le plus à l'intérieur contient un Harrêt du programme.

Section E

La section E gère la combinaison de paires de chiffres ASCII générés par la section G et imprime le caractère codé correspondant et envoie un bloc avec la paire combinée vers la gauche aux sections C et D.

Encore une fois, ci-dessous montre une itération typique avec xet yreprésentant les codes ASCII des chiffres.

E                                                   F
~ [+$4--498+*-:~-10)):] )              <  ~         [y] [x]
) [+$4--498+*-:~-10)):]                   < [x] [y]
+ $4-  - 498  +*- :~ -10 ) )              : [x[y]]
+---  -{-498} +*- ~~{-10} )       ) [x[y]]  [x[y]]
+--    - 498  +*   -{-10}       ~ ) x  [y]  [x[y]]
+-    -{-498} +               * 10 x  )[y]  [x[y]]
+      - 498                    + {10*x} y  [x[y]]
                         + {-498} {10*x+y}  [x[y]]
{10*x+y-498}  [x[y]]
[x[y]]
  • Les blocs de chiffres entrants sont permutés, puis le bloc y est ajouté au bloc x et le bloc de paires entier est copié. Un exemplaire sera laissé jusqu'à la fin pour les sections C et D.
  • L'autre copie est à nouveau débloquée, puis une séquence de fonctions arithmétiques est appliquée pour calculer 10*x+y-498la valeur ASCII du caractère codé. 498 = 10*48+48-30, le 48s annule l’encodage ASCII de xet ytandis que le 30décale l’encodage de 00–99à 30–129, qui inclut tout l’ASCII imprimable.
  • Le nombre résultant est alors laissé à exécuter, ce qui affiche son caractère.

Section F

La section F comprend des blocs inertes contenant des codes de chiffres ASCII. Pour la majeure partie du programme, il y en aura au plus deux ici, car la section E les consomme à la même vitesse que G les produit. Cependant, lors de la phase d'impression finale, certains 0chiffres redondants seront collectés ici.

[y] [x] ...

Section G

La section G gère le fractionnement du grand nombre à la fin du programme, les chiffres les moins significatifs en premier, et l'envoi de blocs avec leurs codes ASCII à gauche des autres sections.

Comme il n'a pas de vérification d'arrêt, il continuera à produire des 0chiffres lorsque le nombre sera réduit à 0, jusqu'à ce que la section D interrompe tout le programme avec la Hfonction.

[BkG] abrégé une copie du gros bloc de code de départ, qui est utilisé pour l'auto-réplication pour démarrer de nouvelles itérations.

Initialisation dans les premiers cycles:

) :~  : [)[):~[)~:~~([:~)*[):~[$1(+48]):~+]-:~~)10)~~]/]+:5):]~:]  ( 106328966328112328136317639696111819119696281563139628116326221310190661962811611211962861109696289611619628116111612896281115421063633063961111116163963011632811111819159628151213262722151522061361613096119619190661966311961128966130281807072220060611612811961019070723232022060611
)  ~ ~ [)[):~[)~:~~([:~)*[):~[$1(+48]):~+]-:~~)10)~~]/]+:5):]~:]  [BkG] [10...11]
) [)[):~[)~:~~([:~)*[):~[$1(+48]):~+]-:~~)10)~~]/]+:5):]~:]     ~ [BkG] [10...11]
) [):~[)~:~~([:~)*[):~[$1(+48]):~+]-:~~)10)~~]/]+:5):]       ~ : [10...11]  [BkG]

Itération typique, Nindique le nombre à diviser:

) [):~[)~:~~([:~)*[):~[$1(+48]):~+]-:~~)10)~~]/]+:5):]        ~ : [N]  [BkG]
) :~ [)~:~~([:~)*[):~[$1(+48]):~+]-:~~)10)~~]/]+ :5 )         : [N]  : [BkG]
)  ~ ~ [)~:~~([:~)*[):~[$1(+48]):~+]-:~~)10)~~]/]  +5 5     ) [N]  [N] [BkG] [BkG]
) [)~:~~([:~)*[):~[$1(+48]):~+]-:~~)10)~~]/]               ~ 10 N  [N] [BkG] [BkG]
) ~:~  ~ ( [:~)*[):~[$1(+48]):~+]-:~~)10)~~]               / N 10  [N] [BkG] [BkG]
)  ~ : [:~)*[):~[$1(+48]):~+]-:~~)10)~~]                 ( {N/10}  [N] [BkG] [BkG]
) [:~)*[):~[$1(+48]):~+]-:~~)10)~~]                    : [{N/10}]  [N] [BkG] [BkG]
:~ )*[):~[$1(+48]):~+]- :~ ~)10 )           ~ ~ [{N/10}]  [{N/10}] [N] [BkG] [BkG]
~~) *[):~[$1(+48]):~+]- ~~10 )             ) [{N/10}]  ~ [{N/10}] [N]  [BkG] [BkG]
)  ~ * [):~[$1(+48]):~+]  -10            ~ ) {N/10}  [N] [{N/10}] [BkG] [BkG]
) [):~[$1(+48]):~+]               * {-10} {N/10}  ) [N]  [{N/10}] [BkG] [BkG]
) :~ [$1(+48]) :~                 + {-10*(N/10)} N  [{N/10}] [BkG] [BkG]
)  ~ ~ [$1(+48]  )                 ~ ~ {N%10}  [{N/10}] [BkG] [BkG]
) [$1(+48]                 ~ ) {N%10}  ~ [{N/10}] [BkG]  [BkG]
$1(                     + 48 {N%10}    ) [BkG]  [{N/10}] [BkG]
                        ( {48+N%10}   BkG [{N/10}] [BkG]            New iteration starts
                        [{48+N%10}]   ....
  • La tâche de retard ici est particulièrement poilue. Cependant, la seule nouvelle astuce de retardement consiste à utiliser +:5au lieu de --10retarder 10deux cycles. Hélas, un seul des participants 10au programme en a bénéficié.
  • Les blocs [N]et [BkG]sont dupliqués, puis une copie de Nest divisée par 10.
  • [{N/10}]est dupliqué, plusieurs fonctions arithmétiques sont utilisées pour calculer le code ASCII du dernier chiffre de Nas 48+((-10)*(N/10)+N). Le bloc avec ce code ASCII est laissé pour la section F.
  • L'autre copie de [{N/10}]est échangée entre les [BkG]blocs pour définir le début d'une nouvelle itération.

Bonus Quine (540 octets)

)$$3371%%1[~!~~!)!]):[)$$20%%0[):]~)~~[)$$12%%0[<$$7%~~0):~[+----48+*-~~10))]<]<~!:~)~~[40~[:~))~:~[)~(~~/[+--48):]~10]+30])):]]][)[H]](11(06(06(21(21(25(19(07(07(19(61(96(03(96(96(03(11(03(63(11(28(61(11(06(06(20(18(07(07(18(61(11(28(63(96(11(96(96(61(11(06(06(19(20(07(07(18(61(30(06(06(25(07(96(96(18(11(28(96(61(13(15(15(15(15(22(26(13(12(15(96(96(19(18(11(11(63(30(63(30(96(03(28(96(11(96(96(61(22(18(96(61(28(96(11(11(96(28(96(61(11(96(10(96(96(17(61(13(15(15(22(26(11(28(63(96(19(18(63(13(21(18(63(11(11(28(63(63(63(61(11(61(42(63(63

Essayez-le en ligne!

Comme je ne savais pas quelle méthode serait la plus courte, j'ai d'abord essayé de coder les caractères sous forme de nombres à deux chiffres séparés par (s. Le code de base est un peu plus court, mais la représentation de données 50% plus grande le compense. Pas aussi golfé que l'autre, car je me suis arrêté quand j'ai réalisé que ça ne battrait pas. Il a un avantage: il ne nécessite pas d'implémentation avec le support bignum.

Sa structure générale est quelque peu similaire à celle principale. La section G est manquante car la représentation des données remplit directement la section F. Cependant, la section E doit effectuer un calcul de divmod similaire pour reconstruire les chiffres des nombres à deux chiffres.

— Ørjan Johansen
source
1
Vous devriez
— jouer au
1
)$n[)](est un octet plus court pour le compteur de délai.
— jimmy23013
15

Gelée, 3 octets

”ṘṘ

Essayez-le en ligne!

Vérification

$ echo $LANG
en_US
$ xxd -g 1 quine.jelly
0000000: ff cc cc                                         ...
$ ./jelly f quine.jelly | xxd -g 1
0000000: ff cc cc                                         ...

Comment ça fonctionne

”ṘṘ    Main link. No input.

”Ṙ     Set the return value to the character 'Ṙ'.
  Ṙ    Print a string representation of the return value.
       This prints: ”Ṙ
       (implicit) Print the return value.
       This prints: Ṙ
— Dennis
source
Quelle version de l'interprète utilise-t-elle? Lorsque je le teste, il sort dans UTF-8 même si l'entrée est dans la page de codes de Jelly (et le changement de codage le rendrait non-quine).
1
Le codage de la sortie dépend des paramètres de votre terminal: s'il est défini sur UTF-x, il l'utilise; s'il est réglé sur autre chose, il utilise la page de code de Jelly. Sous Linux, LANG=en_USréalise exactement cela. tio.run/nexus/bash#@@/…
— Dennis
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.