Votre tâche, si vous souhaitez l'accepter, consiste à écrire un programme générant un entier positif (supérieur à 0). Si le code source est dupliqué, la sortie doit rester la même. La difficulté réside dans le fait que si le code source est saisi trois fois (triplé?), Le résultat sera multiplié par 3.

Règles

• Vous devez construire un programme complet . C'est-à-dire que votre sortie doit être imprimée sur STDOUT.

• La source initiale doit avoir au moins 1 octet de long.

• Les deux nombres entiers doivent être en base 10 (leur sortie dans une autre base ou avec une notation scientifique est interdite).

• Votre programme ne doit pas prendre d’entrée (ou avoir une entrée vide, non utilisée).

• La sortie des entiers avec des espaces de fin / fin est autorisée.

• Les zéros en tête ne sont autorisés que si le nombre de chiffres est cohérent, par exemple: 001 - 001 - 003 ou 004 - 004 - 012

• Vous ne pouvez pas supposer de saut de ligne entre les copies de votre source.

• C'est du code-golf , donc le code le plus court (original) dans chaque langue gagne!

• Les failles par défaut s'appliquent.

Exemple

Disons que votre code source est Abcet que la sortie correspondante est 4. Si j'écris à la AbcAbcplace et l'exécute, la sortie doit toujours l'être 4. Cependant, si j'écris AbcAbcAbcet l'exécute, la sortie doit l'être 12.

Effrontément Stolen Dérivé de M. Xcoder défi

Wumpus , 6 octets

{~)
@O

Essayez-le en ligne!
Essayez-le doublé!
Essayez-le triplé!

Impressions 1et 3.

Explication

J'ai trouvé une tonne de solutions de 6 octets par la recherche par force brute, mais aucune pour 5 octets. Cela ne signifie pas nécessairement qu’il n’ya pas d’octets à 5 octets, mais ils utiliseraient probablement des caractères étranges ou quelque chose du genre.

J'ai fini par choisir cette solution car elle n'imprimait pas de zéros non significatifs (la plupart le font) et son flux de contrôle était intéressant. Commençons par le programme unique:

Le code exécuté est donc:

{~)O@

{   Turn the IP left by 60°.
~   Swap two implicit zeros on the stack, does nothing.
)   Increment the top zero to 1.
O   Print it.
@   Terminate the program.

Assez facile. Maintenant, le programme doublé. Comme la première ligne est ajoutée à la seconde ligne, la grille s'étend jusqu'à la largeur 5 (et la hauteur 3), ce qui modifie considérablement le flux de contrôle:

L'IP tourne autour de cette boucle exactement une fois, donc le code exécuté est:

{~){~)){~O@

{~) As before, we end up with a 1 on top of the stack.
{   Turn left by 60° again.
~   Swap the 1 with the 0 underneath.
))  Increment the zero to 2.
{   Turn left by 60° again.
~   Swap the 2 with the 1 underneath.
O   Print the 1.
@   Terminate the program.

Enfin, le programme triplé est assez similaire au programme doublé, mais nous avons quelques commandes plus importantes sur cette troisième ligne:

Le code exécuté est donc:

{~){~)){~~)O@

{~){~)){~
    As before. We end up with a 1 on top of the stack and a 2 underneath.
~   Swap the 1 with the 2 underneath.
)   Increment the 2 to a 3.
O   Print the 3.
@   Terminate the program.

Husk , 5 octets

KΣK+1

Essayez-le en ligne!

Répété deux fois!

Répété trois fois!

Explication

Il est assez difficile de construire un programme reproductible dans Husk. Comme le système de types interdit l'utilisation d'une fonction pouvant s'appliquer à elle-même, je dois autoriser d'une manière ou d'une autre la première partie à évaluer une fonction et le reste à évaluer une valeur, et les types de fonctions intégrées existantes sont conçues pour empêcher cela sorte d'ambiguïté. Les jetons du programme sont

• K, qui construit une fonction constante. K a best équivalent à a.
• Σ, Ce qui prend un nombre entier n , et renvoie la n ième nombre triangulaire.
• +, qui ajoute deux nombres.
• 1, qui est le littéral 1.

Le programme original est interprété comme ceci:

   K Σ (K+) 1
== Σ 1
== 1

Le (K+)est une fonction absurde qui est mangé par le premier K.

Le programme répété deux fois est interprété comme ceci:

   K Σ (K+1KΣK+) 1
== Σ 1
== 1

La fonction entre parenthèses est à nouveau mangée par le premier K.

