Ecrivez un programme qui produit une sortie telle que:

1. Au moins trois caractères distincts apparaissent.
2. Le nombre d'occurrences de chaque caractère est un multiple de 3.

Par exemple, A TEA AT TEEune sortie valide étant donné que chacun des 4 caractères distincts, A, E, Tet (space), se produit 3 fois.

Bien sûr, un défi sur le nombre 3 doit avoir une troisième exigence. Alors:

3. Le programme lui-même doit également respecter les deux premières exigences. (Cela signifie que votre programme aura au moins 9 octets de long.)

Vous devez écrire un programme complet, pas une fonction. Assurez-vous de montrer la sortie de votre programme dans votre réponse.

Aussi, pour garder les choses intéressantes, vous êtes fortement encouragés:

• ne pas utiliser les commentaires pour répondre à l'exigence 3 si vous pouvez y contribuer
• pour produire une sortie qui n'est pas juste une chaîne répétée 3 fois
• pour que le résultat soit différent du programme lui-même (pour les langues qui peuvent générer automatiquement le contenu de son propre programme, vous pouvez contribuer à ce wiki de communauté ).

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

Brain-Flak , Flakcats , cerveau-Flueue , cerveau-Flak classique , Miniflak et Fλak 18 octets

Prouvé optimal!

((([()][()][()])))

Essayez-le en ligne!

Explication

Flak cérébrale, Cervelle flueue, Miniflak et Fλak

   ([()][()][()]) Push -3
  (              ) Copy
 (                ) Copy

Cela imprime:

-3
-3
-3

(Il y a un retour à la ligne)

Cerveau-Flak Classic

Brain-Flak Classic est la version originale de Brain-Flak et présente quelques différences importantes par rapport à Brain-Flak moderne. Dans BFC [...]imprime son contenu plutôt que de le nier.

   [()] Print 1
       [()] Print 1
           [()] Print 1
  (            ) Push 3
 (              ) Push 3
(                ) Push 3

A la fin de l'exécution, le contenu de la pile ( 3 3 3) est imprimé.

Cela imprime:

1
1
1
3
3
3

(Il y a un retour à la ligne)

Flakcats

Flakcats est assez différent des 4 autres flaks et je suis surpris que cela fonctionne dans Flakcats. Les trois opérateurs ici sont presque les mêmes que ceux utilisés par Brain-Flak.

La principale différence dans ce programme particulier entre Flakcats est l’ (...)opérateur qui, dans Flakcats, est équivalent à ([{}]...)Brain-Flak. Cependant, cela ne fait aucune différence pour nous, car il enregistre des zéros et fonctionne donc de la même manière que Brain-Flak.

Voici ce programme compilé dans Brian-Flak:

([{}]([{}]([{}][()][()][()])))

Cela imprime:

-3
-3
-3

(Il y a un retour à la ligne)

Preuve d'optimalité dans Brain-Flak et Miniflak

Ce n'est pas une preuve formelle, mais plutôt une preuve informelle qui devrait être élargie pour devenir plus rigoureuse.

En raison des restrictions, les programmes Brain-Flak doivent être une chaîne équilibrée et la longueur du programme doit être un multiple de 3, toute soumission valide doit être un multiple de 6. Cela signifie que toute solution inférieure à 18 doit avoir une longueur de 12.

En raison des sorties à la fin de la nouvelle ligne, la hauteur finale de la pile doit être un multiple de trois, sinon nous briserons les restrictions en matière de sortie.

Toute soumission valide de longueur 12 doit comporter 2 types d'accolades (en avoir moins enfreindrait les restrictions relatives au nombre de caractères distincts et plus signifierait plus de 12 caractères). Puisque le programme produit une sortie, il doit avoir un push.

Cela nous laisse choisir notre autre paire d'accolades. Les options sont:

<...>/<>

Cela échoue parce que nous devons générer une "valeur" afin de créer un nombre autre que zéro, nous devons renoncer à un ()pour créer un nombre qui rend impossible de pousser plus de deux fois.

