Comme on le sait ,

Chuck Norris a compté à l'infini. Deux fois

En plus ,

Chuck Norris peut compter à l'infini à l'envers.

Aussi, bien que peut-être moins connu, Chuck Norris peut parler un peu espagnol en plus de l'anglais.

Le défi

Ecrivez un programme (ou une fonction) pouvant être exécuté dans deux langues différentes. Dans une langue, le programme doit sortir la séquence

1, 1, 2, 2, 3, 3, 4, 4, ...

et dans l'autre langue, la séquence doit être produite (y compris les zéros non significatifs)

1, 2, ..., 9, 01, 11, 21, 31, ..., 89, 99, 001, 101, 201, ...

Règles

• Les programmes ou fonctions sont autorisés, dans n'importe quel langage de programmation . Les échappatoires standard sont interdites.
• Différentes versions d'une même langue (telle que Python 2/3) ne comptent pas comme des langues différentes. Les langages associés (tels que C / C ++ ou Matlab / Octave) sont considérés comme différents.
• Aucune entrée ne sera prise.
• Le programme doit continuer à afficher les termes de la séquence jusqu'à ce qu'il soit arrêté par l'utilisateur. Comme le programme ne s'arrête pas tout seul, la sortie ne peut pas être produite à la fin. Il doit être produit pendant l'exécution du programme, de manière continue ou par lots.
• La sortie peut utiliser STDOUT ou équivalent, ou peut être affichée dans une fenêtre graphique. Tout séparateur non numérique entre les termes de la séquence est autorisé, à condition que chaque terme puisse être clairement distingué des termes voisins. Il est également acceptable que l’écran soit effacé entre les termes.
• Chaque séquence peut commencer par au 0lieu de 1. Dans ce cas, dans l'ordre "deux fois", 0il convient de répéter l'opération, tout comme les autres chiffres.
• Les zéros en tête sont significatifs dans la séquence "arrière". Par exemple, le dixième terme est 01; ni 1ni 001sont acceptables.
• Si les deux langues utilisent des codages de caractères différents, le programme est défini par ses octets et non par ses caractères. C'est-à-dire que les octets devraient être les mêmes dans les deux langues.
• Le code le plus court en octets gagne.

05AB1E / Jelly ,  14 à  13 octets

-1 octet grâce à Adnan (évitez les doublons avec une impression non éclatante)

Octets bruts (hexadécimaux):

31 5b 3d 3d 3e 5d fc 06 b6 3b 87 08 15

Dans la page de code de 05AB1E :

1[==>]üε¶;‡ηΩ

Essayez-le en ligne!

Dans la page de code de Jelly :

1[==>]‘©Ṛ;⁷®ß

Essayez-le en ligne!

Comment?

Le programme 05AB1E imprime le double compte avec chaque entrée séparée par des nouvelles lignes:

1[==>]üε¶;‡ηΩ
1             - push 1 onto the stack
 [            - start infinite loop:
  =           - print top of stack
   =          - print top of stack
    >         -   increment the top of the stack (pop(1), x+=1, push)
     ]        - end the infinite loop
      üε¶;‡ηΩ - this code is never executed nor is it parsed

Le programme Jelly imprime le nombre inversé avec chaque entrée séparée par des nouvelles lignes.

L'analyseur traitera un littéral valide entre [et ]comme le littéral inclus, sinon ces octets sont des jetons non définis et, en tant que tels, deviennent équivalents à des jetons séparant le code en lignes. ==>n’analyse pas littéralement, le code est donc:

1 - link 1 (not executed but parsed)
1 - literal 1

==> - link 2 (not executed but parsed)
=   - left equals right? (vectorises)
 =  - left equals right? (vectorises)
  > - is greater than the right argument? (vectorises)

‘©Ṛ;⁷®ß - Main link: no arguments
‘       - increment (implicit 0 on left increments to 1 on the first pass)
 ©      - copy the result to the register and yield it
  Ṛ     - reverse, this has an implicit decimal list build, e.g. 142 -> [2,4,1]
    ⁷   - a newline character
   ;    - concatenate, e.g. [2,4,1] -> [2,4,1,'\n']
     ®  - recall the number from the register, e.g. 142
        - The chain has reduced to one item of arity 0, causing a pre-evaluation print:
        -     ...and since the list contains a character it gets smashed together
        -     e.g. [2,4,1,'\n'] prints 241 followed by a newline character
      ß - call this link with the same arity, e.g. as a monad with left = 142

