Ваше завдання просте. Розмістіть фрагмент будь-якою мовою, яка, якщо фрагмент повторюється 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 багато разів для визначення класів / змінних, які не будуть конфліктувати один з одним при копіюванні на окремі рядки. Більше того, визначення, які мають відбутися лише один раз, розміщуються на першому рядку, який коментується у копіях коду. The#define і#include заяви не хвилюють , що вони отримують повторені, тому не потребує в спеціальній обробці.

Цей код також містить невизначену поведінку у виписці:

printf("%d %o %x",--c,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, ми можемо опустити дві одиничні лапки ''і можемо зменшитись до 38 байт. Без ''Perl видає попередження про застарілу функцію.

Математика, 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. Оскільки $><<не включає зворотний новий рядок, друк порожнього рядка не означає друкувати нічого.