Sua tarefa é simples. Poste um trecho em qualquer idioma que, se o trecho repetido n vezes, produzirá n em decimal, octal e hexadecimal, nessa ordem, separados em espaços. n é um número inteiro maior que zero. Não há zeros à esquerda. Menor resposta ganha

Exemplo

Se o trecho for ABC, o caso de teste será

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

Japonês, 12 bytes

[°TTs8 TsG]¸

Obrigado a @ETHproductions por economizar 2 bytes!

O mesmo que minha resposta.

Perl, 30 bytes

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

Volte para o início da linha, incremente o contador e o contador de impressão substituindo a saída antiga.

JavaScript, 54 53 51 47 bytes

Guardado 4 bytes graças a @ user81655

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

Estou realmente meio surpreso que isso funcione.

Explicação

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

Experimente online

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

(Sem nova linha final - quando copiada, a primeira linha da cópia e a última linha do original devem coincidir)

Basicamente, isso funciona criando uma sequência de variáveis ​​estáticas que, em construção, incrementam um contador de variáveis ​​globais. Então, na destruição, se o contador não for 0, ele realiza toda a sua saída e define o contador como zero.

Para definir uma sequência de variáveis ​​sem conflitos de nome, usamos a macro explicada da seguinte maneira:

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

que depende um pouco das peculiaridades do processador de strings. Usamos zmuitas vezes para definir classes / variáveis ​​que não entrarão em conflito entre si quando copiadas em linhas separadas. Além disso, as definições que devem ocorrer apenas uma vez são colocadas na primeira linha, comentada em cópias do código. As instruções #definee #includenão se importam com a repetição, portanto não precisam de tratamento especial.

Este código também apresenta um comportamento indefinido na instrução:

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

como não há pontos de sequência, mas c é modificado e acessado. O LLVM 6.0 fornece um aviso, mas o compila conforme o desejado - que é --cavaliado antes c. Pode-se, à custa de dois bytes, adicione a declaração --c;antes das saídas e mudanças --cem printfque c, o que se livrar do aviso.

Substituído std::coutpor printfsalvar 26 bytes graças a uma sugestão do meu irmão.

CJam, 20 19 18 bytes

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

Obrigado a @ MartinBüttner por jogar fora um byte!

Experimente online!

Como 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, 14 caracteres / 28 bytes

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

Try it here (Firefox only).

Primeira resposta! Embora haja provavelmente melhores maneiras de lidar com isso.

Explicação

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

Usa a versão atual (6.0.0) . Trabalhos em oitava.

0$N1+ttYUb8YAb16YA3$XhZc1$

Exemplos

Uma vez:

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

Duas vezes:

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

16 vezes:

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

Explicação

O número de elementos na pilha é usado para indicar quantas vezes executamos o 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 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

Inclui uma nova linha à direita e exige que o nome do arquivo comece com um til (eu usei ~.ml; você pode executá-lo ocaml \~.ml) porque é o caractere ASCII padrão imprimível de maior valor. Abusa do fato de que todos os caracteres em uma sequência são mutáveis ​​e Sys.argv.(0).[0]é o primeiro caractere no nome do arquivo.

Deve funcionar apenas para n = 1 a 126, porque o código ASCII para ~é 126 e estou adicionando um à saída. Pode ser feito dois bytes mais curto se quisermos apenas n = 1 a 125. Depois de repetido 126 vezes, ele retornará para n = 1.

Este é o meu primeiro golfe, por isso quaisquer comentários ou melhorias serão muito apreciados.

Versão não destruída:

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

Eu deveria fazê-lo fechar automaticamente ;

Experimente online

Explicação

┼ torna-se ++

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

Há uma nova linha final por trás dos dois pontos.

Trata tudo após a primeira linha como um documento aqui e conta o que está znele. Para cada cópia adicional do código zé adicionada uma. Temos que adicionar 1à contagem, porque não há nenhum para o primeiro trecho (aquele que é executado).

Se a saída adicional para stderr for permitida, podemos omitir as 2 aspas simples ''e diminuir para 38 bytes. Sem o ''perl emite um aviso sobre um recurso obsoleto.

Mathematica, 76 bytes

Observe que não ndeve ter definições antes.

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

Aqui, o comportamento de ;é usado. O snippet acima é um único CompoundExpression, no entanto, quando alguns snippets são reunidos, ainda existe um, CompoundExpressionconforme mostrado abaixo. (Alguns rearranjos desnecessários são feitos.)

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

Portanto, não se pode fazer esse fragmento funcionar se a escrita for explícita CompoundExpression. Além disso, quase tudo o que você gosta pode ser colocado antes do primeiro ;, como E, Piou MandelbrotSetPlot[],.

bash, 49 bytes

Arquivo count.bash:

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

... nenhuma nova linha à direita.

Corre:

$ 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)#

Nenhuma nova linha à direita. Saídas no formulário 1 01 0x1.

Se não estiver certo, 56 bytes

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

Quando colados na frente um do outro, o comprimento do arquivo aumenta em 1 linha por cada tempo colado. O caso base começa com 2 linhas, então você precisa subtrair 1 do comprimento da linha. A computação é suprimida pelo comentário.

Python 2.x 140 bytes

Isso não era para ser uma solução excessivamente competitiva, mas um método que eu achei divertido, por um lado, uma tentativa de um código de golfe 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,));

Mantém um contador, gera um encadeamento para cada contagem e, se o contador não for alterado quando o contador disparar após a conclusão de um problema matemático caro (em vez de um contador para salvar bytes), a sequência formatada será impressa.

Alguns exemplos de configurações e suas saídas:

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 quinze pastas de cópias:

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,

Usa a mesma abordagem da minha resposta para 'Dobro da fonte, você dobra a saída!' .

Experimente online!

Ruby, 35 bytes

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

Cada trecho é incrementado $.(que começa como 0 se nenhum arquivo foi lido), mas apenas o último gera algo. *-~-0avalia como *1, significando imprimir a sequência uma vez, mas com concatenação, torna-se *-~-01uma expressão octal avaliando como 0. Como $><<não inclui uma nova linha à direita, imprimir a sequência vazia significa imprimir nada.