Votre tâche est simple. Publiez un extrait de code dans n'importe quelle langue qui, s'il est répété n fois, affichera n en décimal, octal et hexadécimal, dans cet ordre, séparés dans des espaces. n est un entier supérieur à zéro. Il n'y a pas de zéros non significatifs. La réponse la plus courte l'emporte

Exemple

Si l'extrait est ABCalors le cas de test est

ABC 
1 1 1
ABCABC
2 2 2
ABCABCABCABCABCABCABCABCABC
9 11 9
ABCABCABCABCABCABCABCABCABCABCABCABC
12 14 C
ABCABCABCABCABCABCABCABCABCABCABCABCABCABCABCABCABCABC
18 22 12

Japt, 12 octets

[°TTs8 TsG]¸

Merci à @ETHproductions pour avoir économisé 2 octets!

Identique à ma 𝔼𝕊𝕄𝕚𝕟 réponse.

Perl, 30 octets

printf"\r%d %o %x",++$n,$n,$n;

Revenez au début de la ligne, incrémentez le compteur et le compteur d'impression en remplaçant l'ancienne sortie.

JavaScript, 54 53 51 47 octets

4 octets enregistrés grâce à @ user81655

var d=-~d;d+` ${d[b='toString'](8)} `+d[b](16);

Je suis en fait un peu surpris que cela fonctionne.

Explication

var d=-~d;  // `var` let's `d` not throw an error if it's not defined 
            // -~ essentially increments the variable
d+                    // decimal
` ${                  // space character
   d[b='toString'](8) // octal
} `                   // space character
+d[b](16)             // Hexadecimal

Essayez-le en ligne

C ++, 205 179 octets

int main(){};static int c=1;
#define v(x) A##x
#define u(x) v(x)
#define z u(__LINE__)
#include <cstdio>
class z{public:z(){++c;};~z(){if(c){printf("%d %o %x",--c,c,c);c=0;}}}z;//

(Pas de nouvelle ligne de fin - une fois copiée, la première ligne de la copie et la dernière ligne de l'original doivent coïncider)

Fondamentalement, cela fonctionne en créant une séquence de variables statiques qui, lors de la construction, incrémentent un compteur de variables globales. Ensuite, lors de la destruction, si le compteur n'est pas 0, il fait toute sa sortie et remet le compteur à zéro.

Afin de définir une séquence de variables sans conflits de noms, nous utilisons la macro expliquée comme suit:

#define v(x) A##x    //This concatenates the string "A" with the input x.
#define u(x) v(x)    //This slows down the preprocessor so it expands __LINE__ rather than yielding A__LINE__ as v(__LINE__) would do.
#define z u(__LINE__)//Gives a name which is unique to each line.

qui s'appuie un peu sur les caprices du processeur de chaînes. Nous utilisons zplusieurs fois pour définir des classes / variables qui n'entreront pas en conflit lorsqu'elles seront copiées sur des lignes distinctes. De plus, les définitions qui ne doivent apparaître qu'une seule fois sont placées sur la première ligne, qui est commentée dans des copies du code. Les instructions #defineet #includene se soucient pas qu'elles soient répétées, donc ne nécessitent aucune manipulation particulière.

Ce code présente également un comportement non défini dans l'instruction:

printf("%d %o %x",--c,c,c)

car il n'y a pas de points de séquence, mais c est modifié et accessible. LLVM 6.0 donne un avertissement, mais le compile comme vous le souhaitez - qui --cévalue avant c. On pourrait, au détriment de deux octets, ajoutez l'instruction --c;avant que les sorties et les changements --cdans printfla c, qui se débarrasser de l'avertissement.

Remplacé std::coutpar une printfsauvegarde de 26 octets grâce à une suggestion de mon frère.

CJam, 20 19 18 octets

];U):USU8bSU"%X"e%

Merci à @ MartinBüttner pour avoir joué au golf sur 1 octet!

Essayez-le en ligne!

Comment ça marche

]                  e# Wrap the entire stack in an array.
 ;                 e# Discard the array.
  U                e# Push U (initially 0).
   ):U             e# Increment and save in U.
      S            e# Push a space.
       U8b         e# Convert U to base 8 (array of integers).
          S        e# Push a space.
           U"%X"e% e# Convert U to hexadecimal (string).

𝔼𝕊𝕄𝕚𝕟, 14 caractères / 28 octets

[⧺Ḁ,Ḁß8,Ḁⓧ]ø⬭;

Try it here (Firefox only).

Première réponse! Bien qu'il existe probablement de meilleures façons de gérer cela.

Explication

