Ваша задача проста. Разместите фрагмент кода на любом языке, который, если фрагмент повторяется n раз, будет выводить n в десятичном, восьмеричном и шестнадцатеричном виде в указанном порядке, разделенных пробелами. n является целым числом больше нуля. Здесь нет ведущих нулей. Кратчайший ответ выигрывает

пример

Если фрагмент кода, ABCто контрольный пример

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

Japt, 12 байт

[°TTs8 TsG]¸

Спасибо @ETHproductions за сохранение 2 байта!

Так же, как мой 𝔼𝕊𝕄𝕚𝕟 ответ.

Perl, 30 байт

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

Вернитесь к началу строки, счетчик приращений и счетчик печати перезаписывают старый вывод.

JavaScript, 54 53 51 47 байт

Сохранено 4 байта благодаря @ user81655

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

Я действительно удивлен, что это работает.

объяснение

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

Попробуйте онлайн

C ++, 205 179 байт

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

(Нет завершающего символа новой строки - при копировании первая строка копии и последняя строка оригинала должны совпадать)

По сути, это работает путем создания последовательности статических переменных, которые при построении увеличивают счетчик глобальной переменной. Затем, при уничтожении, если счетчик не равен 0, он делает все свои выходные данные и устанавливает счетчик в ноль.

Чтобы определить последовательность переменных без конфликтов имен, мы используем макрос, объясненный следующим образом:

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

что в некоторой степени зависит от особенностей струнного процессора. Мы используем zмного раз для определения классов / переменных, которые не будут конфликтовать друг с другом при копировании на отдельные строки. Более того, определения, которые должны встречаться только один раз, помещаются в первую строку, которая закомментирована в копиях кода. #define and #includeне заботятся о том, что они повторяются, поэтому не требуют специальной обработки.

Этот код также имеет неопределенное поведение в выражении:

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

так как нет точек последовательности, но с изменен и доступен. LLVM 6.0 выдает предупреждение, но компилирует его по желанию, которое --cоценивается раньше c. Можно было бы, за счет двух байтов, добавьте инструкцию --c;перед выходами и изменения --cв printfк c, что бы избавиться от предупреждения.

Заменено std::coutс printfэкономией 26 байтами благодаря предложению моего брата.

CJam, 20 19 18 байт

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

Спасибо @ MartinBüttner за игру в 1 байт!

Попробуйте онлайн!

Как это работает

]                  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 символов / 28 байт

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

Try it here (Firefox only).

Первый ответ! Хотя, возможно, есть лучшие способы справиться с этим.

объяснение

[⧺Ḁ,Ḁß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 байт

Использует текущий выпуск (6.0.0) . Работает на Октаве.

0$N1+ttYUb8YAb16YA3$XhZc1$

Примеры

Однажды:

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

Дважды:

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

16 раз:

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

объяснение

Количество элементов в стеке используется, чтобы указать, сколько раз мы запускали фрагмент

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 байт

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

Включает завершающий символ новой строки и требует, чтобы имя файла начиналось с тильды (я использовал ~.ml; вы можете запустить его ocaml \~.ml), потому что это самый ценный стандартный печатный символ ASCII. Нарушает тот факт, что все символы в строке являются изменяемыми и Sys.argv.(0).[0]являются первым символом в имени файла.

Это должно работать только для n = 1 - 126, потому что код ASCII для ~- 126, и я добавляю один к выводу. Его можно сделать на два байта короче, если мы хотим, чтобы n = 1 до 125. После того, как это будет повторено 126 раз, он вернется к n = 1.

Это мой первый гольф, поэтому любые комментарии или улучшения будут высоко оценены.

Безголовая версия:

;; 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 байт

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

Я должен сделать это автоматически закрыть на ;

Попробуйте онлайн

объяснение

┼ становится ++

    // 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 байт

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

За толстой кишкой стоит последний перевод строки.

Рассматривает все после первой строки как документ здесь и считает zв нем. Для каждой последующей копии кода zдобавляется один . Мы должны добавить 1к счету, потому что нет ни одного для первого фрагмента (тот, который выполняется).

Если разрешен дополнительный вывод в stderr, мы можем опустить 2 одинарных кавычки ''и сократить их до 38 байт. Без ''perl выдает предупреждение об устаревшей функции.

Mathematica, 76 байт

Обратите внимание, что nраньше не должно быть определений.

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

Здесь поведение ; . Выше приведен фрагмент кода CompoundExpression, однако, когда пара фрагментов собрана вместе, есть еще один, CompoundExpressionкак показано ниже. (Некоторые ненужные перестановки сделаны.)

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

Таким образом, нельзя сделать такой фрагмент работ, если запись написана явно CompoundExpression. Кроме того, почти все, что вам нравится, можно поставить перед первым, ;например E, Piили MandelbrotSetPlot[],.

bash, 49 байт

Файл count.bash:

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

... нет новой строки.

Бег:

$ 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 байта

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

Нет завершающего перевода строки. Выходы в виде 1 01 0x1.

Если это не хорошо, 56 байт

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

При вставке друг перед другом длина файла увеличивается на 1 строку за каждый вставленный файл. Базовый случай начинается с 2 строк, поэтому вы должны вычесть 1 из длины строки. Вычисление подавляется комментарием.

Python 2.x 140 байт

Это было не слишком конкурентное решение, а метод, который я нашел забавным, с одной стороны, попытка многопоточного гольф-кода.

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

Outputs 1 01 0x1 

и пятнадцать копий паст:

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 байт

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

Использует тот же подход, что и мой ответ: «Я удваиваю источник, вы удваивает вывод!» ,

Попробуйте онлайн!

Рубин, 35 байт

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

Каждый фрагмент кода увеличивается $.(который начинается с 0, если файлы не были прочитаны), но выводит только последний. *-~-0вычисляет до *1, то есть печатает строку один раз, но с конкатенацией она становится *-~-01восьмеричным выражением, равным 0. Так $><<как не содержит завершающей строки, печать пустой строки означает ничего не печатать.