Dato uno schema che rappresenta un elenco di lunghezze e una stringa che rappresenta tali lunghezze, corrispondono?

_{Per gli interessati, questa è una domanda equivalente alla verifica se una riga o colonna di un Nonogramma può essere corretta. Tuttavia, ho omesso tutto il linguaggio relativo ai Nonogrammi per rendere la domanda meno confusa per coloro che non hanno familiarità con questi enigmi.}

Ingresso

Due righe di dati, separate da una nuova riga.

1. La prima riga sarà un elenco separato da spazi di numeri interi, ad esempio:

   3 6 1 4 6
   

   Questa riga descrive un modello di spazi riempiti di dimensioni pari all'elenco intero, separati da spazi vuoti di lunghezza sconosciuta e positiva che la seconda riga deve corrispondere. Potrebbero inoltre esserci spazi vuoti all'inizio e alla fine della stringa corrispondente.

2. La seconda riga sarà una riga che può corrispondere o meno al modello nella riga uno. È costituita interamente da #, xe _. Questa linea è garantito essere almeno finché la somma dei numeri interi nella prima linea, più il numero di interi distinti, meno 1, e può essere più lungo. Quindi la seconda riga in questo caso è garantita per essere (3+6+1+4+6) + (5) - 1lunga almeno 24 caratteri. Ecco un esempio di 24 caratteri che corrispondono al modello nella prima riga:

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

Significato dei simboli:

• # Questo rappresenta una casella piena
• x Ciò rappresenta una casella contrassegnata come "garantita essere vuota"
• _ Ciò rappresenta una casella sconosciuta / non contrassegnata.

Obbiettivo

L'idea è di:

1. Convalida che la seconda riga potrebbe essere una riga valida che soddisfa il modello della prima riga.
   • È necessario stampare un messaggio di errore non ambiguo (il modo in cui si sceglie di farlo dipende da te; gli esempi seguenti scrivono ERRORma non devono essere quei 5 caratteri) se gli spazi sconosciuti non possono essere riempiti con nessuno dei due #o xper abbinare il primo linea.
2. Stampa gli indici con indice zero degli interi che sono stati completamente inseriti nella riga, spazio delimitato. In caso di ambiguità, non stampare l'indice .

Esempi:

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.

Regole:

È possibile scrivere un programma o una funzione , che riceve l'input come stringa delimitata da nuova riga o da STDIN (o alternativa più vicina) e restituisce l'output come stringa delimitata da spazio o stampandolo su STDOUT (o alternativa più vicina). Se lo si desidera, è possibile includere una nuova riga finale finale nell'output.

Inoltre, sono vietate le scappatoie standard che non sono più divertenti .

Perl, 134 byte

(include 1 interruttore)

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

Prende due righe di input da STDIN. Deve essere rieseguito per ogni input.

L'idea è di estrarre prima tutti i possibili schemi che corrispondono alle lunghezze indicate. Ad esempio, se abbiamo le lunghezze 1 2e il motivo #_x_#_, i motivi corrispondenti sono (#, _#)e (#, #_). Quindi, concatenare i modelli corrispondenti per ogni indice, ad esempio il risultato è l'elenco (##, _##_). Ora, stampa gli indici di tutte le stringhe nell'elenco che hanno solo caratteri '#'.

Ho ottenuto il metodo per estrarre tutte le possibili corrispondenze da una regex in Perl qui .

• Spiegazione non golfata ed estesa
• ideone.com