Étant donné un modèle représentant une liste de longueurs et une chaîne représentant ces longueurs, correspondent-elles?

_{Pour les personnes intéressées, cette question équivaut à vérifier si une ligne ou une colonne d'un nonogramme peut être correcte. Cependant, j'ai omis tout le langage relatif aux nonogrammes pour rendre la question moins confuse pour ceux qui ne connaissent pas ces puzzles.}

Contribution

Deux lignes de données, séparées par une nouvelle ligne.

1. La première ligne sera une liste d'entiers séparés par des espaces, par exemple:

   3 6 1 4 6
   

   Cette ligne décrit un modèle d'espaces remplis de taille égale à la liste entière, séparés par des espaces vides de longueur positive inconnue auxquels la deuxième ligne doit correspondre. Il peut également y avoir des espaces vides au début et à la fin de la chaîne correspondante.

2. La deuxième ligne sera une ligne qui peut ou non correspondre au modèle de la ligne un. Il se compose entièrement #, xet _. Cette ligne est garantie pour être au moins aussi longue que la somme des entiers de la première ligne, plus le nombre d'entiers distincts, moins 1, et peut être plus longue. Ainsi, la deuxième ligne dans ce cas est garantie d'avoir au moins (3+6+1+4+6) + (5) - 124 caractères. Voici un exemple de ligne de 24 caractères qui correspond au modèle de la première ligne:

   ###_######_#_####_######
   

Signification des symboles:

• # Cela représente une boîte remplie
• x Cela représente une boîte marquée comme "garantie d'être vide"
• _ Cela représente une boîte inconnue / non marquée.

Objectif

L'idée est de:

1. Validez que la deuxième ligne peut être une ligne valide qui correspond au modèle de la première ligne.
   • Vous devez imprimer un message d'erreur sans ambiguïté (la façon dont vous choisissez de faire cela dépend de vous; les exemples ci-dessous écrivent ERRORmais il ne doit pas nécessairement s'agir de ces 5 caractères) si les espaces inconnus ne peuvent pas être remplis avec l'un #ou l' autre ou xcorrespondre au premier ligne.
2. Affiche les index indexés zéro des entiers qui ont été complètement placés dans la ligne, séparés par des espaces. En cas d'ambiguïté, n'imprimez pas l'index .

Exemples:

Input:                    |  Output:    |  Reason:
--------------------------------------------------------------------------
3 6 1 4 6                 | 0 1 2 3 4   |  This is a complete string that 
###x######x#x####x######  |             |  matches perfectly.
--------------------------------------------------------------------------
1 2 1                     | 0 1 2       |  There is no ambiguity which filled cells 
#____xx___##__x_#         |             |  correspond to which parts of the pattern.
--------------------------------------------------------------------------
1 2 1                     |             |  I don't know whether the filled block is
____#___x                 |             |  part of the 1, 2, or 1, so output nothing.
--------------------------------------------------------------------------
1 2 1                     | ERROR       | The first unknown cell will create a block that
#_#x_#                    |             | matches either 1 1 or 3, but not 1 2.
--------------------------------------------------------------------------
1 2 1                     | 0 2         | Even though we know where all the filled cells
#____#                    |             | must be, only 0 and 2 are actually filled here.
--------------------------------------------------------------------------
1 1 1 1                   |             | There are so many possible ways to do fill this,
__#_______#____           |             | we don't know which indices are actually matched.
--------------------------------------------------------------------------
4 4                       |             | Again, we don't know WHICH 4 is matched here, 
______x####________       |             | so output nothing.
--------------------------------------------------------------------------
4 4                       | 0           | However, here, there's no room for a previous 4,
__x####________           |             | so the displayed 4 must be index 0.
--------------------------------------------------------------------------
3                         | ERROR       | We can't fit a 3 into a space before or after
__x__                     |             | the x, so this is impossible to match.
--------------------------------------------------------------------------
5 1 3                     | 0           | While we can match the 5, we don't know whether
x#####x____#____          |             | the single block matches the 1 or the 3.
--------------------------------------------------------------------------
3 2 3                     | 1           | The two has been completely placed,
____##x##____             |             | even though we don't know which it is.

Règles:

Vous pouvez écrire un programme ou une fonction , qui reçoit l'entrée sous forme de chaîne délimitée par des sauts de ligne ou de STDIN (ou l'alternative la plus proche), et renvoie la sortie sous la forme d'une chaîne délimitée par des espaces ou l'imprimant sur STDOUT (ou l'alternative la plus proche). Vous pouvez éventuellement inclure une seule nouvelle ligne de fin dans la sortie.

De plus, les failles standard qui ne sont plus drôles sont interdites .

Perl, 134 octets

(comprend 1 interrupteur)

perl -pe '$p.="([#_]{$_})[x_]+"for@l=split;chop$p,$_=<>;/^[x_]*$p*$(?{$h[$_-1].=$$_ for 1..@l})(?!)/;$_=@h?join$",grep{$h[$_]!~/_/}0..$#l:ERROR'

Prend deux lignes d'entrée de STDIN. Doit être réexécuté pour chaque entrée.

L'idée est d'extraire d'abord tous les motifs possibles qui correspondent aux longueurs données. Par exemple, si nous avons les longueurs 1 2et le motif #_x_#_, les motifs correspondants sont (#, _#)et(#, #_) . Ensuite, concaténez les modèles correspondants pour chaque index - pour l'exemple, le résultat est la liste (##, _##_). Maintenant, imprimez les index de toutes les chaînes de la liste qui n'ont que des caractères '#'.

J'ai obtenu la méthode pour extraire toutes les correspondances possibles à partir d'une expression régulière en Perl ici .

• Explication non golfée et étendue
• ideone.com