สถานการณ์

เพื่อนคนหนึ่งของคุณกำลังดิ้นรนกับการบ้าน เขาต้องการโปรแกรมง่าย ๆ ที่พิมพ์ตัวเลขธรรมชาติ 404 ตัวแรก:

1 2 3 4 5 6 7 8 9 10 11 ... 401 402 403 404

ความท้าทายของคุณนั้นง่าย: เขียนโปรแกรมนี้สำหรับเขา

อย่างไรก็ตามการเชื่อมต่อของคุณแย่มากดังนั้นตัวละครสุ่ม 1 ตัวจะหายไปทุกครั้งที่คุณส่งโปรแกรม เพื่อป้องกันไม่ให้โปรแกรมแตกคุณต้องทำเพื่อให้การลบอักขระเดี่ยวใด ๆจะไม่มีผล:โปรแกรมใช้งานได้โดยไม่คำนึงถึง (โปรแกรมต้นฉบับจะต้องใช้งานได้เช่นกัน)

เนื่องจากการเชื่อมต่อไม่ดีพอที่จะส่งไฟล์ขนาดใหญ่รหัสของคุณจะต้องสั้นที่สุด

_{TL: DR - สร้างโปรแกรมที่ทำให้รังสีแข็งตัวเพื่อส่งออกหมายเลข 1 ถึง 404}

กฎ / รายละเอียด

• ผลลัพธ์อาจเป็นรายการจำนวนเต็มในรูปแบบที่เหมาะสม (คั่นด้วยช่องว่างบรรทัดใหม่จุลภาค ฯลฯ ) อย่างไรก็ตามผลลัพธ์ของคุณจะต้องสอดคล้องและไม่เปลี่ยนแปลงเมื่อมีการแก้ไขโปรแกรม
• การตั้งค่าสถานะบรรทัดคำสั่งที่ประกอบด้วยตรรกะเรียกใช้รหัสจริงสร้างรายการหมายเลขและอื่น ๆ ถูกแบน
• นี่คือโค้ดกอล์ฟดังนั้นการส่งที่สั้นที่สุด (เป็นไบต์) ชนะ!

05AB1E , 12 ไบต์

รหัส:

XX440044ÔÔŸŸ

คำอธิบายรหัสปกติ:

X             # Pushes the number 1.
 X            # Pushes the number 1 again.
  440044      # Pushes the number 440044.
        Ô     # Connected uniquify.
         Ô    # Connected uniquify.
          Ÿ   # Inclusive range of the top two elements.
           Ÿ  # Inclusive range on the array, which leaves it intact.

สิ่งนี้นำไปสู่รหัส golfed ต่อไปนี้: X404Ÿซึ่งเป็นสิ่งที่เราต้องการบรรลุ

หมายเลข404ถูกสร้างขึ้นโดยตัวแปรเหล่านี้:

440044ÔÔ
40044ÔÔ
44044ÔÔ
44004ÔÔ
440044Ô

ช่วงรวมทำงานดังต่อไปนี้กับตัวเลขสองตัว:

`1 5Ÿ`             ->    [1, 2, 3, 4, 5]
[1, 5]Ÿ            ->    [1, 2, 3, 4, 5]
[1, 2, 3, 4, 5]Ÿ   ->    [1, 2, 3, 4, 5]

ซึ่งมักจะทำให้สองไม่มี-opŸ

ใช้การเข้ารหัสCP-1252 ลองออนไลน์!

จาวาสคริปต์, 228 ไบต์

etInterval=stInterval=seInterval=setnterval=setIterval=setInerval=setIntrval=setInteval=setInteral=setIntervl=setInterva=top=>4

setInterval
`405>(i=this.i?i:1)?alert(i++):0`///`
setInterval
`405>(i=this.i?i:1)?alert(i++):0`///`

คำอธิบาย

การประเมินโค้ดในโปรแกรมsetIntervalอนุญาตให้โปรแกรมดำเนินการต่อแม้ว่าจะมีข้อผิดพลาด เราตรวจสอบให้แน่ใจว่ารหัสที่ส่งผ่านจะเกิดข้อผิดพลาดหากมีการลบอักขระตัวเดียว ไวยากรณ์สตริงเทมเพลตสามารถถูกใช้เพื่อโทรsetIntervalด้วยสตริงคงที่โดยไม่ต้องใช้วงเล็บ โชคดีที่แม้ว่าสตริงแม่แบบจะอยู่ในบรรทัดถัดไป แต่ก็ยังแยกวิเคราะห์เป็นการเรียกใช้ฟังก์ชันด้วยไวยากรณ์ดังกล่าว

