Il tuo compito è semplice. Pubblica uno snippet in qualsiasi lingua che, se lo snippet viene ripetuto n volte, produrrà n in decimale, ottale ed esadecimale, in quell'ordine, separato da spazi. n è un numero intero maggiore di zero. Non ci sono zeri iniziali. Vince la risposta più breve

Esempio

Se lo snippet è ABCil caso di test

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

Japt, 12 byte

[°TTs8 TsG]¸

Grazie a @ETHproductions per aver salvato 2 byte!

Come la mia 𝔼𝕊𝕄𝕚𝕟 risposta.

Perl, 30 byte

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

Torna all'inizio della riga, incrementa il contatore e stampa il contatore sovrascrivendo il vecchio output.

JavaScript, 54 53 51 47 byte

4 byte salvati grazie a @ user81655

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

Sono davvero sorpreso che funzioni.

Spiegazione

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

Provalo online

C ++, 205 179 byte

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;//

(Nessuna nuova riga finale: quando viene copiata, la prima riga della copia e l'ultima riga dell'originale devono coincidere)

Fondamentalmente, questo funziona creando una sequenza di variabili statiche che, durante la costruzione, incrementano un contatore di variabili globali. Quindi, alla distruzione, se il contatore non è 0, fa tutto il suo output e imposta il contatore su zero.

Per definire una sequenza di variabili senza conflitti di nomi, utilizziamo la macro spiegata come segue:

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

che si basa in qualche modo sulle stranezze del processore di stringhe. Usiamo zmolte volte per definire classi / variabili che non entreranno in conflitto tra loro quando copiate su righe separate. Inoltre, le definizioni che devono essere presenti una sola volta vengono inserite nella prima riga, che viene commentata in copie del codice. Le dichiarazioni #definee #includenon si preoccupano che vengano ripetute, quindi non è necessario alcun trattamento speciale.

Questo codice presenta anche un comportamento indefinito nell'istruzione:

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

poiché non ci sono punti di sequenza, ma c viene modificato e vi si accede. LLVM 6.0 fornisce un avviso, ma lo compila come desiderato - che --cvaluta prima c. Si potrebbe, a scapito di due byte, aggiungere l'istruzione --c;prima che le uscite e il cambiamento --cin printfa c, che sarebbe sbarazzarsi di avvertimento.

Sostituito std::coutcon il printfsalvataggio di 26 byte grazie a un suggerimento di mio fratello.

CJam, 20 19 18 byte

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

Grazie a @ MartinBüttner per il golf off 1 byte!

Provalo online!

Come funziona

]                  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 caratteri / 28 byte

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

Try it here (Firefox only).

Prima risposta! Anche se probabilmente ci sono modi migliori per gestirlo.

Spiegazione

[⧺Ḁ,Ḁß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 byte

Utilizza la versione corrente (6.0.0) . Funziona su Octave.

0$N1+ttYUb8YAb16YA3$XhZc1$

Esempi

Una volta:

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

Due volte:

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

16 volte:

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

Spiegazione

Il numero di elementi nello stack viene utilizzato per indicare quante volte abbiamo eseguito lo snippet

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 byte

;;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

Include una nuova riga finale e richiede che il nome file inizi con una tilde (ho usato ~.ml; puoi eseguirlo con ocaml \~.ml) perché è il carattere ASCII stampabile standard più apprezzato. Abusa del fatto che tutti i caratteri di una stringa sono mutabili ed Sys.argv.(0).[0]è il primo carattere nel nome file.

Dovrebbe funzionare solo per n = 1 a 126, perché il codice ASCII per ~è 126 e ne sto aggiungendo uno all'output. Potrebbe essere ridotto di due byte se vogliamo solo n = 1 a 125. Dopo che è stato ripetuto 126 volte, tornerà a n = 1.

Questo è il mio primo golf in assoluto, quindi ogni commento o miglioramento sarebbe molto apprezzato.

Versione non golfata:

;; 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 byte

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

Dovrei farlo chiudere automaticamente ;

Provalo online

Spiegazione

┼ diventa ++

    // 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 byte

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

C'è un'ultima riga dietro il colon.

Tratta tutto dopo la prima riga come un documento qui e conta il zcontenuto. Per ogni ulteriore copia del codice zviene aggiunto uno . Dobbiamo aggiungere 1al conteggio, perché non c'è nessuno per il primo frammento (quello che viene eseguito).

Se è consentito un output aggiuntivo per stderr, possiamo omettere le 2 virgolette singole ''e scendere a 38 byte. Senza il ''perl emette un avviso su una funzione obsoleta.

Mathematica, 76 byte

Si noti che non ndovrebbe avere definizioni prima.

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

Qui, ;viene utilizzato il comportamento di . Lo snippet sopra è uno solo CompoundExpression, tuttavia, quando vengono messi insieme un paio di snippet, ce n'è ancora uno CompoundExpressioncome mostrato di seguito. (Vengono effettuati alcuni riarrangiamenti non necessari.)

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

Quindi non è possibile far funzionare tali frammenti se si scrive esplicitamente CompoundExpression. Inoltre, quasi tutto ciò che ti piace può essere messo prima del primo ;come E, Pio MandelbrotSetPlot[],.

bash, 49 byte

File count.bash:

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

... nessuna nuova riga finale.

Correre:

$ 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 byte

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

Nessuna nuova riga finale. Output nel modulo 1 01 0x1.

In caso contrario, 56 byte

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

Se incollati uno di fronte all'altro, la lunghezza del file aumenta di 1 riga per ogni volta incollato. Il caso base inizia con 2 righe, quindi è necessario sottrarre 1 dalla lunghezza della riga. Il calcolo è soppresso dal commento.

Python 2.x 140 byte

Non si trattava di una soluzione eccessivamente competitiva, ma di un metodo che trovavo divertente, essendo per prima cosa un tentativo di giocare a golf 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,));

Mantiene un contatore, genera un thread per ogni conteggio e se il contatore non è cambiato quando il timer dei contatori si spegne dopo aver completato un costoso problema matematico (anziché un timer per salvare byte), viene stampata la stringa formattata.

Alcune configurazioni di esempio e i loro output:

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 

e quindici copie di pasta:

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 byte

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

Utilizza lo stesso approccio della mia risposta per "Raddoppio della sorgente, raddoppi l'output!" .

Provalo online!

Rubino, 35 byte

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

Ogni frammento viene incrementato $.(che inizia come 0 se non è stato letto alcun file), ma solo l'ultimo genera qualcosa. *-~-0valuta *1, il che significa stampare la stringa una volta, ma con concatenazione diventa *-~-01, un'espressione ottale che valuta lo 0. Dato $><<che non include una nuova riga finale, stampare la stringa vuota non significa stampare nulla.