ท้าทาย

เขียนข้อมูลที่สั้นที่สุดของรหัสที่เป็นไปได้ดังกล่าวว่าเมื่อไม่มีสำเนาของมันจะถูกตัดแบ่งกันจำนวนของการส่งออกของตัวละครคือ N 2 N จะเป็นจำนวนเต็มบวก

ตัวอย่างเช่นหากตัวอย่างข้อมูลsoln();จากนั้นการเรียกใช้soln();จะพิมพ์ตัวอักษร 1 ตัวและการsoln();soln();พิมพ์จะทำงานอย่างแน่นอน 4 ตัวอักษรและการรันsoln();soln();soln();จะพิมพ์อย่างแน่นอน 9 ตัวอักษรเป็นต้น

อักขระใด ๆ อาจอยู่ในเอาต์พุตตราบใดที่จำนวนอักขระทั้งหมดถูกต้อง เพื่อหลีกเลี่ยงความสับสนข้ามระบบปฏิบัติการ\r\nบรรทัดใหม่จะถูกนับเป็นหนึ่งอักขระ

โปรแกรมต้องไม่อ่านซอร์สของตนเองหรืออ่านขนาดไฟล์หรือใช้ช่องโหว่อื่น ๆ รักษาเช่นนี้อย่างเคร่งครัดควินท้าทาย

ผลลัพธ์อาจไปที่ stdout หรือไฟล์หรือทางเลือกอื่นที่คล้ายกัน ไม่มีอินพุต

ความคิดเห็นในโค้ดนั้นใช้ได้เนื่องจากกำลังออกจากการดำเนินการกลาง

ตัวละครใด ๆ อาจอยู่ในโปรแกรม การส่งที่สั้นที่สุดในหน่วยไบต์ชนะ

TECO 4 ไบต์

V1\V

Vพิมพ์เนื้อหาของบรรทัดปัจจุบันในบัฟเฟอร์ข้อความ 1\แทรกการแทนสตริงของหมายเลข 1 ที่ตำแหน่งปัจจุบัน

ดังนั้นในการวนซ้ำครั้งที่NของโปรแกรมตัวแรกVจะออกสำเนาN - 1ของตัวละคร1จากนั้นเพิ่มอีกอัน1ลงในข้อความจากนั้นจึงส่งออกN 1 s

Brainfuck, 17 16 ไบต์

[>+>-..+<<-]-.>+

คุณสามารถทดสอบได้ที่นี่ เพียงแค่ใช้ความจริงที่ว่าn2+2n+1=(n+1)2

Brainfuck, 11

ฉันเห็นคำตอบแรกของ Brainfuck และคิดว่ามันนานเกินไป :)

[.<]>[.>]+.

ผลลัพธ์อาจดูง่ายขึ้นหากคุณแทนที่เครื่องหมายบวกด้วยเครื่องหมายบวกจำนวนมาก

ในการทำซ้ำชับแต่ละวงเอาท์พุท N - 1 สำเนาของตัวละครที่มีค่า ASCII 1 +.แล้วหนึ่งมากขึ้นด้วย

Python 2, 22

a='';print a;a+='xx';a

พิมพ์สตริงว่างแล้วตามด้วยสองxแล้วxสี่และต่อไป ด้วยการขึ้นบรรทัดใหม่หลังจากแต่ละสตริงทำให้เกิดn*nอักขระขึ้นมา

หนึ่งสำเนา: "\n"(1 อักขระ)
สองเล่ม: "\nxx\n"(4 ตัวอักษร)
สามเล่ม: "\nxx\nxxxx\n"(9 ตัวอักษร)

เพื่อที่จะหยุดตัวแปรเริ่มต้นaจากการเริ่มต้นใหม่ในแต่ละการรันฉันจะวางโค้ดด้วย a ;aซึ่งเป็นตัวของมันเอง แต่รวมกับลูปถัดไปเพื่อสร้างแพะรับบาปaaที่จะกำหนดแทน เคล็ดลับนี้ไม่ใช่ของฉัน ฉันเห็นมันในคำตอบก่อนหน้า ฉันจะขอบคุณถ้ามีคนชี้ให้ฉันเพื่อฉันจะให้เครดิต

CJam, 6 ไบต์

LLS+:L

ใช้ความจริงที่ว่าn2 + n + (n+1) = (n+1)2

L      "Push L. Initially this is an empty string, but its length increases by 1 with each copy
        of the snippet.";
 L     "Push another L.";
  S+   "Add a space to the second copy.";
    :L "Store the lengthened string in L for the next copy of the snippet.";