[...]/[]

Cela échoue pour la même raison que le dernier a échoué. Les accolades carrées sont vraiment mauvaises à faire de la valeur. La []monade peut créer de la valeur, mais nous devons commencer par les chiffres, puis nous n'avons plus assez de parens pour pousser trois fois.

{...}/{}

Celui-ci est prometteur, nous pourrions créer une boucle et en utiliser une ()pour appuyer plusieurs fois, mais ce n'est hélas pas possible.

Pour que la boucle se termine, il doit y avoir un zéro sur la pile à un moment donné et pour que nous ayons la sortie correcte, nous devons avoir autre chose que zéro sur la pile à la fin du programme. Puisque nous n’avons ni []ni <>le zéro à la fin de la boucle, il faut un zéro implicite du bas de la pile. Cela signifie que la boucle ne peut pas ajouter de nouveaux nombres à la pile, ce qui la rend inutile.

Comme aucun des choix d'accolade ne peut créer un programme de longueur 12, aucun ne peut exister.

Puisque Miniflak est un sous-ensemble de Brain-Flak, tout programme Miniflak plus court serait également un programme Brain-Flak plus court et n’existe donc pas.

Preuve d'optimalité dans Brain-Flueue

Brain-Flueue est un langage de plaisanterie basé sur Brain-Flak. Les deux sont si semblables que leurs interprètes sont identiques partout sauf deux lignes. Comme leur nom l'indique, Brain-Flueue stocke ses données dans des files d'attente, tandis que Brain-Flak stocke ses données dans des piles.

Pour commencer, nous avons les mêmes restrictions sur la taille du programme créées par Brain-Flak. Nous cherchons donc un programme de taille 12. En outre, nous aurons besoin d'un (...)pour créer toute sortie et une autre paire. les paires <>et []ne fonctionnent pas dans Brain-Flueue pour la même raison, elles ne fonctionnent pas dans Brain-Flak.

Nous savons maintenant que notre programme doit être composé de caractères ((())){{{}}}.

En utilisant les mêmes méthodes que celles utilisées dans la preuve précédente, nous pouvons démontrer qu'il doit y avoir une boucle dans le programme final.

À présent, les preuves diffèrent, car Brain-Flueue opère sur des files d'attente plutôt que sur des piles, le programme peut quitter une boucle avec des valeurs dans la file d'attente.