ปัญหาแรกที่เราพบคือนั่นsetIntervalคือฟังก์ชั่นดังนั้นหากมีการลบตัวอักษรและโปรแกรมพยายามโทรsetIntevalแทนมันจะผิดพลาด แน่นอนเนื่องจากมีการเรียกใช้สองการเยื้องของsetIntervalเราไม่ต้องกังวลเกี่ยวกับการทำงานอย่างถูกต้องตราบใดที่เราหลีกเลี่ยงข้อผิดพลาด ดังนั้นบรรทัดแรกจะกำหนด "การสะกดคำผิด" ที่เป็นไปได้ทั้งหมดของsetTimeoutฟังก์ชันที่ถูกต้อง

บรรทัดแรกทำงานโดยการกำหนดสิ่งเหล่านี้ "สะกดผิด" top=>4เพื่อฟังก์ชั่น สังเกตไวยากรณ์ของ ES6 เพียงแค่ใช้พารามิเตอร์ชื่อ "top" และส่งคืน 4. เหตุใดจึงเป็น "top" ดีบรรทัดแรกจะต้องไม่โยนข้อผิดพลาดแม้ว่าตัวละครจะถูกลบออก หาก=จะถูกลบออกเพื่อให้top>4นี้แสดงออกบูลจะถูกต้องตั้งแต่มีการกำหนดไว้ล่วงหน้าในเบราว์เซอร์ก็ยอมtop falseหากลบ 4 เนื้อหาของฟังก์ชันจะกลายเป็นsetIntervalเซ็กเมนต์แรกและส่วนที่สองจะไม่เป็นอันตราย

ตอนนี้สิ่งที่เหลืออยู่ที่ต้องกังวลคือถ้าเอา `` ออก

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

บรรทัดใหม่จะถูกวางไว้เพื่อให้การลบนั้นไม่ส่งผลกระทบต่อการทำงานของโปรแกรม แต่จะป้องกันข้อผิดพลาดในกรณีที่มีการลบอักขระบางตัวเช่น backtick ชั้นนำ

Pyth - 16 ไบต์

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