/// , 21 ไบต์

ฉันแน่ใจว่ามีวิธีที่สั้นและบิดเบี้ยวจริงๆในการแก้ปัญหานี้ใน///แต่ฉันไม่พบอะไรเลยนอกจากวิธี "ตรงไปตรง":

1/1\//112\///2\//1\//

ทั้งนี้ขึ้นอยู่กับวิธีการพิมพ์หมายเลขคี่ ตัวอย่างประกอบด้วย1จุดเริ่มต้นซึ่งจะถูกพิมพ์และสองการแทนที่ซึ่งเพิ่มอีกสอง1s ไปที่ส่วนแรกของแต่ละสำเนาต่อเนื่องของตัวอย่าง ไป Let 's N = 3ผ่านนี้ ควรอ่านข้อมูลต่อไปนี้ในกลุ่มที่มี 3 บรรทัดขึ้นไป: 1. รหัสปัจจุบัน 2. โทเค็นที่ประมวลผล 3. (และต่อไป) แสดงความคิดเห็นสิ่งที่โทเค็นด้านบนทำ

1/1\//112\///2\//1\//1/1\//112\///2\//1\//1/1\//112\///2\//1\//
1
is printed
/1\//112\///2\//1\//1/1\//112\///2\//1\//1/1\//112\///2\//1\//
/1\//112\//
replaces all occurrences of 1/ with 112/. This affects the starts of all further snippets
but not the substitution commands, because the slashes in those are always escaped.
It is necessary to put a 2 in there, because otherwise the interpreter goes into an infinite
loop replacing the resulting 1/ again and again.
/2\//1\//112/1\//112\///2\//1\//112/1\//112\///2\//1\//
/2\//1\//
Replace all occurrences of 2/ with 1/, so the the next snippets substitution works again.
111/1\//112\///2\//1\//111/1\//112\///2\//1\//
111
is printed
/1\//112\///2\//1\//111/1\//112\///2\//1\//
/1\//112\//
add two 1s again
/2\//1\//11112/1\//112\///2\//1\//
/2\//1\//
turn the 2 into a 1 again
11111/1\//112\///2\//1\//
11111
print 11111
/1\//112\///2\//1\//
the last two substitutions have nothing to substitute so they do nothing

ที่น่าสนใจมันใช้งานได้ดีเช่นกันหากเราเลื่อน1ไปยังจุดสิ้นสุด:

/1\//112\///2\//1\//1

> <> , 14 ไบต์

1:na*a*';'10p!

ใช้แนวคิด "ผลรวมของจำนวนเต็มคี่ที่ต่อเนื่องกันเริ่มต้นจาก 1" มันเริ่มต้นด้วย 1 และคูณด้วย 100 ในแต่ละครั้งเพิ่มความยาวของเอาต์พุตอย่างต่อเนื่องโดยเพิ่มขึ้น 2

ตัวอย่างเช่นการผนวก 5 ชุดจะให้

1100100001000000100000000

ฉันทดสอบโดยการไพพ์เอาต์พุตไปยังไฟล์และไม่เห็นบรรทัดใหม่ต่อท้าย

ทำให้พังถล่ม

1                   Push 1, skipped by ! every time except the first
 :n                 Copy top of stack and output as num                  
   a*a*             Multiply by 10 twice
       ';'10p       Modify the source code so that the first : becomes a ; for termination
             !      Skip the next 1

CJam, 10 9 ไบต์

],)_S*a*~

พิมพ์ช่องว่างN ²ซึ่งNเป็นจำนวนสำเนาของรหัส

การขยายรหัส :

],            "Wrap everything on stack and take length";
  )_          "Increment and take copy";
    S*        "Get that length space string";
      a*      "Wrap that space string in an array and create that many copies";
        ~     "Unwrap so that next code can use to get length";

ลองออนไลน์ได้ที่นี่

Python 2, 20 ไบต์

g=0
print'g'*g;g+=2#

Java - 91 ไบต์

{String s=System.getProperty("a","");System.out.println(s);System.setProperty("a","xx"+s);}

โซลูชันนี้เทียบเท่ากับวิธีนี้ใน Python มันคงไม่ชนะ แต่มันก็สนุก :)

Perl, 14 ไบต์

print;s//__/;

สิ่งนี้จะต้องดำเนินการด้วย-lสวิตช์คำสั่งของ Perl ซึ่งทำให้printผนวกบรรทัดใหม่