Python 2 / C (clang) , 109 107 100 84 95 88 89 88 88 84 octets

i=0;
#/*
while 1:i+=1L;print`i`[::-1]
'''*/
a(){for(;;)printf("%i %1$i ",++i);}//'''

Python: essayez-le en ligne!

C: Essayez-le en ligne!

Le L dans le code Python fait partie du délimiteur.

Explication:

Dans le code C, il met d'abord i à 0. Ensuite, il commence un commentaire ( #code valide en C pour les #includeinstructions) où le code Python va. À la fin du commentaire, il définit une fonction qui incrémente pour toujours une variable et l’imprime deux fois, délimitée par des espaces. Il commence alors un commentaire.

Dans le code Python, i=0;met i à zéro. Python ignore la ligne suivante car #commence un commentaire d'une seule ligne. Il l'incrémente ensuite pour toujours, le transforme en un nombre long et affiche sa représentation sous forme de chaîne inversée. Le «L» du long fait partie du délimiteur. Après cela, il commence une chaîne de plusieurs lignes pour commenter le code C, qui se termine plus tard.

-2 octets grâce à @LuisMendo. -7 octets grâce à @ZacharyT. -6 plus d'octets grâce à @ZacharyT. +11 octets pour corriger un bug grâce à @ mbomb007. -7 octets grâce à @Doorknob. +1 octet pour corriger un bug grâce à @Doorknob. -1 octet grâce à @yoann. -1 octet supplémentaire grâce à @yoann. -3 octets grâce à @Cyoce.

Gelée / Pyth, 15 octets

.V1_`b;"1üÉÉ$

Les logiciels non imprimables sont endommagés par le logiciel SE, voici donc un hexdump:

00000000: 2e56 315f 6062 3b22 7f31 fcc9 c924 0b    .V1_`b;".1...$.

Courez avec jelly f fileet pyth filerespectivement.

Explication

