Oto jeden dla wszystkich, którzy tam są! Napisz program lub funkcję, która pobiera listę słów i tworzy listę wszystkich możliwych rozkładów konkatenatywnych dla każdego słowa. Na przykład:

(Uwaga: jest to tylko niewielkie próbkowanie w celach ilustracyjnych. Rzeczywista wydajność jest znacznie większa.)

afterglow = after + glow
afterglow = aft + erg + low
alienation = a + lie + nation
alienation = a + lien + at + i + on
alienation = a + lien + at + ion
alienation = alien + at + i + on
alienation = alien + at + ion
archer = arc + her
assassinate = ass + as + sin + ate
assassinate = ass + ass + in + ate
assassinate = assassin + ate
backpedalled = back + pedal + led
backpedalled = back + pedalled
backpedalled = backpedal + led
goatskin = go + at + skin
goatskin = goat + skin
goatskin = goats + kin
hospitable = ho + spit + able
temporally = tempo + rally
windowed = win + do + wed
windowed = wind + owed
weatherproof = we + at + her + pro + of
yeasty = ye + a + sty

Ok, masz pomysł. :-)

Zasady

• Użyj dowolnego wybranego języka programowania. Wygrywa najkrótszy kod według liczby znaków dla każdego języka . Oznacza to, że jest jeden zwycięzca na każdy używany język. Ogólny zwycięzca będzie po prostu najkrótszym kodem ze wszystkich przesłanych.
• Lista wejściowa może być plikiem tekstowym, standardowym lub dowolną strukturą listy zapewnianą przez Twój język (lista, tablica, słownik, zestaw itp.). Słowami mogą być angielski lub dowolny inny język naturalny. (Jeśli lista zawiera angielskie słowa, zignoruj ​​lub odfiltruj elementy jednuliterowe z wyjątkiem „a” i „i”. Podobnie, w przypadku innych języków, zignoruj ​​elementy bezsensowne, jeśli są one pojawiają się w pliku).
• Lista wyjściowa może być plikiem tekstowym, standardowym plikiem wyjściowym lub dowolną strukturą listy używaną przez język.
• Możesz użyć dowolnego słownika wejściowego, który ci się podoba, ale prawdopodobnie będziesz chciał użyć takiego, który zawiera sensowne słowa, a nie takiego, który zapewnia zbyt wiele niejasnych, tajemnych lub obnubilowanych słów. Tego pliku użyłem: Lista kaczan kukurydzy zawierająca ponad 58000 angielskich słów

pytania

To wyzwanie polega przede wszystkim na napisaniu kodu do wykonania zadania, ale fajnie jest też przeczesywać wyniki ...

1. Jakie słowa podrzędne występują najczęściej?
2. Jakie słowo można rozłożyć na największą liczbę słów podrzędnych?
3. Jakie słowo można rozłożyć na różne sposoby?
4. Jakie słowa składają się z największych słów podrzędnych?
5. Jakie rozkłady były najbardziej zabawne?

Python 186

a=open(raw_input()).read().split()
def W(r):
 if r:
    for i in range(1,len(r)+1):
     if r[:i]in a:
        for w in W(r[i:]):yield[r[:i]]+w
 else:yield[]
while 1:
 for f in W(raw_input()):print f

Niezbyt wydajny, ale w rzeczywistości nie straszny powolny. Po prostu naiwnie (przypuszczam, że jest to możliwe, choć wydaje mi się mało prawdopodobne, aby Python dokonał pewnych sprytnych optymalizacji) sprawdza, czy pod-słowa znajdują się w słowniku kaczan kukurydzy i rekurencyjnie wyszukuje jak najwięcej słów. Oczywiście ten słownik jest dość obszerny i możesz wypróbować taki, który nie zawiera różnych skrótów i akronimów (prowadzących do takich rzeczy bedridden: be dr id den). Również w dołączonym słowniku nie było „A” ani „I” wymienionych jako słowa, więc dodałem je ręcznie.

Edytować:

Teraz pierwszym wejściem jest nazwa pliku słownika, którego należy użyć, a każdy dodatkowy to słowo.

Kobra - 160

sig Z(x,y)
def f(b)
    c as Z=do(x,y)
        if x.length<1,print y
        for z in File.readLines('t'),if z==x[:e=z.length].toLower,c(x[e:],y+' '+z)
    for t in b,c(t,'[t]:')

Jest to funkcja (sortowanie dwóch funkcji), która pobiera List<of String>* i wypisuje ciągi znaków zawierające możliwe układy słów podrzędnych dla każdego łańcucha na liście argumentów.

* typ jest w rzeczywistości List<of dynamic?>, ale podanie czegoś innego niż List<of String>prawdopodobnie go zepsuje.

Scala, 132 129

Edycja: nieco krótsza jako odczyt w pętli ze standardowego wejścia niż funkcja

while(true)print(readLine.:\(Seq(List(""))){(c,l)=>l.flatMap{m=>Seq(c+""::m,c+m.head::m.tail)}}filter(_.forall(args contains _)))

Uruchom jako

scala decompose.scala aft after erg glow low

(lub użyj dłuższej listy słów :))

Oryginalny:

def f(s:Seq[String])=s.map{_.:\(Seq(List(""))){(c,l)=>l.flatMap{m=>Seq(c+""::m,c+m.head::m.tail)}}filter(_.forall(args contains _))}

Funkcja od Seq [String] do Seq [Seq [List [String]]]. Pobiera słownik jako argumenty wiersza poleceń.

Nie golfowany:

def decompose(wordList: Seq[String]) =
  wordList.map{ word =>                              // for each word
    word.foldRight(Seq(List(""))){ (char, accum) =>  // for each character
      accum.flatMap{list =>
        Seq(char+""::list,char+list.head::list.tail) // add it as both a new list and 
      }                                              // the to start of the first list
    }.filter(_.forall(args contains _))              // filter out lists w/ invalid words
  }

Podejście polega na wygenerowaniu wszystkich możliwych list podciągów i odfiltrowaniu tych, które zawierają ciąg nieobecny w słowniku. Zauważ, że niektóre wygenerowane podciągi zawierają dodatkowy pusty ciąg, zakładam, że pusty ciąg nie będzie w słowniku (i tak nie ma możliwości przekazania go w wierszu poleceń).