Nhiệm vụ của bạn rất đơn giản. Đăng một đoạn mã bằng bất kỳ ngôn ngữ nào nếu đoạn trích được lặp lại n lần, sẽ xuất ra n theo số thập phân, bát phân và thập lục phân, theo thứ tự đó, được phân tách trong khoảng trắng. n là một số nguyên lớn hơn 0. Không có số không hàng đầu. Câu trả lời ngắn nhất sẽ thắng

Thí dụ

Nếu đoạn mã là ABCtrường hợp thử nghiệm là

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

Japt, 12 byte

[°TTs8 TsG]¸

Cảm ơn @ETHproductions đã lưu 2 byte!

Giống như câu trả lời my của tôi.

Perl, 30 byte

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

Quay trở lại đầu dòng, bộ đếm tăng và bộ đếm in ghi đè đầu ra cũ.

JavaScript, 54 53 51 47 byte

Đã lưu 4 byte nhờ @ user81655

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

Tôi thực sự hơi ngạc nhiên khi làm việc này.

Giải trình

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

Dùng thử trực tuyến

C ++, 205 179 byte

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

(Không có dòng mới nào - khi được sao chép, dòng đầu tiên của bản sao và dòng cuối cùng của bản gốc sẽ trùng khớp)

Về cơ bản, điều này hoạt động bằng cách tạo một chuỗi các biến tĩnh, khi xây dựng, tăng một bộ đếm biến toàn cục. Sau đó, khi hủy, nếu bộ đếm không bằng 0, nó thực hiện tất cả đầu ra của nó và đặt bộ đếm về 0.

Để xác định một chuỗi các biến không có xung đột tên, chúng tôi sử dụng macro được giải thích như sau:

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

mà phần nào dựa vào các quirks của bộ xử lý chuỗi. Chúng tôi sử dụngz nhiều lần để xác định các lớp / biến sẽ không xung đột với nhau khi được sao chép vào các dòng riêng biệt. Hơn nữa, các định nghĩa chỉ xảy ra một lần được đặt trên dòng đầu tiên, được nhận xét bằng các bản sao của mã. Các tuyên bố #definevà #includekhông quan tâm rằng chúng được lặp đi lặp lại, vì vậy không cần xử lý đặc biệt.

Mã này cũng có hành vi không xác định trong tuyên bố:

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

vì không có điểm thứ tự, nhưng c được sửa đổi và truy cập. LLVM 6.0 đưa ra cảnh báo, nhưng biên dịch nó theo ý muốn - --cđánh giá trước đó c. Người ta có thể, tại các chi phí của hai byte, thêm các tuyên bố --c;trước kết quả đầu ra và thay đổi --ctrong printfđểc , trong đó sẽ thoát khỏi cảnh báo.

Thay thế std::coutbằng việc printftiết kiệm 26 byte nhờ một gợi ý của anh tôi.

CJam, 20 19 18 byte

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

Cảm ơn @ MartinBüttner vì đã chơi golf 1 byte!

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

]                  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 ký tự / 28 byte

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

Try it here (Firefox only).

Câu trả lời đầu tiên! Mặc dù có lẽ có nhiều cách tốt hơn để xử lý việc này.

Giải trình

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

Sử dụng bản phát hành hiện tại (6.0.0) . Hoạt động trên Octave.

0$N1+ttYUb8YAb16YA3$XhZc1$

Ví dụ

Một lần:

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

Hai lần:

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

16 lần:

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

Giải trình

Số phần tử trong ngăn xếp được sử dụng để cho biết số lần chúng tôi chạy đoạn trích

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 byte

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

Bao gồm một dòng mới và yêu cầu tên tệp bắt đầu bằng dấu ngã (tôi đã sử dụng ~.ml; bạn có thể chạy nó ocaml \~.ml) vì đó là ký tự ASCII có thể in tiêu chuẩn có giá trị cao nhất. Lạm dụng thực tế là tất cả các ký tự trong một chuỗi là có thể thay đổi vàSys.argv.(0).[0] là ký tự đầu tiên trong tên tệp.

