A łodygi i liści działka wyświetla wiązka wartości liczbowych w grupach, które są określane przez wszystkich, ale ostatnią cyfrę. Załóżmy na przykład, że mamy ten zestaw danych:

0, 2, 12, 13, 13, 15, 16, 20, 29, 43, 49, 101

Możemy wyprodukować tę łodygę i liść:

0|02
1|23356
2|09
3|
4|39
5|
6|
7|
8|
9|
10|1

Trzon pierwszego rzędu ma wartość 0, więc jego „liście” - cyfry po |- reprezentują wartości od 0 włącznie do 10 wyłącznie. Liście na każdej łodydze są sortowane. Pędy bez liści (jak 3) wciąż pojawiają się na wykresie. Wartość 101 mieści się w przedziale od 100 włącznie do 110, więc jej rdzeń wynosi 10 (100 podzielone przez 10).

Wyzwanie polega na sprawdzeniu, czy fragment tekstu jest prawidłowym wątkiem łodygi i liścia. Prawidłowy działka spełnia następujące zasady:

• Ma dokładnie jeden wiersz dla każdej łodygi (tj. Grupy o szerokości 10) w zakresie danych (w tym łodygi w środku zakresu bez liści)
• Nie ma łodyg poza zakresem
• Wszystkie liście są posortowane rosnąco po prawej stronie
• Wszystkie łodygi są sortowane rosnąco
• Ma tylko znaki numeryczne (oprócz separatora |)

Nie musisz zajmować się liczbami, które mają części ułamkowe. Możesz zatwierdzić lub odrzucić dodatkowe zera wiodące w rdzeniach, ale pusty rdzeń jest niedozwolony. Będzie co najmniej jedna wartość. Możesz zakładać dodatkowe spacje po liściach w każdym rzędzie. Możesz założyć wiodący i / lub końcowy znak nowej linii. Wszystkie znaki będą drukowane ASCII.

Twoja funkcja lub program powinien zwrócić lub wypisać (do ekranu lub standardowego wyjścia) prawdziwą wartość dla prawidłowego wykresu lub wartość fałszowania dla nieprawidłowego wykresu. Możesz pobierać dane ze standardowego wejścia, z pliku, jako jeden duży ciąg, jako tablicę ciągów - cokolwiek jest najwygodniejsze.

Oto kilka przypadków testowych, które są prawidłowymi wykresami (oddzielonymi pustymi wierszami):

2|00003457
3|35
4|799
5|3

99|3
100|0556
101|
102|
103|8

0|0

Oto kilka przypadków testowych, które są nieprawidłowymi wykresami, z komentarzem po prawej stronie:

|0               Blank stem

5|347            Missing a stem (6) in the range
7|9

4|               Has a stem (4) outside the range
5|26
6|7

11|432           Leaves aren't sorted correctly
12|9989

5|357            Stems aren't sorted correctly
4|002
6|1

4|5              Duplicate stem
4|6
4|6
5|1

51114            No stem and leaf separator
609

1|2|03           Multiple separators
2|779|

4|8abcdefg9      Invalid characters
5|1,2,3

75 | 4 6         Invalid characters (spaces)
76 | 2 8 8 9

To jest kod golfowy, więc wygrywa najkrótszy kod! Standardowe luki są niedozwolone.

Perl, 47 bajtów

Obejmuje +2 za -0p

Podaj dane na STDIN

stem.pl:

#!/usr/bin/perl -0p
$"="*";$_=/^((??{$_+$n++})\|@{[0..9,"
"]})+$/

Pip , 60 58 + 1 = 59 bajtów

Pierwsze dźgnięcie w problem, prawdopodobnie przydałoby się więcej golfa. Używa -rflagi do odczytu linii wejścia ze standardowego wejścia. Prawdą jest 1, że fałszem jest 0pusty ciąg znaków.

g=a+,#g&a@vNE'|NEg@v@v&$&{Y(a^'|1)a@`^\d+\|\d*$`&SNy=^y}Mg

Wyjaśnienie i pakiet testowy w toku, ale tymczasem: Wypróbuj online!

JavaScript, 189 bajtów

(x,y=x.split`
`.map(a=>a.split`|`),z=y.map(a=>a[0]))=>!(/[^0-9|\n]|^\|/m.exec(x)||/^\d+\|\n|\|$/.exec(x)||y.some((c,i,a)=>c.length!=2||c[1]!=[...c[1]].sort().join``)||z!=z.sort((a,b)=>a-b))

Alternatywne rozwiązanie o tej samej długości:

(x,y=x.split`
`.map(a=>a.split`|`),z=y.map(a=>a[0]))=>!(/[^0-9|\n]|^\||^.*\|.*\|.*$/m.exec(x)||/^\d+\|\n|\|$/.exec(x)||y.some((c,i,a)=>c[1]!=[...c[1]].sort().join``)||z!=z.sort((a,b)=>a-b))

Definiuje anonimową funkcję, która pobiera dane wejściowe jako ciąg wielowierszowy.

Jestem pewien, że jest coś więcej do gry w golfa, więc daj mi znać, jeśli zobaczysz jakieś możliwe ulepszenia.

Wyjaśnienie:

Funkcja sprawdza szereg złych rzeczy, a jeśli którakolwiek z nich jest prawdziwa, zwraca false (przy użyciu logicznych OR i NIE)

(x,y=x.split("\n").map(a=>a.split`|`),          //y is input in pairs of stem and leaves
z=y.map(a=>a[0]))                               //z is stems
=>                                              //defines function
!(                                              //logical not
/[^0-9|\n]|^\|/m.exec(x)                        //checks for invalid chars and blank stems
||/^\d+\|\n|\|$/.exec(x)                        //checks for stems out of range
||y.some((c,i,a)=>c.length!=2                   //checks for multiple |s in a line
||c[1]!=[...c[1]].sort().join``))               //checks if leaves are in wrong order
||z!=z.sort((a,b)=>a-b))                        //checks for stems in wrong order

W alternatywnym rozwiązaniu sprawdzanie wielu |s w wierszu odbywa się zamiast tego jako część pierwszego wyrażenia regularnego.

Partia, 409 bajtów

echo off
set/pp=||exit/b1
set t=
set i=%p:|=&set t=%
if "%t%"=="" exit/b1
for /f "delims=0123456789" %%s in ("%i%")do exit/b1
:l
set t=-
set s=%p:|=&set t=%
if "%s%"=="" exit/b1
if not "%s%"=="%i%" exit/b1
set/ai+=1
for /f "delims=0123456789" %%s in ("%t%")do exit/b1
:m
if "%t:~1,1%"=="" goto n
if %t:~0,1% gtr %t:~1,1% exit/b1
set t=%t:~1%
goto m
:n
set/pp=&&goto l
if "%t%"=="" exit/b1

Pobiera dane wejściowe na STDIN, ale wychodzi, gdy tylko zobaczy błąd.