ความท้าทายคือการค้นหาสตริงของอักขระที่ไม่สามารถปรากฏในโปรแกรมทางกฎหมายใด ๆในภาษาการเขียนโปรแกรมที่คุณเลือก ซึ่งรวมถึงความคิดเห็นสตริงหรือส่วนอื่น ๆ "ที่ไม่สามารถเรียกใช้งานได้"

ท้าทาย

• โปรแกรมของคุณอาจเฉพาะเจาะจงกับรุ่นที่เฉพาะเจาะจงหรือการใช้สภาพแวดล้อมคอมไพเลอร์ / ล่าม / รันไทม์ของภาษาของคุณ ถ้าเป็นเช่นนั้นโปรดระบุรายการ
• อนุญาตเฉพาะตัวเลือกคอมไพเลอร์ / ล่าม / รันไทม์มาตรฐาน คุณไม่สามารถส่งแฟล็กแปลก ๆ ไปยังคอมไพเลอร์ของคุณเพื่อรับผลลัพธ์เฉพาะ (เช่นการส่งแฟล็กเพื่อแปลงคำเตือนเป็นข้อผิดพลาด)
• หากภาษาการเขียนโปรแกรมของคุณต้องการการเข้ารหัสที่เฉพาะเจาะจง (เช่น UTF-8) สตริงของคุณจะต้องเข้ารหัสอย่างถูกต้อง (เช่นสตริงที่ล้มเหลวเพียงอย่างเดียวเนื่องจากข้อผิดพลาดในการถอดรหัสอักขระไม่ได้รับอนุญาต)
• ตัวละครทุกตัวที่คุณส่งจะต้องเป็นที่ยอมรับในโปรแกรมทางกฎหมาย นั่นคือคุณไม่สามารถใช้ตัวละครที่ถูกปฏิเสธได้เสมอ
• คอมไพเลอร์ / ล่าม / รันไทม์จะต้องให้ข้อผิดพลาดเมื่อได้รับรหัสที่มาใด ๆที่มีสตริงของคุณเป็นสตริงย่อย ข้อผิดพลาดไม่จำเป็นต้องเหมือนกันในทุกโปรแกรม - การฝังสตริงของคุณอาจทำให้เกิดข้อผิดพลาดทางไวยากรณ์ขณะที่อีกอันอาจทำให้เกิดข้อผิดพลาดรันไทม์

เกณฑ์การให้คะแนน

• สตริงผิดกฎหมายที่สั้นที่สุดสำหรับแต่ละภาษาชนะ
• คุณควรอธิบายว่าทำไมสายของคุณจึงผิดกฎหมาย (เหตุใดจึงไม่ปรากฏที่ใดก็ได้ในโปรแกรมทางกฎหมาย)
• ข้อพิพาทที่ไม่ถูกต้องในการแสดงความคิดเห็น โดยเฉพาะอย่างยิ่งคุณควรให้ลิงค์ไปยัง TIO หรือเทียบเท่าแสดงให้เห็นถึงโปรแกรมทางกฎหมาย (เช่นหนึ่งที่ไม่ได้ผลิตข้อผิดพลาดใด ๆ ) ที่มีซับสตริงที่เสนอ
• บางภาษา (เช่น Bash, Batch, Perl) อนุญาตให้ผนวกข้อมูลโดยพลการเข้ากับโปรแกรมโดยไม่มีผลต่อความถูกต้อง (เช่นใช้__DATA__ใน Perl) สำหรับภาษาดังกล่าวคุณสามารถส่งโซลูชันที่สามารถปรากฏได้เฉพาะในส่วนต่อท้าย ตรวจสอบให้แน่ใจว่าได้จดบันทึกสิ่งนั้นไว้ในคำตอบของคุณ (คำจำกัดความของ "ส่วนต่อท้าย" นี้ขึ้นอยู่กับภาษา แต่โดยทั่วไปหมายถึงข้อความใด ๆ หลังจากตัวแยกวิเคราะห์หยุดอ่านสคริปต์ทั้งหมด)

ตัวอย่าง

ใน Python ฉันอาจส่ง