มันพิมพ์ตัวแปรเริ่มต้น$_แล้วเพิ่มขีดล่างสองอันผ่านการแทนที่

ตัวอย่าง:

$ perl -le 'print;s//__/;print;s//__/;print;s//__/;print;s//__/;'

__
____
______

Brainfuck, 10 ตัวอักษร

ทั้งสองโซลูชั่น Brainfuck ก่อนหน้านี้มีwaaayยาวเกินไป (16 และ 11 ตัวอักษร) ดังนั้นนี่คือวิธีที่สั้นกว่า:

+[.->+<]>+

ในnบล็อก -th จะพิมพ์2*n-1อักขระ (พร้อม codepoints จาก2*n-1ถึง1)

โหมโรง , 18 12 ไบต์

^1+(9!1-)#2+

พิมพ์แท็บN ²นี้ จะถือว่าล่ามตามมาตรฐานที่พิมพ์ตัวอักษรแทนตัวเลขดังนั้นถ้าคุณใช้หลามล่ามคุณจะต้องตั้งค่าที่จะNUMERIC_OUTPUTFalse

แนวคิดก็คือใช้ส่วนบนสุดของสแต็ก (ซึ่งเริ่มต้นที่ 0) เป็น2(N-1)และพิมพ์2N-1แท็บจากนั้นเพิ่มส่วนบนสุดของสแต็กด้วย 2 ดังนั้นการทำซ้ำแต่ละครั้งจะพิมพ์จำนวนคี่ถัดไปของแท็บ

Java - 59/44 (ขึ้นอยู่กับข้อกำหนด)

static String n="1";
static{System.out.print(n);n+="11";}//

เห็นได้ชัดว่าเราได้รับอนุญาตให้สมมติว่าโค้ดรันในคลาส

หากสามารถใช้วิธีหลักได้:

String n="1";
System.out.print(n);n+="11";//

C, 87 ไบต์

#if!__COUNTER__
#include __FILE__
main(a){a=__COUNTER__-1;printf("%*d",a*a,0);}
#endif

วิธีนี้ใช้มาโครวิเศษสองอัน __COUNTER__เป็นมาโครที่ขยายไป0เป็นครั้งแรกที่มีการใช้งาน1ที่สอง ฯลฯ มันเป็นส่วนขยายของคอมไพเลอร์ แต่มีทั้ง gcc, เสียงดังกราวและ Visual Studio อย่างน้อย __FILE__เป็นชื่อของไฟล์ต้นฉบับ การรวมไฟล์ใน C / C ++ นั้นเหมือนกับการวางลงในซอร์สโค้ดของคุณโดยตรงดังนั้นมันจึงเป็นเรื่องยุ่งยากเล็กน้อยในการใช้งาน

__COUNTER__มันจะยังคงเป็นไปได้ที่จะใช้เทคนิคนี้ได้โดยไม่ต้อง ในกรณีนั้นสามารถใช้รหัสป้องกันสองครั้งสำหรับ#ifคำสั่งได้และ__LINE__สามารถใช้เพื่อนับจำนวนอักขระที่ต้องการ

Dyalog APL, 20 19 ไบต์

โซลูชั่นที่ใช้เมทริกซ์

{⍺≢⍵:⍵⍪⍵,⍺⋄∊⍺}⍨⍪'a'

ลองได้ที่นี่ กลับสตริงของการเกิดซ้ำของ คำอธิบายโดยการระเบิดสำหรับ:N2aN = 2

{⍺≢⍵:⍵⍪⍵,⍺⋄∊⍺}⍨⍪'a'{⍺≢⍵:⍵⍪⍵,⍺⋄∊⍺}⍨⍪'a'
                                  ⍪'a'  Wrap 'a' into a 1x1 matrix.
                'a'{            }⍨      Binary function: bind 'a' to ⍵ and the matrix to ⍺.
                    ⍺≢⍵:                The arguments are not identical,
                        ⍵⍪⍵,⍺           so add to the matrix 1 column and 1 row of 'a's.
               ⍪                        Identity function for a matrix.
{            }⍨                         Unary function: bind the matrix to both ⍵ and ⍺.
 ⍺≢⍵:                                   The arguments are identical,
           ∊⍺                           so flatten the matrix into the string 'aaaa'.

สถานะ 20

di _n($a)
gl a=$a+2

