Data una stringa di lettere e un insieme di parole, emetti un ordine delle parole in modo che possano essere trovate nella stringa facendo cadere lettere che non sono necessarie. Le parole possono capitare più di una volta nel set di parole. La stringa di input e tutte le parole saranno composte da 1 a 1000 lettere minuscole ciascuna. Le lettere da rilasciare possono apparire all'interno di parole o tra parole.

Il programma o la funzione può accettare la stringa di lettere e le parole come elenchi, stringhe o da STDIN e deve generare tutte le parole in un ordine corretto come output di elenco o stringa. Se esiste più di una soluzione corretta, emetterne solo una. Se non è possibile una soluzione corretta, emettere un elenco vuoto o una stringa vuota.

Esempi:

dogcatfrog cat frog dog
-> dog cat frog

xxcatfixsxhingonxgrapexxxfishingcxat cat grape catfish fishing
-> catfish grape fishing cat

dababbabadbaccbcbaaacdacdbdd aa bb cc dd ba ba ba ab ac da db dc
-> da ab ba ba ba cc bb aa ac dc db dd

flea antelope
->
(no solution)

Questo è il codice golf. Vince il numero più basso di byte.

Modifica: spiegato che i caratteri extra possono essere all'interno delle parole.

Pyth, 20 24 byte

Il mio primo tentativo su Pyth :)

Jcw;FG.ptJI:hJj".*"G0jdG

Come funziona:

Jcw;FG.ptJI:hJj".*"G0jdG
Jcw                         assign("J",chop(input()))
    FG.ptJ                  for G in permutations(tail(J)):
          I:hJj".*"G0        if match(head(J),join(".*",G)):
                     jdG      print(join(" ",G))

Note: ci vuole molto tempo nel terzo esempio ( dababbabadbaccbcbaaacdacdbdd aa bb cc dd ba ba ba ab ac da db dc).

Pyth, 10 byte

h@s./Myz.p

Dimostrazione

Questo programma è molto bruto. Costruisce prima ogni sottoinsieme dell'input, quindi ogni partizione dei sottoinsiemi, quindi controlla il primo che è un riordino dell'elenco di parole. Nessuna possibilità viene gestita tramite errori senza output su stdout, che è consentito dal meta consenso. L'errore può essere rimosso per 2 byte extra.

Si noti che per molti dei casi di test indicati, il programma non verrà completato in un periodo di tempo ragionevole.

JavaScript (ES6), 119 byte

(s,a,t=``,...r)=>a[0]?a.find((w,i)=>(b=[...a],b.splice(i,1),f(s,b,w+t,w,...r)))&&q:~s.search(t.split``.join`.*`)&&(q=r)

Accetta una stringa e una matrice di parole e restituisce una matrice di parole o undefinedin caso di errore. Aggiungi 2 byte se deve restituire la stringa vuota in caso di errore ( ?q:``), nel qual caso questa versione alternativa è solo 120 byte e restituisce la stringa vuota in caso di errore e può anche salvare 2 byte se è consentito restituire 0 in caso di errore:

(s,a,t=``,...r)=>a[0]?a.reduce((q,w,i)=>q||(b=[...a],b.splice(i,1),f(s,b,w+t,w,...r)),0):~s.search([...t].join`.*`)?r:``

(Dopo aver scritto questo ho notato che l'algoritmo è sostanzialmente lo stesso della risposta Pyth di @ KennyLau.)

Modifica modificata: aggiornata dopo il chiarimento della domanda, ma ora è molto lenta nel terzo caso di test; L'ho fatto partire la sera prima e stamattina ho appena notato che ha effettivamente trovato la soluzione, tra le 30 e le 40 ore dopo. Sono stato davvero cattivo e ho fornito la soluzione (funziona meglio con la soluzione inversa, che verificherà all'istante).

Java 7, 256 byte

import java.util.*;String c(String...a){Map s=new HashMap();int j,i=1,l=a[0].length();for(;i<a.length;i++)if((j=a[0].indexOf(a[i]))>-1)s.put(j,s.get(j)!=null?s.get(j)+" "+a[i]:a[i]);a[0]="";for(j=0;j<l;j++)a[0]+=s.get(j)!=null?s.get(j)+" ":"";return a[0];}

Dovrebbe essere sicuramente possibile giocare a golf più usando un approccio diverso, ma per ora lo farà ..

Codice non testato e test:

Provalo qui.

import java.util.*;
class M{
  static String c(String... a){
    Map s = new HashMap();
    int j,
        i = 1,
        l = a[0].length();
    for(; i < a.length; i++){
      if((j = a[0].indexOf(a[i])) > -1){
        s.put(j, s.get(j) != null
                  ? s.get(j) + " " + a[i]
                  : a[i]);
      }
    }
    a[0] = "";
    for(j = 0; j < l; j++){
      a[0] += s.get(j) != null
               ? s.get(j) + " "
               : "";
    }
    return a[0];
  }

  public static void main(String[] a){
    System.out.println(c("dogcatfrog", "cat", "frog", "dog"));
    System.out.println(c("xxcatfixsxhingonxgrapexxxfishingcxat", "cat", "grape", "catfish", "fishing"));
    System.out.println(
        c("dababbabadbaccbcbaaacdacdbdd ", "aa", "bb", "cc", "dd", "ba", "ba", "ba", "ab", "ac", "da", "db", "dc"));
    System.out.println(c("flea", "antelope"));
  }
}

Produzione:

dog cat frog 
cat grape fishing 
da ab ba ba ba bb db ac cc aa dd 

Groovy (44 byte)

Non posso credere che nessun altro abbia usato le regex per questo ...

{a,b->a.findAll(/${b.join('|')}/).join(" ")}

Spiegazione

/${b.join('|')}/- Crea una regex per trovare una delle parole in una stringa.
.findAll(...)- Trova e raccogli tutte le occorrenze nella stringa in un array.
.join(" ")- Unisci l'array con gli spazi.

Fondamentalmente, se non ci sono ricorrenze, l'array è vuoto e restituisce implicitamente una stringa vuota. Se trova ricorrenze, restituisce un oggetto array con le ricorrenze, quindi lo appiattisce in una stringa.