Göreviniz basit. Herhangi bir dilde bir snippet gönderin, eğer snippet n kez tekrarlanırsa, boşlukları ayrılmış, bu sırayla ondalık, sekizli ve onaltılı olarak n çıkacaktır. n, sıfırdan büyük bir tam sayıdır. Baştaki sıfır yok. En kısa cevap kazanır

Örnek

Snippet ABCöyleyse, test durumu

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

Japt, 12 bayt

[°TTs8 TsG]¸

2 byte tasarruf için @ETHproductions teşekkürler !

Benim cevabımla aynı.

Perl, 30 bayt

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

Satırın başına geri dönün, sayaç artırın ve eski çıkışın üzerine yazılan yazdırma sayacı.

JavaScript, 54 53 51 47 bayt

@ User81655 sayesinde 4 bayt kaydedildi

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

Aslında bu işe şaşırdım.

açıklama

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

Çevrimiçi deneyin

C ++, 205 179 bayt

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

(Sondaki yeni satır yok - kopyalandığında, kopyanın ilk satırı ve orijinalin son satırı aynı olmalıdır)

Temel olarak, bu, inşaatta global değişken sayacını artıran bir statik değişkenler dizisi yaparak çalışır. Daha sonra, yıkımda, sayaç 0 değilse, tüm çıktısını yapar ve sayacı sıfıra ayarlar.

Ad çakışması olmayan değişken dizisini tanımlamak için, aşağıda açıklanan makroyu kullanırız:

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

Bu da biraz dize işlemcisinin tuhaflıklarına güveniyor. zAyrı satırlara kopyalandığında birbirleriyle çakışmayacak sınıfları / değişkenleri tanımlamak için birçok kez kullanıyoruz . Ayrıca, sadece bir kez yapılması gereken tanımlar, kodun kopyalarında yorumlanan ilk satıra yerleştirilir. #defineVe #includetablolar hiçbir özel işlem gerekir, onlar tekrarlanan olsun umrumda değil.

Bu kod aynı zamanda ifadedeki tanımsız davranışları da içerir:

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

Sıralama noktaları olmadığından, c değiştirilir ve erişilir. LLVM 6.0 bir uyarı verir, ancak daha --cönce değerlendirdiği şekilde istendiği gibi derler c. Bir, iki bayt pahasına, deyimi ekleyebilirsiniz --c;çıkışları ve değişiklikten önce --cde printfkarşı cuyarı kurtulmak istiyorum.

Ağabeyimin önerisi sayesinde 26 bayt tasarruf std::coutile değiştirildi printf.

CJam, 20 19 18 bayt

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

1 byte'lık golf için @ MartinBüttner'e teşekkürler!

Çevrimiçi deneyin!

Nasıl çalışır

]                  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 karakter / 28 bayt

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

Try it here (Firefox only).

İlk cevap! Bununla birlikte, muhtemelen bununla baş etmenin daha iyi yolları var.

açıklama

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

Geçerli sürümü kullanır (6.0.0) . Octave'da çalışıyor.

0$N1+ttYUb8YAb16YA3$XhZc1$

Örnekler

Bir Zamanlar:

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

İki defa:

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

16 kez:

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

açıklama

Yığındaki öğelerin sayısı, snippet'i kaç kez çalıştırdığımızı belirtmek için kullanılır

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 bayt

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

İzleyen bir yeni satır içerir ve dosya adının bir tilde ile başlamasını gerektirir (kullandım ~.ml; çalıştırabilirsiniz ocaml \~.ml) çünkü en yüksek değerli standart yazdırılabilir ASCII karakteridir. Bir dizedeki tüm karakterlerin değişken olması ve Sys.argv.(0).[0]dosya adındaki ilk karakter olduğu gerçeğini kötüye kullanır .

Yalnızca n = 1 ila 126 arasında çalışmalıdır, çünkü ASCII kodu ~126'dır ve çıktıya bir tane ekliyorum. Sadece n = 1 ila 125 istiyorsak iki bayt kısaltılabilir. 126 kez tekrarlandıktan sonra n = 1 olarak geri döner.

Bu benim ilk golf. Bu yüzden herhangi bir yorum veya iyileştirmeler çok takdir edilecektir.

Ungolfed versiyonu:

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

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

Bunu otomatik olarak kapatmalıyım ;

Çevrimiçi deneyin

açıklama

┼ olur ++

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

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

Kolonun arkasında son bir yeni hat var.

İlk satırdan sonraki her şeyi burada bir belge olarak ele alır ve içinde sayar z. Kodun her kopyası için bir tane zeklenir. Sayıya eklemek 1zorundayız, çünkü ilk pasaj için (idam edilen) hiçbiri yoktur.

Stderr'e ek çıktı alınmasına izin verilirse, 2 tek alıntıyı atlayabilir ve ''38 bayta kadar indirebiliriz. ''Perl olmadan kullanımdan kaldırılan bir özellik hakkında bir uyarı yayar.

Mathematica, 76 bayt

Daha nönce tanımları olmaması gerektiğini unutmayın .

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

Burada, davranış ;kullanılır. Yukarıdaki kod parçası bir tanedir CompoundExpression, ancak birkaç parçacık bir araya getirildiğinde, CompoundExpressionaşağıda gösterildiği gibi hala bir tane vardır . (Bazı gereksiz düzenlemeler yapılmıştır.)

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

Bu yüzden, eğer açık bir şekilde yazı yazılırsa böyle bir snippet çalışamaz CompoundExpression. Ayrıca, sevdiğiniz hemen hemen her şey , veya ;gibi birinciden önce konulabilir .EPiMandelbrotSetPlot[]

bash, 49 bayt

Dosya count.bash:

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

... takip eden yeni hat yok.

Koşmak:

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

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

Sondaki yeni satır yok. Formdaki çıktılar 1 01 0x1.

Bu tamam değilse, 56 bayt

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

Birbirlerinin önüne yapıştırıldığında, dosyanın uzunluğu her yapıştırıldığında 1 satır uzar. Temel durum 2 satırla başlar, bu yüzden satır uzunluğundan 1 çıkarmanız gerekir. Hesaplama yorum ile bastırılır.

Python 2.x 140 bayt

Bu, aşırı rekabetçi bir çözüm değildi, ama bir iş için çok iş parçacığı kodlu bir golf oynamaya teşebbüs etmek için eğlenceli bulduğum bir yöntemdi .

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

Bir sayacı tutar, her sayım için bir iş parçacığı açar ve sayaçları zamanlayıcı kapandığında pahalı bir matematik problemini tamamladıktan sonra sayaç değişmediyse (baytları kaydetmek için bir zamanlayıcı yerine), biçimlendirilmiş dize yazdırılır.

Bazı örnek yapılandırmalar ve bunların çıktıları:

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 

ve on beş kopya macunu:

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 bayt

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

Aynı yaklaşımı kullanır benim yanıt 'Kaynağını, çıktısını ikiye katlayın!' .

Çevrimiçi deneyin!

Ruby, 35 bayt

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

Her kod parçacığı artar $.(eğer hiç dosya okunmadıysa 0 ile başlar), ancak yalnızca sonuncusu herhangi bir çıktı verir. *-~-0değerlendirir *1, anlamı bir kez dizeyi basar, ancak bittiğinde *-~-01, 0 olur . Bir sekizli ifade 0 olur $><<.