SSsetSS[404  404

คำอธิบาย:

SS                       First one does 1-index range, second one sorts, which is no-op 
 s                       If the e is there, this is no-op, if only t is there, it sums a one element list, which is the item
  et                     e picks last element in list, and if e is gone, then t gets you the list without the first element which is good enough when combined with s
   SS                    Sorting twice is no-op
    [                    Start list, this can't be two element because if we get rid of initial 4, the 0 becomes third element which neeeds to be captured
     404                 One of the 404's
     <space><space>404   Need two spaces for redundancy, because 404404 *is* bigger than 404

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

Befunge-98 , 37 bytes

20020xx##;;11++::''ee44**``kk@@::..;;

ลองออนไลน์!

คำอธิบาย

ทำรหัสรังสีแข็งใน Befunge-98 ไม่มากเกินไปไม่ดีเพราะคุณสามารถตั้งค่า "เดลต้า" (คือขนาดของตัวชี้ขั้นตอนการเรียนการสอน) xด้วยตนเอง ดังนั้นหากตั้งค่าเดลต้าเป็น(2,0)จากนั้นตัวละครอื่น ๆ จะถูกข้ามและเราสามารถเพิ่มคำสั่งทั้งหมดได้สองเท่า สิ่งที่ยุ่งยากคือการ2 0อยู่บนกองซ้อนด้วยวิธีที่เชื่อถือได้ เราจะต้อง0 2 0ให้โปรแกรมที่เหลือทำงานอย่างถูกต้อง แต่เราจะให้โปรแกรมฟรี นี่คือวิธีที่เราทำ:

20020xx

โปรดทราบว่าตัวเลขแต่ละตัวนั้นพุชตัวเองดังนั้นในโปรแกรมเต็มรูปแบบจะมีจุดเริ่มต้น2 0ที่เราจะไม่สนใจ

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

ลองพิจารณาสิ่งที่เกิดขึ้นในอีกสองกรณี วางอักขระที่สี่:

2000xx

(0,0)หมายเหตุเดลต้ามีการตั้งค่า แต่สิ่งนี้จะไม่ย้ายตัวชี้คำสั่งเลยดังนั้นxจะมีการดำเนินการอีกครั้งในทันทีและในเวลานี้จะปรากฏขึ้น(2,0)และทั้งหมดก็เป็นไปด้วยดี (มีค่าศูนย์ที่ด้านล่างของสแต็คเพื่อจุดประสงค์ในภายหลัง)

ลองวางอักขระตัวที่ห้าแทน:

2002xx

(0,2)ตอนนี้เดลต้าได้รับการตั้งค่าให้ อย่างไรก็ตามยังคงไม่มีการเคลื่อนไหวในแนวนอนดังนั้น IP จะย้อนกลับไปที่xอีกครั้งทันทีที่มีการตั้งค่าเดลต้าที่ถูกต้อง

จากจุดนี้เป็นต้นไปเราสามารถเพิกเฉยต่อการซ้ำซ้อนของตัวละครได้เช่นเดียวกับส่วนเริ่มต้นเพราะมันจะถูกข้าม:

...#;1+:'e4*`k@:.;

;เป็นประเภทของคำสั่งคิดเห็นที่ข้ามทุกอย่างต่อไปจนกว่าที่;จะพบ อย่างไรก็ตามเรากระโดดข้ามส่วนแรก;ด้วย#ดังนั้นส่วนระหว่าง;จะดำเนินการจากจุดนั้นเป็นต้นไป

1+    Increment the top of the stack.
:     Duplicate it.
'e    Push 101.
4*    Multiply by 4 to get 404.
`     Greater-than check. Pushes 1 once the top
      reaches 405, otherwise 0.
k@    Terminate the program that many times.
:.    Print a copy of the top of the stack (and a space).

> <> , 103 60 51 ไบต์

               vv
;?=*4o" e"n:ll<<
;?=*4o" e"n:ll<<

ทดสอบที่นี่

ใช้กลยุทธ์เดียวกันกับโปรแกรมนี้ หากตัวละครถูกลบในบรรทัดแรกบรรทัดที่ 2 จะยังคงทำงานอยู่ หากลบอักขระในบรรทัดที่ 2 vจะย้ายการดำเนินการไปที่บรรทัดที่ 3 เนื่องจากบรรทัดที่ 2 เป็นอักขระที่สั้นกว่า การลบในบรรทัดที่ 3 ไม่มีผลต่อการควบคุมโปรแกรมเนื่องจากเป็นการดำเนินการหลังจากการลบในบรรทัดที่ 2 เท่านั้น

โปรแกรมจะทำงานในกรณีที่ตัวแบ่งบรรทัดถูกลบ:

กรณีที่ 1:

บรรทัดที่ 2 จะถูกเรียกใช้

               vv;?=*4o" e"n:ll<<
;?=*4o" e"n:ll<<

กรณีที่ 2:

บรรทัดทั้งสองกลายเป็นหนึ่งบรรทัด

               vv
;?=*4o" e"n:ll<<;?=*4o" e"n:ll<<

คำอธิบาย:

แกนหลักของโปรแกรมมีดังต่อไปนี้ โปรดสังเกตว่า a 1ถูกผลักลงบนสแต็กแล้วโดยบรรทัดแรก

ll:n        Push length of the stack twice, duplicate, print as number
"e "o       Push 101, 32, output 32 as space
4*          101 * 4 is 404
=?;         Pop twice, if equal, halt
            (Execution wraps around)

> <> , 42 38 34 ไบต์

ลองออนไลน์!

ขอบคุณ@Martin Enderและ@Teal Pelicanสำหรับการโกนหนวด 8 ไบต์!

<<;?=*4o" e"lnll/
 ;?=*4o" e"lnll<

คล้ายกับคำตอบของ mbomb007แต่ใช้เพียง 2 บรรทัด

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

รหัสเดิม

<s เปิด IP รอบและ/เป็น no-op เป็น IP ล้อมรอบและยังคงไปตามเส้นทางปกติ ดังนั้นรหัสที่เกี่ยวข้องคือ:

          lnll   Prints the size of the stack + 1 and pushes the stack size twice
     o" e"       Prints a space and pushes 101
   *4            Multiplies to get 404
;?=              If the number we just printed was 404, end the program

และสิ่งนี้ซ้ำ

การลบ

/คีย์ใหญ่ที่นี่เป็นกระจก มันไม่ได้ทำอะไรเลยหากมีการแก้ไขบรรทัดที่สอง - เพียงแค่ล้อมรอบกลับเข้าหาตัวเองเท่านั้น แต่ถ้าลบอักขระจากบรรทัดแรกบรรทัดนั้นจะเลื่อนลงเพื่อให้มิเรอร์ชนกับลูกศร<ซึ่งนำไปสู่ลูปที่เหมือนกันและไม่ได้แก้ไข

การลบที่สำคัญอื่น ๆ เท่านั้นที่จะเป็น\nตัวละคร นี่เป็นสาเหตุที่ทำให้รหัสนี้:

<<;?=*4o" e"lnll/ ;?)*4o" e"lnll<

ตอนนี้เราเพิ่งต่อท้ายสำเนาของลูปดั้งเดิม;?=*4o" e"lnllกับตัวเอง เนื่องจากนี่เป็นลูปจึงไม่ต่างกับการดำเนินการและทำงานเหมือนกับไม่มีอะไรเปลี่ยนแปลง

ต้นแพร์ 34 ไบต์

โปรแกรมมีอักขระควบคุมดังนั้นนี่คือxxdดัมพ์:

00000000: 7072 696e 7420 312e 2e34 3034 2327 108a  print 1..404#'..
00000010: af70 7269 6e74 2031 2e2e 3430 3423 2710  .print 1..404#'.
00000020: 8aaf                                     ..

ต้นแพร์นั้นเป็นอนุพันธ์ของ Perl ด้วยคุณสมบัติบางอย่างที่ "น่าสนใจ" ฉันโยนมันด้วยกันเป็นเรื่องตลก (เพื่อที่ฉันจะได้พูดได้ว่าคนที่พูดได้หลายภาษาของฉันพิมพ์a partridgeใน A Pear Tree; อันที่จริงโปรแกรมเกือบทั้งหมดทำ) อย่างไรก็ตามมันเป็นทัวริงที่สมบูรณ์และจริง ๆ แล้วเป็นประเภทที่ท้าทายประเภทนี้

คุณลักษณะที่เราส่วนใหญ่เกี่ยวกับการดูแลที่นี่เป็นที่ลูกแพร์ต้นไม้เท่านั้นที่จะเรียกใช้โปรแกรมถ้าย่อยของรหัสบางอย่างมี CRC-32 00000000ของ รหัสได้รับการหมุนเพื่อใส่ซับสตริงในคำถามที่จุดเริ่มต้น ในขณะที่มันเกิดขึ้นทั้งสองส่วน (เหมือนกัน) ของรหัสแต่ละคนมีคำถาม CRC-32 (เนื่องจากความคิดเห็นไบนารีที่ดูน่าสงสัยในตอนท้าย) ดังนั้นหากคุณลบตัวละครจากแหล่งที่มา (ทำลาย CRC) อีกครึ่งหนึ่งได้รับการหมุนไปที่จุดเริ่มต้นและ#สัญญาณที่อยู่ใกล้กับส่วนท้ายจะแสดงความเห็นครึ่งที่เสียหายออกไปนอกเหนือจากขยะไบนารี

คุณสมบัติอื่นที่ทำให้โปรแกรมมีขนาดเล็กลงเล็กน้อย: แม้ว่า A Tree Tree จะถูกตีความว่าเป็น Perl เป็นส่วนใหญ่ แต่ก็มีการเปลี่ยนแปลงเล็กน้อยเพื่อให้ทำงานได้เหมือน Python สิ่งหนึ่งที่เกี่ยวข้องที่นี่คือไม่เหมือนprintคำสั่งPerl (ซึ่งเพิ่งจะวิ่งตัวเลขด้วยกัน) printคำสั่งของ A Pear Tree จะแยกอาร์กิวเมนต์ด้วยช่องว่างและพิมพ์บรรทัดใหม่สุดท้าย นั่นทำให้เรามีช่องว่างที่แยกออกมาอย่างดีซึ่งหมายความว่าเราไม่ต้องเสียไบต์ในการจัดรูปแบบ (โปรดทราบว่าคุณจะต้องให้โปรแกรมไม่ป้อนข้อมูลหากภาษาได้รับการป้อนข้อมูลจะถือว่าเป็นค่าเริ่มต้นว่าควรจะทำอะไรกับมันตามค่าเริ่มต้น)

แน่นอนว่านี่ไม่สามารถแข่งขันกับภาษากอล์ฟที่แท้จริง (หรือฉันคาดหวังได้) แต่ฉันคิดว่าผู้คนอาจสนใจมัน

Befunge 98 , 34 bytes

ลองออนไลน์!

<<.:@k`*4e':+1[

2.:@k`*4e':+1<^^j

สิ่งนี้ทำงานคล้ายกับคำตอบ> <>ของฉันมากแต่แทนที่จะใช้มิเรอ/ร์ฉันใช้การเลี้ยวซ้าย[แล้วกลับทิศทาง IP ซึ่งทำหน้าที่เทียบเท่ากับกระจกเงาในกรณีนี้

รหัสเดิม

<<                 Reverses code direction, sending IP to right
               [   Turns the IP left, into the ^, which reverses it.
                   It then hits this again, turning left to go West. (No-op)
            :+1    Adds 1 to the sum
        *4e'       Pushes 404
     @k`           Ends the program if (sum > 404)
   .:              Prints the sum

การลบ

หากสิ่งที่อยู่ในบรรทัดที่สองถูกลบออกมันจะเลื่อนไปมาและจะไม่ส่งผลกระทบต่อส่วนบนเลย

หากมีการลบสิ่งใดในบรรทัดแรก[จะส่ง IP ไปที่<ซึ่งจะเริ่มวนซ้ำเหมือนกัน (ยกเว้น2j^^ว่าจะหลีกเลี่ยง^s ที่ใช้ควบคู่กับ[)

เนื่องจากมี 2 บรรทัดใหม่มันจึงไม่ต่างกับรหัสหากลบออกไป (ขอบคุณ@ masterX244สำหรับสิ่งนี้!)

Befunge-93, 54 51 bytes

ขอบคุณMistah Figgins ที่ช่วยฉัน 3 ไบต์

111111111111111vv
+1_@#-*4"e":.:<<
+1_@#-*4"e":.:<<

ลองออนไลน์!

นี่เป็นเคล็ดลับเดียวกับที่ใช้ในการท้าทายHello World Fault-Tolerant บรรทัดแรกเริ่มต้นโดยตรวจสอบให้แน่ใจว่ามี 1 อยู่ด้านบนสุดของสแต็กสำหรับการเริ่มต้นของลำดับและจากนั้นหนึ่งvลูกศรที่จุดสิ้นสุดของบรรทัดเปลี่ยนเส้นทางรหัสเส้นทางไปยังจุดเริ่มต้นของรูทีนหลักบนบรรทัด 2 ดำเนินการจากขวาไปซ้าย

การลบอักขระออกจากบรรทัดแรกจะเป็นการย้ายvลูกศรไปทีละบรรทัดแต่ก็ยังทำให้โค้ดสามารถเปลี่ยนเส้นทางไปยังบรรทัดที่สองได้สำเร็จ การลบอักขระออกจากบรรทัดที่สองทำให้<ลูกศรที่ท้ายบรรทัดเลื่อนออกจากพา ธvด้านบนดังนั้นโค้ดพา ธ จะถูกเปลี่ยนเส้นทางไปยังรูทีนการสำรองข้อมูลในบรรทัดที่ 3

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

JavaScript + HTML + ตัวอย่างสแตก, 167 158 154 ไบต์

เหยียดหยามความจริงที่ว่า JavaScript ในกองตัวอย่างได้รับการวางในหน้าเว็บภายใน<script>องค์ประกอบ

or(x="",i=405,d=document;--i;)d[i]||(x=d[i]=i+' '+x);d.write(x)</script></script><script>for(x="",i=405,d=document;--i;)d[i]||(x=d[i]=i+' '+x);d.write(x)

จริงแล้ว 18 ไบต์

:404::404kMkMMRRSS

จริง ๆ แล้วเป็นภาษาเล่นกอล์ฟตามกอง

คำอธิบายของคำสั่งที่เกี่ยวข้อง (ขณะที่ทำงานในบริบทด้านบน):

Numbers are indicated by round brackets () and lists by square brackets []

:         - pushes the longest string of characters in '0123456789+-.ij' as a numeric
k         - pop all the elements on the stack into a list [l] and push [l]
M         - pop [l], push max([l])
            pop (a), push (a)
R         - pop [l], push reverse([l])
            pop (a), push range([1,a])
S         - pop [a], push sorted([a])