var QUESTION_ID=69;
var OVERRIDE_USER=98;
var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe";var COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk";var answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;function answersUrl(index){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+index+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}
function commentUrl(index,answers){return"https://api.stackexchange.com/2.2/answers/"+answers.join(';')+"/comments?page="+index+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}
function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(data){answers.push.apply(answers,data.items);answers_hash=[];answer_ids=[];data.items.forEach(function(a){a.comments=[];var id=+a.share_link.match(/\d+/);answer_ids.push(id);answers_hash[id]=a});if(!data.has_more)more_answers=!1;comment_page=1;getComments()}})}
function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(data){data.items.forEach(function(c){if(c.owner.user_id===OVERRIDE_USER)
answers_hash[c.post_id].comments.push(c)});if(data.has_more)getComments();else if(more_answers)getAnswers();else process()}})}
getAnswers();var SCORE_REG=(function(){var headerTag=String.raw `h\d`
var score=String.raw `\-?\d+\.?\d*`
var normalText=String.raw `[^\n<>]*`
var strikethrough=String.raw `<s>${normalText}</s>|<strike>${normalText}</strike>|<del>${normalText}</del>`
var noDigitText=String.raw `[^\n\d<>]*`
var htmlTag=String.raw `<[^\n<>]+>`
return new RegExp(String.raw `<${headerTag}>`+String.raw `\s*([^\n,]*[^\s,]),.*?`+String.raw `(${score})`+String.raw `(?=`+String.raw `${noDigitText}`+String.raw `(?:(?:${strikethrough}|${htmlTag})${noDigitText})*`+String.raw `</${headerTag}>`+String.raw `)`)})();var OVERRIDE_REG=/^Override\s*header:\s*/i;function getAuthorName(a){return a.owner.display_name}
function process(){var valid=[];answers.forEach(function(a){var body=a.body;a.comments.forEach(function(c){if(OVERRIDE_REG.test(c.body))
body='<h1>'+c.body.replace(OVERRIDE_REG,'')+'</h1>'});var match=body.match(SCORE_REG);if(match)
valid.push({user:getAuthorName(a),size:+match[2],language:match[1],link:a.share_link,})});valid.sort(function(a,b){var aB=a.size,bB=b.size;return aB-bB});var languages={};var place=1;var lastSize=null;var lastPlace=1;valid.forEach(function(a){if(a.size!=lastSize)
lastPlace=place;lastSize=a.size;++place;var answer=jQuery("#answer-template").html();answer=answer.replace("{{PLACE}}",lastPlace+".").replace("{{NAME}}",a.user).replace("{{LANGUAGE}}",a.language).replace("{{SIZE}}",a.size).replace("{{LINK}}",a.link);answer=jQuery(answer);jQuery("#answers").append(answer);var lang=a.language;lang=jQuery('<i>'+a.language+'</i>').text().toLowerCase();languages[lang]=languages[lang]||{lang:a.language,user:a.user,size:a.size,link:a.link,uniq:lang}});var langs=[];for(var lang in languages)
if(languages.hasOwnProperty(lang))
langs.push(languages[lang]);langs.sort(function(a,b){if(a.uniq>b.uniq)return 1;if(a.uniq<b.uniq)return-1;return 0});for(var i=0;i<langs.length;++i)
{var language=jQuery("#language-template").html();var lang=langs[i];language=language.replace("{{LANGUAGE}}",lang.lang).replace("{{NAME}}",lang.user).replace("{{SIZE}}",lang.size).replace("{{LINK}}",lang.link);language=jQuery(language);jQuery("#languages").append(language)}}
body{text-align:left!important}#answer-list{padding:10px;float:left}#language-list{padding:10px;float:left}table thead{font-weight:700}table td{padding:5px}
<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="https://cdn.sstatic.net/Sites/codegolf/primary.css?v=f52df912b654"> <div id="language-list"> <h2>Winners by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr></thead> <tbody id="languages"> </tbody> </table> </div><div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr></thead> <tbody id="answers"> </tbody> </table> </div><table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td><a href="{{LINK}}">{{SIZE}}</a></td></tr></tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td><a href="{{LINK}}">{{SIZE}}</a></td></tr></tbody> </table>
Réponses:
Hexagone , longueur de côté
1716,816705 octetsEssayez-le en ligne!
Voici à quoi cela ressemble déplié:
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:
la source
!
, 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?MySQL, 167 caractères
C'est vrai. :-)
J'ai vraiment écrit celui-ci moi-même. Il a été initialement publié sur mon site .
la source
GolfScript, 2 octets
(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
: poussez 9 à la pile,
: consomme le 9 comme argument, place le tableau[0 1 2 3 4 5 6 7 8]
dans la pile(
: consomme le tableau en argument, pousse le tableau[1 2 3 4 5 6 7 8]
et l'élément0
vers la pile;
: élimine le premier élément de la pileLa 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.la source
1
n'est pas un Quine dans GolfScript: il sort1\n
, où\n
désigne un saut de ligne. Cependant, le programme de deux personnages1\n
est une quine.\n
probablement aussi?Brain-Flak ,
9.8e5801.3e5629.3e51612818110244452433242404200418038523656361635402485 + 3 = 2488 octetsS'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.
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
la source
Prelude ,
5 1574 5142 34817611537664569535423241214184178175169148142136133 octetsMerci à Sp3000 pour la sauvegarde de 3 octets.
C’est plutôt long ...(bon, c’est encore long ... au moins, il bat le plus petitBrainfuckC #connusur 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. :)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
42
pousseront a4
, puis a2
. 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 avecv
et^
. 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
^
etv
est synonyme. C’est bien parce quev
le 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 par2
une 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,0
a un 0 dans sa représentation (50), mais nous n’avons vraiment pas besoin0
du 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:
Diviser en paires et inverser, puis soustraire deux, puis rechercher les codes de caractère:
où
32
est 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:
Premièrement, nous poussons une
7
voix 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 que7
nous 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. Le7
nous avons poussé sur la première pile est toujours là, donc la boucle se répète.Cette fois, il y a aussi un
7
sur 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 maintenant7
, 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=
: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 le7
premier 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:
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
2
ne fait pas partie de la boucle, donc le corps de la boucle est en fait+8+2
ce qui ajoute 10 (en utilisant le2
poussé 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
-7
en bas). Le reste est assez simple: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
8
temps et ajoute à6
chaque fois. Le résultat est imprimé avec!
et8
la fin est pour la prochaine itération.Alors qu'en est-il
-7
? Oui,48 - 7 = 41
qui est le code de caractère de)
. La magie!Enfin, lorsque nous avons terminé avec cette boucle, nous éliminons le bouton que
8
nous 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.la source
Hexagone , longueur de côté 11, 314 octets
Essayez-le en ligne!
Ancienne version:
Hexagone , longueur de côté 11, 330 octets
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é:
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.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.!
l'imprime,et
$
saute à travers la suivante>
.À partir du
<
. Si la valeur de la mémoiremem
est falsy (<= 0
c'est-à-dire que la conditionmem > 0
n'est pas remplie), nous avons imprimé le programme et devons quitter. L'IP suivrait le chemin supérieur.(laissez l'IP parcourir
le mondependant 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.
Maintenant, la mémoire ressemble à ceci:
Si la valeur est la vérité:
le code suivant est exécuté:
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,
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
En supposant que nous laissions
a
la valeur de la cellule en cours etb
celle de la bonne cellule, une traduction directe en BF est la suivante: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
a
ce que nous sommes au début de chaque itération, alors nous avons ce code: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:
\
qui le reflète, maintenant il se dirige vers le haut)
Si la valeur (de l'opération 2 du mod 2 ci-dessus) est falsy (zéro), alors nous suivons ce chemin:
Je ne vais pas expliquer trop en détail ici, mais l'offset n'est pas vraiment
33
, mais correspond au33
mod256
. Etchr
a un implicite% 256
.la source
Vim, 11 octets
iq"qP<Esc>
: Insère manuellement une copie du texte devant être en dehors de l'enregistrement.q"
ethqP
: enregistrez l’intérieur directement dans le""
registre sans nom afin qu’il puisse être collé au milieu. Leh
est 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,"0
pour les virements ou"1
pour 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"0
mais 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.
la source
y
ou quelque chose avant de courir peut aider␛
pour montrer en appuyant sur la touche <Échap>? Partie de ce bloc Unicode «Images de contrôle»<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.Cubix , 20 octets
J'ai presque le
\o/
...Net :
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:
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
,S
etQ
qui poussent10
,32
et34
respectivement, 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 leQ
(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.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):
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
Q
au 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.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:
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).
C'est une boucle, comme vous l'avez peut-être vu / attendu. Le corps principal est:
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.la source
Javascript ES6 - 21 octets
J'appelle cette quine "The Bling Quine".
Parfois, il faut jouer au golf avec style.
la source
!$=_=>`!$=${$}()`()
vous économisez 2 octets?Invalid assignment left hand side
. Souhaite que cela fonctionne :(Array.prototype.join
.alert
ouconsole.log
après la fonction de flèche et le renvoi entre parenthèses de la chaîne de modèle fonctionneraient.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!
la source
ESultanik's Quine!
configure la mémoire en tant que pile de codageESultanik'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.Hexagone , longueur de côté
15 14 1312,616 533 456383 octetsAprè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.
Essayez-le en ligne!
Déplié:
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:Le numéro est encodé dans la première moitié de l'hexagone, avec tous les
sur le côté gauche et le
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
->
:!
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
.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é: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
Ceci exécute
='=:'
ce qui divise le nombre actuel par 80 et navigue vers la cellule correcte.Ancienne version (longueur 13)
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.
la source
PostScript, 20 caractères
Court et légitime. 20 caractères, y compris le retour à la ligne.
la source
Cubix , 45 octets
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:
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;
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.La
u
commande 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.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 laW
commande é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é unR
, tourner à droite et aller à gauche le long de la rangée supérieure; puis le$
saute leR
via 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.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 lao
commande, ce qui rend la cinquième colonne entièrement vide. Nous revenons donc à lau
commande, 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éeo
précédemment pour ignorer la commande.) Nous rencontrons une paire deR
commandes et les utilisons pour faire un demi-tour "manuel" (la deuxièmeR
commande a été utilisée plus tôt pour atteindre la première rangée, il semblait donc tout à fait naturel d’adapter une autreR
commande à côté.W
commande, 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'uno
(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) .
la source
"
estQ
.Python 2, 30 octets
Tiré d'ici
la source
_
, 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
Vim,
17, 14 frappesQuelqu'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 :
Ceci est la première quine que j'ai jamais faite, et
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:
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ésente0x1B
, 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
ou tapez
qqq
avant d'exécuter ceci.Explication:
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.
la source
2i2i<esc>
est si proche. Je pense que je peux faire quelque chose pour que cela fonctionne.<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.q"iq"qbP<Esc>qbP
Aprè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.Lost ,
120 116 98 96 76 7066 octetsEdit: oui, moins de 100
Edit: enregistré un tas d'octets en basculant vers tous les
/
s sur la ligne du basEssayez-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?1
consiste à 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.la source
Ce sont les deux quines Ruby les plus courtes de SO :
et
Ne me demandez pas comment fonctionne le second ...
la source
<<2
commence une chaîne sur la ligne suivante et*2
répète la chaîneFission , 6 octets
Il semble que ce soit maintenant la quine "correcte" la plus courte parmi ces réponses.
Explication
Le flux de contrôle commence
R
avec 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'!+OR
avant 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"
etO
imprime 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 avecO
.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
J
umpEncore une fois, le code commence à
R
. Les@
échanges de masse et d'énergie à donner(0,1)
. Par conséquent, l'J
atome saute par-dessus laO
droite 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''"O
impression"
. 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
Cela a deux atomes, partant de gauche à
L
droiteR
. L'atome de gauche obtient sa valeur définie par'"
laquelle est immédiatement imprimé avecO
(et l'atome détruit). Pour l’atome de droite, nous échangeons à nouveau la masse et l’énergie, nous sautons par dessusO
pour imprimer le reste du code en mode impression. Ensuite, sa valeur est définie par'L
mais peu importe, car l’atome est ensuite rejeté;
.la source
'!+
encode"
.|R@JO"'
fonctionnerait-il ou auriez-vous toujours besoin de cet espace après le'
?'
premier.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:
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):Ou converti en bookmarklet (coûtant 22 caractères):
la source
C,
6460 octetsJusqu'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:
main(s)
les abusmain
'arguments, en déclarant une variable pratiquement non typées
. (Notez que ces
n'est pas réellement non typé, mais puisque les compilateurs listés le convertissent automatiquement si nécessaire, il pourrait aussi bien être *.)printf(s="..."
ensembless
la chaîne fournie et passe le premier argument àprintf
.s
est réglé surmain(s){printf(s=%c%s%1$c,34,s);}
.%c
est réglé sur ASCII34
,"
. Cela rend la quine possible.s
Ressemble maintenant à ceci:main(s){printf(s="%s%1$c,34,s);}
.%s
est réglé surs
lui-même, ce qui est possible grâce à # 2.s
Ressemble maintenant à ceci:main(s){printf(s="main(s){printf(s=%c%s%1$c,34,s);}%1$c,34,s);}
.%1$c
est réglé sur ASCII 34"
,printf
« s premier ** argument. Celas
ressemble 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
printf
le spécificateur de format était accessible via$
, cela fonctionnerait pour 52 octets:la source
s
est de typeint
, pas une "variable non typée".s=3
ne fonctionnerait évidemment pas parce que vous devez passer la chaîne deux foisprintf
.Java, 528 octets:
Une solution Java avec une approche originale:
sous forme lisible:
la source
if(++i==92)
,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ùabc
serait le nombre magique nouvellement calculé, String. Dans java 8+, il est également possible de passerclass a{public static void main
àinterface a{static void main
, et dans Java 10+, il est également possible de changerimport java.math.*;
etBigInteger b=new BigInteger(
devar b=new java.math.BigInteger(
.Poulet , 7
Non, ce n'est pas directement répercuté :)
la source
chicken
!Retina ,
201497 octetsAvant de commencer, je voudrais mentionner la solution triviale d’un fichier qui en contient un
0
. Dans ce cas, Retina essaiera de compter les0
s dans l'entrée vide, ce qui donnera également le résultat0
. 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.la source
Javascript (36 caractères)
C’est, AFAICT, la plus courte quine javascript publiée à ce jour.
la source
a
, vous pouvez accéder à son contenu en appelanta.toString
.a
exactement 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.!function a(){alert("!"+a+"()")}()
.(a=()=>alert(
($ a))))()
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:
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 quen
contient 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 lesn
impressions sans.Comme l'a souligné Thomas Kwa, le CJam quine à 7 octets peut également être adapté à une solution à 8 octets:
Encore une fois, nous avons besoin du saut de ligne de fuite.
la source
Labyrinth ,
12411053 octetsMerci à Sp3000 d’avoir joué 9 octets au golf, ce qui m’a permis de jouer 7 autres fois.
Essayez-le en ligne!
Explication
Labyrinth 101:
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:
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 lemod
et 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: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 obtenonsMaintenant, 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:
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: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:
Ou disposé linéairement:
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):
Une fois le
N
zé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 à6
nouveau. Cela rend le haut de la pile positif, donc l’IP tourne à droite (sud) et exécute le fichier9
. Le sommet de la pile est maintenant69
, 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:
Le problème est que maintenant nous avons changé le
"
en a3
, ce qui modifie également le nombre réel que nous voulons avoir. Et bien sûr, ce nombre ne se termine pas par3
. 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
3
endroit à 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:@
pour/
. Dans ce cas, nous pouvons utiliser n'importe quel chiffre1357
et 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._
). 26 choix offrent de nombreuses possibilités. Par exemple, pourA
tout 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.1
, le codage se termine également par1
. 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.la source
Lost ,
293262249 octetsEssayez-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.
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.
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
essentiellementemprunté le Klien Quine à Martin Ender .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.
la source
Yup ,
1165879606561540522498 + 7 = 505 octetsRequiert le
-cheat
drapeau pour permettre la définition des alias.Essayez-le en ligne!
Explication
Cela comporte deux parties (comme avec la plupart des quines). Les données:
Et le décodeur:
Les données sont simplement un codage binaire du décodeur (ou plutôt son inverse). Chacun
0
commence un nouveau caractère et les1
s et2
s sont respectivement les0
- et -1
bits.Notez que
0
est une commande standard Yup qui pousse un zéro, alors que1
et2
ne sont pas définis à ce stade. Cependant, nous affectons la totalité de la partie de données à la commande%
afin que le1
et2
puisse rester indéfini jusqu'à ce qu'il%
soit réellement utilisé.Ensuite, nous définissons quelques commandes supplémentaires:
<
décrémente le haut de la pile, l’>
incrémente.1
(de manière peu intuitive) double le sommet de la pile.2
le double et puis l'incrémente. Grâce à ces définitions, quelque chose comme0221111
laissera 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.
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.
la source
Fueue , 423 octets
Fueue est un esolang basé sur une file d'attente dans lequel le programme en cours est la file d'attente.
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:
+*/-%
: 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:
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]
retardsA
pour un cycle. (Probablement la méthode la plus facile et la plus lisible.)~ef
permute les élémentse
etf
retarde également leur exécution. (Probablement le moins lisible, mais souvent le plus court pour les retards mineurs.)$1e
retarde un seul élémente
.-
et%
sont utiles pour retarder des nombres (ces derniers pour0
et1
.):
ou$
peut être utilisé pour les créer à partir d'un seul.(n
les enveloppesn
entre 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:
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,
10
code 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.
0
tant qu’entier48
), en séparant d’abord les chiffres les moins significatifs. Il produit un chiffre tous les 15 cycles.[x[y]]
et en imprimant également le caractère codé de chaque paire.[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.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.$
fonction crée 4255 copies de ce qui suit%
tandis que le(
retour à la ligne est mis~
entre crochets.%
est utilisé pour faire basculer le nombre suivant entre0
et1
.%
s sont utilisés, le$1
cré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.
:
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.:<
décale , se transforme en<<
et~
échange deux blocs, plaçant le code d’une nouvelle section C en dernier.<
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.)
supprime les crochets extérieurs. Next se~:)
transforme en):
et bascule~)
a)
au début du code de la section C.)
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: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
x
ety
repré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.~
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 quifait 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.~
ligne a un~~
reste qui remplace~
le suivant)
. L'autre<
ajoute la section D à un[)))~]
bloc.~
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.
(
encapsule la fonction d’arrêtH
entre parenthèses. A-
suit, il sera utilisé comme élément factice pour la première itération au lieu d’une paire de chiffres.[49[49]]
correspond au dernier11
dans le chiffre.[49[48]]
(correspondant10
au 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 enA[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 unH
arrê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
x
ety
représentant les codes ASCII des chiffres.10*x+y-498
la valeur ASCII du caractère codé.498 = 10*48+48-30
, le48
s annule l’encodage ASCII dex
ety
tandis que le30
décale l’encodage de00–99
à30–129
, qui inclut tout l’ASCII imprimable.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
0
chiffres redondants seront collectés ici.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
0
chiffres lorsque le nombre sera réduit à 0, jusqu'à ce que la section D interrompe tout le programme avec laH
fonction.[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:
Itération typique,
N
indique le nombre à diviser:+:5
au lieu de--10
retarder10
deux cycles. Hélas, un seul des participants10
au programme en a bénéficié.[N]
et[BkG]
sont dupliqués, puis une copie deN
est divisée par10
.[{N/10}]
est dupliqué, plusieurs fonctions arithmétiques sont utilisées pour calculer le code ASCII du dernier chiffre deN
as48+((-10)*(N/10)+N)
. Le bloc avec ce code ASCII est laissé pour la section F.[{N/10}]
est échangée entre les[BkG]
blocs pour définir le début d'une nouvelle itération.Bonus Quine (540 octets)
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.
la source
)$n[)](
est un octet plus court pour le compteur de délai.Gelée, 3 octets
Essayez-le en ligne!
Vérification
Comment ça fonctionne
la source
LANG=en_US
réalise exactement cela. tio.run/nexus/bash#@@/…