Twoje zadanie jest proste. Opublikuj fragment kodu w dowolnym języku, który jeśli zostanie powtórzony n razy, wyświetli n w postaci dziesiętnej, ósemkowej i szesnastkowej, w tej kolejności, oddzielonych spacjami. n jest liczbą całkowitą większą niż zero. Brak zer wiodących. Najkrótsza odpowiedź wygrywa

Przykład

Jeśli fragment jest, ABCto przypadek testowy to

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

Japt, 12 bajtów

[°TTs8 TsG]¸

Dzięki @ETHproductions za oszczędność 2 bajtów!

Taki sam jak moja odpowiedź..

Perl, 30 bajtów

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

Wróć do początku wiersza, licznik przyrostów i licznik wydruku zastępują stary wynik.

JavaScript, 54 53 51 47 bajtów

Zaoszczędzono 4 bajty dzięki @ user81655

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

Jestem właściwie zaskoczony, że to działa.

Wyjaśnienie

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

Wypróbuj online

C ++, 205 179 bajtów

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

(Brak końcowego nowego wiersza - po skopiowaniu pierwszy wiersz kopii i ostatni wiersz oryginału powinny się pokrywać)

Zasadniczo działa to poprzez utworzenie sekwencji zmiennych statycznych, które podczas budowy zwiększają licznik zmiennych globalnych. Następnie po zniszczeniu, jeśli licznik nie jest równy 0, wykonuje całą swoją moc wyjściową i ustawia licznik na zero.

Aby zdefiniować sekwencję zmiennych bez konfliktów nazw, używamy makra objaśnionego w następujący sposób:

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

co nieco opiera się na osobliwościach procesora ciągów. zWielokrotnie używamy do definiowania klas / zmiennych, które nie będą ze sobą sprzeczne podczas kopiowania na osobne linie. Co więcej, definicje, które muszą wystąpić tylko raz, są umieszczane w pierwszym wierszu, który jest komentowany w kopiach kodu. The#define i #includenie dbają o to, aby się powtarzały, więc nie wymagają specjalnego postępowania.

Ten kod zawiera również niezdefiniowane zachowanie w instrukcji:

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

ponieważ nie ma punktów sekwencji, ale c jest modyfikowane i dostępne. LLVM 6.0 daje ostrzeżenie, ale kompiluje je zgodnie z potrzebami - co --cocenia wcześniej c. Można by, kosztem dwóch bajtach, dodać oświadczenie --c;przed wyjść i zmiany --cw printfcelu c, który będzie pozbyć się ostrzeżenia.

Zastąpiony std::cout z printfoszczędności 26 bajty dzięki sugestią mojego brata.

CJam, 20 19 18 bajtów

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

Dzięki @ MartinBüttner za grę w golfa na 1 bajcie!

Wypróbuj online!

Jak to działa

]                  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 znaków / 28 bajtów

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

Try it here (Firefox only).

Pierwsza odpowiedź! Chociaż są prawdopodobnie lepsze sposoby na poradzenie sobie z tym.

Wyjaśnienie

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

Wykorzystuje bieżącą wersję (6.0.0) . Działa na Octave.

0$N1+ttYUb8YAb16YA3$XhZc1$

Przykłady

Pewnego razu:

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

Dwa razy:

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

16 razy:

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

Wyjaśnienie

Liczba elementów w stosie służy do wskazania, ile razy uruchomiliśmy fragment kodu

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 bajtów

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

Zawiera końcowy znak nowej linii i wymaga, aby nazwa pliku rozpoczynała się od tyldy (użyłem ~.ml; możesz ją uruchomić ocaml \~.ml), ponieważ jest to najbardziej ceniony standardowy znak ASCII do wydruku. Nadużywa faktu, że wszystkie znaki w ciągu są zmienne i Sys.argv.(0).[0]jest pierwszym znakiem w nazwie pliku.

Powinno działać tylko dla n = 1 do 126, ponieważ kod ASCII dla ~to 126, a ja dodaję jeden do wyniku. Można by zrobić dwa bajty krótsze, jeśli chcemy tylko n = 1 do 125. Po powtórzeniu 126 razy nastąpi powrót do n = 1.

To mój pierwszy golf, więc wszelkie uwagi i ulepszenia będą mile widziane.

Wersja bez golfa:

;; 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 bajtów

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

Powinienem włączyć automatyczne zamykanie ;

Wypróbuj online

Wyjaśnienie

┼ staje się ++

    // 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 bajtów

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

Za okrężnicą znajduje się ostatnia linia.

Traktuje wszystko po pierwszym wierszu jako dokument tutaj i liczy się zw nim. Dla każdej kolejnej kopii kodu jedenz dodawana jest . Musimy dodać 1do liczby, ponieważ nie ma żadnego dla pierwszego fragmentu (tego, który jest wykonywany).

Jeśli dozwolone są dodatkowe dane wyjściowe do stderr, możemy pominąć 2 pojedyncze cudzysłowy ''i uzyskać do 38 bajtów. Bez ''perla wysyła ostrzeżenie o przestarzałej funkcji.

Mathematica, 76 bajtów

Pamiętaj, że nwcześniej nie powinny mieć żadnych definicji.

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

Tutaj ;wykorzystywane jest zachowanie . Powyższy fragment jest jednym pojedynczym CompoundExpression, jednak po złożeniu kilku fragmentów jest jeszcze jeden, CompoundExpressionjak pokazano poniżej. (Wprowadzono niepotrzebne zmiany).

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

Tak więc nie można sprawić, by taki fragment kodu działał, jeśli jest napisany jednoznacznie CompoundExpression. Ponadto prawie wszystko, co lubisz, można umieścić przed pierwszym, ;takim jak E, Pilub MandelbrotSetPlot[].

bash, 49 bajtów

Plik count.bash:

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

... brak końcowego znaku nowej linii.

Biegać:

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

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

Brak końca nowej linii. Dane wyjściowe w formularzu 1 01 0x1.

Jeśli to nie w porządku, 56 bajtów

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

Po wklejeniu przed sobą długość pliku wydłuża się o 1 linię za każdym razem, gdy jest wklejany. Przypadek podstawowy zaczyna się od 2 linii, więc musisz odjąć 1 od długości linii. Komentarz jest pomijany w obliczeniach.

Python 2.x 140 bajtów

To nie miało być zbyt konkurencyjne rozwiązanie, ale metoda, którą uznałem za zabawną, ponieważ była to próba wielowątkowego golfa.

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

Utrzymuje licznik, odradza wątek dla każdej liczby, a jeśli licznik nie zmienił się, gdy licznik czasu zgaśnie po ukończeniu kosztownego zadania matematycznego (zamiast licznika, aby zapisać bajty), sformatowany ciąg jest drukowany.

Niektóre przykładowe konfiguracje i ich wyniki:

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 

i piętnaście kopii past:

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 bajtów

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

Używa tego samego podejścia, co moja odpowiedź na „Podwajam źródło, podwajasz wynik!”.

Wypróbuj online!

Rubin, 35 bajtów

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

Przyrosty każdego fragmentu kodu $.(który zaczyna się od 0, jeśli nie odczytano żadnych plików), ale tylko ostatni wynik. zwraca *-~-0wartość *1, co oznacza, że ​​wydrukuje jeden raz, ale z konkatenacją staje *-~-01się ósemkowym wyrażeniem o wartości 0. Ponieważ $><<nie zawiera końcowego nowego wiersza, wydrukowanie pustego ciągu oznacza, że ​​nic nie zostanie wydrukowane.