Учитывая строку букв и набор слов, выведите порядок слов, чтобы их можно было найти в строке, отбрасывая ненужные буквы. Слова могут встречаться более одного раза в наборе слов. Строка ввода и все слова будут состоять из 1 до 1000 строчных букв каждая. Буквы, которые нужно отбросить, могут встречаться внутри слов или между словами.

Ваша программа или функция может принимать буквенную строку и слова в виде списков, строки или из STDIN и должна выводить все слова в правильном порядке в виде вывода списка или строки. Если существует более одного правильного решения, выведите только одно из них. Если нет правильного решения, выведите пустой список или пустую строку.

Примеры:

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)

Это код гольф. Наименьшее количество байтов побеждает.

Изменить: Объяснил, что дополнительные символы могут быть внутри слов.

Pyth, 20 24 байт

Моя первая попытка на Pyth :)

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

Как это работает:

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))

Примечания: в третьем примере это занимает много времени ( dababbabadbaccbcbaaacdacdbdd aa bb cc dd ba ba ba ab ac da db dc).

Pyth, 10 байт

h@s./Myz.p

демонстрация

Эта программа очень грубой силы. Сначала он создает каждое подмножество входных данных, затем каждый раздел подмножеств, а затем проверяет первый, который является переупорядочением списка слов. Никакие возможности не обрабатываются ошибками без вывода на стандартный вывод, что допускается мета-консенсусом. Ошибка может быть удалена за 2 дополнительных байта.

Обратите внимание, что для многих из приведенных тестовых случаев программа не будет завершена в течение разумного периода времени.

JavaScript (ES6), 119 байт

(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)

Принимает строку и массив слов и возвращает массив слов или undefinedпри ошибке. Добавьте 2 байта, если он должен возвращать пустую строку при отказе ( ?q:``), и в этом случае эта альтернативная версия составляет всего 120 байтов и возвращает пустую строку при ошибке, и может даже сохранить 2 байта, если ей разрешено возвращать 0 при ошибке:

(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:``

(После того, как я написал это, я заметил, что алгоритм в основном совпадает с ответом @ KennyLau's Pyth.)

Отредактированное редактирование: обновлено после прояснения вопроса, но теперь очень медленно в третьем тестовом примере; Я включил его накануне вечером, а сегодня утром заметил, что он действительно нашел решение, где-то между 30 и 40 часами позже. Хотя я был действительно злым и дал ему решение (оно лучше всего работает с обратным решением, которое он проверит мгновенно).

Java 7, 256 байт

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];}

Определенно должно быть возможно сыграть в гольф, используя другой подход, но пока это подойдет.

Ungolfed & тестовый код:

Попробуй это здесь.

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"));
  }
}

Вывод:

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

Groovy (44 байта)

Я не могу поверить, что никто не использовал регулярные выражения для этого ...

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

объяснение

/${b.join('|')}/- Создать регулярное выражение, чтобы найти любое из слов в строке.
.findAll(...)- Найти и собрать все вхождения в строке в массив.
.join(" ")- Соединить массив вместе с пробелами.

По сути, если вхождений нет, массив пуст и возвращает неявную пустую строку. Если он находит вхождения, он возвращает объект массива с вхождениями, а затем выравнивает его в строку.