Dans ce défi, vous devez écrire un programme ou une fonction qui ne prend aucune entrée et affiche ou renvoie une chaîne avec le même nombre d'octets que le programme lui-même. Il y a quelques règles:

• Vous pouvez uniquement générer des octets dans la plage ASCII imprimable (0x20 à 0x7E, inclus) ou des retours à la ligne (0x0A ou 0x0D).
• Votre code ne doit pas être un code, le code et la sortie doivent donc différer d'au moins un octet.
• Votre code doit avoir au moins un octet de long.
• Si votre sortie contient des nouvelles lignes de fin, celles-ci font partie du nombre d'octets.
• Si votre code nécessite des indicateurs de ligne de commande non standard, comptez-les comme d'habitude (en ajoutant la différence à un appel standard de l'implémentation de votre langue au nombre d'octets), et la longueur de la sortie doit correspondre au score de votre solution. Par exemple, si votre programme est abet requiert le drapeau non standard -n(nous supposerons qu'il ne peut pas être combiné avec des drapeaux standard, donc 3 octets), vous devez générer 5 octets au total.
• La sortie ne doit pas toujours être identique, tant que vous pouvez montrer que toutes les sorties possibles répondent aux exigences ci-dessus.
• Les règles quine habituelles ne s'appliquent pas . Vous pouvez lire le code source ou sa taille, mais je doute que cela soit plus court que le codage en dur dans la plupart des langues.

Vous pouvez écrire un programme ou une fonction et utiliser l’une des méthodes standard de sortie. Notez que si vous imprimez le résultat, vous pouvez choisir de l'imprimer soit sur la sortie standard, soit sur le flux d'erreur standard, mais un seul d'entre eux compte.

Vous pouvez utiliser n'importe quel langage de programmation , mais notez que ces failles sont interdites par défaut.

C'est du code-golf , donc la réponse valide la plus courte - mesurée en octets - est gagnante.

Classement

