Tu tarea es simple. Publique un fragmento en cualquier idioma que si el fragmento se repite n veces, generará n en decimal, octal y hexadecimal, en ese orden, separados en espacios. n es un número entero mayor que cero. No hay ceros a la izquierda. La respuesta más corta gana

Ejemplo

Si el fragmento es ABCentonces el caso de prueba es

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

Japt, 12 bytes

[°TTs8 TsG]¸

¡Gracias a @ETHproductions por guardar 2 bytes!

Igual que mi 𝔼𝕊𝕄𝕚𝕟 respuesta.

Perl, 30 bytes

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

Regrese al principio de la línea, incremente el contador y el contador de impresión sobrescribiendo la salida anterior.

JavaScript, 54 53 51 47 bytes

Guardado 4 bytes gracias a @ user81655

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

De hecho, estoy un poco sorprendido de que esto funcione.

Explicación

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

Pruébalo en línea

C ++, 205 179 bytes

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

(Sin nueva línea final: cuando se copia, la primera línea de la copia y la última línea del original deben coincidir)

Básicamente, esto funciona haciendo una secuencia de variables estáticas que, en la construcción, incrementan un contador de variable global. Luego, en la destrucción, si el contador no es 0, realiza toda su salida y lo pone a cero.

Para definir una secuencia de variables sin conflictos de nombres, usamos la macro explicada de la siguiente manera:

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

lo que depende de las peculiaridades del procesador de cadenas. Usamos zmuchas veces para definir clases / variables que no entrarán en conflicto entre sí cuando se copien en líneas separadas. Además, las definiciones que deben aparecer solo una vez se colocan en la primera línea, que se comenta en copias del código. Las declaraciones #definey #includeno les importa que se repitan, por lo que no es necesario un manejo especial.

Este código también presenta un comportamiento indefinido en la declaración:

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

ya que no hay puntos de secuencia, pero se modifica y se accede a c. LLVM 6.0 da una advertencia, pero la compila según lo deseado, que --cevalúa antes c. Se podría, a expensas de dos bytes, agregue la instrucción --c;antes de las salidas y el cambio --cen printfa c, lo que deshacerse de la advertencia.

Reemplazado std::coutpor printfguardar 26 bytes gracias a una sugerencia de mi hermano.

CJam, 20 19 18 bytes

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

¡Gracias a @ MartinBüttner por jugar golf en 1 byte!

Pruébalo en línea!

Cómo funciona

]                  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 caracteres / 28 bytes

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

Try it here (Firefox only).

Primera respuesta! Aunque probablemente hay mejores formas de manejar esto.

Explicación

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

Utiliza la versión actual (6.0.0) . Funciona en Octave.

0$N1+ttYUb8YAb16YA3$XhZc1$

Ejemplos

Una vez:

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

Dos veces:

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

16 veces:

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

Explicación

El número de elementos en la pila se usa para indicar cuántas veces hemos ejecutado el fragmento

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 bytes

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

Incluye una nueva línea final y requiere que el nombre del archivo comience con una tilde (lo usé ~.ml; puede ejecutarlo ocaml \~.ml) porque es el carácter ASCII imprimible estándar de mayor valor. Abusa del hecho de que todos los caracteres de una cadena son mutables y Sys.argv.(0).[0]es el primer carácter del nombre de archivo.

Solo debería funcionar para n = 1 a 126, porque el código ASCII para ~es 126 y estoy agregando uno a la salida. Podría hacerse dos bytes más cortos si solo queremos n = 1 a 125. Después de que se repita 126 veces, volverá a n = 1.

Este es mi primer golf, por lo que cualquier comentario o mejora sería muy apreciado.

Versión sin golf:

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

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

Debería hacer que se cierre automáticamente en ;

Pruébalo en línea

Explicación

┼ se convierte ++

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

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

Hay una nueva línea final detrás del colon.

Trata todo después de la primera línea como un documento aquí y cuenta el contenido z. Por cada copia adicional del código zse agrega uno . Tenemos que agregar 1al conteo, porque no hay ninguno para el primer fragmento (el que se ejecuta).

Si se permite una salida adicional a stderr, podemos omitir las 2 comillas simples ''y podemos bajar a 38 bytes. Sin el ''perl emite una advertencia sobre una característica en desuso.

Mathematica, 76 bytes

Tenga en cuenta que no ndebe tener definiciones antes.

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

Aquí, ;se utiliza el comportamiento de . El fragmento de arriba es uno solo CompoundExpression, sin embargo, cuando se juntan un par de fragmentos, todavía hay uno CompoundExpressioncomo se muestra a continuación. (Se hacen algunos reordenamientos innecesarios).

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

Por lo tanto, no se puede hacer que tal fragmento funcione si se escribe explícitamente CompoundExpression. Además, casi todo lo que te gusta se puede poner antes del primero ;, como E, Pio MandelbrotSetPlot[],.

bash, 49 bytes

Archivo count.bash:

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

... sin línea nueva.

Correr:

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

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

Sin nueva línea final. Salidas en el formulario 1 01 0x1.

Si eso no está bien, 56 bytes

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

Cuando se pega uno frente al otro, la longitud del archivo se alarga 1 línea por cada vez que se pega. El caso base comienza con 2 líneas, por lo que debe restar 1 de la longitud de la línea. La computación es suprimida por el comentario.

Python 2.x 140 bytes

Esto no estaba destinado a ser una solución demasiado competitiva, sino un método que encontré divertido, por ser, un intento de un código de golf multiproceso .

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 contador, genera un hilo para cada recuento y si el contador no ha cambiado cuando el temporizador de contadores se apaga después de completar un costoso problema matemático (en lugar de un temporizador para guardar bytes), se imprime la cadena formateada.

Algunas configuraciones de ejemplo y sus salidas:

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 

y quince copias de pastas:

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 bytes

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

Utiliza el mismo enfoque que mi respuesta para '¡Doblo la fuente, tú doblas la salida!' .

Pruébalo en línea!

Ruby, 35 bytes

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

Cada fragmento se incrementa $.(que comienza como 0 si no se han leído archivos), pero solo el último genera algo. *-~-0se evalúa como *1, lo que significa imprimir la cadena una vez, pero con la concatenación se convierte en *-~-01una expresión octal que se evalúa en 0. Dado $><<que no incluye una nueva línea final, imprimir la cadena vacía no significa imprimir nada.