Un automa finito non deterministico è una macchina a stati finiti in cui una tupla è mappata su più stati. Vale a dire. sostituiamo la solita funzione di transizione δ : Q × Σ → Q di un DFA con un'altra funzione Δ : Q × Σ → P ( Q ) .
Se sai cos'è un NFA, potresti voler saltare la sezione successiva.
Definizione formale
Un NFA è descritto in modo univoco da
- un insieme finito di stati
- un insieme finito di simboli
- la funzione di transizione
- lo stato iniziale
- un insieme di stati finali
La macchina inizia in e legge una stringa finita di simboli w ∈ Σ ∗ , per ogni simbolo applicherà simultaneamente la funzione di transizione con uno stato corrente e aggiungerà ogni nuovo set di stati al set di stati correnti.
Sfida
Per questa sfida ignoreremo per semplificare esso, inoltre l'alfabeto sarà sempre il (minuscole) lettere una per z e l'insieme degli stati sarà { 0 ... N } per qualche intero non negativo N . Lo stato iniziale sarà sempre 0 .
Data una parola e una descrizione dell'NFA, il tuo compito è determinare tutti gli stati finali.
Esempio
Considera la stringa e la seguente descrizione:
state, symbol, new-states
0, 'a', [1]
1, 'a', [0]
1, 'b', [1,2]
La macchina si avvierà in :
- leggi a : new states { 1 }
- leggi a : nuovi stati { 1 , 2 }
- leggi un : nuovi stati { 0 }
- leggi a : new states { 1 }
- leggi a : nuovi stati { 1 , 2 }
Quindi gli stati finali e quindi l'output sarebbero .
Nota: nel passaggio (2) la transizione dello stato mappata su ∅ poiché la descrizione include solo le transizioni verso insiemi non vuoti.
Regole
L'input consisterà in una stringa e una sorta di descrizione dell'NFA (senza transizioni ):
- la stringa di input sarà sempre l'elemento di
- input validi (non limitati a):
- lista / matrice di tuple / liste
- input separato da nuova riga
- la descrizione dell'NFA conterrà solo transizioni con set non vuoti come risultato
- puoi abbreviare le regole con gli stessi caratteri se il loro risultato è lo stesso (es. regole
0,'a',[1,2]e0,'b',[1,2]potrebbe essere abbreviato con0,"ab",[1,2] - puoi prendere ciascuna regola separatamente (es. regola
0,'a',[1,2]può essere0,'a',[1]e0,'a',[2])
- puoi abbreviare le regole con gli stessi caratteri se il loro risultato è lo stesso (es. regole
- puoi scegliere lettere maiuscole se lo desideri
- puoi prendere il numero di stati come input
- potresti assumere un qualche tipo di ordinamento degli ingressi (es. ordinato da stato o simboli)
L'output sarà un elenco / set / output separato da nuova riga ecc. Degli stati finali
- l'ordine non ha importanza
- nessun duplicato (in quanto è un set)
Casi test
Questi esempi saranno nel formato in description word -> statescui descriptionè presente un elenco di tuple (state,symbol,new-states):
[] "x" -> []
[] "" -> [0]
[(0,'a',[1]),(1,'a',[0]),(1,'b',[1,2])] "abaab" -> [1,2]
[(0,'a',[1]),(1,'a',[0]),(1,'b',[1,2])] "abc" -> []
[(0,'p',[0,1]),(0,'g',[2]),(1,'c',[1]),(1,'g',[4]),(1,'p',[2]),(2,'c',[0])] "ppcg" -> [2,4]
[(0,'f',[1]),(1,'o',[1,2]),(2,'b',[3]),(3,'a',[4]),(4,'r',[0,4])] "foobar" -> [0,4]
[(0,'f',[1]),(1,'o',[1,2]),(2,'b',[3]),(3,'a',[4]),(4,'r',[0,4])] "fooooooobar" -> [0,4]
[(0,'f',[1]),(1,'o',[1,2]),(2,'b',[3]),(3,'a',[4]),(4,'r',[0,4])] "fobarfo" -> [1,2]
[(0,'f',[1]),(1,'o',[1,2]),(2,'b',[3]),(3,'a',[4]),(4,'r',[0,4])] "foobarrf" -> [1]
[(0,'d',[1,2]),(1,'u',[2]),(2,'u',[2,3]),(2,'p',[3]),(3,'p',[3])] "dup" -> [3]
[(0,'a',[0,2]),(0,'b',[3]),(1,'a',[1]),(1,'b',[1]),(2,'b',[1,4]),(4,'b',[2])] "aab" -> [3,1,4]
[(0,'a',[0,2]),(0,'b',[3]),(1,'a',[1]),(1,'b',[1]),(2,'b',[1,4]),(4,'b',[2])] "abb" -> [1,2]