x
"""
'''

แต่สิ่งนี้สามารถฝังลงในโปรแกรมที่มีขนาดใหญ่ขึ้น

"""
x
"""
'''
y
'''

ดังนั้นจึงไม่อนุญาต

การเปลี่ยนแปลง 2 ไบต์

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

ข้อผิดพลาดเป็นข้อผิดพลาดในการแยกวิเคราะห์เสมอและเหมือนกันเสมอ:

This shape is unpleasant.

พร้อมด้วยรหัสทางออก1

ลองออนไลน์!

Java, 4 ไบต์

;\u;

ลองออนไลน์!

นี่เป็นลำดับ Unicode escape ที่ไม่ถูกต้องและจะทำให้เกิดข้อผิดพลาดในคอมไพเลอร์

error: illegal unicode escape

COBOL (GNU) , 8 ไบต์

THEGAME

ก่อนอื่นให้ป้อนบรรทัดเพื่อป้องกันไม่ให้คุณใส่คำของฉันในบรรทัดความคิดเห็น

จากนั้นในอดีตโปรแกรมภาษาโคบอลถูกพิมพ์ลงบนแผ่นการเข้ารหัสคอมไพเลอร์อาศัยบรรทัดที่ จำกัด จำนวน 80 ตัวอักษรไม่มีความคิดเห็นแบบหลายบรรทัดและตัวอักษร 6 ตัวแรกเป็นความคิดเห็น (มักใช้เป็นหมายเลขบรรทัดที่สามารถแก้ไขได้) , AFAIK. ฉันเลือกTHEGAMที่จุดเริ่มต้นของบรรทัดถัดไป

จากนั้นเป็นสัญลักษณ์ที่ 7 ในสายใด ๆ จะยอมรับเฉพาะรายการที่ จำกัด มากของตัวอักษร: อวกาศ (ไม่มีผล) ดอกจัน (ความเห็นส่วนที่เหลือของบรรทัด) ยัติภังค์, Slash อาจจะมีคนอื่น ๆ Eแต่ไม่แน่นอน

ตัวอย่างเช่นข้อผิดพลาดที่ได้รับจาก GnuCobol คือ:

error: invalid indicator 'E' at column 7

ลองออนไลน์!

นอกจากนี้คุณเพิ่งแพ้เกม

JavaScript ขนาด 7 ไบต์

;*/\u)

หมายเหตุ newline ชั้นนำ

• \u) เป็นลำดับ Unicode escape ที่ไม่ถูกต้องและนี่คือสาเหตุที่สตริงนี้ไม่ถูกต้อง
• การเพิ่ม//ที่จุดเริ่มต้นจะยังคงไม่ทำงานเนื่องจากการขึ้นบรรทัดใหม่นำโดยปล่อยให้บรรทัดที่สองไม่ใส่เครื่องหมายข้อคิดเห็น
• เพิ่ม/*จะไม่ uncomment สตริงสมบูรณ์เนื่องจากการปิดที่*/ว่าเสร็จสมบูรณ์ออกจาก\u)การสัมผัส
• ตามที่ระบุโดย @tsh บรรทัดล่างสามารถกลายเป็น regex โดยมี/สตริงหลังดังนั้นโดยมี)ด้านหน้าของ\uเราสามารถมั่นใจได้ว่าตัวอักษร regex จะไม่ถูกต้องเสมอ
• ตามที่ระบุโดย @asgallant เราสามารถทำได้1||1(string)/เพื่อหลีกเลี่ยงการประเมิน regex กึ่งลำไส้ใหญ่ที่จุดเริ่มต้นของบรรทัดที่สองจะหยุดไม่ให้เกิดขึ้นโดยยกเลิกการแสดงออก1||1ก่อนที่จะ hits บรรทัดที่สองจึงบังคับให้ SyntaxError ;*กับ

ลองมัน!

clicky.onclick=a=>{console.clear();console.log(eval(before.value+"\n;*/\\u)"+after.value));}

textarea {
  font-family: monospace;
}

<button onclick="console.clear();">Clear console</button>
<br>
<textarea id=before placeholder="before string"></textarea>
<pre><code>
 */\u)</code></pre>
<textarea id=after placeholder="after string"></textarea>
<br>
<button id=clicky>Evaluate</button>

Python 10 ไบต์ (ไม่ใช่ cpython)

?"""?'''?

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

@feersum ในความคิดเห็นดูเหมือนจะแตกโปรแกรม cpython ใด ๆ บน Windows อย่างสมบูรณ์เท่าที่ฉันสามารถบอกได้โดยการเพิ่มอักขระ 0x1A ไปยังจุดเริ่มต้นของไฟล์ ดูเหมือนว่าอาจ (?) นี่เป็นเพราะวิธีการที่ตัวละครนี้ได้รับการจัดการโดยระบบปฏิบัติการซึ่งดูเหมือนว่าจะถูกแปลเป็น EOF เมื่อมันผ่าน stdin เนื่องจากมาตรฐาน DOS ดั้งเดิมบางตัว

ในความเป็นจริงอย่างมากนี่ไม่ใช่ปัญหาของงูหลาม แต่กับระบบปฏิบัติการ หากคุณสร้างสคริปต์ไพ ธ อนที่อ่านไฟล์และใช้บิวอินcompileในนั้นมันจะให้พฤติกรรมที่คาดหวังมากขึ้นของการขว้างปาข้อผิดพลาดทางไวยากรณ์ Pypy (ซึ่งอาจทำแค่ภายในนี้) ก็มีข้อผิดพลาดเช่นกัน

แก้ไข:

เนื่องจากความขยันของ @ feersum ในการหาวิธีที่ชัดเจนในการทำลายล่าม Python คำตอบนี้จึงไม่ถูกต้องสมบูรณ์สำหรับสภาพแวดล้อม cpython ทั่วไปเท่าที่ฉันสามารถบอกได้! (Python 2 และ 3 สำหรับทั้ง Windows และ Linux) ฉันยังเชื่อว่ารอยแตกเหล่านี้จะไม่ทำงานสำหรับ Pypy บนแพลตฟอร์มใด ๆ (การติดตั้ง Python อื่น ๆ ที่ฉันได้ทดสอบเท่านั้น)

C (เสียงดังกราว) 16 ไบต์

 */
#else
#else

ลองออนไลน์!

*/ปิด/*ความคิดเห็นใด ๆและพื้นที่ชั้นนำทำให้แน่ใจว่าเราไม่ได้เพิ่งเริ่มต้น ขึ้นบรรทัดใหม่ปิด//ความคิดเห็นและแบ่งสตริงตัวอักษรใด ๆ จากนั้นเราก็ทำให้เกิดการ#else without #ifหรือ#else after #elseข้อผิดพลาด (โดยไม่คำนึงถึงวิธีการหลาย#if 0s เราอาจจะภายใน)

Pyth, 6 ไบต์

¡¡$¡"¡

¡เป็นอักขระที่ไม่ได้ดำเนินการซึ่งหมายความว่าหากตัวแยกวิเคราะห์ Pyth เคยประเมินค่ามันจะเกิดข้อผิดพลาดด้วย PythParseError รหัสทำให้แน่ใจว่าสิ่งนี้จะเกิดขึ้นกับหนึ่งใน¡s

มีสามวิธีไบต์สามารถจะนำเสนอในโปรแกรม Pyth และไม่สามารถแยกวิเคราะห์เป็น: ในสตริงตัวอักษร ( "หรือ."ซึ่งมีการแยกวิเคราะห์เท่า) ในหลามตัวอักษร ( $) \และทันทีหลังจากที่

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

$ฝังโค้ดภายใน$s ลงในโค้ด Python ที่คอมไพล์แล้วโดยตรง ฉันไม่มีข้อสมมติฐานเกี่ยวกับสิ่งที่อาจเกิดขึ้นที่นั่น

หากโปรแกรมเข้าถึงรหัสนี้ใน$บริบทโปรแกรมจะสิ้นสุดที่$และ¡หลังจากนั้นโปรแกรมจะทำการแยกวิเคราะห์ข้อผิดพลาด ตัวอักษร Python ของ Pyth จะลงท้ายด้วยตัวถัดไป$เสมอไม่ว่ารหัส Python นั้นจะทำอะไร

หากโปรแกรมเริ่มต้นใน"บริบทโปรแกรม"จะทำการจบการทำงานของสตริงและโปรแกรมสุดท้าย¡จะทำการแยกวิเคราะห์ข้อผิดพลาด

Ada - 2 ไบต์

ฉันคิดว่าสิ่งนี้ควรใช้งานได้:

_

นั่นคือบรรทัดใหม่ - ขีดล่าง ขึ้นบรรทัดใหม่ยุติความคิดเห็นและไม่อนุญาตในสตริง ขีดเส้นใต้ไม่สามารถติดตามช่องว่าง มันเคยได้รับอนุญาตหลังจากตัวอักษรและตัวเลขเท่านั้น แต่การแนะนำ Unicode ทำให้สิ่งต่าง ๆ มีความซับซ้อน

x86 รหัสเครื่อง 32 บิต, 11 ไบต์ (และหลักฐานในอนาคต 64 บิต)

90 90 90 90 90 90 90 90 90 0f 0b

นี่คือtimes 9 nop/ ud2. เป็นพื้นเลื่อน NOPดังนั้นจึงยังคงทำงานเป็น 0 หรือมากกว่าnopนั้นแล้วud2ยกข้อยกเว้นโดยไม่คำนึงถึงจำนวน0x90ไบต์ที่ถูกใช้เป็นตัวถูกดำเนินการไปยัง opcode ก่อนหน้านี้ คำแนะนำแบบไบต์เดียวอื่น ๆ (เช่นtimes 9 xchg eax, ecx) จะใช้ได้เช่นกัน

x86 รหัสเครื่อง 64 บิต, 10 ไบต์ (CPU ปัจจุบัน)

มีคำแนะนำที่ผิดกฎหมาย 1 ไบต์ในโหมด 64 บิตจนกว่าส่วนขยาย ISA ในอนาคตจะแสดงคำนำหน้าเหล่านั้นเป็นส่วนนำหน้าหรือบางส่วนของหลายไบต์ opcodes ในโหมด 64 บิตเท่านั้นแยกจากความหมายในโหมด 32 บิต 0x0eอยู่push csในโหมด 32 บิต แต่ผิดกฎหมายในซีพียูปัจจุบัน (ทดสอบกับ Intel Skylake) เป็น 64 บิต

0e 0e 0e 0e 0e 0e 0e 0e 0e 0e

การตีความกฎสำหรับรหัสเครื่องที่ปฏิบัติการได้ :

• ไบต์ไม่สามารถข้ามไปได้ (เช่นข้อ จำกัด "ไม่แจง") เนื่องจาก CPU ไม่ยกข้อยกเว้นจนกว่าพวกเขาจะพยายามถอดรหัส / ดำเนินการ (ไม่ใช่แบบพิเศษ)

• วิธีการที่ผิดกฎหมายทำให้เกิดข้อยกเว้นเสมอตัวอย่างเช่นข้อยกเว้นการสอนที่ผิดกฎหมาย (โปรแกรมจริงสามารถตรวจจับสิ่งนั้นได้ด้วยตัวจัดการข้อยกเว้นบนโลหะเปลือยหรือติดตั้งตัวจัดการสัญญาณ OS แต่ฉันคิดว่านี่เป็นสิ่งที่จับวิญญาณของความท้าทาย)

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

ฉันคิดว่าคำสั่งสามารถใช้งานได้สูงสุด 9 ไบต์ของสิ่งที่กำหนดเอง: SIB ไบต์, disp32 และ imm32 เช่น 2 ไบต์แรกของคำสั่งนี้สามารถใช้งาน 8 NOPs และ ud2 ได้ แต่ไม่ใช่ 9

c7 84 4b 00 04 00 00 78 56 34 12        mov dword [rbx+rcx*2+0x400],0x12345678

ไม่สามารถเอาชนะ 9 nops:

    db 0xc7, 0x84   ; opcode + mod/rm byte: consumes 9 bytes (SIB + disp32 + imm32)
    times 9 nop          ; 1-byte xchg eax, ecx or whatever works, too
    ud2
  ----
   b:   c7 84 90 90 90 90 90 90 90 90 90        mov    DWORD PTR [rax+rdx*4-0x6f6f6f70],0x90909090
  16:   0f 0b                   ud2    

โหมด 64 บิต:

 c7 84 0e 0e 0e 0e 0e 0e 0e 0e 0e        mov    DWORD PTR [rsi+rcx*1+0xe0e0e0e],0xe0e0e0e
 0e                      (bad)  

แต่ไบต์สำหรับ 8 NOPs + ud2 (หรือtimes 9 db 0x0e) สามารถปรากฏเป็นส่วนหนึ่งของ insns อื่น ๆ :

    db 0xc7, 0x84   ; defender's opcode + mod/rm that consumes 9 bytes

    times 8 nop          ; attacker code
    ud2

    times 10 nop    ;; defenders's padding to be consumed by the 0b opcode (2nd half of ud2)
----
  18:   c7 84 90 90 90 90 90 90 90 90 0f        mov    DWORD PTR [rax+rdx*4-0x6f6f6f70],0xf909090
  23:   0b 90 90 90 90 90       or     edx,DWORD PTR [rax-0x6f6f6f70]
  29:   90                      nop
  2a:   90                      nop
  ...

C #, 16 ไบต์

*/"
#endif<#@#>

ทำงานได้เพราะ:

• // ความคิดเห็นจะไม่ทำงานเนื่องจากบรรทัดใหม่
• /* ความคิดเห็นจะไม่ทำงานเพราะ */
• คุณไม่สามารถมีค่าคงที่ในรหัสเพียงอย่างเดียว
• การเพิ่ม#if falseไปยังจุดเริ่มต้นจะไม่ทำงานเนื่องจาก#endif
• "ปิดสตริงตัวอักษร
• <#@#>เป็นคำสั่งนิรนามจึงล้มเหลวสำหรับแม่แบบ T4
• การขึ้นบรรทัดใหม่/จะเป็นการหลอกลวงเมื่อเริ่มต้นจะไม่เป็นการหลอกลวง*/

แต่ละรูปแบบล้มเหลวด้วยข้อผิดพลาดในการรวบรวม

APLและMATLและFortranขนาด 3 ไบต์

'

Newline, Quote, Newline จะพ่นข้อผิดพลาดเสมอเนื่องจากไม่มีความคิดเห็นบล็อก:

• APL: unbalanced quotes
• MATL: string literal not closed
• Fortran: Invalid character in name

Literary Haskell , 15 ไบต์

การซ่อมแซมความพยายามที่ถูกลบโดย nimi

\end{code}
5
>

ลองออนไลน์!

ความพยายามดั้งเดิมของ nimi คือสองบรรทัดสุดท้ายโดยยึดตาม Literate Haskell ที่ไม่อนุญาตให้ใช้>รหัสการรู้หนังสือสไตล์ในบรรทัดข้างเคียงกับบรรทัดความคิดเห็นที่รู้ ( 5ที่นี่) ล้มเหลวเนื่องจากสามารถฝังในความคิดเห็นในรูปแบบการเขียนสำรอง ("LaTeX")

\begin{code}
{-
5
>
-}
\end{code}

อย่างไรก็ตาม\begin{code}สไตล์ของ Literate Haskell ไม่ได้ซ้อนอยู่ทั้งในตัวเองและใน{- -}ความคิดเห็นหลายบรรทัดดังนั้นโดยการวางบรรทัด\end{code}ก่อนหน้าบรรทัดด้วย5วิธีแก้ปัญหานั้นจะล้มเหลวและฉันไม่เห็นอีกแบบหนึ่ง

ฟรี Pascal ขนาด 18 ไบต์

*)}{$else}{$else}

ก่อนปิดความคิดเห็นที่เป็นไปได้ทั้งหมดจากนั้นจัดการคอมไพล์ตามเงื่อนไข

โปรดแสดงความคิดเห็นที่นี่ถ้าฉันลืมบางสิ่งบางอย่าง

พลเรือจัตวา 64 พื้นฐาน 2 ไบต์

B

(นั่นคือบรรทัดใหม่ตามด้วยตัวอักษร "B")

บรรทัดใด ๆ ในโปรแกรม Commodore 64 จะต้องเริ่มต้นด้วยหมายเลขบรรทัดหรือคีย์เวิร์ด BASIC และโปรแกรมที่เก็บไว้จะอนุญาตเฉพาะหมายเลขบรรทัดเท่านั้น ไม่มีคำหลักที่ขึ้นต้นด้วย "B" (หรือ "H", "J", "K", "Q", "X", "Y" หรือ "Z")

Brain-Hack (รูปแบบของBrain-Flak ) ขนาด3 2 ไบต์

ขอบคุณWheat Wizardสำหรับการชี้ให้เห็นว่า Brain-Hack ไม่สนับสนุนความคิดเห็นช่วยฉันไบต์

(}

ลองออนไลน์!

CJam , 7 ไบต์

"e#"
:"

ลองออนไลน์!

VBA, 2 ไบต์

Linefeed ตามด้วยขีดล่าง - _ฟังก์ชั่นเป็นตัวต่อเนื่องของสายอักขระใน VBA และเนื่องจากไม่มีสิ่งใดในบรรทัดตรงไปทางซ้ายหรือด้านบนของความต่อเนื่องของบรรทัดควบคู่ไปกับการขาดความคิดเห็นหลายบรรทัดของ VBA หมายความว่า ข้อผิดพลาดเวลาCompile Error: Invalid character

_

SmileBASIC ขนาด 2 ไบต์

!

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

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

มีอักขระทางเลือกมากมายที่สามารถใช้ที่นี่ได้ดังนั้นฉันคิดว่ามันน่าสนใจกว่าที่จะแสดงรายการอักขระที่สามารถใช้ได้

@คือจุดเริ่มต้นของป้ายกำกับตัวอย่างเช่น@DATA; (อาจเป็นส่วนหนึ่งของการแสดงออก(X)=1ที่ได้รับอนุญาตด้วยเหตุผลบางอย่าง; จดหมายหรือ_อาจจะเป็นชื่อตัวแปรX=1, การเรียกใช้ฟังก์ชันLOCATE 10,2หรือคำหลักWHILE 1; 'คือความคิดเห็น; และสั้นสำหรับ?PRINT

INTERCAL 12 ไบต์

DOTRYAGAINDO

พยายามที่จะถอดรหัสออนไลน์!

วิธีการของข้อผิดพลาดทางไวยากรณ์ของ INTERCAL นั้นค่อนข้างพิเศษ โดยพื้นฐานแล้วคำสั่งที่ไม่ถูกต้องจะไม่เกิดข้อผิดพลาดยกเว้นในกรณีที่โปรแกรมพยายามดำเนินการ ในความเป็นจริงไวยากรณ์สำนวนสำหรับความคิดเห็นคือการเริ่มต้นพวกเขาด้วยซึ่งจริงๆเพียงแค่เริ่มต้นคำสั่งบอกว่ามันไม่ได้ที่จะดำเนินการและจากนั้นเริ่มต้นด้วยตัวอักษรPLEASE NOTE EหากรหัสของคุณมีDODOที่อยู่ตรงกลางของมันคุณสามารถย่อหน้าDOABSTAINFROM(1)(1)และกลัดคำสั่งที่ถูกต้องใด ๆ ลงบนปลายและคุณจะปรับถ้ามันDODODOคุณสามารถดำเนินการเพียงแค่โค้งรอบ ๆ (1)DON'TDODODOCOMEFROM(1)มันเป็น แม้ว่า INTERCAL จะไม่มีไวยากรณ์ตามตัวอักษรของสตริงสำหรับการหลบหนี แต่ก็ไม่มีวิธีที่จะใช้ข้อผิดพลาดทางไวยากรณ์เพื่อสร้างสตริงที่ผิดกฎหมายได้แม้จะหมดทุกหมายเลขบรรทัดที่เป็นไปได้ด้วย(1)DO(2)DO...(65535)DODODOเนื่องจากดูเหมือนว่าเป็นไปได้ที่จะมีหมายเลขบรรทัดซ้ำกับCOME FROMการทำงานกับหมายเลขใด ๆ

TRY AGAINเพื่อให้เป็นสตริงที่ผิดกฎหมายเราจริงต้องใช้คำสั่งที่ถูกต้องสมบูรณ์: แม้ว่าจะไม่ได้รับการดำเนินการมันจะต้องเป็นคำสั่งสุดท้ายในโปรแกรมอย่างเคร่งครัดหากอยู่ในโปรแกรมเลย 12 ไบต์คือความรู้ของฉันสตริงที่สั้นที่สุดที่ผิดกฎหมายสามารถใช้TRY AGAINงานได้เนื่องจากมันต้องรับประกันว่าจะมีคำสั่งหลังจากนั้น (ดำเนินการหรือไม่) ดังนั้นจึงDOTRYAGAINเป็นเพียงรหัสปกติและต้องการให้แน่ใจว่าคำสั่งทั้งหมดนั้น เป็นที่แน่นอนTRY AGAINจึงTRYAGAINDOไม่ทำงานเพราะมันสามารถจะกลายเป็นละเว้นไวยากรณ์ผิดพลาดปกติหรือDON'TRYAGAINDOGIVEUP PLEASE DO NOT TRY TO USE TRYAGAINDO NOT THAT IT WOULD WORKไม่ว่าสิ่งที่คุณใส่ที่ด้านข้างของทั้งDOTRYAGAINDOคุณจะเกิดข้อผิดพลาดอย่างใดอย่างหนึ่งICL993I I GAVE UP LONG AGO, หรือICL079I PROGRAMMER IS INSUFFICIENTLY POLITEICL099I PROGRAMMER IS OVERLY POLITE

AWK , 4 ไบต์

/

ลองออนไลน์!

เนื่องจากAWKไม่ได้มีวิธีการที่จะทำความเห็นหลายคู่สายที่ต้องใช้เวลา 2 บรรทัดใหม่ก่อนและหลังจาก 1 /เพื่อป้องกันไม่ให้แสดงความคิดเห็นออกหรือเปลี่ยนนี้ใน regex e 1/กรัมเพิ่ม ข้อความที่พบบ่อยที่สุดคือ `บรรทัดใหม่หรือจุดสิ้นสุดที่ไม่คาดคิด

ด้วยรอยร้าวก่อนหน้า

Fortran, 14 ไบต์

end program
e

ไม่มีความคิดเห็นหลายบรรทัดหรือคำสั่ง preprocessor ใน Fortran

JavaScript (Node.js)ขนาด9 8 ไบต์

`*/
\u`~

ลองออนไลน์!

ฉันคิดว่านี่น่าจะผิดกฎหมายพอสมควร

JS ก่อนหน้าพยายามในคำตอบอื่น ๆ

;*/\ยู)

โดย @Cows นักต้มตุ๋น

ในฐานะที่เป็นคำตอบ ES5 นี้ควรจะถูกต้อง แต่ใน ES6 ห่อรหัสด้วยคู่ของ backticks ทำลายนี้ ดังนั้นคำตอบของ ES6 ที่ถูกต้องจะต้องมี backticks

`
`* /}" `\ U!

โดย @iovoid

นี่เป็นรุ่นปรับปรุงที่เกี่ยวข้องกับ backticks อย่างไรก็ตามเดียว/หลังจากรหัสแบ่งนี้ (มันจะกลายเป็นแม่แบบตัวอักษรที่ถูกคูณด้วย regex ที่ไร้ประโยชน์ แต่ที่ถูกต้อง syntactically.) @Neil ทำข้อเสนอแนะว่าการเปลี่ยนไป! )ในทางทฤษฎีควรใช้งานได้เนื่องจากการเพิ่ม/ในตอนท้ายไม่สามารถใช้งานได้อีกต่อไป (เนื่องจาก regex ที่มีรูปแบบไม่ถูกต้อง)

การอธิบาย

`*/
\u`~

สิ่งนี้เป็นสิ่งผิดกฎหมายและยังปิดกั้นการเสนอราคาเดี่ยวและคู่ทั้งหมดเนื่องจากราคาไม่สามารถครอบคลุมข้ามบรรทัดโดยไม่มีเครื่องหมาย\ที่ท้ายบรรทัด

//`*/
\u`~

และ

/*`*/
\u`~

บล็อกความคิดเห็นโดยแนะนำ ลำดับการหลบหนีที่ผิดกฎหมาย

``*/
\u`~

บล็อก backtick เริ่มต้นด้วยการแนะนำ RegExp ที่ไม่สิ้นสุด

console.log`*/
\u`~

บล็อกตัวอักษรเทมเพลตที่ติดแท็กโดยแนะนำตัวดำเนินการที่คาดหวังระหว่างสอง backticks

Rockstar , 4 5 ไบต์

ข้ามออก 4 ยังคงเป็น 4 :(

)
"""

Rockstar เป็นภาษาที่พูดมาก ...
ในขณะที่"สามารถใช้ในการกำหนดสตริงเช่นPut "Hello" into myVarความรู้ของฉันไม่มีวิธีสำหรับ 3 คำพูดที่จะปรากฏอยู่นอกความคิดเห็นและ Paren ปิดมั่นใจว่าจะไม่เกิดขึ้นอย่างใดอย่างหนึ่ง (ความเห็นใน Rockstar จะอยู่ในวงเล็บเช่น นี้).

Rockstar ยังมีไวยากรณ์ตัวอักษรบทกวีโดยที่เครื่องหมายวรรคตอนจะถูกละเว้นดังนั้นการขึ้นบรรทัดใหม่ทำให้แน่ใจว่าการเสนอราคา 3 รายการเป็นการเริ่มต้นของบรรทัดรหัสซึ่งควรจะไม่ถูกต้องเสมอ

Powershell, 10 8 12 14 13 14 16 ไบต์

^{ต้องขอบคุณ -2 by Mazzy เพื่อหาวิธีที่ดีกว่าในการทำลายมัน
+4 -1 bytes ขอบคุณ IsItGreyOrGray}

$#>
'@';
"@";
@=

ฉันหวังว่างานนี้ 'และ"เพื่อป้องกันเครื่องหมายคำพูด#>เพื่อแยกความคิดเห็นบล็อกบรรทัดใหม่เพื่อหยุดความคิดเห็นบรรทัดเดียวทั้งคู่'@และ"@เพื่อจับรูปแบบของสตริงอื่นแล้วเริ่มอาร์เรย์ที่ไม่เหมาะสมเพื่อโยนข้อผิดพลาดทางไวยากรณ์

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

Runic Enchantments ขนาด 3 ไบต์

Ṷ

หนึ่งในหลากหลายรูปแบบที่เป็นไปได้

ลองออนไลน์!

Runic ใช้ unicode รวมอักขระใน " Mปรับเปลี่ยนพฤติกรรมของC" (โดยที่Cคำสั่ง) ดังนั้นจึงไม่มีตัวดัดแปลงสองตัวที่ได้รับอนุญาตให้แก้ไขคำสั่งเดียวกันและ parser จะโยนข้อผิดพลาดหากพบเหตุการณ์ดังกล่าว

ในทำนองเดียวกันคำสั่งบางอย่างที่เปลี่ยนเส้นทาง IP ไม่สามารถแก้ไขได้ในทุกวิถีทางเนื่องจากการมีอยู่ของทิศทางการปรับเปลี่ยนอักขระตัวแก้ไข (และทั้งสองในเซลล์เดียวกันไม่มีเหตุผล)

ไม่มีวิธีที่จะหลบหนีหรือตามตัวอักษรสตริงเพื่อให้ถูกต้อง ลิงก์ Tio มี;ข้อผิดพลาด "ไม่ต้องปิด" ที่มีลำดับความสำคัญสูงกว่า

TI-Basic (83 + / 84 + / SE, 24500 ไบต์)

A

(24500 ครั้ง)

TI (-83 + / 84 + / SE) ขั้นพื้นฐานไม่ตรวจสอบไวยากรณ์เฉพาะในงบที่จะถึงดังนั้นแม้ 5000 งบในแถวที่สามารถข้ามกับEnd Returnในทางตรงกันข้ามสิ่งนี้ไม่สามารถพอดีกับ RAM ของ TI-83 + / 84 + / SE ดังนั้นจึงไม่มีโปรแกรมใดสามารถมีสตริงนี้ได้ เป็นคนหัวโบราณเล็กน้อยกับจำนวนตัวละครที่นี่

TI-83 ดั้งเดิมมี RAM 27,000 ไบต์ดังนั้นคุณจะต้องใช้ 27500 As ในกรณีนั้น

TI-Basic (89 / Ti / 92 + / V200, 3 ไบต์)

"

ขึ้นบรรทัดใหม่เสนอราคาขึ้นบรรทัดใหม่ ขึ้นบรรทัดใหม่ปิดความคิดเห็นใด ๆ (และไม่อนุญาตให้ฝังอักขระที่ผิดกฎหมายในสตริงเนื่องจากไม่อนุญาตให้มีค่าคงที่สตริงหลายบรรทัดของ AFAIK) บรรทัดใหม่อื่นไม่อนุญาตให้ปิดสตริงและเครื่องหมายคำพูดแสดงข้อผิดพลาดทางไวยากรณ์

คุณสามารถไปถึง 2 ไบต์ด้วย

±

โดยไม่มีการขึ้นบรรทัดใหม่ แต่ฉันไม่แน่ใจว่าสิ่งนี้นับว่า±ถูกต้องเพราะมีค่าคงที่ในสตริงเท่านั้น

ไป 6 ไบต์

*/```

พยายามที่จะถอดรหัสออนไลน์!

สำเนียงหลุมฝังศพ (`) ทำเครื่องหมายสตริงตัวอักษรดิบซึ่งภายในตัวละครทั้งหมดยกเว้น` รวมถึงการขึ้นบรรทัดใหม่และแบ็กสแลชจะถูกตีความอย่างแท้จริงเป็นส่วนหนึ่งของสตริง สามในแถวนั้นเป็นแกนกลาง: ตัวอักษรสตริงที่อยู่ติดกันนั้นไม่ถูกต้องและ `` ปิดสตริงเสมอ'ดังนั้นจึงไม่มีทางที่จะเข้าใจได้ ฉันต้องใช้อีก 3 ไบต์สำหรับการป้องกันการหลบเลี่ยงบรรทัดใหม่ดังนั้นเราจึงไม่สามารถอยู่ในความคิดเห็นบรรทัดเดียวหรือสตริงที่ยกมาตามปกติและ * / ดังนั้นเราจึงไม่สามารถอยู่ในความคิดเห็นแบบหลายบรรทัด

SILOS 4 ไบต์

ไซโลมีการแข่งขัน \ o /

x+

SILOS ทำงานบน interpreter / compiler สองตัว ก่อนที่จะดำเนินการ "คอมไพเลอร์" พยายามที่จะลดความซับซ้อนของแหล่งที่มาลงในอาร์เรย์ที่อธิบายถึง sourc แต่ละบรรทัดจะได้รับการปฏิบัติแยกต่างหาก x + a เป็นผู้ดำเนินการที่ได้รับมอบหมายซึ่งจะเพิ่ม ea ให้กับค่าของ x และเก็บไว้ใน x อย่างไรก็ตาม "คอมไพเลอร์" จะแตก ดังนั้นเราจึงใช้สายนี้และเพิ่มบรรทัดใหม่ก่อนและหลังตรวจสอบให้แน่ใจว่ามันอยู่ในบรรทัดของตัวเองและแบ่งคอมไพเลอร์

ลองออนไลน์!

AutoHotkey 5 ไบต์

`เป็นตัวละครที่หลบหนี คุณสามารถยกเว้น "เมื่อกำหนดให้ตัวแปรเท่านั้น

\ n * / ป้องกันไม่ให้มีการใส่ความคิดเห็นหรือมอบหมายให้กับตัวแปร

*/`"

JavaScript, 11 ตัวอักษร

`
`*/}'"`\u)

backticks ตรวจสอบให้แน่ใจว่าฆ่าสตริงเทมเพลตเครื่องหมายอัญประกาศบรรทัดใหม่จะไม่แสดงความคิดเห็นบรรทัดจุดสิ้นสุดของความคิดเห็นหลีกเลี่ยงความคิดเห็นที่ถูกบล็อกและ backtick สุดท้ายและหลบเลี่ยง (ด้วย! เพื่อหลีกเลี่ยงการต่อท้ายหมายเลข) พยายามเริ่มไม่ถูกต้อง เชือก

ลองออนไลน์!