Sortie avec la même longueur que le code

97

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 , donc la réponse valide la plus courte - mesurée en octets - est gagnante.

Classement

Martin Ender
la source
18
"Votre code ne doit pas être un quine" mais ... mais ... il est étiqueté quine
Okx
4
@Okx Parce que c'est un quine généralisé, c'est-à-dire que la sortie requise dépend du code source.
Martin Ender
4
@MartinEnder Vous devriez probablement interdire la sortie par le code de sortie, qui est un code par défaut. Si vous le permettez, presque tous les programmes sur un octet dans presque toutes les langues sont autorisés. Un utilisateur a déjà fait cela
Wheat Wizard
2
La sortie de @WheatWizard par le code de sortie n'est pas une chaîne, elle ne s'applique donc pas ici.
Martin Ender

Réponses:

204

C (Linux moderne), 19 octets

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

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

Segmentation fault
MD XF
la source
20
C'est génial: D
Beta Decay
4
cela ressemble plus à "C + anglais langue unix / posix OS;)"
Florian Castellane
5
Je pense qu'il serait préférable d'écrire "C, Linux moderne" plutôt que "C": Sous Windows, le message d'erreur est différent et autrefois, les programmes Linux étaient même compilés de manière à ce que l'adresse 0x73 ('s') soit lisible. donc aucune exception n'a été causée.
Martin Rosenau
9
J'ai rejoint le site juste pour upvote cette réponse.
Nitish
7
Aussi impressionnant soit-il, ce n'est pas vraiment le programme C qui imprime la sortie, mais le shell dans lequel il s'exécute.
Dennis
80

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.

pyjonk
la source
106
Cela donne un tout nouveau sens à "choisir le bon langage pour le poste".
Martin Ender
4
C'est une bonne idée. Ce serait plus court, ce =9^7&""qui génère un numéro à 7 chiffres dans l'une ou l'autre langue et ne représente que 7 octets.
OpiesDad
@OpiesDad Belle solution, je pense que vous devriez l'afficher en guise de réponse, afin que je puisse upvoter.
pajonk
4
@MartinEnder Cela m'amuse de voir que votre blague de spéculation / potentielle est plus populaire que cette réponse (même si elle est proche).
HyperNeutrino
55

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.
Martin Ender
la source
6
C'est trop malin. Avoir un +1, sur la maison!
Caird coinheringaahing
54

Bash (intégré seulement), 8 octets

{e,,}cho

Des impressions cho choet une nouvelle ligne.

Anders Kaseorg
la source
40

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).

Martin Ender
la source
27
+1 Pour que le code me dise de ne pas l'exécuter: P
Christopher
33

Mathematica, 2 octets

4!

factoriel

24

J42161217
la source
1
Gah! trop malin.
Tuskiomi
2
me battre à elle! +1 ( Je pense que vous devriez mentionner que cela est dans la version REPL de Mathematica.)
Greg Martin
S'il s'agit d'une réponse raisonnable, la réponse "1" ne serait-elle pas également une réponse raisonnable? (Mettre "1" dans la REPL de Mathematica renverrait également "1" ...)
Mark Segal
3
@MarkSegal Cela violerait la règle no-quine.
AlexR
6
Règles: ... "... le code et la sortie doivent différer d'au moins un octet"
J42161217
29

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.

Poignée de porte
la source
Je suis heureux de voir une réponse qui utilise la règle de sortie variable. :)
Martin Ender
Cela ne pourrait pas segfault?
Daniel
Où se trouve le ou les liens TIO?
CalculatriceFeline
@Daniel Non, le numéro imprimé proviendra du contenu précédent du %esiregistre.
Poignée de porte
8
@Doorknob mais il est un comportement encore non défini, donc un compilateur plus sadique pourrait faire quelque chose tout à fait différente
Sarge Borsch
29

Bash sur Linux, 6

uname

