โปรแกรมกระดานหมากรุกเป็นโปรแกรมที่ค่าลำดับของตัวละครแต่ละตัวจะเปลี่ยนจากคู่ไปเป็นคี่โดยไม่รวมตัวยุติบรรทัด (ซึ่งอาจเป็นจุดสิ้นสุดบรรทัดมาตรฐาน)

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

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

โปรแกรมของคุณจะต้องตรงตามเกณฑ์เหล่านี้

ตัวอย่างของโปรแกรมที่ถูกต้อง

G
`e
@u^
5r{B

^
cB
+$C
VA01

กฎระเบียบ

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

Stax , 26 ไบต์

L
Y$
i:-
 {2%
*OFyF
%vi =*

เรียกใช้กรณีทดสอบออนไลน์

ฉันต้องแนะนำตัวละครขยะ 3 ตัว iเป็น no-op เมื่ออยู่นอกการสร้างลูปทั้งหมด อยู่เสมอไม่มี Oติด 1 ในด้านบนสุดของสแต็ก แต่ไม่มีการใช้ค่าในโปรแกรม

LY      move input lines into a list and store in Y register
$       flatten
i       no-op
:-      get pairwise differences
{2%*OF  foreach delta, mod by 2, and multiply, then tuck a 1 under the top of stack
yF      foreach line in original input do...
  %v    subtract 1 from length of line
  i=    is equal to iteration index?
  *     multiply

เรียกใช้อันนี้

C (gcc), 189 ไบต์

j
;l
;b;
d;f␉
(char
␉*␉t) 
{b=*␉t%
2;for␉(␉
j=d=0;j=j
+ 1,␉l=j+ 
1,␉*␉t; ) {
for␉(;l=l- 1
 ;t=t+ 1 )b= 
!b␉,␉d=d+ !(␉*
␉t␉*␉(␉*␉t- 10)
*␉(␉*␉t%2-b) ) ;
d␉|=*␉t- 10;t=t+ 
1 ; }b= !d; } ␉ ␉ 

ลองออนไลน์!

␉แสดงถึงอักขระแท็บ (ฉันขอโทษ) โปรดทราบว่ามีช่องว่าง / แท็บต่อท้ายหลายแห่ง (ฉันเสียใจยิ่งขึ้น) ต้นฉบับพร้อมแท็บครบถ้วนจะดูได้ดีที่สุดในกลุ่มด้วย:set tabstop=1 (คำไม่สามารถอธิบายได้ว่าฉันขอโทษ)

มันเป็นฟังก์ชั่น (เรียกว่าfซึ่งไม่ชัดเจนในทันทีจากการเหลือบมองมัน) ซึ่งรับค่าสตริงเป็นอาร์กิวเมนต์และส่งกลับค่าใดค่าหนึ่ง0หรือ1หรือ

ฉันทำได้ลดสิ่งนี้ได้อย่างน้อยหนึ่งเส้นและอาจมากกว่าสองบรรทัดขึ้นไป แต่โปรดสังเกตว่ามันเพิ่มความยุ่งเหยิงและความพยายามต่ำลงเรื่อย ๆ ซึ่งส่วนใหญ่เป็นเพราะการเขียนโค้ดที่แย่มาก (แม้แต่มาตรฐาน PPCG) ทำให้ฉันรู้สึกเหมือนคนเลว และฉันต้องการหยุดโดยเร็วที่สุด

ความคิดพื้นฐานที่นี่คือการหลีกเลี่ยงการก่อสร้างที่ต้องทำลายรูปแบบ ( ++, +=, returnฯลฯ ) อย่างน่าอัศจรรย์คำหลักที่สำคัญชอบfor, charและwhile(ซึ่งผมไม่ได้จบลงโดยใช้) เกิดขึ้นเพื่อให้พอดีกับกฎสลับเท่าเทียมกัน จากนั้นฉันใช้ช่องว่าง (แม้แต่พาริตี้) และแท็บ (พาริตีคี่) เป็นช่องว่างภายในเพื่อให้ส่วนที่เหลือสอดคล้องกับกฎ

Haskell , 1080 1033 ไบต์

;
f=
 g 
ij=f
a =hi
hi = g
hij= ij
g ' ' =0
g '"' =0;
 g '$' =0;
 g '&' =0-0
g '(' =0-0-0
g '*' =0-0-0;
 g ',' =0-0-0;
 g '.' =0-0-0-0
g '0' =0-0-0-0-0
g '2' =0-0-0-0-0;
 g '4' =0-0-0-0-0;
 g '6' =0; g '8' =0
g ':' =0; g '<' =0-0
g '>' =0; g '@' =0-0;
 g 'B' =0; g 'D' =0-0;
 g 'F' =0; g 'H' =0-0-0
g 'J' =0; g 'L' =0-0-0-0
g 'N' =0; g 'P' =0-0-0-0;
 g 'R' =0; g 'T' =0-0-0-0;
 g 'V' =0; g 'X' =0-0-0-0-0
g 'Z' =0; g '^' =0; g '`' =0
g 'b' =0; g 'd' =0; g 'f' =0;
 g 'h' =0; g 'j' =0; g 'l' =0;
 g 'n' =0; g 'p' =0; g 'r' =0-0