Le programme répété trois fois est interprété comme ceci:

   K (Σ (K (+1) (KΣK+) 1)) (KΣK+1)
== Σ (K (+1) (KΣK+) 1)
== Σ ((+1) 1)
== Σ (+1 1)
== Σ 2
== 3

Gelée , 7 5 octets

»‘µ*Ḃ

Essayez-le en ligne!

Essayez-le doublé!

Essayez-le triplé!

Comment ça fonctionne

»‘µ*Ḃ            Main link. No arguments. Implicit argument: x = 0

 ‘               Increment; yield x + 1 = 1.
»                Take the maximum of x and 1. Yields 1.
  µ              Begin a new, monadic chain. Argument: y = 1
    Ḃ            Bit; yield 1 if y is odd, 0 if it is even. Yields 1.
   *             Power; yield y**1 = 1.

»‘µ*Ḃ»‘µ*Ḃ       Main link.

»‘µ*Ḃ            As before.
      ‘          Increment; yield y + 1 = 2.
     »           Take the maximum of 1 and 2. Yields 2.
       µ         Begin a new, monadic chain. Argument: z = 2
         Ḃ       Bit; yield 1 if z is odd, 0 if it is even. Yields 0.
        *        Power; yield z**0 = 1.

»‘µ*Ḃ»‘µ*Ḃ»‘µ*Ḃ  Main link.

»‘µ*Ḃ»‘µ*Ḃ       As before.
           ‘     Increment; yield z + 1 = 3.
          »      Take the maximum of 1 and 3. Yields 3.
            µ    Begin a new, monadic chain. Argument: w = 3
              Ḃ  Bit; yield 1 if w is odd, 0 if it is even. Yields 1.
             *   Power; yield w**1 = 3.

Haskell , 24 octets

main=print.div 3$4
 -1--

Prints 1: Essayez-le en ligne!

main=print.div 3$4
 -1--main=print.div 3$4
 -1--

Imprime également 1: essayez-le en ligne!

main=print.div 3$4
 -1--main=print.div 3$4
 -1--main=print.div 3$4
 -1--

Prints 3: Essayez-le en ligne!

Cubix , 5 octets

)<@OP

Essayez-le en ligne: une fois , deux fois , trois fois .

Explication

Cubix est un langage basé sur une pile dont les instructions sont encadrées à l’extérieur d’un cube. Il est important de noter que la pile est initialement remplie de zéros infinis, ce qui nous permet de "tirer les valeurs de nulle part" avec les opérateurs plutôt que de les pousser explicitement.

Je dois admettre que cela a été trouvé par un brute-forcer; Je ne l'aurais jamais trouvé par moi-même. En fait, @MartinEnder est celui qui m'a demandé d'essayer de forcer brutalement, car il cherchait cette solution sans succès. C'est la seule solution que Brute-Forcer ait trouvée, et je pense que c'est la seule et la plus courte solution de Cubix.

Programme unique

Regardez le courir!

Le programme d'origine s'adapte sur un cube unitaire. Voici le net déplié:

  )
< @ O P
  .

L'IP (pointeur d'instruction) commence sur la face la plus à gauche (la <) en direction est. La <pointe immédiatement vers l'ouest, et elle tourne autour de la P. PC'est une exponentiation, et comme il n'y a rien sur la pile, l'interprète sort deux 0 et calcule 0 ⁰ , ce qui donne 1 selon JavaScript. Oaffiche ensuite cette valeur et @termine le programme.

Programme double

Regardez le courir!

)<@OP)<@OP

Le programme de 10 octets est trop long pour tenir sur un cube d'unité et est donc étendu à un cube de taille 2:

    ) <
    @ O
P ) < @ O P . .
. . . . . . . .
    . .
    . .

Comme auparavant, l’IP commence en haut à gauche de la face la plus à gauche. Cette fois, la toute première instruction est P, ce qui pousse un 1 comme avant. Next est )ce qui incrémente l’élément supérieur en le transformant en 2 . Ensuite, <l'adresse IP est retournée et il frappe à )nouveau en transformant le 2 en 3 .

Voici où ça devient intéressant. Pélève le deuxième élément en partant du haut à la puissance du premier élément, ce qui donne 0 ³ = 0 . Ensuite, l’IP s’enroule sur le visage le plus à droite et passe par deux interdictions .avant d’en frapper une autre P. Nous voyons ici une autre bizarrerie de Cubix: les opérateurs binaires (tels que P) ne suppriment pas leurs opérandes de la pile. Donc, puisque la pile est maintenant [3, 0], nous calculons 3 ⁰ = 1 , ce qui Osort et @termine le programme.