Pour sortir de la boucle, nous aurons besoin d'un zéro dans la file d'attente (ou d'une file vide, mais si la file est vide, nous rencontrons le même problème que Brain-Flak). Cela signifie que nous devrons ouvrir notre programme avec ({})pour créer le zéro. Nous aurons besoin d'un appui dans la boucle pour insérer le nombre d'éléments requis dans la file d'attente. Nous devrons également indiquer un nombre différent de zéro avant la boucle pour pouvoir y entrer. cela nous coûtera au minimum absolu (()). Nous avons maintenant utilisé plus de parens que nous avons.

Ainsi, il n'y a pas de programme Brain-Flueue pour effectuer la tâche qui est de 12 octets, et de plus notre programme est optimal.

Solution optimale dans Flakcats et Brain-Flak Classic

La solution suivante est optimale dans Flakcats et Brain-Flak Classic.

((([][][])))

Explication

    [][][] -3
 (((      ))) push 3 times

Solutions Brain-Flak alternatives sur 24 octets

(<((<((<(())>)())>)())>)

Essayez-le en ligne!

((<((<((<>)())>)())>)())

Essayez-le en ligne!

((((((()()()){}){}){})))

Essayez-le en ligne!

Gelée , 9 octets

**‘‘‘888*

Un programme complet qui imprime 700227072 , soit 888 cubes.

TryItOnline!

Comment?

**‘‘‘888* - Main link: no arguments
          - implicit L=R=0
*         - power       A = L ^ R = 1
  ‘       - increment   B = L + 1 = 1
 *        - power       C = A ^ B = 1
   ‘      - increment   D = C + 1 = 2
    ‘     - increment   E = D + 1 = 3
     888  - literal     F = 888
        * - power           F ^ E = 700227072

Polyglotte de réponses purement littérales, 9 octets

333111222

Il s'agit d'un post wiki de la communauté destiné à recueillir des réponses littérales que la langue en question imprime automatiquement. Parce que c'est un wiki de communauté, n'hésitez pas à le modifier pour ajouter plus de langues là où il fonctionne.

Ce programme fonctionne dans:

• PHP
• HTML (sans doute pas une langue)
• Gelée (et M )
• 7 (plus intéressant, car le programme est interprété à la fois comme des données et du code; le premier 3imprime les données, le reste du programme est une manipulation de pile inutile)
• CJam
• Japt
• Carotte
• R (l'écran R fournit également [1] en tant que métadonnées)
• RProgN
• En fait (bien qu'il imprime réellement 2\n2\n2\n1\n1\n1\n3\n3\n3\n)
• ///
• Noodel
• TI-Basic
• SimpleTemplate
• ReRegex
• Décortiquer
• Ressource (bien que ceci retourne la chaîne inversée)

En ignorant la nouvelle ligne finale, ceci est valable dans de nombreuses autres langues:

• 05AB1E
• 2sable
• GolfScript
• PowerShell
• m4 (toute version, le programme est portable)
• Pyth
• MATL
• Pépin
• Stax
• Encre
• Tonnelet

La plupart des liens vont à Try It Online!

C #, 114 111 118 102 octets

Si nous ne nous soucions pas d'utiliser les mots appropriés: (102 octets)

class CCcddiilMMmmnrrSSsttvvWWyy{static void Main(){{System.Console.Write(("A TEA AT TEE"));;;}}}///".

Si nous nous soucions des mots appropriés: (120 octets)

class erebeWyvern{static void Main(){int embedWildbanana;{System.Console.Write(("A TEA AT TEE"));;}}}///CC Myst mvcSMS".

Ma soumission originale - insensible à la casse: (113 octets)

class EreBeWyvern{static void Main(){int embedwildbanana; {System.Console.Write(("A TEA AT TEE"));;}}}/// vyt".

Je sais que le commentaire n’est pas vraiment dans l’esprit du CG, mais c’est tout ce que je pourrais dire en peu de temps. Je verrai si je peux l’améliorer tout au long de la journée. Je dois sûrement obtenir au moins quelques points de bonus pour être un peu aventureux.

Edit: Merci à roberto06 pour avoir attrapé les lettres manquantes!

JavaScript, 36 33 octets

alert(((alert|alert||333111222)))

Alertes 333111222. Cela fonctionne parce que |convertit ses deux opérandes en entiers 32 bits et que toute valeur qui ne ressemble en rien à un entier (par exemple la fonction alert) est convertie en 0. 0|0est 0, de sorte que l' ||opérateur retourne son opérande droit, ou333111222

Quelques versions plus intéressantes:

(a="(trelalert)\\\"")+alert(a+=a+=a)

Sorties (trelalert)\"(trelalert)\"(trelalert)\".

Une solution utilisant .repeataurait la même longueur, grâce au partage aert:

alert("(trpp.all)\\\"".repeat(3.33))

qui sort (trpp.all)\"(trpp.all)\"(trpp.all)\".

Profitant des barres obliques inverses supplémentaires pour se débarrasser let fonctionne p presque :

a\x6cert("(trax.cc)\"".re\x70eat(6.00677))

Celui-ci sort (trax.cc)"(trax.cc)"(trax.cc)"(trax.cc)"(trax.cc)"(trax.cc)".

CJam , 9 octets

10,10,10,

Les sorties 012345678901234567890123456789

Essayez-le en ligne!

Explication

10,       The range from 0 to 9
   10,    The range from 0 to 9
      10, The range from 0 to 9

brainfuck , 12 octets

++[+...][][]

Personne n'a dit que la sortie devait être courte. Cela produira 3 copies de chaque caractère ASCII sauf les 2 premiers.

Vous pouvez prouver que c'est aussi court que possible. Vous devez sortir donc vous avez besoin de 3 '.' il doit y avoir différentes sorties donc vous avez besoin de 3 [+ -] maintenant nous sommes à 6. Il faut imprimer 9 caractères, ce qui signifie soit d'ajouter 6 autres '.' ou en ajoutant une boucle, qui ajoutera 6 autres caractères.

Essayez-le en ligne!

Python 2, 36 30 octets

Dans la mesure où un retour à la ligne n'est pas autorisé, il est probablement aussi bref que possible:

print"\\\""*3;print;print;3**3

Essayez-le en ligne

Sorties \"trois fois, suivies de trois nouvelles lignes.

Les programmes ci-dessous ne comptent pas le retour à la ligne final, ils ne sont donc pas valides.

27 octets :

print"""printprint"""*3*3*3

Imprime 54 caractères de chaque personnage dans print.

Essayez-le en ligne

Même longueur, sortie plus courte:

print"""printprint*3*3"""*3

Les sorties printprint*3*3printprint*3*3printprint*3*3

24 octets:

print~9;print~9;print~9;

Perl 6 , 15 octets

.say;.say;.say;

Imprime six caractères distincts, trois fois chacun:

(Tout)
(Tout)
(Tout)

Essayez-le en ligne!

Comment ça fonctionne

• Un appel de méthode fonctionne nue sur le sujet en cours, $_.
• $_commence en tant que type objet de type Any, qui est sayimprimé en tant que (Any).

C, 66 octets

main(i){{for(i=0;i<3;i++){printf("""poop+fart=<3<3at0m=m0n""");}}}

Sortie

poop+fart=<3<3at0m=m0npoop+fart=<3<3at0m=m0npoop+fart=<3<3at0m=m0n    

Ancienne Version 72 Octets

main(i){for(i=0;i<3;i++){printf("poop+fart=<3<3 at {\"0m=m0\"}" "\n");}}

JavaScript (ES6), 30 octets

+alert((({alert}+{alert}+{})))

Sorties [object Object][object Object][object Object].

Fonctionne en créant trois objets:

• les deux premiers sont de la forme { "alert" : alert }utilisant la notation ES6{alert}

• le troisième est un simple objet vide

Il utilise ensuite +pour les concaténer ensemble, et tous les trois ont une expression identique comme une chaîne, [object Object].

Le texte en tête +est inutile, il n’est présent que pour renseigner le nombre de +caractères, mais il est inoffensif pour la sortie du programme.

PKod , 9 octets

sonsonson

Sorties: 111222333

Explication:

Background: PKod has only one variable that you mess with, with the code
This variable starts with default value of 0

s  -  Add next char to the variable, and jump over it. 
n  -  Print numeric value of variable

o a le code de caractère ascii "111" en décimal. Ainsi, s ajoute 111 à la variable, puis affiche le nombre. Le premier "fils" en fait 111 et imprime 111. Suivant en 222 et en 222, enfin en 333 et en 333

Ruby , 12 octets

p$@;p$@;p$@;

les sorties

nil
nil
nil

Essayez-le en ligne!

Pour remplir le deuxième critère "encouragé", il me faut 15 caractères:

p 1;p 3;p 1133;

produit

1
3
1133

Essayez-le aussi en ligne!

Microscript II, 9 octets

{{{~~~}}}

Explanation: Crée un bloc de code, mais ne l'invoque pas. Lorsque l'exécution est terminée, le contenu du registre principal (IE ce bloc de code) est implicitement imprimé.

Hexagonie , 9 octets

x!!xx@@!@

Essayez-le en ligne!

Imprimez 120120120. xpeut être remplacé par f-m(102-109)

Explication

  x ! ! 
 x x @ @
! @ . . .

Le xx@@n'est qu'un remplissage pour se conformer aux règles. Le flux principal enregistre xdans la mémoire (avec la valeur ASCII 120), puis l’imprime sous la forme d’un chiffre 3 fois.

C, 111 octets

(Notez que le nombre d'octets est également composé des trois mêmes nombres. Wow. Vous ne pouvez pas faire plus de méta que cela.)

#include<stdio.h>
#define b "<acdhlmoprsu>."
#define t "en"
main(){{{printf(("<acdhlmoprsu>." b b t t t));;;}}}

Impressions:

<acdhlmoprsu>.<acdhlmoprsu>.<acdhlmoprsu>.enenen

PHP , 33 octets

<?=($s="<?;<?=;'".'"').($s).($s);

A opté pour quelque chose de plus intéressant que le programme de 9 octets sans balise PHP.

Les sorties <?;<?=;'"<?;<?=;'"<?;<?=;'"

Essayez-le en ligne!

99 , 15 octets

9 9  9999
9
9
9

C'est neuf neuf, trois espaces et trois sauts de ligne, la sortie est -1110-1110-1110 .

Essayez-le en ligne!

Comment?

9 9  9999 - V(9)=V(9)-V(9999)=1-1111=-1110
9         - print V(9)
9         - print V(9)
9         - print V(9)

Les deux espaces sont traités comme un seul, ce troisième espace peut également être un espace de fin sur n'importe quelle ligne.

Bash + coreutils, 15 9 octets

id;id;id;

Essayez-le en ligne!

Exemple de sortie:

uid=1000 gid=1000 groups=1000 context=system_u:unconfined_r:sandbox_t:s0-s0:c19,c100,c173,c211
uid=1000 gid=1000 groups=1000 context=system_u:unconfined_r:sandbox_t:s0-s0:c19,c100,c173,c211
uid=1000 gid=1000 groups=1000 context=system_u:unconfined_r:sandbox_t:s0-s0:c19,c100,c173,c211

(Si vous essayez ceci, il imprimera votre uid, gid, etc. 3 fois.)

Si vous voulez éviter de répéter la même chaîne 3 fois (et que vous ayez la même sortie pour tout le monde, contrairement à ma première réponse), le meilleur que j'ai trouvé pour les utilitaires bash + Unix est de 15 octets:

dc<<<cczdzfzfdf

Essayez cette deuxième version en ligne!

Sortie:

2
0
0
3
2
0
0
3
3
2
0
0

(Pas de nouvelles lignes dans le programme, 12 nouvelles lignes dans la sortie.)

Explication du programme cc dans cette réponse:

c Clears the stack.
Stack: (empty)

c Clears the stack.
Stack: (empty)

z Pushes the current size of the stack (0) onto the stack.
Stack: (top) 0

d Duplicates the item at the top of the stack.
Stack: (top) 0 0

z Pushes the current size of the stack (2) onto the stack.
Stack: (top) 2 0 0

f Prints the stack, top to bottom, with a newline after each item printed (this prints the first 3 lines of the output, 2 / 0 / 0 /)

z Pushes the current size of the stack (3) onto the stack.
Stack: (top) 3 2 0 0

f Prints the stack, top to bottom, with a newline after each item printed (this prints the next 4 lines of the output, 3 / 2 / 0 / 0 /)

d Duplicates the item at the top of the stack.
Stack: (top) 3 3 2 0 0

f Prints the stack, top to bottom, with a newline after each item printed (this prints the final 5 lines of the output, 3 / 3 / 2 / 0 / 0 /)

LOLCODE , 273 240 ( 360 286) octets

HAI 1.2
I HAS A U
IM IN YR M UPPIN YR Q TIL BOTH SAEM Q 1
VISIBLE "Y SUB.EK"
IM OUTTA YR M
IM IN YR T UPPIN YR Q TIL BOTH SAEM Q 2
VISIBLE "Y SUB.EK"
IM OUTTA YR T
IM IN YR X UPPIN YR Q TIL BOTH SAEM Q 12
VISIBLE "IM"
IM OUTTA YR X
KTHXBYE

Notez la nouvelle ligne de fuite et essayez-la en ligne . La deuxième ligne était plus ou moins arbitraire et peut éventuellement être remplacée par une commande plus courte, mais je viens d’apprendre LOLCODE pour ce casse-tête. Comme le numéro de version est requis sur la première ligne, j'ai utilisé les numéros pour ajouter des boucles de longueur 1, 2 et 0 mod 3 afin de garantir que le nombre correct de caractères sera imprimé. À partir de cela, j'ai simplement compté chaque personnage (avec cet outil ). S'il apparaissait 0 mod 3 fois, aucune action n'était requise. S'il est apparu 1 mod 3 fois, il a été ajouté aux boucles 1- et 2 afin qu'il apparaisse trois fois dans la sortie. Si elle est apparue 2 fois 3 fois, le personnage a été ajouté à la boucle 12. EDIT: En remplaçant le premierVISIBLE avec une tâche (encore inutile mais obligé d'avoir 12 lignes au lieu de 11 nouvelles), j'ai pu couper 33 octets.

Sortie (60 octets):

Y SUB.EK
Y SUB.EK
Y SUB.EK
IM
IM
IM
IM
IM
IM
IM
IM
IM
IM
IM
IM

Notez la nouvelle ligne de fuite.

Le bon côté de cette solution par rapport aux autres réponses est que la sortie peut être facilement manipulée pour produire un texte assez significatif. Exemple (286 octets avec une nouvelle ligne):

HAI 1.2
I HAS A U
IM IN YR MW UPPIN YR Q TIL BOTH SAEM Q 1
VISIBLE "YO SUB. EEEEK!"
IM OUTTA YR MW
IM IN YR STA UPPIN YR Q TIL BOTH SAEM Q 2
VISIBLE "YO SUB. EEEEK!"
IM OUTTA YR STA
IM IN YR XURG UPPIN YR Q TIL BOTH SAEM Q 12
VISIBLE "IMO U R SWAG! "
IM OUTTA YR XURG
KTHXBYE

Essayez-le en ligne. Sortie (222 octets avec une nouvelle ligne):

YO SUB. EEEEK!
YO SUB. EEEEK!
YO SUB. EEEEK!
IMO U R SWAG! 
IMO U R SWAG! 
IMO U R SWAG! 
IMO U R SWAG! 
IMO U R SWAG! 
IMO U R SWAG! 
IMO U R SWAG! 
IMO U R SWAG! 
IMO U R SWAG! 
IMO U R SWAG! 
IMO U R SWAG! 
IMO U R SWAG! 

Malheureusement, je ne suis pas aussi bon avec les anagrammes que je le pensais: ')

COQUILLE

plaisanter :) ( 9 octets )

ls;ls;ls;

ou plus sérieusement ( 24 octets )

sed s/./sed.g./g <<< edg

Résultat :

sed.g.sed.g.sed.g.

PHP, 24 octets

<?=111?><?=222?><?=333?>

Lot, 36 21 octets

@echo
@echo
@echo

Les sorties

ECHO is on.
ECHO is on.
ECHO is on.

Edit: Sauvegardé 15 octets grâce à @ P.Ktinos.

Japt, 9 octets

000OoOoOo

Impressions undefinedundefinedundefined. Testez-le en ligne!

Explication

Ce code est transpilé dans le code JavaScript suivant:

000,O.o(O.o(O.o()))

O.oest une fonction qui sort quelque chose sans nouvelle ligne. Si aucun argument ne lui est attribué, il est imprimé undefined, ce qui pourrait être considéré comme un bug, mais il est pratique ici. Il revient également undefined, donc les trois appels sont imprimés undefined.

Je suis sûr qu'il y a plein d'autres façons de faire ça ...

05AB1E , 9 octets (je suppose que vous pourriez dire que c'était un morceau de PI)

-0 octets grâce à Emigna / ETHProductions, ont rendu la solution plus correcte.

žqžqžq???

Versions alternatives:

ž[g-Q]ž[g-Q]ž[g-Q]???

[g-Q] - Peut mettre n'importe quelle lettre aQ ici, à condition qu'elles correspondent toutes (voir ci-dessous).

Essayez-le en ligne!

A expliqué:

PI,PI,PI,SORT,JOIN,SORT,JOIN,SORT,JOIN.

Résultat:

...111111222333333333444555555555666777888999999999

La raison pour laquelle il ne s'agit que de 9 octets, c'est parce que vous n'avez pas besoin des sortes, je les mets juste pour aider à illustrer.

Résultat sans {le code:

3.1415926535897933.1415926535897933.141592653589793

Renditions alternatives:

Les commandes suivantes peuvent être utilisées à la place de PI:

ž 23  > žg       push current year
        žh       push [0-9]
        ži       push [a-zA-Z]
        žj       push [a-zA-Z0-9_]
        žk       push [z-aZ-A]
        žl       push [z-aZ-A9-0_]
        žm       push [9-0]
        žn       push [A-Za-z]
        žo       push [Z-Az-a]
        žp       push [Z-A]
        žq       push pi
        žr       push e
        žu       push ()<>[]{}
        žy       push 128
        žz       push 256
        žA       push 512
        žB       push 1024
        žC       push 2048
        žD       push 4096
        žE       push 8192
        žF       push 16384
        žG       push 32768
        žH       push 65536
        žI       push 2147483648
        žJ       push 4294967296
        žK       push [a-zA-Z0-9]
        žL       push [z-aZ-A9-0]
        žM       push aeiou
        žN       push bcdfghjklmnpqrstvwxyz
        žO       push aeiouy
        žP       push bcdfghjklmnpqrstvwxz
        žQ       push printable ASCII character set (32-128)

Cubix , 12 octets

Une réponse un peu ennuyeuse vraiment. Sorties trois 10s suivies de nouvelles lignes

N@N@NOoOoOo@

Essayez-le en ligne! Mappe au cube

    N @
    N @
N O o O o O o @
. . . . . . . .
    . .
    . .

NPousse 10 dans la pile
Oox3 Sorties 10 et nouvelle ligne
@interrompt le programme

L'initiale N@N@n'est pas touchée.

Pepe , 24 octets

rEeEEeeEEErreEErreEEreEE

Essayez-le en ligne!

Le programme contient 6 r, 6 e et 12 E.

Explication:

rEeEEeeEEErreEErreEEreEE # full program

rEeEEeeEEE               # push '103' to the stack
          rreEErreEE     # output as int (r flag: preserve)
                    reEE # output as int

Sortie:

103103103

V , 9 octets

12i12i12i

Essayez-le en ligne!

Sorties 12i24 fois:

12i12i12i12i12i12i12i12i12i12i12i12i12i12i12i12i12i12i12i12i12i12i12i12i

Vim, 12 octets

12i12i12i<ESC><ESC><ESC>

Émet la même chose que la réponse V

empilés , 24 octets

''''   'putput'3*3*3*put

Essayez-le en ligne! Sorties 54chacune de p uet t.

Befunge 93 , 9 octets

...,,,@@@

TIO

Impressions 0 0 0(espace de fin, suivi de 3 octets nuls)

Comme la pile de Befunge est complétée par 0s, nous pouvons imprimer le caractère ASCII avec cette valeur et le nombre entier lui-même. Comme Befunge imprime automatiquement un espace après un entier, il nous reste 3 caractères distincts.

.imprime 0(espace de fin), ,affiche un octet null et @termine le programme