g 't' =0; g 'v' =0; g 'x' =0-0-0
g 'z' =0; g '\92' =0-0; g '|' =0;
 g '~' =0; g y = 1 ;z=0; i(-0)z=z;
 i m('\10':y ) ="y"; ; ; ; ; ; ; ; 
i m(mnmnmnmnm:y ) = i(m - 1 ) y ; ; 
i k m ="y"; ; k i [ ] =01<1010101010;
 k m('\10':y ) = k(m + 1 )(i m y ) ; ;
 k m y =01>10; m o = k 1$'\10':o ; ; ; 
o i('\10':y ) = o i y ; ; ; ; ; ; ; ; ; 
o i(k:y )|g k<i = o(1 - i ) y ; ; ; ; ; ;
 o i(k:y )|g k>i = o(1 - i ) y ; ; ; ; ; ;
 o i [ ] =01<10; o i y =01>10;v=01>10101010
s y|o 1 y = m y|o(-0) y = m y ; s y =v; ; ; 

ลองออนไลน์!

คำอธิบาย

นี่เป็นงานที่น่าสนใจสำหรับ Haskell

ความเท่าเทียมกัน

ในการเริ่มต้นเราต้องการวิธีการพิจารณาว่าตัวละครมีจุดรหัสคี่หรือคู่ วิธีปกติที่อาจทำเช่นนี้คือการได้รับรหัสจุดและดัดแปลงโดย 2 อย่างไรก็ตามในฐานะที่อาจจะตระหนักถึงการได้รับรหัสจุดของตัวละครที่ต้องการนำเข้าซึ่งเนื่องจากข้อ จำกัด แหล่งที่มาหมายความว่ามันไม่สามารถ ใช้ Haskeller ที่มีประสบการณ์มากกว่าจะคิดว่าใช้การเรียกซ้ำ Charเป็นส่วนหนึ่งของEnumtypeclass เพื่อให้เราสามารถรับรุ่นก่อนหน้าและผู้สืบทอด อย่างไรก็ตามpredและsuccยังมีทั้งที่ใช้ไม่ได้เพราะไม่ได้สลับพาริตีไบต์

ดังนั้นสิ่งนี้ทำให้เราติดค้างอยู่ค่อนข้างมากเราไม่สามารถจัดการกับตัวอักษรได้ วิธีแก้ปัญหานี้คือการฮาร์ดโค้ดทุกอย่าง เราสามารถเป็นตัวแทน (ส่วนใหญ่) แม้กระทั่งตัวอักษรเป็นตัวอักษรอัตราต่อรองที่เรามีปัญหาเพราะ'เป็นเลขคี่ดังนั้นจึงไม่สามารถอยู่ข้างตัวถ่านทำให้ตัวอักษรไม่สามารถแสดงตัวอักษรแปลก ๆ ได้ ดังนั้นเราจึงยากรหัสไบต์ทั้งหมดแล้วเพิ่มการจับทั้งหมดสำหรับไบต์คี่ในตอนท้าย

ปัญหาไบต์