[⧺Ḁ,Ḁß8,Ḁⓧ]ø⬭; // implicit: Ḁ = 0
[⧺Ḁ,             // increment Ḁ by 1
    Ḁß8,         // octal representation of Ḁ
        Ḁⓧ]     // hex representation of Ḁ
            ø⬭; // join above array with spaces
                 // repeat as desired until implicit output

MATL , 26 octets

Utilise la version actuelle (6.0.0) . Fonctionne sur Octave.

0$N1+ttYUb8YAb16YA3$XhZc1$

Exemples

Une fois que:

>> matl 0$N1+ttYUb8YAb16YA3$XhZc1$
1 1 1

Deux fois:

>> matl 0$N1+ttYUb8YAb16YA3$XhZc1$0$N1+ttYUb8YAb16YA3$XhZc1$
2 2 2

16 fois:

>> matl 0$N1+ttYUb8YAb16YA3$XhZc1$0$N1+ttYUb8YAb16YA3$XhZc1$0$N1+ttYUb8YAb16YA3$XhZc1$0$N1+ttYUb8YAb16YA3$XhZc1$0$N1+ttYUb8YAb16YA3$XhZc1$0$N1+ttYUb8YAb16YA3$XhZc1$0$N1+ttYUb8YAb16YA3$XhZc1$0$N1+ttYUb8YAb16YA3$XhZc1$0$N1+ttYUb8YAb16YA3$XhZc1$0$N1+ttYUb8YAb16YA3$XhZc1$0$N1+ttYUb8YAb16YA3$XhZc1$0$N1+ttYUb8YAb16YA3$XhZc1$0$N1+ttYUb8YAb16YA3$XhZc1$0$N1+ttYUb8YAb16YA3$XhZc1$0$N1+ttYUb8YAb16YA3$XhZc1$0$N1+ttYUb8YAb16YA3$XhZc1$
16 20 10

Explication

Le nombre d'éléments dans la pile est utilisé pour indiquer combien de fois nous avons exécuté l'extrait de code

0$         % specify zero inputs for next function, in case this is not the first
           % occurence of the snippet.
N          % number of elements in stack
1+         % add one
tt         % duplicate twice. We now have three copies of the number
YU         % convert to string (decimal)
b8YA       % bubble up number and convert to octal string
b16YA      % bubble up number and convert to hex string
3$XhZc     % join top three elements (strings) with a space
1$         % specify one input for next function. If the program ends here, that next
           % function will be implicit display, so it will print the top of the stack.
           % Else the stack will be left with one element more than at the beginning of
           % the current snippet

OCaml, 198 octets

;;open Char
;;(if Sys.argv.(0).[0]='~'then Sys.argv.(0).[0]<-'\000'else Sys.argv.(0).[0]<-chr(1+int_of_char Sys.argv.(0).[0]));let n=1+int_of_char Sys.argv.(0).[0]in Printf.printf"\r%d %o %x"n n n

Inclut une nouvelle ligne de fin et nécessite que le nom de fichier commence par un tilde (j'ai utilisé ~.ml; vous pouvez l'exécuter avec ocaml \~.ml) car c'est le caractère ASCII imprimable standard le plus apprécié. Abuse le fait que tous les caractères d'une chaîne sont modifiables et Sys.argv.(0).[0]est le premier caractère du nom de fichier.

Cela ne devrait fonctionner que pour n = 1 à 126, car le code ASCII ~est 126 et j'en ajoute un à la sortie. Il pourrait être raccourci de deux octets si nous voulons seulement n = 1 à 125. Après qu'il soit répété 126 fois, il reviendra à n = 1.

C'est mon tout premier golf, donc tout commentaire ou amélioration serait très apprécié.

Version non golfée:

;; open Char
;; if Sys.argv.(0).[0] = '~' 
   then Sys.argv.(0).[0] <- '\000'
   else Sys.argv.(0).[0] <- chr (1 + int_of_char Sys.argv.(0).[0])
;; let n = 1 + int_of_char Sys.argv.(0).[0] in
   Printf.printf "\r%d %o %x" n n n

TeaScript , 21 20 octets

[┼d,dT8),dT16)]j(p);

Je devrais le fermer automatiquement ;

Essayez-le en ligne

Explication

┼ devient ++

    // Implicit: d = 0
[   // Start array
 ++d,  // Increment d, decimal value
dT8),  // d to base 8
dT16)  // d to base 16
]j(p); // Join by spaces
    // Implicit: Output *last* expression

Perl, 40 octets