Nó chỉ hoạt động với n = 1 đến 126, vì mã ASCII cho ~là 126 và tôi đang thêm một vào đầu ra. Nó có thể được rút ngắn hai byte nếu chúng ta chỉ muốn n = 1 đến 125. Sau khi lặp lại 126 lần, nó sẽ quay trở lại n = 1.

Đây là lần đầu tiên chơi golf của tôi vì vậy mọi nhận xét hoặc cải tiến sẽ được đánh giá cao.

Phiên bản bị đánh cắp:

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

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

Tôi nên làm cho nó tự động đóng ;

Dùng thử trực tuyến

Giải trình

┼ trở thành ++

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

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

Có một dòng mới cuối cùng đằng sau dấu hai chấm.

Xử lý tất cả mọi thứ sau dòng đầu tiên như một tài liệu ở đây và tính ztrong đó. Đối với mỗi bản sao tiếp theo của mã, một zđược thêm vào. Chúng tôi phải thêm 1vào số đếm, vì không có đoạn mã đầu tiên nào (đoạn được thực thi).

Nếu cho phép đầu ra bổ sung cho thiết bị lỗi chuẩn, chúng ta có thể bỏ qua 2 dấu ngoặc đơn ''và có thể giảm xuống còn 38 byte. Không có ''perl sẽ phát ra một cảnh báo về một tính năng không dùng nữa.

Toán học, 76 byte

Lưu ý rằng nkhông nên có định nghĩa trước.

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

Ở đây, hành vi của ;được sử dụng. Đoạn mã ở trên là một đoạn đơn CompoundExpression, tuy nhiên, khi một vài đoạn được ghép lại với nhau, vẫn có một đoạn CompoundExpressionnhư được hiển thị bên dưới. (Một số sắp xếp lại không cần thiết được thực hiện.)

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

Vì vậy, người ta không thể làm cho đoạn trích như vậy hoạt động nếu viết rõ ràng CompoundExpression. Ngoài ra, hầu như tất cả mọi thứ bạn thích có thể được đặt trước đầu tiên ;như E, Pihoặc MandelbrotSetPlot[],.

bash, 49 byte

Tập tin count.bash:

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

... không có dòng mới.

Chạy:

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

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

Không có dòng mới. Đầu ra dưới dạng 1 01 0x1.

Nếu điều đó không ổn, 56 byte

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

Khi dán trước mặt nhau, độ dài của tệp sẽ dài hơn 1 dòng cho mỗi lần dán. Trường hợp cơ sở bắt đầu với 2 dòng, do đó bạn phải trừ 1 từ chiều dài dòng. Tính toán bị đàn áp bởi các bình luận.

Python 2.x 140 byte

Đây không phải là một giải pháp cạnh tranh quá mức, mà là một phương pháp mà tôi thấy thú vị, vì một điều, là một nỗ lực tại một sân golf mã đa luồng .

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

Giữ một bộ đếm, sinh ra một luồng cho mỗi số đếm và nếu bộ đếm không thay đổi khi bộ đếm thời gian tắt sau khi hoàn thành một bài toán đắt tiền (thay vì bộ đếm thời gian để lưu byte), chuỗi được định dạng sẽ được in.

Một số cấu hình ví dụ và kết quả đầu ra của chúng:

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 

và mười lăm bản sao dá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;
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 byte

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

Sử dụng cách tiếp cận tương tự như câu trả lời của tôi cho 'Tôi nhân đôi nguồn, bạn nhân đôi sản lượng!' .

Hãy thử trực tuyến!

Ruby, 35 byte

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

Mỗi gia số đoạn trích $.(bắt đầu bằng 0 nếu không có tệp nào được đọc), nhưng chỉ xuất ra kết quả cuối cùng. *-~-0ước tính *1, nghĩa là in chuỗi một lần, nhưng với phép nối nó sẽ trở thành*-~-01 , một biểu thức bát phân đánh giá là 0. Vì $><<không bao gồm một dòng mới, in chuỗi trống có nghĩa là không in gì.