คุณอาจสังเกตเห็นว่ามีบางไบต์ที่ไม่สามารถสร้างตัวอักษรได้โดยการใส่คำพูดในเครื่องหมายคำพูดเดี่ยว พวกเขาเป็น unprintables, \การขึ้นบรรทัดใหม่และ เราไม่จำเป็นต้องกังวลเกี่ยวกับ unprintables ตั้งแต่ตราบใดที่เราไม่ได้ใช้สิ่งเหล่านี้เราไม่จำเป็นต้องตรวจสอบ ในความเป็นจริงเรายังคงสามารถใช้ unprintables แปลก ๆ เช่นแท็บฉันเพียงแค่ไม่จำเป็นต้อง ขึ้นบรรทัดใหม่ได้อย่างมากเพราะมันจะถูกตัดออกจากโปรแกรมต่อไป (เราอาจรวมบรรทัดใหม่เนื่องจากเป็นจุดรหัสค่อนข้างสะดวก แต่เราไม่จำเป็นต้อง) ใบ\นี้ตอนนี้\มี codepoint 92 ซึ่งสะดวกเป็นเลขคี่ตามด้วยหมายเลขคู่ดังนั้น\92สลับระหว่าง evens และอัตราต่อรองดังนั้นตัวอักษร'\92'ถูกต้องสมบูรณ์ '\10'ต่อมาเมื่อเราทำจำเป็นต้องหมายถึงการขึ้นบรรทัดใหม่เราจะสังเกตเห็นว่ามันโชคดีที่มีคุณสมบัติเดียวกันนี้

ปัญหาระยะห่าง

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

;
f=
 g 
ij=f
a =hi
hi = g
hij= ij

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

Hardcoder

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

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

ฟังก์ชันสำเร็จรูป

เมื่อเสร็จสิ้นการ hardcoder มันเป็นไปอย่างราบรื่นในตอนท้ายของโปรแกรม เราจำเป็นต้องสร้างฟังก์ชั่นง่ายๆ ครั้งแรกที่ฉันสร้างรุ่นของที่เรียกว่า drop จะแตกต่างจากในว่าถ้าเราพยายามที่จะลดลงที่ผ่านมาท้ายของสตริงก็แค่ผลตอบแทน จะแตกต่างจากการดรอปในกรณีที่มันพยายามที่จะดรอปขึ้นบรรทัดใหม่มันจะกลับมาสิ่งเหล่านี้จะเป็นประโยชน์เพราะต่อมาเมื่อเราตรวจสอบว่าโปรแกรมเป็นรูปสามเหลี่ยมนี้จะช่วยให้เรากลับมาเมื่อ บรรทัดสิ้นสุดก่อนiidrop"y"i"y"False

kk$n$$s$$s$True$n$k$n+1$False

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

oต่อไปเรามี oใช้ตัวเลขและสตริง มันเป็นตัวกำหนดว่าสตริงไบต์ (ละเว้นบรรทัดใหม่) สลับในความเท่าเทียมกัน (ใช้ของเราg) เริ่มต้นด้วยหมายเลขอินพุต

สุดท้ายเรามีsซึ่งทำงานoกับทั้ง1และหากประสบความสำเร็จอย่างใดอย่างหนึ่งก็จะคล้อยตาม0 mหากมันล้มเหลวทั้งคู่ก็จะกลับFalseมา นี่คือฟังก์ชั่นที่เราต้องการ มันเป็นตัวกำหนดว่าการป้อนข้อมูลเป็นรูปสามเหลี่ยมและสลับ

05AB1E , 34 26 ไบต์