Vient d’abord la partie Pyth. .Vexécute une boucle infinie sur la séquence incrémentante à partir de son entrée, qui est ici 1. Ensuite, nous _inversons ( `) l'index de boucle stringified ( ) et le sortons bimplicitement. Il ;y a là pour terminer la boucle et il "est nécessaire de traiter le reste du programme comme un littéral afin d'éviter que l'analyseur ne s'étouffe.

La partie Jelly sera expliquée en traduisant d’abord le reste du programme à partir de la page de code Jelly:

¶1‘ṄṄ$¿

Le ¶agit comme un saut de ligne, ignorant effectivement la première partie du programme en en faisant un lien jamais appelé. Ensuite, nous commençons à 1et exécutons une boucle while ( ¿) qui utilise ṄṄ$(print deux fois) comme condition et incrémente ( ‘) la valeur comme corps de la boucle.

Soit dit en passant, en remplacement de la partie Pyth avec 1[DR,>] serait de créer une soumission Jelly / 05AB1E valable dans 14 octets, mais le interpeter actuel contient un bug qui empêche cela.

Perl / JavaScript, 87 octets

s=0;print=console.log;m=s;$_=s=s=s=m;while(++$_){print((m/s,$_+`
`+$_||/&&reverse.$/))}

Perl

s/0;print/console.log;m/s;$_=s/s/s/m;while(++$_){print((/s,$_+`
`+$_||/&&reverse.$/))}

Un mécanisme que je l' ai utilisé beaucoup dans polyglottes JS / Perl est d'abuser du fait que la substitution peut accepter à peu près tout delimiter, en utilisant des =moyens que je peux utiliser les substitutions inutiles initiales (remplaçant tout d' abord 0;printavec console.log;mun drapeau /sdans $_, qui est actuellement undef) , puis définissant $_le résultat du remplacement spar sen mode multiligne ( /m), qui est 0. Maintenant $_est 0et je commence la whileboucle, cela incrémente alors $_. J'appelle ensuite print, en passant une expression régulière qui correspond (en raison de ||la fin qui correspond à une chaîne vide) et utilise l' &&opérateur pour envoyer l'inverse de la $_concaténation avec une nouvelle ligne ($/est pré-initialisé à "\n"). Cela compte à l'infini à l'envers.

JavaScript

s=0;print=console.log;m=s;$_=s=s=s=m;while(++$_){print((m/s,$_+`
`+$_||/&&reverse.$/))}

Beaucoup d'assignations de variables ici, masquées dans les s///appels Perl . Je mis en place des variables set mque 0, alias console.logpour print, exécutez une division inutile, ensemble $_à 0et commence la whileboucle incrémenter $_, appel en printpassant 0( m/s, cela commence l'appel à mPerl, mais est traité comme division standard JS) et notre chaîne cible ( $_+"\n"+$_) via l’opérateur virgule, qui renvoie le dernier élément de la liste. J'évite le dernier morceau de code Perl ( &&reverse.$/) car ce $_+"\n"+$_sera une vérité et je pourrai ainsi utiliser ||pour produire un RegExpobjet contenant la fin du code Perl qui ne sera jamais évalué.

Testé avec Perl 5 et Node 6.

NodeJS / PHP, 131 106 octets

-25 octets grâce à @Titus

<!--
printf=(_,i)=>process.stdout.write(i+i),strrev=i=>i+" "//--><?
for($i=0;;)printf("%s ",strrev($i++));

Utiliser NodeJS au lieu du navigateur JS pour un meilleur formatage de sortie et une meilleure gestion des boucles infinies.

Essayez le JavaScript en ligne
Essayez le PHP en ligne

Notez que la sortie TIO est coupée après 128 Ko.

V / Brain-Flak Classic , 27 , 26 octets

(()){[[({}())[]]]}é1òÙæ_æ

Hexdump:

00000000: 2828 2929 7b5b 5b28 7b7d 2829 295b 5d5d  (()){[[({}())[]]
00000010: 5d7d e931 f2d9 e65f 01e6                 ]}.1..._..

Essayez-le en ligne! dans V (légèrement modifié pour qu'il se termine afin que vous puissiez voir la sortie. Sur TIO, V ne sort que si le programme se termine)

Essayez-le en ligne! dans Brain-Flak Classic

Ce n'est pas le plus intéressant des polyglottes, car le code V n'a aucun effet sur brain-flak classic, et inversement, mais c'est vraiment amusant d'utiliser mes deux langues sur un challenge, et les deux solutions sont très intéressantes. par eux-même.

V Explication:

é1              " Insert a '1'
  ò             "   Recursively:
   Ù            "   Duplicate this number
    æ_          "   Flip this line
      <C-a>     "   Increment the number on this line
           æ    "   Flip it back (the '_' is implicit because it's at the end of the program)

Explication de BFC:

#Push a one onto the main stack
(())

#Forever:
{

  #Print twice:
  [[

    #Increment the top of the stack.
    #Evaluates to *i + 1*
    ({}())

    #Minus one
    []
  ]]

#Endwhile
}

Retina / Python 2, 61 octets

#{*M`
#*M`
"""

}`$
1
""";i=1
while 1:print str(i)[::-1];i+=1

Rétine | Python 2

R / Octave , 83 80 78 71 octets

-3 octets grâce à Luis Mendo

i=0;
while(1)
#{
print(c(i<-i+1,i))
#}
disp(flip(num2str(i)))
i+=1;
end

#{ }#est un commentaire de bloc Octave et #se trouve être le commentaire de R. L'interprète R ne voit que la ligne suivante comme corps de la whileboucle et l'interprète Octave passe directement au code Octave.

La partie R imprime des paires de nombres commençant à 1 et la partie octave imprime les nombres arrière commençant à 0.

Je m'attends vraiment à être sur-joué (même par la même combinaison de langues); Je viens d'écrire tellement de code Matlab et R récemment que j'ai décidé de tenter le coup.

Essayez-le en ligne! - lien octave

Ruby / Python2: 68 64 octets

i=0
"#{loop{p i+=1,i}}"
exec('while 1:print str(i)[::-1];i+=1')

Ruby perspective

simple init de variable:

i = 0

"#{}"est la syntaxe pour l'interpolation de chaîne. Je l'utilise pour exécuter l'expression à la place.

"#{loop{p i+=1,i}}"

pest un raccourci pour puts. loopcrée une boucle infinie.

Ensuite, il y a la execchose, mais elle n'est jamais évaluée, car la boucle infinie est par définition infinie. Nécessaire execpour ne pas générer d'erreur de syntaxe avec le code Python.

Perspective python

Du point de vue de Python, il y a un point commun i=0. Ensuite, Python a une syntaxe différente pour l’interpolation de chaîne, cette ligne est donc simplement ignorée. Ensuite, il y a une boucle infinie semblable à celle affichée par les autres.

Bash / Check , 50 à 28 octets

^{Merci à @Doorknob d’avoir économisé de nombreux octets en passant de Python à Bash}

#>
#v
 #p<p<)#
seq 1 inf|rev

Pour Bash:

#>
#v
 #p<p<)#

Ce ne sont que quelques commentaires, qui sont ignorés.

seq 1 inf|rev

Commencez une séquence allant de 1 à l'infini, puis transmettez le résultat à rev.

Vérifier:

#>

Ceci bascule immédiatement en mode 2D en allant à droite. >dirige le droit de propriété intellectuelle, qui n'a aucun effet. Il retourne au début de la ligne et frappe à #nouveau, ce qui permet de sortir du mode 2D. Il frappe ensuite >en mode 1D, ce qui pousse 0 dans la pile. Comme il est en mode 1D, l’IP passe à la ligne suivante.

#v

#fait basculer l’IP en mode 2D et le vdirige vers le bas.

 #p<p<)#

Le premier #repasse en mode 1D. prenvoie le TOS sous forme de nombre (mais ne le saute pas), puis <imprime une nouvelle ligne. Ceci est fait deux fois, puis le nombre est incrémenté de ). #bascule à nouveau en mode 2D, de sorte que l'adresse IP retourne au début de la ligne, clique #pour passer en mode 1D, etc.

CJam /> <>, 27 23 octets

"la,:naonao
"1{_sW%n)}h

À CJam:

Essayez-le en ligne! - Notez que vous devez attendre la limite de 60 secondes pour voir la sortie, mais cela fonctionne hors ligne.

"la,:naonao
"

Ceci définit un littéral de chaîne multiligne qui n'est jamais utilisé.

 1{_sW%n)}h

