งานของคุณง่าย โพสต์ตัวอย่างในภาษาใด ๆ ที่หากมีการทำซ้ำขนาด 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 ไบต์!

เหมือนกับคำตอบ my ของฉัน

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และ#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 เราสามารถละเว้น 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 *)

ดังนั้นหนึ่งไม่สามารถทำผลงานตัวอย่างข้อมูลดังกล่าวหาก writting CompoundExpressionอย่างชัดเจน นอกจากนี้เกือบทุกอย่างที่คุณต้องการสามารถใส่ก่อนคนแรก;เช่นE, PiหรือMandelbrotSetPlot[],

ทุบตี 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,

ใช้วิธีการเดียวกันกับคำตอบของฉันสำหรับ 'ฉันเพิ่มแหล่งข้อมูลสองเท่าคุณเพิ่มผลผลิตเป็นสองเท่า!' .

ลองออนไลน์!

Ruby, 35 ไบต์

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

แต่ละส่วนย่อยเพิ่มขึ้น$.(ซึ่งเริ่มเป็น 0 หากไม่มีไฟล์ที่อ่าน) แต่จะส่งออกเฉพาะสิ่งสุดท้ายเท่านั้น *-~-0ประเมินถึง*1หมายถึงพิมพ์สตริงหนึ่งครั้ง แต่เมื่อมีการต่อกันกลาย*-~-01เป็นนิพจน์ฐานแปดที่ประเมินเป็น 0 เนื่องจาก$><<ไม่มีบรรทัดใหม่ต่อท้ายการพิมพ์สตริงว่างหมายถึงไม่มีการพิมพ์อะไรเลย