Ein Stamm- und Blattdiagramm zeigt eine Reihe numerischer Werte in Gruppen an, die von allen bis auf die letzte Ziffer bestimmt werden. Angenommen, wir haben diesen Datensatz:

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

Wir könnten diese Stengel- und Blattparzelle herstellen:

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

Der Stamm der ersten Zeile ist 0, daher stehen die "Blätter" - die Ziffern nach dem |- für die Werte zwischen 0 einschließlich und 10 ausschließlich. Die Blätter an jedem Stiel sind sortiert. Stängel ohne Blätter (wie 3) erscheinen immer noch in der Handlung. Der Wert von 101 liegt zwischen 100 einschließlich und 110 ausschließlich, sodass sein Stamm 10 ist (100 geteilt durch 10).

Ihre Herausforderung besteht darin, zu überprüfen, ob ein Textabschnitt eine gültige Stamm- und Blattdarstellung ist. Ein gültiger Plot erfüllt diese Regeln:

• Hat genau eine Zeile für jeden Stamm (dh 10-breite Gruppe) im Bereich der Daten (einschließlich Stämme in der Mitte des Bereichs ohne Blätter)
• Hat keine Stiele außerhalb des Bereichs
• Alle Blätter sind aufsteigend nach rechts sortiert
• Alle Stiele sind aufsteigend nach unten sortiert
• Hat nur numerische Zeichen (außer dem Trennzeichen |)

Sie müssen sich nicht mit Zahlen befassen, die Bruchteile enthalten. Sie können zusätzliche führende Nullen in den Stämmen genehmigen oder ablehnen, ein leerer Stamm ist jedoch nicht zulässig. Es wird mindestens einen Wert geben. Sie dürfen in jeder Zeile nach den Blättern nur zusätzliche Leerzeichen eingeben. Sie können eine führende und / oder nachfolgende Zeile annehmen. Alle Zeichen sind druckbar in ASCII.

Ihre Funktion oder Ihr Programm sollte einen Wahrheitswert für ein gültiges Diagramm oder einen falschen Wert für ein ungültiges Diagramm zurückgeben oder ausgeben (auf dem Bildschirm oder in der Standardausgabe). Sie können Eingaben aus der Standardeingabe, aus einer Datei, als eine große Zeichenfolge, als ein Array von Zeichenfolgen verwenden - was auch immer am bequemsten ist.

Hier sind einige Testfälle , die gültige Diagramme sind (durch Leerzeilen getrennt):

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

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

0|0

Hier sind einige Testfälle , die ungültige Darstellungen sind, mit Kommentaren rechts:

|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

Das ist Codegolf, also gewinnt der kürzeste Code! Standardlücken sind nicht zulässig.

Perl, 47 Bytes

Beinhaltet +2 für -0p

Geben Sie eine Eingabe für STDIN ein

stem.pl:

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

Pip , 60 58 + 1 = 59 Bytes

Erster Stich ins Problem, könnte wohl mehr Golf vertragen. Verwendet das -rFlag, um Eingabezeilen von stdin zu lesen. Wahrheitsausgabe ist 1, falsche Ausgabe ist 0oder leere Zeichenfolge.

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

Erklärung und Testsuite anstehend, aber in der Zwischenzeit: Probieren Sie es online aus!

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

Alternative Lösung gleicher Länge:

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

Definiert eine anonyme Funktion, die Eingaben als mehrzeilige Zeichenfolge akzeptiert.

Ich bin mir sicher, dass Golf mehr zu bieten hat. Lassen Sie mich wissen, wenn Sie Verbesserungsvorschläge sehen.

Erläuterung:

Die Funktion prüft auf eine Reihe von schlechten Dingen, und wenn eine davon wahr ist, gibt sie falsch zurück (unter Verwendung von logischen ODERs und einem NICHT).

(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

Bei der alternativen Lösung erfolgt die Überprüfung auf mehrere |s in einer Zeile stattdessen als Teil des ersten regulären Ausdrucks.

Batch, 409 Bytes

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

Übernimmt die Eingabe für STDIN, wird jedoch beendet, sobald ein Fehler auftritt.