Ini satu untuk semua yang Anda kata-kata di luar sana! Tulis sebuah program atau fungsi yang mengambil daftar kata-kata dan menghasilkan daftar semua dekomposisi concatenative yang mungkin untuk setiap kata. Sebagai contoh:

(Catatan: Ini hanya contoh kecil untuk tujuan ilustrasi. Output aktual jauh lebih produktif.)

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, Anda mengerti. :-)

Aturan

• Gunakan bahasa pemrograman apa pun yang Anda pilih. Kode terpendek berdasarkan jumlah karakter untuk setiap bahasa menang. Ini berarti ada satu pemenang untuk setiap bahasa yang digunakan. Pemenang keseluruhan hanya akan menjadi kode terpendek dari semua yang dikirimkan.
• Daftar input dapat berupa file teks, input standar, atau struktur daftar apa pun yang disediakan bahasa Anda (daftar, larik, kamus, set, dll.). Kata-katanya bisa bahasa Inggris atau bahasa alami lainnya. (Jika daftar adalah kata-kata bahasa Inggris, Anda akan ingin mengabaikan atau menyaring-keluar item huruf tunggal kecuali untuk "a" dan "i". Demikian pula, untuk bahasa lain, Anda akan ingin mengabaikan item yang tidak masuk akal jika mereka muncul di file.)
• Daftar output dapat berupa file teks, output standar, atau struktur daftar apa pun yang digunakan bahasa Anda.
• Anda dapat menggunakan kamus input apa pun yang Anda suka, tetapi Anda mungkin ingin menggunakan kamus yang memberikan kata-kata yang masuk akal daripada kamus yang terlalu banyak memberikan kata-kata yang tidak jelas, misterius, atau tidak jelas. Ini file yang saya gunakan: Daftar Corncob lebih dari 58000 kata bahasa Inggris

Pertanyaan

Tantangan ini terutama tentang menulis kode untuk menyelesaikan tugas, tetapi juga menyenangkan untuk menyisir hasil ...

1. Subword apa yang paling sering terjadi?
2. Kata apa yang dapat diuraikan menjadi jumlah subword terbanyak?
3. Kata apa yang dapat diuraikan dengan cara yang paling berbeda?
4. Kata-kata apa yang terdiri dari subword terbesar?
5. Dekomposisi apa yang menurut Anda paling lucu?

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

Tidak terlalu efisien tetapi sebenarnya tidak terlalu lambat. Itu hanya naif (saya kira itu mungkin, meskipun saya pikir tidak mungkin bahwa python melakukan beberapa optimasi pintar) memeriksa bahwa sub-kata dalam kamus tongkol jagung dan secara rekursif menemukan kata-kata sebanyak mungkin. Tentu saja kamus ini cukup luas dan Anda bisa mencoba yang tidak menyertakan berbagai singkatan dan akronim (mengarah ke hal-hal seperti bedridden: be dr id den). Juga kamus yang ditautkan tampaknya tidak memiliki 'A' atau 'I' terdaftar sebagai kata-kata jadi saya menambahkannya secara manual.

Edit:

Sekarang input pertama adalah nama file kamus yang akan digunakan, dan setiap tambahan adalah kata.

Cobra - 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]:')

Ini adalah fungsi (semacam-dua fungsi) yang mengambil List<of String>* dan mencetak string yang berisi pengaturan kata-kata yang mungkin untuk setiap string dalam daftar argumen.

* Jenisnya sebenarnya List<of dynamic?>, tetapi menyediakan apa pun selain List<of String>mungkin akan mematahkannya.

Scala, 132 129

Sunting: sedikit lebih pendek sebagai pengulangan dari stdin daripada fungsi

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

jalankan sebagai

scala decompose.scala aft after erg glow low

(atau gunakan daftar kata yang lebih panjang :))

Asli:

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

Berfungsi dari Seq [String] ke Seq [Seq [Daftar [String]]]. Mengambil kamus sebagai argumen baris perintah.

Tidak Disatukan:

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
  }

Pendekatan adalah untuk menghasilkan semua daftar substring yang mungkin dan menyaring yang berisi string yang tidak ada dalam kamus. Perhatikan bahwa beberapa substring yang dihasilkan mengandung string kosong tambahan, saya menganggap string kosong tidak akan ada di kamus (tidak ada cara untuk meneruskannya di baris perintah).