var QUESTION_ID=121056,OVERRIDE_USER=8478;function answersUrl(e){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"https://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&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(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.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(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/<a/.test(o)&&(o=jQuery(o).text()),s[o]=s[o]||{lang:e.language,user:e.user,size:e.size,link:e.link}});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){var F=function(a){return a.lang.replace(/<\/?a.*?>/g,"").toLowerCase()},el=F(e),sl=F(s);return el>sl?1:el<sl?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;

body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;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="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <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><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><table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table>

C (Linux moderne), 19 octets

main(){puts('s');}

Une fois compilé et exécuté, ceci affiche:

Segmentation fault

Excel, 11 octets

Version norvégienne:

=SMÅ(13^9)

Version anglaise (12 octets):

=LOWER(17^9)

Génère un nombre à n chiffres et le convertit en texte en le convertissant en minuscule.

Labyrinthe , 4 octets

!!>@

Essayez-le en ligne!

Impressions 0000

Explication

!   Print an implicit 0 from the stack.
!   Print an implicit 0 from the stack.
>   Rotate the source code right by one cell, so the code now becomes

    @!!>

    The IP is moved along, so it's now at the end of the line, which is 
    a dead end. So the IP turns around and starts moving left.
!   Print an implicit 0 from the stack.
!   Print an implicit 0 from the stack.
@   Terminate the program.

Bash (intégré seulement), 8 octets

{e,,}cho

Des impressions cho choet une nouvelle ligne.

Rétine , 2 octets

no

Essayez-le en ligne!

Des impressions 0et un saut de ligne.

Il y a beaucoup de solutions à 2 octets, mais je pense que c'est optimal. Par défaut, Retina imprime toujours un retour à la ligne de fin et s’en débarrasser prend trop d’octets. Il nous faut donc trouver un programme sur 1 octet qui laisse l’entrée vide inchangée. Je crois que le seul programme qui fait cela est le programme contenant un seul saut de ligne, qui est donc égal à la sortie et donc non autorisé par le défi.

La prochaine étape la plus simple consiste à utiliser Retina avec un seul chiffre (le nombre de correspondances de certaines expressions rationnelles par rapport à une entrée vide), et nous pouvons le faire avec beaucoup de modèles à 2 octets défaillants (ou correspondants).

Mathematica, 2 octets

4!

factoriel

24

C, 20 octets

f(){printf("%20d");}

Sort un certain nombre, complété d'espaces d'une longueur de 20. (Quel nombre? Quoi qu'il arrive ensuite dans la mémoire.)

Quelques exemples s'exécutent sur mon système:

llama@llama:...code/c/ppcg121056samelen$ ./a.out 
           -666605944
llama@llama:...code/c/ppcg121056samelen$ ./a.out 
          -1391039592
llama@llama:...code/c/ppcg121056samelen$ ./a.out 
           1727404696
llama@llama:...code/c/ppcg121056samelen$ ./a.out 
             10717352
llama@llama:...code/c/ppcg121056samelen$ ./a.out 
           1485936232

Il est dommage que la sortie ne puisse pas être constituée d'octets arbitraires, car cela aurait permis cette solution à 19 octets:

f(){write(1,f,19);}

qui fournit 19 octets de courrier indésirable, en commençant à fl'adresse de.

Bash sur Linux, 6

uname

(suivi d'une nouvelle ligne)

Sorties Linuxsuivies d'une nouvelle ligne.

Javascript ES6, 9 octets

Utilisation de chaînes de modèle

_=>`${_}`

f=

_=>`${_}`

console.log(f());
console.log(typeof f());

Schéma de pyramide , 74 43 42 octets

Sauvegardé 31 octets grâce à Khuldraeseth na'Barya! Enregistré 1 octet grâce à la solution redessinée de JoKing!

  ^
 /^\
^---^
-^ ^-
 -^-
 /2\
/ 8 \
-----

Essayez-le en ligne! Affiche le nombre à 41 chiffres 28^28 = 33145523113253374862572728253364605812736, suivi d'un retour à la ligne final.

Ancienne version

  ^
 / \
/out\
-----^
    /^\
   ^---^
  /1\ /9\
 /606\---
/51015\
-------

Essayez-le en ligne!

Sorties 71277303925397560663333806233294794013421332605135474842607729452115234375= 160651015 ** 9ou environ 10 ⁷⁴ .

Python 2 , 9 octets

print{+1}

Ceci imprime set([1])et un saut de ligne.

Essayez-le en ligne!

Python 2 , 9 octets

print 1e5

La sortie affichée contient une nouvelle ligne de fin.

Essayez-le en ligne!

brainfuck , 25 octets

--[-->+<]+++++[->-.....<]

Essayez-le en ligne! Remarque: Nécessite une implémentation avec des cellules non signées 8 bits.

Sortie:

~~~~~}}}}}|||||{{{{{zzzzz

Explication

--[         254
 -->+<]      /2 = 127 into the second cell
+++++[      Five times
 ->-.....<]  Print the second cell - 1 five times

C (Idéone), 14 octets

f(){warn(0);}

Sur Ideone , qui nomme son exécutable prog, le résultat suivant est affiché avec une nouvelle ligne.

prog: Success

C (GCC), 15 octets

f(){warn(00);}

Etant donné que GCC écrit un exécutable nommé a.outpar défaut (en l’absence d’indicateurs supplémentaires qui coûteraient des octets), les résultats suivants sont générés avec une nouvelle ligne.

a.out: Success

C (gcc) , 18 17 octets

f(){puts('@C');}

Notez qu'il y a un octet STX ( 0x02 ) entre @et C.

Essayez-le en ligne!

Portabilité

Cela a été testé avec gcc 6.3.1 et clang 3.9.1 sur Fedora 25, gcc 4.8.4 sur Ubuntu 14.04.4 et gcc 4.8.3 sur openSUSE 13.2, où il affiche la sortie suivante.

inux-x86-64.so.2

Je m'attends à ce que cela produise la même sortie avec toutes les versions de gcc, à condition qu'il soit compilé en un exécutable du type suivant.

ELF 64-bit LSB executable, x86-64, version 1 (SYSV), dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2

Différentes plates-formes nécessiteront une adresse mémoire différente et éventuellement un ordre différent pour les octets dans la constante de caractère multi-caractères.

Par exemple, remplacer @\2Cpar des @\2\4impressions exec/ld-elf.so.1et une nouvelle ligne sous FreeBSD 11 avec Clang 3.8.0.

Vérification hors ligne

$ printf "%b\n" "f(){puts('@\2C');}main(){f();}" > quine.c
$ gcc -w -o quine quine.c
$ ./quine
inux-x86-64.so.2
$ ./quine | wc -c
17

Comment ça fonctionne

Par défaut, ld utilise 0x400000 comme adresse de base du segment de texte, ce qui signifie que le contenu du ELF commence à l'adresse de mémoire 0x400000 .

Les 640 premiers octets du fichier ELF sont largement indépendants du code source réel. Par exemple, si la déclaration de f est suivie de main(){f();}et de rien d'autre, ils se présentent comme suit.

00000000: 7f 45 4c 46 02 01 01 00 00 00 00 00 00 00 00 00  .ELF............
00000010: 02 00 3e 00 01 00 00 00 00 04 40 00 00 00 00 00  ..>.......@.....
00000020: 40 00 00 00 00 00 00 00 e8 19 00 00 00 00 00 00  @...............
00000030: 00 00 00 00 40 00 38 00 09 00 40 00 1e 00 1b 00  ....@.8...@.....
00000040: 06 00 00 00 05 00 00 00 40 00 00 00 00 00 00 00  ........@.......
00000050: 40 00 40 00 00 00 00 00 40 00 40 00 00 00 00 00  @.@.....@.@.....
00000060: f8 01 00 00 00 00 00 00 f8 01 00 00 00 00 00 00  ................
00000070: 08 00 00 00 00 00 00 00 03 00 00 00 04 00 00 00  ................
00000080: 38 02 00 00 00 00 00 00 38 02 40 00 00 00 00 00  8.......8.@.....
00000090: 38 02 40 00 00 00 00 00 1c 00 00 00 00 00 00 00  8.@.............
000000a0: 1c 00 00 00 00 00 00 00 01 00 00 00 00 00 00 00  ................
000000b0: 01 00 00 00 05 00 00 00 00 00 00 00 00 00 00 00  ................
000000c0: 00 00 40 00 00 00 00 00 00 00 40 00 00 00 00 00  ..@.......@.....
000000d0: 04 07 00 00 00 00 00 00 04 07 00 00 00 00 00 00  ................
000000e0: 00 00 20 00 00 00 00 00 01 00 00 00 06 00 00 00  .. .............
000000f0: 08 0e 00 00 00 00 00 00 08 0e 60 00 00 00 00 00  ..........`.....
00000100: 08 0e 60 00 00 00 00 00 1c 02 00 00 00 00 00 00  ..`.............
00000110: 20 02 00 00 00 00 00 00 00 00 20 00 00 00 00 00   ......... .....
00000120: 02 00 00 00 06 00 00 00 20 0e 00 00 00 00 00 00  ........ .......
00000130: 20 0e 60 00 00 00 00 00 20 0e 60 00 00 00 00 00   .`..... .`.....
00000140: d0 01 00 00 00 00 00 00 d0 01 00 00 00 00 00 00  ................
00000150: 08 00 00 00 00 00 00 00 04 00 00 00 04 00 00 00  ................
00000160: 54 02 00 00 00 00 00 00 54 02 40 00 00 00 00 00  T.......T.@.....
00000170: 54 02 40 00 00 00 00 00 44 00 00 00 00 00 00 00  T.@.....D.......
00000180: 44 00 00 00 00 00 00 00 04 00 00 00 00 00 00 00  D...............
00000190: 50 e5 74 64 04 00 00 00 b0 05 00 00 00 00 00 00  P.td............
000001a0: b0 05 40 00 00 00 00 00 b0 05 40 00 00 00 00 00  ..@.......@.....
000001b0: 3c 00 00 00 00 00 00 00 3c 00 00 00 00 00 00 00  <.......<.......
000001c0: 04 00 00 00 00 00 00 00 51 e5 74 64 06 00 00 00  ........Q.td....
000001d0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  ................
000001e0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  ................
000001f0: 00 00 00 00 00 00 00 00 10 00 00 00 00 00 00 00  ................
00000200: 52 e5 74 64 04 00 00 00 08 0e 00 00 00 00 00 00  R.td............
00000210: 08 0e 60 00 00 00 00 00 08 0e 60 00 00 00 00 00  ..`.......`.....
00000220: f8 01 00 00 00 00 00 00 f8 01 00 00 00 00 00 00  ................
00000230: 01 00 00 00 00 00 00 00 2f 6c 69 62 36 34 2f 6c  ......../lib64/l
00000240: 64 2d 6c 69 6e 75 78 2d 78 38 36 2d 36 34 2e 73  d-linux-x86-64.s
00000250: 6f 2e 32 00 04 00 00 00 10 00 00 00 01 00 00 00  o.2.............
00000260: 47 4e 55 00 00 00 00 00 02 00 00 00 06 00 00 00  GNU.............
00000270: 20 00 00 00 04 00 00 00 14 00 00 00 03 00 00 00   ...............

Utiliser, par exemple, à la main(int c, char**v){f();}place change quelques octets, mais pas le décalage de la chaîne /lib64/ld-linux-x86-64.so.2, que nous utiliserons pour produire une sortie.

Le décalage de cette chaîne est 0x238 et sa longueur est de 27 octets. Nous voulons seulement imprimer 17 octets (et le dernier sera une nouvelle ligne si nous l'utilisons puts), nous ajoutons donc 11 à l'offset pour obtenir 0x243 , l'offset de inux-x86-64.so.2. L'ajout de 0x400000 et 0x243 donne 0x400243 , l'emplacement mémoire de inux-x86-64.so.2.

Pour obtenir cette adresse mémoire, nous pouvons utiliser des constantes multi-caractères, qui présentent un comportement défini par l'implémentation. 0x400243 est (64) (2) (67) en base 256 et les constantes à plusieurs caractères de gcc utilisent l'ordre des octets big-endian, générant ainsi '@\2C'l'adresse de la mémoire de la chaîne souhaitée.

Enfin, putsaffiche la chaîne (terminée par un zéro) à cet emplacement de la mémoire et une nouvelle ligne, créant ainsi 17 octets de sortie.

Brainfuck à modification automatique , 5 octets

<[.<]

Essayez-le en ligne!

Sortie:

]<.[<

Explication:

Vraiment simple, imprime la source en sens inverse. Dans SMBF, le contenu du programme est stocké sur la bande, à gauche de la position initiale du pointeur. Si vous glissez à gauche et que l’impression reprendra le code source.

Étant donné que la lecture du code source est autorisée dans ce défi, cela devrait être dans les règles.

Calculatrice arithmétique de base , 2 octets

1=

estampes 1.ou:

    |
    |
    |  .

sur ces écrans sept segments stupides.

Pour reproduire, prenez n'importe quelle calculatrice aléatoire; ils ont tous ce langage de programmation installé en quelque sorte.

Fourier, 26 22 20 octets

5^(`na`&i)` Batman!`

Essayez-le sur FourIDE!

Les sorties:

nananananana Batman!

Pour une capitalisation correcte, il s'agit de 4 octets supplémentaires:

`N`7^(`an`i^~i)`a Batman!`

Essayez-le sur FourIDE!

Nanananananananana Batman!

_{RIP Adam West}

Brachylog , 1 octet

w

Essayez-le en ligne!

Explication

west le "écrit" intégré. Ici, il va écrire l'entrée. Comme l'entrée est une variable libre, elle wsera étiquetée comme un entier avant impression. Le premier entier qu'il essaie est 0.

Java (OpenJDK 8) , 11 octets

o->1e8-1+""

Essayez-le en ligne!

Sortie:

9.9999999E7

Juste un peu plus élaborée que la réponse évidente, ()->"".format("%23s",0).

Enregistre

• 18 -> 16 octets: Combinaison plus avantageuse d'arrondi et de puissance 10, grâce à PunPun1000
• 16 -> 13 octets: meilleure formule grâce à JollyJoker
• 13 -> 11 octets: formule améliorée grâce à Kevin Cruijssen

05AB1E , 1 octet

õ

Sort une nouvelle ligne. õpousse une chaîne vide et elle est implicitement sortie avec une nouvelle ligne.

Essayez-le en ligne!

Quelques autres solutions à 2 octets, pour votre plus grand plaisir, (le résultat est entre parenthèses et tout le contenu a une nouvelle ligne):

X, (1)
Y, (2)
¾, (0)
¼, (1)
¶, (newline)
ð, (space)
Î, (0)

Il existe cependant beaucoup plus de solutions à 2 octets.

V / vim, 1 octet

o

Ceci imprime une nouvelle ligne.

Essayez-le en ligne!

Il y a un tas de variantes sur ceci qui fonctionneraient aussi. Par exemple,

O

in vim, et

Ä
ä
ï
Ï

en V.

Il existe également de nombreuses solutions à trois octets. Par exemple:

3ii
i³i
¬ac

Ce sont tous spécifiques à V.

Lot, 12 octets

@echo %OS%

Le nombre d'octets inclut le retour à la ligne final pour le script et la sortie, qui est

Windows_NT

Hexagonie , 3 octets

o!@

Essayez-le en ligne!

Impressions 111.

Déplié:

 o !
@ . .
 . .

Mais le code est vraiment juste exécuté dans l'ordre o!@.

o   Set the memory edge to 111, the code point of 'o'.
!   Print this value as a decimal integer.
@   Terminate the program.

/// , 12 octets

/a/bcd/aaaa/

Essayez-le en ligne!

Ceci affiche bcdbcdbcdbcd, et comme il s’agit de 12 octets, j’ajoute un fin inoffensif / à la fin du code pour le compléter .

R, 7 octets

mode(T)

Imprime "logique"

MATL , 2 octets

H

Il y a un retour à la ligne.

Essayez-le en ligne!

Explication

Le presse-papier H contient le numéro 2par défaut. Hpousse ce contenu dans la pile, qui est implicitement affichée avec une nouvelle ligne.

Charbon de bois , 2 octets

→¹

Essayez-le en ligne!

Imprime une ligne horizontale de longueur 1 -à droite et une nouvelle ligne.

Gelée , 1 octet

V

Un certain nombre de byings Jelly one - c’est un - il évalue l’argument de gauche qui, lorsque rien n’est fourni en entrée, a la valeur par défaut de zéro, qui s’évalue à zéro et le résultat est implicitement imprimé, a 0.

Essayez-le en ligne!

En fait, sur les 256 octets de la page de code, seuls 95 ne produisent pas actuellement une sortie d'un octet différente dans la plage spécifiée lorsqu’ils sont exécutés en tant que programme complet; ce sont (en tant que caractères de page de code dans l'ordre des octets):

¡¢£¦©½¿€ÇÑÞßçıȷñ÷þ"#&',-./0123456789:;?@IMRTVZ\`dmpstxyz{}~°³⁴⁵⁹ƓƈɠḶỌṬḊĖİĿṄȮṖṘẆẊṃọṣṭḃḟḣŀṁṗṡẋż’“

Remarques:

• La plupart des programmes sur 1 octet impriment un 0(pas d'opération / donnant une liste avec un seul zéro dans, qui imprime un 0), la plupart des autres impriment un 1( 0=0et ainsi de suite)

• Ọest le seul programme qui fait donner un octet différent, mais une qui est hors de la plage conformément à la spécification - il produit le null-octet (jette le 0personnage)

• ⁶ produit un espace (un littéral)

• ⁷ produit un saut de ligne (littéral)

• Certains octets qui fonctionnent actuellement risquent de ne plus fonctionner à l'avenir - quelques octets sont réservés (je crois) pour des valeurs niladiques qui, une fois affectées, ne produiront presque certainement pas une sortie d'un octet.

Befunge , 2 octets

.@

Essayez-le en ligne!

Imprime 0avec un espace de fin. Fonctionne également dans Befunge 98.