Đây là một cho tất cả các bạn wordmiths ngoài kia! Viết chương trình hoặc hàm lấy danh sách các từ và tạo danh sách tất cả các phân tách ghép có thể có cho mỗi từ. Ví dụ:

(Lưu ý: Đây chỉ là một mẫu nhỏ cho mục đích minh họa. Sản lượng thực tế có độ lớn hơn nhiều.)

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, bạn có được ý tưởng. :-)

Quy tắc

• Sử dụng bất kỳ ngôn ngữ lập trình nào bạn chọn. Mã ngắn nhất theo số ký tự cho mỗi ngôn ngữ sẽ thắng. Điều này có nghĩa là có một người chiến thắng cho mỗi ngôn ngữ được sử dụng. Người chiến thắng tổng thể sẽ chỉ đơn giản là mã ngắn nhất trong số tất cả được gửi.
• Danh sách đầu vào có thể là tệp văn bản, đầu vào tiêu chuẩn hoặc bất kỳ cấu trúc danh sách nào mà ngôn ngữ của bạn cung cấp (danh sách, mảng, từ điển, bộ, v.v.). Các từ có thể là tiếng Anh hoặc bất kỳ ngôn ngữ tự nhiên khác. (Nếu danh sách là các từ tiếng Anh, bạn sẽ muốn bỏ qua hoặc lọc trước các mục đơn lẻ ngoại trừ "a" và "i". Tương tự, đối với các ngôn ngữ khác, bạn sẽ muốn bỏ qua các mục vô nghĩa nếu chúng xuất hiện trong tập tin.)
• Danh sách đầu ra có thể là tệp văn bản, đầu ra tiêu chuẩn hoặc bất kỳ cấu trúc danh sách nào mà ngôn ngữ của bạn sử dụng.
• Bạn có thể sử dụng bất kỳ từ điển đầu vào nào bạn thích, nhưng có lẽ bạn sẽ muốn sử dụng một từ cung cấp các từ hợp lý hơn là một từ cung cấp quá nhiều từ khó hiểu, phức tạp hoặc khó hiểu. Đây là tập tin tôi đã sử dụng: Danh sách Corncob gồm hơn 58000 từ tiếng Anh

Câu hỏi

Thử thách này chủ yếu là viết mã để hoàn thành nhiệm vụ, nhưng cũng rất vui khi kết thúc các kết quả ...

1. Những từ khóa nào xảy ra phổ biến nhất?
2. Từ nào có thể được phân tách thành số lượng lớn nhất của các từ khóa phụ?
3. Từ nào có thể được phân tách theo những cách khác nhau nhất?
4. Những từ nào bao gồm các từ khóa lớn nhất?
5. Những phân tách nào bạn thấy là thú vị nhất?

Con trăn 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

Không đặc biệt hiệu quả nhưng thực sự không chậm khủng khiếp. Nó chỉ ngây thơ (tôi cho rằng điều đó là có thể, mặc dù tôi nghĩ rằng con trăn không thực hiện một số tối ưu hóa thông minh) kiểm tra các từ phụ có trong từ điển corncob và tìm thấy đệ quy càng nhiều từ càng tốt. Tất nhiên từ điển này khá rộng và bạn có thể thử một từ không bao gồm các từ viết tắt và từ viết tắt khác nhau (dẫn đến những thứ như bedridden: be dr id den). Ngoài ra, từ điển được liên kết dường như không có 'A' hoặc 'Tôi' được liệt kê dưới dạng từ nên tôi đã thêm chúng vào.

Biên tập:

Bây giờ đầu vào đầu tiên là tên tệp của từ điển sẽ sử dụng, và mỗi cái thêm vào là một từ.

Rắn hổ mang - 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]:')

Đây là một hàm (sắp xếp hai hàm) lấy List<of String>* và in các chuỗi chứa các sắp xếp từ phụ có thể có cho mỗi chuỗi trong danh sách đối số.

* loại này thực sự List<of dynamic?>, nhưng cung cấp bất cứ thứ gì khác ngoài List<of String>có thể sẽ phá vỡ nó.

Scala, 132 129

Chỉnh sửa: ngắn hơn một chút khi đọc vòng lặp từ stdin so với hàm

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

chạy như

scala decompose.scala aft after erg glow low

(hoặc sử dụng danh sách từ dài hơn :))

Nguyên:

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

Chức năng từ Seq [Chuỗi] đến Seq [Seq [Danh sách [Chuỗi]]]. Lấy từ điển làm đối số dòng lệnh.

Ung dung:

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
  }

Cách tiếp cận là tạo ra tất cả các danh sách các chuỗi con có thể và lọc ra những danh sách có chứa một chuỗi không có trong từ điển. Lưu ý rằng một số chuỗi con được tạo có chứa một chuỗi rỗng bổ sung, tôi giả sử chuỗi trống sẽ không có trong từ điển (không có cách nào để chuyển nó vào trong bất kỳ dòng lệnh nào).