Program szachownicy to program, w którym wartość porządkowa każdego pojedynczego znaku zmienia się z parzystej na nieparzystą, z wyłączeniem terminatora linii (którym mogą być dowolne standardowe zakończenia linii).

Program trójkątny to program, w którym każda linia ma jeden dodatkowy znak niż poprzedni, przy czym pierwsza linia ma jeden znak. Nie musisz obsługiwać pustych danych wejściowych.

Twoim zadaniem jest zbudowanie programu, który potwierdzi, że dane dane wejściowe są zgodne z tymi kryteriami, a wyniki / zwraca coś prawdziwego, jeśli program spełnia kryteria, lub coś innego fałszywego.

Twój program musi również spełniać te kryteria.

Przykłady prawidłowych programów

G
`e
@u^
5r{B

^
cB
+$C
VA01

Zasady

• Twój program może zaczynać się od nieparzystego lub parzystego bajtu, o ile zmienia się parzystość znaków.
• Twój program musi sprawdzać poprawność programów rozpoczynających się od znaku nieparzystego lub parzystego.
• W przypadku znaków Unicode podstawowe wartości bajtów muszą mieć naprzemienną parzystość.
• Możesz założyć, że dane wejściowe zawierają tylko znaki do wydrukowania. Jeśli twój program zawiera niedrukowalne, nadal powinien być w stanie sam się zweryfikować.
• Twój program może zawierać jeden końcowy znak nowej linii, nie musi to być dozwolone przez twoją walidację, ponieważ możesz założyć, że została ona usunięta przed walidacją.
• Standardowe luki są zabronione.
• Wygrywa najkrótszy kod w bajtach w każdym języku.

Stax , 26 bajtów

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

Uruchom przypadki testowe online

Musiałem przedstawić 3 śmieciowe postacie. ijest opcją, gdy znajduje się poza wszystkimi konstrukcjami pętli. to zawsze brak możliwości. Owsuwa 1 pod górę stosu, ale wartość nie jest używana w programie.

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

Uruchom ten

C (gcc), 189 bajtów

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

Wypróbuj online!

␉reprezentuje znak tabulacji (przepraszam). Zauważ, że istnieje kilka końcowych spacji / tabulatorów (przepraszam bardziej). Oryginał z nienaruszonymi zakładkami najlepiej oglądać w vim z :set tabstop=1(słowa nie wyrażają, jak mi przykro).

Jest to funkcja (wywoływana f, co nie jest od razu widoczne po spojrzeniu na nią), która przyjmuje ciąg znaków jako argument i zwraca albo 0albo 1.

Mógłbym to zmniejszyć o co najmniej jedną i prawdopodobnie dwie lub więcej linii, ale zauważ, że pod koniec robi się coraz bardziej niechlujny i wymaga mniej wysiłku, głównie dlatego, że pisanie tak okropnego kodu (nawet według standardów PPCG) sprawiało, że czułam się jak zła osoba i chciałem się zatrzymać jak najszybciej.

Podstawowym założeniem jest, aby uniknąć konstrukcje, które muszą złamać format ( ++, +=, return, itd.). Cudem ważne słowa kluczowe, takie jak for, chari while(których nie skończyłem) pasują do naprzemiennej reguły parzystości. Następnie użyłem spacji (parzystości) i tabulatorów (parzystości nieparzystej) jako wypełnienia, aby reszta pasowała do reguł.

Haskell , 1080 1033 bajtów

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

Wypróbuj online!

Wyjaśnienie

To było dość interesujące zadanie dla Haskell.

Parytet

Na początek potrzebujemy jakiegoś sposobu ustalenia, czy znak ma parzysty czy nieparzysty punkt kodowy. Normalnym sposobem, aby to zrobić, jest uzyskanie punktu kodowego i zmodyfikowanie go o 2. Jednak, jak wiadomo, uzyskanie punktu kodowego znaku wymaga importu, co z powodu ograniczenia źródła oznacza, że ​​nie można używany. Bardziej doświadczony Haskeller pomyślałby o użyciu rekurencji. Charsą częścią tej Enumklasy, dzięki czemu możemy zdobyć ich poprzedników i następców. Jednak predi succto też zarówno bezużyteczny, ponieważ nie alternatywny bajtów parzystości.

Więc to nas mocno utknęło, że prawie nie możemy manipulować znakami. Rozwiązaniem tego jest zaszyfrowanie wszystkiego. Możemy reprezentować (większość) parzystych znaków jako literały, szanse, z którymi mamy problem, ponieważ 'są nieparzyste, więc nie może znajdować się obok samego znaku, co uniemożliwia dosłowne wyrażenie większości nieparzystych znaków. Więc na stałe kodujemy wszystkie parzyste bajty, a następnie dodajemy catch dla wszystkich nieparzystych bajtów na końcu.

Problem Bajty

Możesz zauważyć, że istnieją pewne nawet bajty, dla których literałów nie można utworzyć, zawijając je w cudzysłowy. Są to niedrukowalne, nowe linie i \. Nie musimy się martwić o materiały niedrukowalne, ponieważ dopóki nie użyjemy żadnego z nich, nie musimy weryfikować. W rzeczywistości nadal możemy używać dziwnych, niedrukowalnych elementów, takich jak tab, po prostu nie muszę tego robić. Newline można zignorować, ponieważ i tak zostanie on przycięty z programu. (Moglibyśmy dodać znak nowej linii, ponieważ jego kod jest raczej wygodny, ale nie musimy). To pozostawia \, teraz \ma kododpunkt 92, który dogodnie jest liczbą nieparzystą, po której następuje parzysta liczba, więc na \92przemian wyrównuje i wyrównuje, a zatem dosłownie'\92'jest całkowicie poprawny. Później, kiedy będziemy musieli reprezentować znak nowej linii, zauważymy, że na szczęście ma tę samą właściwość '\10'.

Problemy z odstępami

Teraz, aby rozpocząć pisanie rzeczywistego kodu, musimy umieć znaczną liczbę znaków w jednym wierszu. Aby to zrobić, napisałem cap:

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

Czapka nie robi nic oprócz ważnego Haskella. Początkowo miałem nadzieję stworzyć definicje, które pomogą nam w kodzie później, ale tak się nie stało. Są też łatwiejsze sposoby na dodanie znaku, na przykład białe znaki i średniki, ale nie oszczędzają w ten sposób bajtów, więc nie zadałem sobie trudu, aby go zmienić.

Hardcoder

Teraz, gdy mam już wystarczająco dużo miejsca w linii, zaczynam wartości na stałe. Jest to w większości dość nudne, ale jest kilka interesujących rzeczy. Po raz pierwszy linie stają się jeszcze dłuższe, możemy użyć ;do umieszczenia wielu deklaracji w linii, co oszczędza nam mnóstwo bajtów.

Po drugie, ponieważ nie zawsze możemy zaczynać linię od gtak często, musimy nieco wciąć linie. Teraz Haskell naprawdę dba o wcięcia, więc będzie na to narzekać. Jeśli jednak ostatnia linia przed linią wcięcia kończy się średnikiem, pozwoli na to. Dlaczego? Nie mam najsłabszego, ale działa. Musimy więc pamiętać o umieszczeniu średników na końcu linii.

Bloki konstrukcyjne funkcji

Po wykonaniu hardcodera płynne przejście do końca programu. Musimy zbudować kilka prostych funkcji. Najpierw buduję wersję o dropnazwie i. iróżni się od droptego, że jeśli spróbujemy przejść poza koniec łańcucha, po prostu zwraca "y". iróżni się od upuszczania również tym, że jeśli spróbuje upuścić nową linię, zwróci "y", Przydadzą się, ponieważ później, gdy sprawdzimy, czy program jest trójkątem, pozwoli nam to powrócić, Falsegdy ostatni wiersz nie jest kompletny, lub gdy linia kończy się wcześnie.

kk$n$$s$$s$True$n$ znaków z przodu. Następnie dzwonik$n+1$False

Następnie zrobić alias k, m. mjest tylko kz 1pierwszym argumentem, a nowy wiersz jest dodawany do drugiego argumentu.

Następnie mamy o. obierze liczbę i ciąg znaków. Określa, czy bajty ciągu (ignorując znaki nowej linii) zmieniają się w parzystości (używając naszego g), zaczynając od numeru wejściowego.

Na koniec mamy, sktóry działa oz oboma 1i 0, jeśli któryś z nich się powiedzie, odracza się m. Jeśli zawiedzie oba, po prostu wraca False. To jest funkcja, której chcemy. Określa, że ​​wejście jest trójkątne i naprzemienne.

05AB1E , 34 26 bajtów

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

Wypróbuj online!

Pobiera dane wejściowe jako ciąg wielowierszowy (dane między „” ” ). Objaśnienia, które przyjdą później.

Java 10, 209 bajtów

Pusta lambda przyjmująca iterowalną tablicę byte . Wskazuje wartość true, zwracając normalnie, wartość false, zgłaszając wyjątek czasu wykonywania. Program oczekuje, że ostatnia linia zostanie poprawnie zakończona, tzn. Zakończy się znakiem nowej linii. Ostatnia linia programu jest podobnie zakończona.

Wszystko odbywa się w UTF-8, z interpretacją, że „znak” odnosi się do punktów kodu Unicode.

W tym widoku karty są zastępowane spacjami.

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

Wypróbuj online

Zrzut heksowy

Przywróć za pomocą xxd -p -r na Uniksie.

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

Nie golfił

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

fjest oczekiwaną liczbą znaków w bieżącym wierszu, hjest liczbą znaków widoczną do tej pory w bieżącym wierszu, cjest ostatnim widocznym bajtem i określa, bczy ajest to nowy wiersz.

Warunek a > -65sprawdza, czy ajest to pierwszy bajt w znaku. Działa to, ponieważ znaki jednobajtowe (ASCII) są nieujemne w 8-bitowym uzupełnieniu dwóch, pierwszy bajt dłuższych znaków ma postać binarną 11xxxxxx(co najmniej -64 w uzupełnieniu dwóch), a niepowiązane bajty w tych znakach są forma 10xxxxxx, najwyżej -65 w uzupełnieniu do dwóch. ( Źródło )

Gdy znak narusza wzór trójkąta lub szachownicy (tj. Nowa linia pojawia się wcześnie lub późno lub pojawia się bajt złej parzystości), lewa gałąź odpowiedniej trójki (w przypisaniu do flub c) aktywuje się, a metoda zgłasza wyjątek arytmetyczny.

Python 3 (3,4?), 350 bajtów

Trudne wyzwanie dla języka tak specyficznego dla białych znaków jak Python 3. Przesłanie jest drukowane 0lub 1standardowe i ulega awarii dla niektórych danych wejściowych. Program oczekuje, że ostatnia linia zostanie poprawnie zakończona, tzn. Zakończy się znakiem nowej linii. Ostatnia linia programu jest podobnie zakończona. UTF-8 służy do sprawdzania parzystości bajtów.

W tym widoku karty są zastępowane spacjami.

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

Działa dla mnie z Python 3.4.2; nie działa na żadnym Pythonie 3 na TIO. Wydaje mi się, że to błąd w tłumaczach TIO.

Hex Dump

Przywróć zxxd -p -r na Uniksie.

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