Програма шашки - це програма, де порядкове значення кожного символу чергується від парного на непарне, виключаючи лінійний термінатор (який може бути будь-яким стандартним закінченням рядка).

Трикутна програма - це програма, де кожен рядок має один додатковий символ, ніж попередній рядок, причому перший рядок має один символ. Не потрібно обробляти порожній вхід.

Ваше завдання - створити програму, яка підтверджує, що даний вхід дотримується цих критеріїв і виводить / повертає щось правдоподібне, якщо програма відповідає критеріям, або щось хибне в іншому випадку.

Ваша програма також повинна відповідати цим критеріям.

Приклади дійсних програм

G
`e
@u^
5r{B

^
cB
+$C
VA01

Правила

• Ваша програма може починатись з непарного або парного байта, доки чесність символів чергується.
• Ваша програма повинна підтвердити програми, які починаються з непарного або парного символу.
• Для символів unicode базові значення байтів повинні мати чергування парності.
• Можна припустити, що вхід містить лише символи для друку. Якщо у вашій програмі є недруковані версії, вона все одно повинна мати можливість перевірити себе.
• У вашій програмі може бути один зворотний новий рядок, цього не потрібно допускати валідацією, оскільки ви можете припустити, що це видалено до перевірки.
• Стандартні лазівки заборонені.
• Виграє найкоротший код у байтах на кожній мові.

Стакс , 26 байт

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

Запускайте тестові приклади в Інтернеті

Мені довелося представити 3 непотрібних персонажа. iне працює, коли знаходяться поза всіма контурними конструкціями. завжди є неоператором. 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; } ␉ ␉ 

Спробуйте в Інтернеті!

␉являє собою символ вкладки (вибачте). Зверніть увагу, що є кілька пробілів / вкладок (мені більше шкода). Оригінал із вкладками неушкодженим найкраще переглядати vim з :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є частиною класу Enumтипу, щоб ми могли отримати своїх попередників та наступників. Однак predі succтакож як непридатна , тому що вони не роблять альтернативні парності байтів.

Таким чином, це залишає нас досить застряглими, ми майже не можемо жодних маніпуляцій із символами. Рішення цього полягає в жорсткому коді всього. Ми можемо представити (більшість) парних символів як буквальні, шанси, з якими ми маємо проблеми, тому що 'це непарно, тому це не може бути поруч із самим знаком, що робить буквальне неможливим виразити більшість непарних знаків. Тож ми жорстко кодуємо всі парні байти, а потім додаємо улов усі для непарних байтів наприкінці.

Проблема байтів

Ви можете помітити, що є кілька парних байтів, для яких літерали неможливо зробити, обернувши їх в одиничні лапки. Вони є недрукованими, новинками та \. Нам не потрібно турбуватися про недруковані версії, оскільки поки ми не використовуємо жодну з них, нам не потрібно перевіряти. Насправді ми все ще можемо використовувати непарні друковані версії, як-от вкладка, я просто не закінчую цього. Новий рядок може бути ігноровано, тому що він все одно буде відрізаний від програми. (Ми можемо включити новий рядок, оскільки це кодова точка досить зручна, але нам цього не потрібно). Це залишає \, тепер \має кодову точку 92, яка зручно є непарним числом, за яким слідує парне число, тому \92чергується між рівнами і коефіцієнтами'\92'цілком справедливий. Пізніше, коли нам потрібно представити новий рядок, ми помітимо, що він, на щастя, має таку саму властивість '\10'.

Проблеми з інтервалом

Тепер для того, щоб почати писати фактичний код, нам потрібно вміти розміщувати значну кількість символів на одному рядку. Для цього я написав шапку:

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

Ковпак не робить нічого, крім дійсного Haskell. Спочатку я сподівався зробити визначення, які допоможуть нам у коді пізніше, але це не вдалося. Існують також більш прості способи зробити обробку, наприклад, пробіли та крапки з комою, але вони не економлять байти таким чином, тому я не намагаюся її змінити.

Hardcoder

Тому тепер, коли мені достатньо місця в рядку, я починаю значення жорсткого кодування. Це в основному досить нудно, але є кілька цікавих речей. Один раз, коли рядки стають ще довші, ми можемо використовувати ;для розміщення декількох декларацій на рядку, що економить нам тонну байтів.

Друга полягає в тому, що оскільки ми не завжди можемо починати рядок з gкожного так часто, нам доведеться трохи відступити рядки. Тепер Haskell дійсно піклується про відступ, тому він скаржиться на це. Однак якщо останній рядок перед відступним рядком закінчується крапкою з комою, це дозволить. Чому? Я не найменший, але це працює. Тож нам просто потрібно пам’ятати, щоб ставити крапки з комою в кінці рядків.

Функціональні блоки

Після того, як жорсткий кодер буде зроблено, він плавно пливе до кінця програми. Нам потрібно побудувати кілька простих функцій. Спочатку будую версію drop, що називається i. iвідрізняється dropтим, що якщо ми намагаємося пропустити повз кінець рядка, він просто повертається "y". iвідрізняється від drop також тим, що якщо він спробує скинути новий рядок, він повернеться. "y"Вони будуть корисні тим, що пізніше, коли ми перевіримо, що програма є трикутником, це дозволить нам повернутися, Falseколи останній рядок не завершений, або коли лінія закінчується рано.

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

Потім зробити псевдонім k, m. mтільки kз 1першим аргументом, і символ нового рядка передує до другого аргументу.

Далі маємо o. oбере число і рядок. Він визначає, чи байти рядків (ігноруючи нові рядки) чергуються в паритеті (використовуючи наш g), починаючи з вхідного числа.

Нарешті, у нас є те, sщо працює oз обома, 1і 0, якщо це вдається, відкладається m. Якщо не вдасться обох, він просто повертається False. Це функція, яку ми хочемо. Він визначає, що вхід трикутний і змінний.

05AB1E , 34 26 байт

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

Спробуйте в Інтернеті!

Вважає вхід як багаторядковий рядок (вхід між "" " ). Пояснення, які надходять пізніше.

Java 10, 209 байт

Порожня лямбда, що приймає ітерабельний або масив 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 -rUnix.

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

Безумовно

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 у доповненні двох. ( Джерело )

Коли символ порушує трикутний або шаховий зразок (тобто новий рядок з’являється рано чи пізно або з'являється байт неправильного паритету), ліва гілка відповідного потрійного (за призначенням 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 -rUnix.

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