La deuxième ligne est la suivante:

1     e# Push 1:               | 1 
{     e# Forever:              | 1
  _   e#   Duplicate:          | 1 1
  s   e#   Convert to string:  | 1 "1"
  W%  e#   Reverse:            | 1 "1"
  n   e#   Print with newline: | 1
  )   e#   Increment:          | 2
}h    e# End loop

Pour> <>:

"

Commence un littéral de chaîne.

 la,:naonao

Contenu de la chaîne littérale. Chacun des codes de caractères est poussé individuellement dans la pile.

"

L'adresse IP tourne autour pour atteindre à "nouveau, ce qui met fin au mode chaîne.

 la,

lprend la longueur de la pile, apousse 10 et se ,divise. Cela nous donne la longueur de la pile / 10.

    :nao

:duplique, nimprime sous forme de nombre, aappuie sur 10 et oimprime sous forme de code de caractère (nouvelle ligne).

        nao

Même chose. Imprimer le numéro suivi d'une nouvelle ligne. La pile a maintenant à nouveau la longueur 10 (le contenu du littéral de chaîne d'origine est sur la pile).

Ensuite, l’IP "revient à nouveau, ce qui conduit à 10 éléments supplémentaires à pousser. La prochaine fois,l retourne 20, donc 2 est imprimé, etc.

La deuxième ligne n'est jamais touchée par l'IP.

Röda / C (gcc) , 90 octets

main(){f(0);}f(a){a=1//1{[` $a`[::-1]];a++}while[]/*
;for(;;a++)printf("%d %d ",a,a);/**/}

Röda: Essayez-le en ligne!

C: Essayez-le en ligne!

Explication

Cela abuse du fait qu’il //s’agit d’un int divison dans Röda mais d’un commentaire de ligne dans C.

Dans les deux langues, main(){}désigne le programme principal et tous deux appellent function favec un argument factice de 0.

En Röda, a=1//1fait division int et affecte le résultat 1à a. C voit a=1et fait la même chose, mais tout ce qui suit est un commentaire pour C. À partir de là, les deux langues se séparent.

Röda

Nous avons une boucle infinie avec while[]( une condition vide est la vérité ). À l'intérieur de celui-ci, ` $a`convertit l'entier aen chaîne (avec un espace de tête) après quoi l' [::-1]inverse (et le produit avec un espace de fin). Ensuite, la valeur de aest incrémentée de un.