¶
¡D
©€g
´ā´Q
´sJÇÈ
¥Ä{´нP

ลองออนไลน์!

รับอินพุตเป็นสตริงหลายบรรทัด (อินพุตระหว่าง"" " ) คำอธิบายจะมาภายหลัง

Java 10, 209 ไบต์

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

ทุกอย่างดำเนินการภายใต้ UTF-8 พร้อมการตีความว่า "ตัวอักษร" หมายถึงจุดโค้ด Unicode

แท็บจะถูกแทนที่ด้วยช่องว่างในมุมมองนี้

d
->
{  
long
f= 1,
 h=0 ,
c = - 1
,e ;for 
( byte a:
 d) {var b
=(e = a^10)
<1&e>- 1 ;f=
b?( h ^ f)> 0
?0/0 : f+ 1: f
;h=b?0 :a>-65 ?
h+ 1: h; c =b? c
:c>=0 & ( (c^a )&
1 )<1 ?0/0 :a ; } 
/*1010101010101*/ }

ลองออนไลน์

ฐานสิบหก

ย้อนกลับด้วยxxd -p -rบน Unix

640a2d3e0a7b20090a6c6f6e670a663d20312c0a09683d30092c0a63203d
202d20310a2c65203b666f72090a28096279746520613a0a096429207b76
617209620a3d2865203d20615e3130290a3c3126653e2d2031203b663d0a
623f280968095e0966293e09300a3f302f30093a09662b20313a09660a3b
683d623f30093a613e2d3635203f0a682b20313a09683b2063203d623f20
630a3a633e3d30092609280928635e612029260a3120293c31203f302f30
093a61203b207d200a2f2a313031303130313031303130312a2f207d0a

Ungolfed

d -> {
    long f = 1, h = 0, c = ~h, e;
    for (byte a : d) {
        var b = (e = a^10) < 1 & e > -1;
        f = b ?
            (h^f) > 0 ? 0/0 : f + 1
            : f
        ;
        h = b ? 0 :
            a > -65 ? h + 1 : h
        ;
        c = b ? c :
            c >= 0 & ((c^a) & 1) < 1 ? 0/0 : a
        ;
    }
}

fคือจำนวนอักขระที่คาดหวังในบรรทัดปัจจุบันhคือจำนวนอักขระที่เห็นจนถึงบรรทัดปัจจุบันcคือไบต์สุดท้ายที่เห็นและbไม่ว่าจะaเป็นบรรทัดใหม่หรือไม่

เงื่อนไขa > -65ทดสอบว่าaเป็นไบต์แรกของตัวละครหรือไม่ สิ่งนี้ทำงานได้เนื่องจากอักขระไบต์เดียว (ASCII) ไม่เป็นค่าลบในส่วนประกอบ 8 บิตสองไบต์แรกของอักขระที่ยาวกว่ามีรูปแบบไบนารี11xxxxxx(อย่างน้อย -64 ในส่วนประกอบสองตัว) และไบต์ที่ไม่นำหน้าในอักขระเหล่านั้น แบบฟอร์มอย่าง10xxxxxxน้อยที่สุด -65 ในส่วนเติมเต็มของทั้งสอง ( ที่มา )

เมื่อตัวละครละเมิดรูปแบบสามเหลี่ยมหรือกระดานหมากรุก (เช่นการขึ้นบรรทัดใหม่ปรากฏขึ้นในช่วงต้นหรือปลายหรือไบต์ของพาริตีที่ไม่ถูกต้องปรากฏขึ้น) สาขาด้านซ้ายของ ternary ที่สอดคล้องกัน (ในการมอบหมายให้fหรือc) เปิดใช้งานและวิธีการ

Python 3 (3.4?) 350 ไบต์

ความท้าทายที่ยากสำหรับภาษาโดยเฉพาะเกี่ยวกับช่องว่างเช่น Python 3 การส่งจะพิมพ์0หรือ1ออกมาตรฐานและหยุดทำงานสำหรับอินพุตบางส่วน โปรแกรมคาดว่าบรรทัดสุดท้ายจะถูกยกเลิกอย่างถูกต้องเช่นจบด้วยอักขระขึ้นบรรทัดใหม่ บรรทัดสุดท้ายของโปรแกรมจะถูกยกเลิกเช่นเดียวกัน UTF-8 ใช้สำหรับตรวจสอบพาริตีไบต์

แท็บจะถูกแทนที่ด้วยช่องว่างในมุมมองนี้

0
i\
= 1
t=(#
 '0'*
 0) ;(
g,) =(#
 open (1
, "w"),) 
k = eval (
'p' + 'rin'
 + 't' ) #01
for  a in (#0
open ( 0) ):#0
#01010101010101
 a = a [:- 1 ] #
 if ( len (a )<i\
or len (a )>i ):[\
k('0' ),1 /0] #0101
 i, t= -~i, t+ a #01
(k( 2-len ({(c^i )&1\
 for  i,c in  eval (#0
 "enu"+"m"+"erate")(#01
 eval ( " byte"+"s")( t#
,' u8' ) ) } ) ) ) #01010

ทำงานได้สำหรับฉันด้วย Python 3.4.2; ไม่ทำงานบน Python 3 บน TIO ดูเหมือนว่าฉันจะเป็นแมลงในล่ามของ TIO

ฐานสิบหก

ย้อนกลับด้วยxxd -p -rบน Unix

300a695c0a3d20310a743d28230a202730272a0a093029203b280a672c29
203d28230a206f70656e0928310a2c09227722292c29200a6b203d206576
616c09280a277027202b202772696e270a202b202774272029202330310a
666f7209206120696e092823300a6f70656e092809302920293a23300a23
30313031303130313031303130310a2061203d2061205b3a2d2031205d20
230a2069660928096c656e09286120293c695c0a6f72096c656e09286120
293e6920293a5b5c0a6b2827302720292c31202f305d2023303130310a20
692c09743d202d7e692c09742b2061202330310a286b2809322d6c656e09
287b28635e69202926315c0a09666f720920692c6320696e09206576616c
092823300a0922656e75222b226d222b2265726174652229282330310a20
6576616c092809220962797465222b22732229280974230a2c2720753827
20292029207d202920292029202330313031300a