Triple programme

Regardez le courir!

)<@OP)<@OP)<@OP

Comme pour le programme double, le triple peut être placé sur un cube de taille 2:

    ) <
    @ O
P ) < @ O P ) <
@ O P . . . . .
    . .
    . .

Ce programme démarre de la même manière que le précédent: Pappuie sur 1 , )incrémente, <pointe l’IP Ouest, )augmente à nouveau, puis Pappuie sur 0 . L'adresse IP est ensuite enroulée <sur la face la plus à droite, ce qui ne fait rien car l'adresse IP est déjà dirigée vers l'ouest.

Voici une différence par rapport à la double programme: le )incrémente le 0 sur le dessus de la pile à un 1 . Quand il Preprend sa magie, il calcule cette fois 3 ¹ = 3 . Osorties et se @termine, et nous prouvons de manière concluante que la troisième fois est en effet le charme.

Brain-Flak , 10 octets

<>([]{}())

Essayez-le en ligne!

Essayez-le doublé!

Essayez-le triplé!

Explication:

#Toggle stacks
<>

#Push
(
    #Stack-height (initially 0) + 
    []

    #The TOS (initially 0) + 
    {}

    #1
    ()
)

Lorsque nous courons cette fois, il sera mis (0 + 0 + 1) == 1sur la pile alternative. Couru une deuxième fois, il met la même chose sur la pile principale. Exécuté une troisième fois, il évalue (1 + 1 + 1) == 3puis, le transfère sur la pile alternative et l’imprime implicitement.

SQL, 25 24 23 octets

