Chương trình bàn cờ là một chương trình trong đó giá trị thứ tự của mỗi ký tự riêng lẻ xen kẽ từ chẵn đến lẻ, ngoại trừ dấu kết thúc dòng (có thể là bất kỳ kết thúc dòng tiêu chuẩn nào).

Chương trình tam giác là một chương trình trong đó mỗi dòng có một ký tự bổ sung so với dòng trước, với dòng đầu tiên có một ký tự. Bạn không cần phải xử lý đầu vào trống.

Nhiệm vụ của bạn là xây dựng một chương trình xác nhận rằng đầu vào đã cho tuân thủ các tiêu chí đó và đầu ra / trả về một cái gì đó trung thực nếu chương trình đáp ứng các tiêu chí, hoặc một cái gì đó sai lệch.

Chương trình của bạn cũng phải đáp ứng các tiêu chí này.

Ví dụ về các chương trình hợp lệ

G
`e
@u^
5r{B

^
cB
+$C
VA01

Quy tắc

• Chương trình của bạn có thể bắt đầu bằng một byte lẻ hoặc byte chẵn miễn là tính chẵn lẻ của các ký tự thay thế.
• Chương trình của bạn phải xác nhận các chương trình bắt đầu bằng một ký tự lẻ hoặc chẵn.
• Đối với các ký tự unicode, các giá trị byte bên dưới phải có tính chẵn lẻ xen kẽ.
• Bạn có thể cho rằng đầu vào chỉ chứa các ký tự có thể in được. Nếu chương trình của bạn chứa không thể in được, nó vẫn có thể tự xác nhận.
• Chương trình của bạn có thể bao gồm một dòng mới, điều này không cần phải được cho phép bởi xác nhận của bạn vì bạn có thể cho rằng điều này bị xóa trước khi xác thực.
• Sơ hở tiêu chuẩn bị cấm.
• Mã ngắn nhất tính bằng byte, trong mỗi ngôn ngữ, sẽ thắng.

Stax , 26 byte

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

Chạy thử nghiệm trực tuyến

Tôi đã phải giới thiệu 3 nhân vật rác. ilà một no-op khi bên ngoài tất cả các cấu trúc vòng lặp. luôn luôn là không có. OĐặt 1 dưới đầu ngăn xếp, nhưng giá trị không được sử dụng trong chương trình.

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

Chạy cái này

C (gcc), 189 byte

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; } ␉ ␉ 

Hãy thử trực tuyến!

␉đại diện cho một nhân vật tab (tôi xin lỗi). Lưu ý rằng có một số dấu cách / dấu cách (tôi xin lỗi nhiều hơn). Bản gốc với các tab còn nguyên vẹn được xem tốt nhất trong vim với :set tabstop=1(các từ không thể diễn tả mức độ tôi xin lỗi).

Đó là một hàm (được gọi f, không rõ ràng ngay lập tức khi liếc vào nó) lấy một chuỗi làm đối số và trả về 0hoặc 1.

Tôi có thể giảm ít nhất một hoặc hai hoặc nhiều dòng, nhưng lưu ý rằng nó ngày càng lộn xộn và nỗ lực thấp cho đến cuối cùng, chủ yếu là do viết mã khủng khiếp như vậy (thậm chí theo tiêu chuẩn PPCG) khiến tôi cảm thấy như một người xấu và tôi muốn dừng lại càng sớm càng tốt.

Ý tưởng cơ bản ở đây là để tránh công trình xây dựng cụ thể cần phá vỡ định dạng ( ++, +=, return, vv). Thật kỳ diệu, các từ khóa quan trọng như for, charvà while(cuối cùng tôi không sử dụng) xảy ra để phù hợp với quy tắc ngang giá xen kẽ. Sau đó, tôi đã sử dụng khoảng trắng (chẵn lẻ) và các tab (chẵn lẻ) làm phần đệm để làm cho phần còn lại phù hợp với các quy tắc.

Haskell , 1080 1033 byte

;
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; ; ; 

Hãy thử trực tuyến!

Giải trình

Đây là nhiệm vụ khá thú vị đối với Haskell.

Ngang bằng

Để bắt đầu, chúng ta cần một số cách xác định xem một ký tự có điểm mã chẵn hay lẻ. Cách thông thường mà người ta có thể làm là lấy điểm mã và sửa đổi nó bằng 2. Tuy nhiên, như người ta có thể biết, việc lấy điểm mã của một ký tự yêu cầu nhập, do hạn chế nguồn có nghĩa là không thể đã sử dụng. Một Haskeller có kinh nghiệm hơn sẽ nghĩ sử dụng đệ quy. CharLà một phần của kiểu chữ Enumđể chúng ta có thể có được những người tiền nhiệm và người kế nhiệm của họ. Tuy nhiên predvà succcả hai đều không sử dụng được vì chúng không xen kẽ byte chẵn lẻ.

Vì vậy, điều này khiến chúng tôi khá bế tắc, chúng tôi gần như không thể thực hiện bất kỳ thao tác nào với ký tự. Giải pháp cho vấn đề này là mã hóa mọi thứ. Chúng ta có thể đại diện (hầu hết) ngay cả các ký tự là chữ, tỷ lệ cược chúng ta gặp rắc rối vì 'là số lẻ nên không thể ở bên cạnh char khiến cho nghĩa đen không thể diễn tả hầu hết các ký tự lẻ. Vì vậy, chúng tôi cứng mã tất cả các byte chẵn, và sau đó thêm một bắt tất cả cho các byte lẻ ở cuối.

Vấn đề Byte

Bạn có thể nhận thấy rằng có một số byte chẵn mà chữ không thể được tạo ra bằng cách gói nó trong dấu ngoặc đơn. Họ là những người không thể in, dòng mới và \. Chúng tôi không cần phải lo lắng về việc không thể in được miễn là chúng tôi không sử dụng bất kỳ ứng dụng nào trong số chúng tôi không cần xác minh. Trong thực tế, chúng ta vẫn có thể sử dụng những thứ không thể in được, như tab, cuối cùng tôi không cần. Dòng mới có thể bị bỏ qua một cách khó khăn bởi vì dù sao nó cũng sẽ bị cắt khỏi chương trình. (Chúng tôi có thể bao gồm dòng mới, vì đó là điểm mã khá thuận tiện, nhưng chúng tôi không cần). Lá này \, hiện \có mã số 92, thuận tiện là một số lẻ theo sau là một số chẵn, do đó, \92xen kẽ giữa evens và tỷ lệ cược theo nghĩa đen'\92'là hoàn toàn hợp lệ. Sau này khi chúng tôi cần đại diện cho dòng mới, chúng tôi sẽ nhận thấy rằng nó may mắn có cùng tài sản này '\10'.

Vấn đề khoảng cách

Bây giờ để bắt đầu viết mã thực tế, chúng ta cần có thể đặt một số lượng lớn các ký tự trên một dòng. Để làm điều này, tôi đã viết nắp:

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

Mũ không làm bất cứ điều gì ngoại trừ Haskell hợp lệ. Ban đầu tôi đã hy vọng đưa ra các định nghĩa sẽ giúp chúng tôi viết mã sau, nhưng không được. Cũng có những cách dễ dàng hơn để tạo giới hạn, ví dụ như khoảng trắng và dấu chấm phẩy, nhưng chúng không lưu byte theo cách này vì vậy tôi không bận tâm thay đổi nó.

Bộ giải mã

Vì vậy, bây giờ tôi có đủ không gian trên một dòng, tôi bắt đầu mã hóa giá trị. Điều này chủ yếu là khá nhàm chán, nhưng có một vài điều quan tâm. Đối với một lần, các dòng bắt đầu dài hơn nữa, chúng ta có thể sử dụng ;để đặt nhiều khai báo trên một dòng, giúp chúng ta tiết kiệm được rất nhiều byte.

Thứ hai là vì chúng ta không thể luôn bắt đầu một dòng với gthường xuyên nên chúng ta phải thụt dòng một chút. Bây giờ Haskell thực sự quan tâm đến vết lõm, vì vậy nó sẽ phàn nàn về điều này. Tuy nhiên, nếu dòng cuối cùng trước khi dòng thụt lề kết thúc bằng dấu chấm phẩy thì nó sẽ cho phép nó. Tại sao? Tôi không phải là người mờ nhạt nhất, nhưng nó hoạt động. Vì vậy, chúng ta chỉ cần nhớ đặt dấu chấm phẩy ở cuối dòng.

Khối xây dựng chức năng

Một khi trình mã hóa cứng được thực hiện, nó sẽ thuận buồm xuôi gió đến cuối chương trình. Chúng ta cần xây dựng một vài chức năng đơn giản. Đầu tiên tôi xây dựng một phiên bản drop, được gọi là i. ikhác với dropở chỗ nếu chúng ta cố gắng thả qua phần cuối của chuỗi thì nó chỉ trả về "y". ikhác với thả cũng ở chỗ nếu nó cố gắng bỏ dòng mới thì nó sẽ trả về "y", Chúng sẽ hữu ích vì sau này khi chúng tôi xác minh rằng chương trình là một hình tam giác, điều này sẽ cho phép chúng tôi quay lại Falsekhi dòng cuối cùng không hoàn thành hoặc khi nào một dòng kết thúc sớm.

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

Sau đó chúng tôi thực hiện một bí danh cho k, m. mchỉ kvới 1trong đối số thứ nhất và một dòng mới được thêm vào đối số thứ hai.

Tiếp theo chúng ta có o. olấy một số và một chuỗi. Nó xác định nếu các byte chuỗi (bỏ qua dòng mới) thay thế theo chẵn lẻ (sử dụng của chúng tôi g) bắt đầu bằng số đầu vào.

Cuối cùng, chúng ta có schạy ovới cả hai 1và 0, nếu thành công, nó sẽ làm theo m. Nếu thất bại cả hai nó chỉ trở về False. Đây là chức năng chúng tôi muốn. Nó xác định rằng đầu vào là hình tam giác và xen kẽ.

05AB1E , 34 26 byte

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

Hãy thử trực tuyến!

Lấy đầu vào dưới dạng một chuỗi nhiều dòng (đầu vào giữa "" " ). Giải thích để đến sau.

Java 10, 209 byte

Một lambda void lấy một iterable hoặc mảng của byte. Biểu thị đúng bằng cách trả về bình thường, sai bằng cách ném ngoại lệ thời gian chạy. Chương trình hy vọng dòng cuối cùng được kết thúc đúng, tức là kết thúc bằng một ký tự dòng mới. Dòng cuối cùng của chương trình cũng bị chấm dứt tương tự.

Mọi thứ được thực hiện theo UTF-8, với cách giải thích rằng "ký tự" chỉ các điểm mã Unicode.

Các tab được thay thế bằng khoảng trắng trong khung nhìn này.

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*/ }

Dùng thử trực tuyến

Đổ lục giác

Hoàn nguyên với xxd -p -rUnix.

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

Ung dung

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
        ;
    }
}

flà số lượng ký tự dự kiến ​​trên dòng hiện tại, hlà số lượng ký tự được nhìn thấy cho đến nay trên dòng hiện tại, clà byte cuối cùng được nhìn thấy và bliệu đó có phải alà dòng mới hay không.

Điều kiện a > -65kiểm tra xem abyte đầu tiên trong một ký tự. Điều này hoạt động vì các ký tự một byte (ASCII) là không âm trong phần bù hai bit 8 bit, byte đầu tiên của các ký tự dài hơn có dạng nhị phân 11xxxxxx(ít nhất là -64 trong phần bù hai) và các byte không dẫn trong các ký tự đó là hình thức 10xxxxxx, nhiều nhất là -65 trong hai phần bổ sung. ( Nguồn )

Khi một ký tự vi phạm mẫu hình tam giác hoặc hình bàn cờ (tức là một dòng mới xuất hiện sớm hoặc muộn hoặc một byte của tính chẵn lẻ xuất hiện), nhánh bên trái của ternary tương ứng (gán cho fhoặc c) kích hoạt và phương thức sẽ ném ngoại lệ số học.

Python 3 (3,4?), 350 byte

Một thách thức khó khăn đối với một ngôn ngữ cụ thể về khoảng trắng như Python 3. Việc đệ trình in 0hoặc 1để chuẩn hóa và gặp sự cố đối với một số đầu vào. Chương trình hy vọng dòng cuối cùng được kết thúc đúng, tức là kết thúc bằng một ký tự dòng mới. Dòng cuối cùng của chương trình cũng bị chấm dứt tương tự. UTF-8 được sử dụng để kiểm tra tính chẵn lẻ byte.

Các tab được thay thế bằng khoảng trắng trong khung nhìn này.

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

Hoạt động với tôi với Python 3.4.2; không hoạt động trên bất kỳ Python 3 nào trên TIO. Dường như với tôi là một lỗi trong phiên dịch của TIO.

Bãi rác Hex

Hoàn nguyên với xxd -p -rUnix.

300a695c0a3d20310a743d28230a202730272a0a093029203b280a672c29
203d28230a206f70656e0928 310a2c09227722292c29200a6b203d206576
616c09280a277027202b202772696e270a202b202774272029202330310a
666f7209206120696e092823300a6f70656e092809302920293a23300a23
30313031303130313031303130310a2061203d2061205b3a2d2031205d20
200a2069660928096c656e09286120293c695c0a6f72096c656e09286120
293e6920293a5b5c0a6b2827302720292c31202f305d2023303130310a20
692c09743d202d7e692c09742b2061202330310a286b2809322d6c656e09
287b28635e69202926315c0a09666f720920692c6320696e09206576616c
092823300a0922656e75222b226d222b2265726174652229282330310a20
6576616c092809220962797465222b22732229280974230a2c2720753827
20292029207d202920292029202330313031300a