$_=<<'';printf"%d %o %x",(1+y/z//)x3;
:

Il y a une dernière ligne derrière le colon.

Traite tout après la première ligne comme un document ici et compte le zcontenu. Pour chaque nouvelle copie du code, une zest ajoutée. Nous devons ajouter 1au nombre, car il n'y en a pas pour le premier extrait (celui qui est exécuté).

Si une sortie supplémentaire vers stderr est autorisée, nous pouvons omettre les 2 guillemets simples ''et descendre à 38 octets. Sans ''perl émet un avertissement concernant une fonctionnalité obsolète.

Mathematica, 76 octets

Notez qu'il nne devrait pas y avoir de définitions auparavant.

0;If[ValueQ@n,++n,n=1];StringJoin@Riffle[IntegerString[n,#]&/@{10,8,16}," "]

Ici, le comportement de ;est utilisé. L'extrait ci-dessus est un seul CompoundExpression, cependant, lorsque quelques extraits sont rassemblés, il y en a toujours un CompoundExpressioncomme indiqué ci-dessous. (Certains réarrangements inutiles sont effectués.)

0;
If[ValueQ@n,++n,n=1]; StringJoin@Riffle[IntegerString[n,#]&/@{10,8,16}," "] 0;
If[ValueQ@n,++n,n=1]; StringJoin@Riffle[IntegerString[n,#]&/@{10,8,16}," "] 0;
If[ValueQ@n,++n,n=1]; StringJoin@Riffle[IntegerString[n,#]&/@{10,8,16}," "]

(* 3 3 3 *)

Donc, on ne peut pas faire fonctionner un tel extrait si l'écriture est explicite CompoundExpression. De plus, presque tout ce que vous aimez peut être mis avant la première ;telle que E, Piou MandelbrotSetPlot[],.

bash, 49 octets

Fichier count.bash:

((++n));trap 'printf "%d %o %x\n" $n $n $n' exit;

... pas de retour à la ligne.

Courir:

$ bash count.bash
1 1 1
$ cat count.bash count.bash count.bash | bash
3 3 3
$ for i in $(seq 10) ; do cat count.bash ; done | bash
10 12 a

Python 2, 54 octets

n=len(open(__file__).read())/54;print n,oct(n),hex(n)#

Pas de nouvelle ligne de fin. Sorties dans le formulaire 1 01 0x1.

Si ça ne va pas, 56 octets

n=len(open(__file__).read())/56;print"%d %o %x"%(n,n,n)#

Une fois collés les uns devant les autres, la longueur du fichier s'allonge d'une ligne pour chaque fois collé. Le cas de base commence par 2 lignes, vous devez donc soustraire 1 de la longueur de la ligne. Le calcul est supprimé par le commentaire.

Python 2.x 140 octets

Ce n'était pas censé être une solution trop compétitive, mais une méthode que j'ai trouvée amusante, étant pour une chose, une tentative de golf à code multithread .

import thread;n=eval("n+1")if"n"in globals()else 1;
def t(c):99**99;print("%s "*3)%(n,oct(n),hex(n))*(c==n)
thread.start_new_thread(t,(n,));

Conserve un compteur, génère un thread pour chaque comptage et si le compteur n'a pas changé lorsque la minuterie des compteurs s'éteint après avoir terminé un problème mathématique coûteux (au lieu d'une minuterie pour économiser des octets), la chaîne formatée est imprimée.

Quelques exemples de configurations et leurs sorties:

import thread;n=eval("n+1")if"n"in globals()else 1;
def t(c):99**99;print("%s "*3)%(n,oct(n),hex(n))*(c==n)
thread.start_new_thread(t,(n,));

Outputs 1 01 0x1 

et quinze copies de pâtes:

import thread;n=eval("n+1")if"n"in globals()else 1;
def t(c):99**99;print("%s "*3)%(n,oct(n),hex(n))*(c==n)
thread.start_new_thread(t,(n,));import thread;n=eval("n+1")if"n"in globals()else 1;
def t(c):99**99;print("%s "*3)%(n,oct(n),hex(n))*(c==n)
thread.start_new_thread(t,(n,));import thread;n=eval("n+1")if"n"in globals()else 1;

...


Outputs 15 017 0xf 

Perl 5 , 31 octets

exit+printf"%d %o %x",(++$-)x3,

Utilise la même approche que ma réponse pour 'Je double la source, tu double la sortie!' .

Essayez-le en ligne!

Rubis, 35 octets

1;$.+=1;$><<"#$. %1$o %1$x"%$.*-~-0

Chaque extrait de code incrémente $.(qui commence à 0 si aucun fichier n'a été lu), mais seul le dernier produit quelque chose. *-~-0évalue à *1, ce qui signifie imprimer la chaîne une fois, mais avec la concaténation, elle devient *-~-01une expression octale évaluant à 0. Puisque $><<n'inclut pas de retour à la ligne de fin, l'impression de la chaîne vide ne signifie rien imprimer.