( -1 octet Suppression d' un caractère erroné qui a toujours été commenté et ne rien faire )
( -1 octet modifié SELECTà PRINTtel que recommandé par Razvan Socol )

PRINT 2/*
*2+1--*/-1
--

Comment ça marche:
En SQL, vous pouvez commenter les balises de commentaire, comme ceci:

/*
'Comment'--*/

contre

--/*
'Not Comment'--*/

Code sur 1 ligne avec les commentaires exclus:
Première itération: SELECT 2-1Sortie: 1
Deuxième itération: SELECT 2-1*2+1Sortie: 1
Troisième itération: SELECT 2-1*2+1*2+1Sortie:3

SOGL V0.12 , 7 5 4 octets

ē»«I

Essayez-le ici!

Essayez-le doublé!

Essayez-le triplé!

Explication:

ē»«I
ē     push counter, then increment it.
      First time running this will push 0, then 1, then 2.
             TOS on each: 0  1  2
 »    floor divide by 2   0  0  1
  «   multiply by 2       0  0  2
   I  and increment       1  1  3

05AB1E , 6 5 octets

.gDÈ+

Essayez-le en ligne! ou essayez-le doublé! ou essayez-le triplé!

Explication

.g     # push length of stack
  D    # duplicate
   È   # check if even
    +  # add

Simple: 0 + (0 % 2 == 0) -> 1
Double: 1 + (1 % 2 == 0) -> 1
Triple:2 + (2 % 2 == 0) -> 3

> <> , 9 octets

\5 n;
\\1

Essayez-le en ligne!

Essayez-le doublé!

Essayez-le triplé!

J'ai trouvé cette sorte de chance, en utilisant la philosophie suivante: "Si le chemin du poisson est assez compliqué, il finira par arriver à un résultat". Les versions originale et doublée impriment un 5, et la version triplée imprime 1 puis 5 pour obtenir 15 = 3 × 5. Voici les versions multipliées, pour votre lecture:

\5 n;
\\1\5 n;
\\1

\5 n;
\\1\5 n;
\\1\5 n;
\\1

Python 2 ,  46 45  39 octets

Inspiré par la réponse de Halvard . Je suis heureux que mon défi en ait inspiré un nouveau, que je trouve encore plus intéressant. Enregistré 6 octets grâce à Kevin Cruijssen .

print open(__file__,"a").tell()/79*3|1#

Essayez-le en ligne!

Essayez-le doublé!

Essayez-le triplé!

Comment ça marche (obsolète)

k=open(__file__,"a").tell() # Read the source code in "append" mode and get its length.
                            # Assign it to a variable k.
;print k>>(k==90)#          # Print k, with the bits shifted to the right by 1 if k
                            # is equal to 90, or without being shifted at all overwise.
                            # By shifting the bits of a number to the right by 1 (>>1),
                            # we basically halve it.

Quand il est doublé, la longueur devient 90 , mais le nouveau code est ignoré grâce à #, k==90évalue donc True. Booléens sont des sous - classes d'entiers en Python, donc k>>Trueest équivalent à k>>1, qui est essentiellement k / 2 = 45 . Lorsqu'il est triplé, le nouveau code est à nouveau ignoré. La nouvelle longueur est donc 135 , elle n'est pas décalée car elle est k==90évaluée à False, donc k>>(k==90) ⟶ k>>(135==90) ⟶ k>>False ⟶ k>>0 ⟶ k, et k est imprimé tel quel .

Python 2 , 36 octets

Il s’agissait d’une suggestion de Aidan F. Pierce à 38 octets, et j’ai joué au golf par 2 octets. Je ne poste pas ceci comme ma solution principale parce que je ne l'ai pas inventé moi-même.

0and""
True+=1
print True>3and 3or 1

Essayez-le en ligne! Essayez-le doublé! Essayez-le triplé!

R , 37 31 28 octets

Merci à Giuseppe pour avoir joué aux 3 derniers octets.

length(readLines())%/%2*2+1

(avec une nouvelle ligne de fuite).

Essayez une fois!

Essayez-le deux fois!

Essayez-le trois fois!

Cela utilise l' readLines()astuce de la réponse de Giuseppe au défi 8 balles , où les stdinredirections vers le fichier source. En gros, ce code ne compte que le nombre de lignes sous la première ligne et est affiché 1s'il y a 1 ou 3 lignes (le code est simple ou doublé) ou 3s'il y a 5 lignes (le code est triplé).

Lost , 38 octets

\\<<<<</<<<<>
2>((1+@>?!^%^
.........v

Essayez-le en ligne!

\\<<<<</<<<<>
2>((1+@>?!^%^
.........v\\<<<<</<<<<>
2>((1+@>?!^%^
.........v

Essayez-le en ligne!

\\<<<<</<<<<>
2>((1+@>?!^%^
.........v\\<<<<</<<<<>
2>((1+@>?!^%^
.........v\\<<<<</<<<<>
2>((1+@>?!^%^
.........v

Essayez-le en ligne!

Explication

Lost est une langue très intéressante pour ce défi. La technique habituelle de Lost consiste à construire un "piège". Un piège est une section du programme conçue pour capturer toutes les IPS en un seul endroit, de manière à ce que leurs piles puissent être effacées et qu’elles puissent être contrôlées pour aller dans une direction spécifique. Cela rend les programmes d'écriture dans Lost beaucoup plus faciles à gérer. Cependant, étant donné que le programme est dupliqué, nous devons également éviter la duplication des interruptions. Cela nous oblige à concevoir un nouveau piège qui fonctionne correctement, mais lorsqu'il est dupliqué, un seul des pièges fonctionne. Mon idée de base ici est la suivante

v<<<<>
>%?!^^

Tant que la pile est non vide, ?elle supprimera un élément et le ramènera au début si cet élément est différent de zéro. La clé ici est que lorsque cela empile la ^^ligne s

v<<<<>
>%?!^^v<<<<>
>%?!^^v<<<<>
>%?!^^v<<<<>
>%?!^^v<<<<>
>%?!^^

Ce qui signifie que peu importe la façon dont vous entrez, vous sortez toujours au même endroit.

À partir de là, nous pouvons essayer de mettre en œuvre la même idée à partir de ma réponse de Klein .

\\<<<<<v<<<<>
2>((1+@>?!^%^

La colonne vertébrale de notre programme est le côté gauche qui pousse plusieurs 2s. Chaque fois que nous ajoutons une copie du programme, un autre 2est ajouté à la colonne vertébrale du programme, ce qui signifie qu'un 2 supplémentaire est placé dans la pile. Une fois en bas, il rebondit \\>et exécute le code

((1+@

Cela supprime les 2 premiers éléments de la pile, ajoute un à ce qui reste et quitte. Une fois que notre colonne vertébrale a 3 2s, nous allons ajouter 1 et obtenir 3, si nous avons moins de 3 éléments, nous allons simplement rejeter la pile entière et renvoyer 1.

Maintenant, le seul problème est que !dans notre programme peut provoquer une boucle infinie. Si l'IP commence à !monter, il sautera et atterrira là où il était. Cela signifie que nous devons ajouter une autre ligne en dessous pour empêcher la boucle.

\\<<<<</<<<<>
2>((1+@>?!^%^
.........^

Cela a le léger problème de mettre quelques barres obliques entre nos ^s dans le piège. Cependant, assez miraculeusement, tout se passe bien. Nos ips rebondissent correctement pour que cela ne fasse aucune différence.

Stax , 5 octets

|dhH^

Exécuter et déboguer en ligne! · Doublé · Triplé

Explication

|dhH^
|d       Push Current stack depth `d`, originally 0
         Doubled -> 1, Tripled -> 2
  hH^    Map d to 2*(floor(d/2))+1
         Implicit print

C (gcc) , 95 91 85 octets

#ifndef a
#define a-1
main(){puts(3
#include __FILE__
?"1":"3");}
#define a
#endif
a

Essayez-le en ligne!

Japt , 8 6 5 octets

-1 octet grâce à @ETHproductions

°U-v

Explication:

°U-v
 U     # variable U=0                # U=0
°U     # ++U                         # U=1
  -    # minus:
   v   #   1 if U is divisible by 2  
       #     else
       #   0                         # U=1

Ceci évalue à 1-0 = 1

Doubled évalue à 2-1 = 1

Triplé évalue à 3-0 = 3

Pure Bash (aucun wcou autre utilitaire externe), 27

trap echo\ $[a++&2|1] EXIT

• Essayez une fois.
• Essayez deux fois.
• Essayez-le trois fois.

Perl 5 , 18 15 13 12 11 octets

-3 octets grâce à nwellnhof

say 1|
+.7#

Une fois l' essayer en ligne!

Deux fois Essayez-le en ligne!

Thrice Essayez-le en ligne!

> <> , 10 9 8 octets

562gn|

Essayez-le en ligne!

Essayez-le doublé!

Essayez-le triplé!

Je suis sûr qu'il y a une solution de 8 octets quelque part.

Le non imprimable à la fin a la valeur ASCII 1 et n'est récupéré que par la gcommande et à la troisième itération. Pour les deux premiers, il imprime 05, puis imprime 15.

C (gcc) , 107 octets

Ma première soumission en C (gcc). Bien trop long ...

i;
#ifdef c
#define c
#ifdef b
i=2;
#else
#define b
#endif
#else
#define c main(){putchar(i+49);}
#endif
c

Liens TIO: simple , double , triple .

Labyrinth , 12 11 9 octets

: #%! @
 sept

TIO (1x) , TIO (2x) , TIO (3x)

JavaScript, 81 77 74 70 octets

^{4 octets sauvés grâce à Shaggy}

var t,i=(i||[3,1,1]),a=i.pop()
clearTimeout(t)
t=setTimeout(alert,9,a)

Jolie solution JS boiteuse. Consomme les valeurs du [3,1,1]tableau de droite ( pop()). Enregistre un délai d'attente pour afficher la valeur actuelle dans le futur. Si un délai a déjà été enregistré, annulez-le. S'appuie sur la nature sale de var, qui lève des déclarations variables.

Deux fois:

var t,i=(i||[3,1,1]),a=i.pop()
clearTimeout(t)
t=setTimeout(alert,9,a)

var t,i=(i||[3,1,1]),a=i.pop()
clearTimeout(t)
t=setTimeout(alert,9,a)

Trois fois:

var t,i=(i||[3,1,1]),a=i.pop()
clearTimeout(t)
t=setTimeout(alert,9,a)

var t,i=(i||[3,1,1]),a=i.pop()
clearTimeout(t)
t=setTimeout(alert,9,a)

var t,i=(i||[3,1,1]),a=i.pop()
clearTimeout(t)
t=setTimeout(alert,9,a)

C (gcc) , 53 52 octets

Notez l'espace après #endif.

n;main(){putchar(n+49);}
#if __LINE__>7
n=2;
#endif 

Essayez-le en ligne!

Charbon de bois , 12 octets

⎚≔⁺ι¹ιＩ⁻ι⁼ι²

Essayez-le en ligne! Le lien est en code verbeux.

Essayez-le doublé!

Essayez-le triplé!

Explication

⎚             Clear
 ≔⁺ι¹ι        Assign plus(i, 1) to i
       Ｉ      Cast (and implicitly print)
         ⁻ ⁼ι² Subtract equals(i, 2) from
          ι    i

JavaScript, 43 40 octets

var t=t?--t:~!setTimeout`t=alert(1|~t)`;

2x:

var t=t?--t:~!setTimeout`t=alert(1|~t)`;var t=t?--t:~!setTimeout`t=alert(1|~t)`;

3x:

var t=t?--t:~!setTimeout`t=alert(1|~t)`;var t=t?--t:~!setTimeout`t=alert(1|~t)`;var t=t?--t:~!setTimeout`t=alert(1|~t)`;

PowerShell , 54 48 45 44 octets

if(99-gt(gc $PSCOMMANDPATH|wc -c)){1;exit}3#

Essayez-le en ligne!

Essayez-le doublé!

Essayez-le triplé!

Obtient son propre chemin d'appel avec $PSCOMMANDPATHet effectue une get- contenu sur le fichier. Ifle nombre de caractères de ce fichier est inférieur à 99(vérifié via wc -ccoreutils), puis nous produisons 1et exit(c'est-à-dire, nous arrêtons l'exécution). Cela représente le code d'origine et le code doublé. Sinon, nous sortons 3et sortons. Le code qui se trouve dans les sections doublées ou triplées n'a pas de sens, car nous allons le prendre exitavant, ou c'est derrière un commentaire #.

Sauvegardé 6 octets grâce à M. Xcoder
Sauvegardé 3 4 octets grâce à Pavel

C # (178 octets)

Console.WriteLine(1+2*4%int.Parse(System.Configuration.ConfigurationManager.AppSettings["z"]=(int.Parse(System.Configuration.ConfigurationManager.AppSettings["z"]??"0"))+1+""));

solution folle en C #, mais je suis heureux que cela soit possible en une ligne en C #. :)

Pour moi, le plus difficile était d'avoir un C # valide qui initialiserait ou incrémenterait la même variable. J'ai donc abusé de ConfigurationManager car j'avais besoin d'un NameValueCollection statique global et ConfigurationManager était le seul auquel je pouvais penser que je pouvais mettre à jour en mémoire. EnvironmentVariables est une autre option à laquelle j’ai pensé mais il n’a pas d’indexeur et je ne sais pas comment le faire sur une ligne qui peut être copiée-collée pour produire la sortie requise conformément à la spécification.

Enchantements runiques , 35 octets

^w3'\
    f
    1
/1@
/
 '54\w
/yyy

Essayez-le en ligne!

Travailler sur celui-ci m'a permis de trouver une erreur dans mon analyseur traitant des nouveaux caractères modificateurs de délai, bien que le résultat final ne soit pas affecté par cela, car je n'en ai plus eu besoin.

Fonctionne en raison du fait que la dernière ligne n'a pas de nouvelle ligne de fin (ni d'espaces de fin), ce qui permet aux IP dupliquées de se créer à un endroit différent. La partie supérieure gauche finit par créer une grande boucle autour de la grille, tandis que la deuxième adresse IP effectue une opération de réflexion pour remplacer \la 6ème ligne par a . Cette adresse IP sera alors bouclée pour toujours et ne fera rien.

La troisième adresse IP effectue également le même remplacement en même temps, mais comme il est situé sur la 13ème ligne, sa copie de ce réflecteur l’envoie vers le haut et il exécute la 1f'3wséquence présente dans le coin supérieur droit, qui remplace le 1avec un 314 line, juste avant que l'IP d'origine ne l'exécute, entraînant la sortie du programme triplé au 3lieu de 1(les valeurs peuvent également être 2et 6, 3et 9, 4et 12, 5et ou et en 15raison de la disponibilité des a-fconstantes numériques; 1et 3ont été choisies arbitrairement). Il est ensuite laissé dans une boucle sans fin en effectuant plus de commandes de réflexion qui ne font rien.

Essayez-le en trois exemplaires!

Perl 5, 28 25 octets

-3 octets grâce à @neil!

print"\e[D$a"if(++$a!=2);

Déplace le curseur en arrière (ne fait rien au début de la ligne) et imprime la valeur de la $apremière et de la troisième fois (c.-à-d. La troisième fois qu'un 1 est imprimé, le curseur se déplace et un 3 est imprimé sur la position du 1).

QBasic, 19 octets

CLS
x=2^x
?x-1OR 1

La source devrait inclure une fin de ligne.

Explication

Nous voulons sortie 1, 1, 3. Notez que ces nombres sont un moins que les puissances de 2. Donc:

CLS      ' CLear Screen of any output from previous copies of the code

x        ' Numeric variables are preset to 0...
 =2^x    ' so as this statement is repeated, the value of x goes 1, 2, 4

 x-1     ' Therefore x-1 goes 0, 1, 3...
    OR 1 ' and we bitwise OR it with 1 to change the 0 to 1...
?        ' and print.