Un diagramma a gambo e foglia mostra un gruppo di valori numerici in gruppi, che sono determinati da tutti tranne l'ultima cifra. Ad esempio, supponiamo di avere questo set di dati:

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

Potremmo produrre questo diagramma a gambo e foglia:

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

La radice della prima riga è 0, quindi le sue "foglie" - le cifre dopo la |- rappresentano i valori compresi tra 0 inclusi e 10 esclusivi. Le foglie su ogni gambo sono ordinate. Gli steli senza foglie (come 3) appaiono ancora nella trama. Il valore di 101 è compreso tra 100 inclusi e 110 esclusivi, quindi la sua radice è 10 (100 divisa per 10).

La tua sfida è verificare se un pezzo di testo è una trama di gambo e foglia valida. Una trama valida soddisfa queste regole:

• Ha esattamente una riga per ogni gambo (vale a dire gruppo largo 10) nell'intervallo dei dati (compresi gli steli nel mezzo dell'intervallo senza foglie)
• Non ha steli al di fuori della gamma
• Tutte le foglie sono ordinate in ordine crescente verso destra
• Tutti gli steli sono ordinati in ordine crescente
• Ha solo caratteri numerici (oltre al separatore |)

Non devi avere a che fare con numeri che hanno parti frazionarie. È possibile approvare o rifiutare zeri iniziali aggiuntivi negli steli, ma non è consentito uno stelo vuoto. Ci sarà almeno un valore. Puoi assumere spazi extra solo dopo le foglie su ogni riga. Puoi assumere una nuova riga iniziale e / o finale. Tutti i caratteri saranno ASCII stampabili.

La tua funzione o programma dovrebbe restituire o produrre (sullo schermo o sullo standard output) un valore di verità per un diagramma valido o un valore di falsa per un diagramma non valido. Puoi prendere l'input dall'input standard, da un file, come una stringa grande, come una matrice di stringhe - qualunque cosa sia più conveniente.

Ecco alcuni casi di test che sono grafici validi (separati da righe vuote):

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

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

0|0

Ecco alcuni casi di test che sono grafici non validi, con commenti a destra:

|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

Questo è il codice golf, quindi vince il codice più corto! Le scappatoie standard non sono ammesse.

Perl, 47 byte

Include +2 per -0p

Dare input su STDIN

stem.pl:

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

Pip , 60 58 + 1 = 59 byte

Prima pugnalata al problema, probabilmente potrebbe usare più golf. Utilizza il -rflag per leggere le righe di input dallo stdin. L'output vero è 1, l'output falso è 0o una stringa vuota.

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

Spiegazione e test suite in sospeso, ma nel frattempo: provalo online!

JavaScript, 189 byte

(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))

Soluzione alternativa della stessa lunghezza:

(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))

Definisce una funzione anonima che accetta l'input come stringa multilinea.

Sono sicuro che c'è di più nel golf, quindi fammi sapere se vedi eventuali miglioramenti.

Spiegazione:

La funzione controlla una serie di cose cattive e, se una di queste è vera, restituisce false (usando OR logici e un NOT)

(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

Nella soluzione alternativa, il controllo di più |s in una riga viene invece eseguito come parte della prima regex.

Lotto, 409 byte

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

Riceve input su STDIN, ma esce non appena viene visualizzato un errore.