En dehors de la boucle while, un commentaire multiligne commence /*et se termine juste avant la fin de la fonction.

C

Après avoir ignoré le reste de la ligne, le programme passe à la deuxième ligne. Nous commençons par un point-virgule car l' a=1instruction doit être terminée. Après cela, nous rencontrons une simple boucle for qui affiche la variable itérative a, deux fois à chaque itération.

En dehors de la boucle for, the /*est juste là pour ignorer le dernier */commentaire de Röda .

QBIC / QBasic 4.5 , 58 octets

do
p=p+1
if q then
'?`_f!p$|
else
?p,p,
end if
loop

Cela abuse fortement du fait que toutes les lettres minuscules sont considérées comme du code QBasic littéral par l'interpréteur QBIC et sont donc simplement transmises à la couche QBasic de QBIC. Comment les deux langues voient ce code, côte à côte:

LOC         QBasic                    QBIC
-------------------------------------------------------
do                   Start an infinite loop
p=p+1                Increment p, starts off as 0
if q then    q = 0, goto ELSE         q = 1, execute IF
'?`_f!p$|    ' = comment, invalid     '?` is a 'code literal', passing PRINT to QBASIC
             syntax is ignored        followed by QBIC code to flip p cast as string.
else         q=0, execute             q=1, so ignored
?p,p,        PRINT p twice,
             separated by tab
end if               End of the branching logic
loop                 Wrap around for the next pass

laserLANG / > <> , 163 octets

