Contexte
Un arbre non étiqueté peut ressembler à ceci:
o
/ | \
o o o
| / \
o o o
Pour linéariser cet arbre, nous étiquetons d'abord chaque nœud o
avec son nombre de nœuds enfants:
3
/ | \
1 0 2
| / \
0 0 0
puis écrivez les nombres dans une liste d'une manière haletante, ce qui signifie ligne par ligne et de gauche à droite:
[3, 1, 0, 2, 0, 0, 0]
Il s'agit d'une représentation unique et sans ambiguïté de l'arbre ci-dessus, ce qui signifie que deux arbres purs différents n'auront pas les mêmes linéarisations et que nous pouvons reconstruire l'arbre d'origine à partir de la liste.
Bien que chaque arbre corresponde à une certaine liste d'entiers, chaque liste d'entiers ne représente pas un arbre linéarisé valide: par exemple [2, 0, 0, 0]
ne représente pas un arbre valide, si nous essayons de le linéariser, nous nous retrouvons avec cet arbre
[2,0,0,0] -> 2 [0,0,0] -> 2 [0,0] -> 2 [0]
/ \ / \ / \
0 0 0
mais ont encore une 0
gauche dans la liste et nulle part où le mettre. De même [2, 0]
, la linéarisation d'arbre n'est pas non plus valide, car l'arbre dé-linéarisé a une tache enfant vide:
2
/ \
0
Tâche
Étant donné une liste entière, décidez s'il s'agit d'une linéarisation valide d'un arbre en utilisant le moins d'octets possible. Vous pouvez écrire un programme complet ou une fonction.
Entrée: une liste non vide d'entiers non négatifs.
Sortie: une valeur vraie si la liste est une linéarisation d'un arbre, une valeur fausse sinon.
Cas de test
Truthy[0]
[2, 0, 0]
[1, 1, 1, 1, 1, 0]
[3, 1, 0, 2, 0, 0, 0]
[2, 0, 2, 2, 0, 0, 2, 0, 0]
[3, 2, 2, 1, 1, 1, 0, 0, 0, 0, 0]
[1, 5, 3, 0, 2, 1, 4, 0, 1, 0, 0, 2, 1, 0, 0, 1, 1, 0, 0, 0, 0, 2, 1, 0, 0, 1, 0]
Falsy
[0, 1]
[2, 0]
[2, 0, 0, 0]
[1, 0, 1]
[3, 2, 1, 0]
[2, 0, 0, 2, 0, 0]
[4, 1, 0, 3, 0, 0, 0, 0]
[4, 2, 0, 3, 1, 0, 0, 0, 0, 0]
{X0@{+\(_{\}&}/|!}
Je pense?