Program kotak-kotak adalah program di mana nilai ordinal setiap karakter individu berganti dari genap menjadi ganjil, tidak termasuk terminator garis (yang dapat berupa akhir garis standar).

Program segitiga adalah program di mana setiap baris memiliki satu karakter tambahan dari baris sebelumnya, dengan baris pertama memiliki satu karakter. Anda tidak perlu menangani input kosong.

Tugas Anda adalah untuk membangun program yang memvalidasi bahwa input yang diberikan mematuhi kriteria dan output / mengembalikan sesuatu yang benar jika program memenuhi kriteria, atau sesuatu yang palsu sebaliknya.

Program Anda juga harus memenuhi kriteria ini.

Contoh program yang valid

G
`e
@u^
5r{B

^
cB
+$C
VA01

Aturan

• Program Anda dapat mulai dengan byte ganjil atau genap asalkan paritas karakternya berganti.
• Program Anda harus memvalidasi program yang dimulai dengan karakter ganjil atau genap.
• Untuk karakter unicode, nilai byte yang mendasarinya harus memiliki paritas bolak-balik.
• Anda dapat berasumsi bahwa input hanya berisi karakter yang dapat dicetak. Jika program Anda mengandung unsintables, itu masih bisa memvalidasi dirinya sendiri.
• Program Anda dapat menyertakan satu baris tambahan, ini tidak perlu diizinkan oleh validasi Anda karena Anda dapat menganggap ini dihapus sebelum memvalidasi.
• Celah standar dilarang.
• Kode terpendek dalam byte, dalam setiap bahasa, menang.

Stax , 26 byte

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

Jalankan test case online

Saya harus memperkenalkan 3 karakter sampah. iadalah no-op ketika di luar semua konstruksi loop. selalu menjadi no-op. Omelipat 1 di bawah tumpukan, tetapi nilainya tidak digunakan dalam program.

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

Jalankan yang ini

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

Cobalah online!

␉mewakili karakter tab (maaf). Perhatikan bahwa ada beberapa spasi / tab tambahan (saya lebih menyesal). Dokumen asli dengan tab utuh paling baik dilihat di vim with :set tabstop=1(kata-kata tidak bisa mengungkapkan betapa aku menyesal).

Ini adalah fungsi (dipanggil f, yang tidak langsung terlihat dengan meliriknya) yang mengambil string sebagai argumen dan mengembalikan salah satu 0atau 1.

Saya dapat mengurangi ini dengan setidaknya satu dan mungkin dua atau lebih baris, tetapi perhatikan bahwa itu menjadi semakin berantakan dan usaha rendah menjelang akhir, sebagian besar karena menulis kode yang mengerikan (bahkan dengan standar PPCG) membuat saya merasa seperti orang jahat dan saya ingin berhenti sesegera mungkin.

Ide dasar di sini adalah untuk menghindari konstruksi yang tentu melanggar format ( ++, +=, return, dll). Ajaibnya, kata kunci penting seperti for,, chardan while(yang akhirnya tidak saya gunakan) kebetulan cocok dengan aturan paritas bolak-balik. Kemudian saya menggunakan spasi (bahkan paritas) dan tab (paritas ganjil) sebagai padding untuk membuat sisanya sesuai dengan aturan.

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

Cobalah online!

Penjelasan

Ini merupakan tugas yang cukup menarik bagi Haskell.

Keseimbangan

Untuk memulainya kita perlu beberapa cara untuk menentukan apakah suatu karakter memiliki titik kode genap atau ganjil. Cara normal yang dapat dilakukan seseorang adalah mendapatkan titik kode dan memodifikasinya dengan 2. Namun, karena orang mungkin sadar, mendapatkan titik kode dari suatu karakter memerlukan impor, yang karena pembatasan sumber berarti bahwa tidak dapat bekas. Haskeller yang lebih berpengalaman akan berpikir untuk menggunakan rekursi. CharIni adalah bagian dari Enumtypeclass sehingga kita bisa mendapatkan pendahulu dan penggantinya. Namun preddan succkeduanya juga tidak dapat digunakan karena mereka tidak mengganti paritas byte.

Jadi ini membuat kita cukup macet, hampir tidak bisa melakukan manipulasi dengan karakter. Solusi untuk ini adalah untuk mem-hardcode semuanya. Kita dapat mewakili (kebanyakan) bahkan karakter sebagai literal, kemungkinan kita memiliki masalah dengan 'itu aneh sehingga tidak bisa di sebelah karakter itu sendiri membuat literal tidak mungkin untuk mengekspresikan sebagian besar karakter aneh. Jadi kita membuat kode semua byte genap, dan kemudian menambahkan tangkapan semua untuk byte aneh di akhir.

Bytes yang bermasalah

Anda mungkin memperhatikan bahwa ada beberapa bahkan byte yang tidak dapat dibuat literal dengan membungkusnya dalam tanda kutip tunggal. Mereka adalah unsintables, newlines dan \. Kita tidak perlu khawatir tentang hal-hal yang tidak patut karena selama kita tidak menggunakannya, kita tidak perlu memverifikasi. Bahkan kita masih bisa menggunakan unsintables aneh, seperti tab, saya hanya akhirnya tidak perlu. Newline secara bijaksana dapat diabaikan karena itu akan dipangkas dari program. (Kita dapat memasukkan baris baru, karena itu titik kode agak mudah, tetapi kita tidak perlu). Daun ini sangat valid. Kemudian ketika kita perlu mewakili baris baru kita akan melihat bahwa untungnya memiliki properti yang sama .\ , sekarang\ memiliki codepoint 92, yang nyaman adalah bilangan ganjil diikuti oleh bilangan genap, sehingga \92berganti-ganti antara genap dan odds dengan demikian literal'\92''\10'

Masalah spasi

Sekarang untuk mulai menulis kode aktual kita harus dapat menempatkan sejumlah besar karakter pada satu baris. Untuk melakukan ini, saya menulis topi:

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

Tutup tidak melakukan apa pun kecuali Haskell valid. Saya awalnya berharap untuk membuat definisi yang akan membantu kami dalam kode nanti, tetapi tidak. Ada juga cara yang lebih mudah untuk membuat tutup, misalnya spasi putih dan titik koma, tetapi mereka tidak menyimpan byte melalui cara ini jadi saya belum repot-repot mengubahnya.

Hardcoder

Jadi sekarang saya memiliki cukup ruang pada sebuah baris saya mulai nilai hardcoding. Ini sebagian besar sangat membosankan, tetapi ada beberapa hal yang menarik. Untuk satu kali garis mulai semakin lama bisa kita gunakan; untuk meletakkan beberapa deklarasi pada sebuah baris, yang menghemat satu ton byte.

Yang kedua adalah karena kita tidak selalu dapat memulai sebuah baris dengan yang gsering kita harus membuat indentasi sedikit. Sekarang Haskell benar-benar peduli tentang lekukan, sehingga akan mengeluh tentang ini. Namun jika baris terakhir sebelum baris indentasi berakhir dengan tanda titik koma, itu akan memungkinkannya. Mengapa? Saya belum pingsan, tapi berhasil. Jadi kita hanya harus ingat untuk meletakkan titik koma di akhir baris.

Fungsi Blok Bangunan

Setelah hardcoder selesai, lancar berlayar ke akhir program. Kita perlu membangun beberapa fungsi sederhana. Pertama saya membangun versi drop, bernama i. iberbeda dari dropitu jika kita mencoba untuk melewati akhir string itu hanya mengembalikan "y". iberbeda dari drop juga dalam bahwa jika ia mencoba untuk menjatuhkan baris baru itu akan kembali "y", Ini akan berguna karena nanti ketika kita memverifikasi bahwa program adalah segitiga ini akan memungkinkan kita untuk kembaliFalse ketika baris terakhir tidak selesai, atau ketika garis berakhir lebih awal.

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

Kami kemudian membuat alias untuk k, m. mhanya kdengan 1dalam argumen pertama, dan baris baru diawali dengan argumen kedua.

Selanjutnya yang kita miliki o. omengambil nomor dan string. Ini menentukan apakah byte string (mengabaikan baris baru) bergantian dalam paritas (menggunakan kami g) dimulai dengan nomor input.

Terakhir kita memiliki syang berjalan odengan keduanya 1dan 0, jika berhasil maka itu berlaku untuk m. Jika gagal keduanya hanya kembali False. Ini adalah fungsi yang kita inginkan. Ini menentukan bahwa input adalah segitiga dan bergantian.

05AB1E , 34 26 byte

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

Cobalah online!

Mengambil input sebagai string multiline (input antara "" " ). Penjelasan yang akan datang nanti.

Java 10, 209 byte

Void lambda mengambil iterable atau array byte. Menunjukkan benar dengan mengembalikan secara normal, salah dengan melemparkan pengecualian runtime. Program mengharapkan garis akhir untuk diakhiri dengan benar, yaitu diakhiri dengan karakter baris baru. Baris terakhir dari program ini juga diakhiri.

Semuanya dilakukan di bawah UTF-8, dengan interpretasi bahwa "karakter" mengacu pada poin kode Unicode.

Tab diganti dengan spasi dalam tampilan ini.

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

Cobalah secara Online

Hex dump

Kembalikan dengan xxd -p -rdi Unix.

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

Tidak disatukan

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

fadalah jumlah karakter yang diharapkan pada baris saat ini, hadalah jumlah karakter yang terlihat sejauh ini pada baris saat ini, cadalah byte terakhir yang terlihat, dan bapakah aadalah baris baru.

Kondisi a > -65menguji apakah abyte pertama dalam sebuah karakter. Ini berfungsi karena karakter single-byte (ASCII) nonnegatif dalam komplemen 8-bit two, byte pertama dari karakter yang lebih panjang memiliki bentuk biner 11xxxxxx(setidaknya -64 dalam komplemen dua), dan byte non-leading dalam karakter tersebut adalah dari formulir 10xxxxxx, paling banyak -65 dalam pelengkap dua. ( Sumber )

Ketika sebuah karakter melanggar pola segitiga atau kotak-kotak (yaitu baris baru muncul lebih awal atau lebih lambat atau satu byte dari paritas yang salah muncul), cabang kiri terner terkait (dalam penugasan ke fatau c) diaktifkan dan metode melempar pengecualian aritmatika.

Python 3 (3.4?), 350 byte

Tantangan rumit untuk bahasa tertentu tentang spasi putih sebagai Python 3. Kiriman dicetak 0atau 1standar keluar dan macet untuk beberapa input. Program mengharapkan garis akhir untuk diakhiri dengan benar, yaitu diakhiri dengan karakter baris baru. Baris terakhir dari program ini juga diakhiri. UTF-8 digunakan untuk memeriksa paritas byte.

Tab diganti dengan spasi dalam tampilan ini.

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

Bekerja untuk saya dengan Python 3.4.2; tidak berfungsi pada Python 3 apa pun di TIO. Menurut saya bug di penerjemah TIO.

Hex Dump

Kembalikan dengan xxd -p -rdi Unix.

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