!\0 \
/:+1/!   ]oo\
\:a( ?\:a%$a ,!
/r[-1l//" ,"/
/!n-%1:\?(1l
 \ --\/ <<---\
/----/'
\----  v
/>>--\#>---->/
\     /
/----<
\  \
/ -<< \
 /<< \
 "
">=>= /
\>=>=/

Première fois au golf, il est donc un peu plus grand qu'il pourrait l'être. Je voulais utiliser> <>, mais comme quelques personnes l'utilisaient déjà pour créer la deuxième séquence, j'ai décidé de tenter de créer la première séquence.

Essayez> <> en ligne!
Pour laserLANG, un interprète hors ligne est nécessaire pour l’essayer. On peut le trouver ici .

laserLANG

!\
 \ --\/ <<---\
/----/'
\----  v
/>>--\#>---->/
\     /
/----<
\  \
/ -<< \
 /<< \
 "
">=>= /
\>=>=/

l'exécution commence à !laquelle est complètement ignorée. il atteint ensuite le \et commence à descendre plusieurs personnages qu’il ignore complètement. Finalement, on en atteint un autre \et le plaisir commence. J'ai essentiellement pris l'idée derrière le "Hello, World!" boucle et condensé aussi bien que je pouvais. Le fait que laserLANG n’est sur le point de décrémenter / d’augmenter le compteur de mémoire que lorsque le compteur de programme va respectivement vers la gauche et la droite représente un défi. Je pense que la plupart des octets pourraient être sauvegardés ici en effectuant des astuces auxquelles je n'avais pas pensé.

> <>

!\0 \
/:+1/!   ]oo\
\:a( ?\:a%$a ,!
/r[-1l//" ,"/
/!n-%1:\?(1l

L’exécution commence, !ce qui le fait sauter le \. Il continue ensuite comme si le code laserLANG n'était pas là. Je n'avais pas réalisé que> <> ne disposait que d' un support pour la division float, donc une troncature courte et simple était un peu déroutante au début.

Befunge-98 / > <> , 32 octets

\r.#%a/# :_::p#+a#1,#
>l::naonao

A écrit ceci avant de voir combien de ><>réponses il y avait. Un peu d’arrière-plan: \c’est un opérateur qui change de direction dans> <>, dans ce cas, il le pousse vers le bas, alors que dans Befunge, il échange les deux premiers éléments de la pile. Le code Befunge ressemble à:

\r.#%a/# :_::p#+a#1,#

Essayez-le en ligne!

Imprime les nombres en arrière séparés par des nouvelles lignes. Befunge imprime automatiquement un espace après chaque nombre, de sorte que chaque chiffre est séparé par des espaces. Obtient à plusieurs reprises le dernier chiffre, l’imprime et le divise par 10 jusqu’à ce qu’il soit égal à 0. Puis incrémentez et répétez.

Le code> <> descend immédiatement à la deuxième ligne.

>l::naonao

Essayez-le en ligne!

Et c'est assez simple. Obtenez la longueur de la pile, imprimez deux fois avec des nouvelles lignes et laissez une copie de la longueur sur la pile pour la prochaine boucle.

Ruby / Stacked , 37 octets

0#/0[1+:tostr rev out]
loop{p p$.+=1}

Essayez-le en ligne!

Cela imprime 1 1 2 2... en rubis et 1 2 3 ... 01 11 21...en empilé.

Explication

En rubis:

0#/0[1+:tostr rev out]
loop{p p$.+=1}

Après avoir supprimé le commentaire, cela devient:

0
loop{p p$.+=1}

La seule ligne pertinente ici est la dernière. prenvoie son argument, donc p paffiche son argument deux fois. $.commence à 0, donc $.+=1incrémente $.en renvoyant la valeur incrémentée. Par conséquent, cela imprime chaque nombre de 1deux fois.

En empilés:

0#/0[1+:tostr rev out]
loop{p p$.+=1}

Ceci est équivalent aux jetons suivants:

0 #/ 0 [ 1 + : tostr rev out ] loop { p p $ . + = 1 }

Les deux premiers ne sont pas pertinents (essentiellement, transformation 0en une onction réduite). Ensuite, 0est poussé dans la pile. Après, la fonction [1+:tostr rev out]est poussée dans la pile.loopfait apparaître cette fonction et l'exécute à l'infini.

L'intérieur de la fonction incrémente le haut de la pile ( 1+), le duplique ( :), le convertit en chaîne ( tostr), l'inverse ( rev) et le renvoie ( out). Ce processus est répété indéfiniment. Comme la boucle est infinie, tout ce qui vient après ce jeton est essentiellement ignoré par l'interpréteur.

> <> / Jelly , 37 octets (25 dans la page de codes de Jelly)

01+:nao:nao!
DU;⁷Ṙ€
®‘©Çß

Essayez> <> en ligne!

Essayez Jelly en ligne!

> <> imprime deux fois la séquence à l'infini, Jelly décompte en arrière.

> <> ne concerne que la ligne supérieure:

Et merci à @ Challenger5 d’avoir économisé quelques octets ici sur le saut de ligne

01+:nao:nao!                           Stack at: 1st run   2nd run ...
0                 Push a 0             0         -
 1                Push a 1             0,1       1,1   
  +               Pop 2, add them      1         2 
   :              Duplicate top item   1, 1      2, 2
    n             Pop top, show as num 1         2
     a            Push the number 10   1, 10     2, 10
      o           Pop and show 10 as an ACII char (ie '\lf')
                                       1         2
         :nao     And again, for repetition
             !    ><> wraps around; this skips pushing a 0 again.

Jelly exécute son code de bas en haut. Seules les deux dernières lignes sont pertinentes.

®‘©Çß       main link, keeps track of the current number

®           Get a number from the register (0 on first run)
 ‘          Increment that by 1
  ©         Store in register
   Ç        Call helper (printer) link
    ß       Call this link again

DU;⁷Ṙ€      Printer

            (Say we are at number 21)
D           Break into digits         [2, 1]
 U          Reverse array             [1, 2]
  ;⁷        Append a line break       [1, 2, \n]
    Ṙ€      Print each char in array

C (gcc) / PHP , 102 86 80 octets

#//\
for(;;)echo strrev(++$i).'
int main(i){for(;;i++)printf("%d %d ",i,i);}//';

Affiche la double séquence en C et la séquence inverse en PHP.

Essayez-le en C!

Essayez-le en PHP!

Des explications

C

En C, le # trucs du préprocesseur de formulaires. Je ne connais pas vraiment grand chose à propos de C mais il ne se plaint pas quand il y a une ligne vide pour ce genre de choses. Le //forme un commentaire de ligne. UNE\ en fin de ligne est essentiellement "échappé" de la nouvelle ligne et fait en sorte que les deux lignes soient traitées comme une seule. Cela fonctionne également pour les commentaires de ligne. La deuxième ligne est donc considérée comme un commentaire en C. La troisième ligne effectue le travail de sortie des nombres avec une simple boucle for. Ensuite, il y a simplement un commentaire.

PHP

En PHP, #forme un commentaire de ligne, la première ligne est donc totalement ignorée. La deuxième ligne imprime les nombres inversés avec une boucle for et les sépare avec \nint main(i){for(;;i++)printf("%d %d ",i,i);}//(le code C enveloppé dans une chaîne).