มีบรรทัดใหม่ต่อท้ายเพื่อให้แน่ใจว่าคำสั่ง display (di) ทำงาน ก่อนแสดงหมายเลขปัจจุบันในบรรทัดใหม่ $ a (และอีกหนึ่งจากการเริ่มต้นของการแสดงผล) จากนั้นเพิ่ม 2 ถึง $ a

ใช้แนวทางแบบคู่ (เช่นตัวเลขคี่เข้าใกล้ลบ 1) โดยมีการขึ้นบรรทัดใหม่ทุกครั้ง

T-SQL 117

IF OBJECT_ID('tempdb..#')IS NULL CREATE TABLE #(A INT)INSERT INTO # VALUES(1)SELECT REPLICATE('a',COUNT(*)*2-1)FROM #

สังเกตช่องว่างท้ายเพื่อให้แน่ใจว่าเงื่อนไข if ถูกตรวจสอบอย่างถูกต้องทุกครั้ง

ใช้วิธีเลขคี่ ไม่แน่ใจว่ามีการขึ้นบรรทัดใหม่ของข้อความสั่งที่เลือกหรือไม่

ไม่แน่ใจว่ามีวิธีที่สั้นกว่าในการสร้างตารางหากไม่มีอยู่หรือไม่

PostScript, 35 ตัวอักษร

count dup 2 mul 1 add string print

แต่ละรอบจะ "รั่ว" หนึ่งครั้งในกองซ้อนดังนั้นcountจะเพิ่มขึ้น 1 ครั้งในแต่ละครั้ง จากนั้นมันก็ใช้ผลรวมของเคล็ดลับตัวเลขคี่

เอาต์พุตไบต์ทั้งหมดเป็น\000เพราะนั่นคือค่าเริ่มต้นของสตริง

Haskell, 72

putStr$let a="1";aputStr=(\n->take(n^2)$show n++cycle" ").(+1).read in a

คำอธิบาย

ตัวดำเนินการนำไปใช้$ทำหน้าที่เสมือนว่าคุณวางวงเล็บล้อมรอบส่วนที่เหลือของบรรทัด (มีข้อยกเว้นสำหรับสิ่งนี้ แต่จะใช้ได้ในกรณีนี้) aputStrเป็นฟังก์ชันที่รับสตริงที่มีรูปแบบ "abc ... " โดยที่ "abc" คือรากที่สองของความยาวของสตริงรวมถึง abc มันจะแยกสตริงเป็นจำนวนเต็มและส่งกลับสตริงที่เริ่มต้นด้วย abc + 1 และมีความยาวนั้นกำลังสอง เนื่องจากตัว$ดำเนินการสิ่งนี้จะถูกเรียกซ้ำใน "1" N ครั้ง

Pyth, 8 ไบต์

*d*2Z~Z1

นี่ขึ้นอยู่กับความจริงที่ว่า N ²เท่ากับผลรวมของNเลขคี่ ตอนนี้ Pyth อัตโนมัติพิมพ์บรรทัดใหม่ดังนั้นฉันมีเพียงแค่พิมพ์Z * 2ตัวอักษรในรหัสที่แต่ละZไปจากการ0N - 1

การขยายรหัส :

*d               "Print d whose value is a space character"
  *2Z            "2 * Z times where Z's initial value is 0"
     ~Z1         "Increment the value of Z";

ลองออนไลน์ได้ที่นี่

Golflua, 23 ไบต์

X=2+(X|-2)w(S.t("&",X))

แสดงผลการรวมกันของ&และ\nตัวละคร

รหัส Lua ที่เทียบเท่า

X = 2 + (X or -2)          -- initialize X to 0 the first time, add 2 ever other time

print(string.rep("&", X))

แต่ละครั้งที่โค้ดขนาดสั้นทำงานจะสร้างเอาต์พุตจำนวน 2 อักขระมากกว่าครั้งที่แล้วโดยเริ่มต้นด้วย 1 ตัวอักษร printฟังก์ชั่นการขึ้นบรรทัดใหม่ผนวกดังนั้นฉันเริ่มต้น X 0 แทน 1

ActionScript - 27/26 ไบต์

var n=""
trace(n);n+="11"//

หรือ

var n=1
trace(n);n+="11"//

มันทำงานอย่างไร:

var n=""
trace(n);n+="11"//var n=""
trace(n);n+="11"//

มันเป็นเพียงการแสดงความคิดเห็นออกบรรทัดแรก หมายเหตุ: traceเพิ่มบรรทัดใหม่ หรือบางที IDE ทั้งหมดที่ฉันใช้ทำโดยอัตโนมัติ

GML, 27

a=''show_message(a)a+='xx'a