(suivi d'une nouvelle ligne)

Sorties Linuxsuivies d'une nouvelle ligne.

Trauma numérique
la source
2
Techniquement, ce unamen'est pas une bash, mais un exécutable séparé
Jason Musgrove
@GammaFunction Où voyez-vous unameune bash intégrée? Chaque distribution sur laquelle je peux mettre la main maintenant est un binaire séparé, y compris TIO . À l'inverse, comme l'indique votre réponse liée, elle umaskest intégrée à la plupart / à tous les shells.
Digital Trauma
Je ne vois pasuname comme intégré. Quand j'ai dit "-1, et en fait une commande intégrée", je voulais dire "Cette réponse utilise umaskpour -1 octets et umaskest en fait une commande intégrée".
GammaFunction
@GammaFunction Désolé - j'ai mal compris le sens du "-1" dans votre commentaire - je suis habitué à ce que le sens signifie "vote négatif" et un commentaire expliquant pourquoi.
Trauma numérique
27

Javascript ES6, 9 octets

Utilisation de chaînes de modèle

_=>`${_}`

f=

_=>`${_}`

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

Weedoze
la source
Est undefinedconsidéré comme une chaîne?
Shaggy
3
@Shaggy Voir l'édition. J'utilise l'interpolation de cordes
Weedoze
Wow c'est mon deuxième post sur PPCG et 14 votes positifs! Merci
Weedoze
1
Pourquoi le lactosérum simple peut-il être difficile? (_=>_+'').
GOTO 0
1
@ GOTO0 Oh ok tu gardes la parenthèse. Ceci est une autre option.
Personnellement,
24

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 74 .

Conor O'Brien
la source
6
Hey, essayez-vous de vendre votre langue? Si c'est le cas, vous êtes en état d'arrestation. - Les flics
NoOneIsHere le
2
@NoOneIsHere pardon?
Conor O'Brien
3
Désolé, cela s'appelle Pyramid Scheme, qui est aussi le nom d'un type d'escroquerie.
NoOneIsHere
1
ohhhhhhhhhhhh rofl
Conor O'Brien
1
La sortie implicite vous ramène à 43 octets .
Khuldraeseth na'Barya
23

Python 2 , 9 octets

print{+1}

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

Essayez-le en ligne!

Dennis
la source
11
À partir des programmes brute-forcés print, il n'y a pas de solutions plus courtes, et les seuls à 9 octets sont des variantes de celui-ci et de Luis Mendo print 1e5 .
xnor
23

Python 2 , 9 octets

print 1e5

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

Essayez-le en ligne!

Luis Mendo
la source
Les nouvelles lignes suivies comptent-elles comme un caractère dans la sortie? Sinon, cela affiche huit octets.
OldBunny2800
@ OldBunny2800 Oui, le défi dit Si votre sortie contient des nouvelles lignes, celles-ci font partie du nombre d'octets . Quoi qu'il en soit, je vais préciser cela dans ma réponse
Luis Mendo
18

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
Zack C.
la source
4
Il existe de nombreuses variantes de BF, comme une bande infite à cellules 8 bits. ou une bande limitée et des cellules infinies. Je suis presque sûr que votre modèle est un modèle de cellule 8 bits non signé, mais je pense que ce serait bien si vous incluez cela dans votre réponse.
Roman Gräf
@ RomanGräf Bon point! J'inclus habituellement cette information si une implémentation non standard est requise. Cette réponse devrait fonctionner avec n'importe quelle implémentation standard (cellules non signées 8 bits, toute bande), mais je vais ajouter une note pour clarifier.
Zack C.
Ne pourriez-vous pas avoir un programme de 1 octet .qui imprime le NULLcaractère non imprimable ?
Graviton
@Graviton Cela violerait la première règle de ce défi. Cependant, c'est une solution valable dans un dérivé de BF qui prend par défaut une valeur imprimable (voir: ma réponse brainbool ).
Zack C.
24 octets
Jo King
16

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
Anders Kaseorg
la source
7
@MDXF La spécification dit programme ou fonction. La soumission d'une fonction est donc parfaitement valide. Puisque le nom de fichier n’est pas choisi par l’utilisateur ici (Ideone et gcc ont tous deux des valeurs par défaut), je pense que ça va (opinion personnelle).
Dennis
15

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  [email protected]...@.....
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  [email protected].......
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.

Dennis
la source
C'est de la magie ... cela suppose-t-il l'ordre des octets de l'assembly compilé ou quelque chose?
Patrick Roberts
Sortie sur mon système (Linux avec GCC 6.3.1): Ulors de la compilation avec -Df=main. Ulors de la compilation avec main(){f();}.
MD XF
@ PatrickRoberts À ce stade, je ne suis pas vraiment sûr des hypothèses. Puisqu'il fouille dans le fichier ELF assemblé, cela dépend à peu près de tout ce que le compilateur écrit avant le code réel.
Dennis
@MDXF Trouve un moyen plus rapide d'obtenir une adresse mémoire appropriée. Cela fonctionne sur mon Ubuntu 14.04 VPS maintenant, mais ymmv.
Dennis
@ Dennis fonctionne bien maintenant (dang it). La prime vous appartient si, à la fin de la semaine, personne ne trouve de solution plus courte.
MD XF
13

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.

Zack C.
la source
13

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.

OldBunny2800
la source
1
Est-ce vrai pour toutes les calculatrices? Je suis sûr qu'ils affichent constamment le point décimal
Beta Decay
N'est-ce pas 1.au lieu de 1x? C'est aussi une quine, ce qui est interdit par les règles.
Erik l'Outgolfer
Non, 1=je me suis planté. Je voulais dire 1xque les égaux implicites, mais j'ai oublié que =c'est un bouton.
OldBunny2800
Il ne sort que 1sur les modèles TI-36 et TI-84 CE. Ne sont-ils pas considérés comme des calculatrices "de base"?
Benjamin Urquhart le
Non, une TI 84 n’est pas une calculatrice arithmétique, c’est une calculatrice graphique. Je ne sais pas pour le 36, mais je suis presque sûr que c'est une calculatrice scientifique. Cette réponse concerne les calculatrices à quatre fonctions.
OldBunny2800
13

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

Beta Decay
la source
1
Vous n'avez pas à inclure NC (seulement si vous avez imprimé des cordes pour ce défi (et ce serait idiot)
Christopher
@Christopher Hein, je ne savais pas ça
Beta Decay le
12

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.

Fataliser
la source
Here, it will write the Input.Est-ce que 'l'entrée' est le programme lui-même? Cela ne compte-t-il pas dans la lecture du code source, qui est par défaut une triche dans un quine?
MD XF
4
@MDXF "Les règles habituelles ne s'appliquent pas"
Rob Watts
3
@MDXF L'entrée est une variable spéciale de Brachylog que vous pouvez définir lors de l'appel d'un programme Brachylog. Il entre dans la partie Entrée de TryItOnline. Ici, nous n’affectons rien à l’entrée, c’est donc une variable. Ce n'est pas le programme.
Fataliser
10

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
Olivier Grégoire
la source
2
()->1E10-1+"", "9.999999999E9" (13)sauve trois octets de plus
JollyJoker
1
Vous pouvez enregistrer 1 octet en passant 1e10à 1e9, ou 2 octets en utilisant une entrée vide au lieu de() ceci: o->1e8-1+""(sorties 9.9999999E7; longueur & nombre d'octets 11 ).
Kevin Cruijssen le
9

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.

Okx
la source
"qui est une méthode de sortie acceptée" uniquement pour les solutions fonctionnelles, pas pour les programmes complets.
Martin Ender
@MartinEnder Ces solutions compteraient-elles comme des fonctions, alors? Pas vraiment sûr, car je n'utilise pas souvent les fonctions ici.
Okx
Je ne connais pas suffisamment le sujet 05AB1E, mais elles ne sont considérées comme des fonctions que s'il s'agit d'expressions qui correspondent à un objet de fonction (ce dont je doute, car leur utilisation entraîne immédiatement l'exécution de la commande).
Martin Ender
9

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.

DJMcMayhem
la source
3ii ne se développe pas tant que vous n’avez pas appuyé sur la touche Échap; le nombre de octets doit-il être de trois ou quatre octets (ou de touches)?
Algmyr
@ algmyr In vim, vous avez raison. Il faudrait 4ii<ESC>toutefois que V remplisse implicitement l'évasion à la fin du programme.
DJMcMayhem
8

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
Neil
la source
Il semble que ce soit 11 octets et non pas 12.
Erik the Outgolfer
@EriktheOutgolfer cmd.exefera bien sûr écho à un CRLF après le Windows_NT, donc 12 octets.
Neil
Alors vous devriez clarifier?
Erik l'Outgolfer
8

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.
Martin Ender
la source
8

R, 7 octets

mode(T)

Imprime "logique"

Ivanneke
la source
Bienvenue chez PPCG!
Martin Ender
7

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.

Luis Mendo
la source
7

Charbon de bois , 2 octets

→¹

Essayez-le en ligne!

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

ASCII seulement
la source
Le charbon de bois est une langue vraiment chouette, je devrais l'apprendre un peu de temps
Skidsdev
7

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.

Jonathan Allan
la source
1
Lien mort pourbyte
Weedoze