Cách ngắn nhất để xem liệu đầu vào là một wordinian sử dụng bất kỳ ngôn ngữ lập trình nào?

Một wordinian là một từ có chứa các từ có độ dài 1 đến độ dài của từ gốc. Ví dụ,

thùng

'Tôi' là một từ
'trong' là một từ
'bin' là một từ

Hoặc là,

sân khấu

'a' là một từ
'ta' là một từ ( đúng vậy )
'tuổi' là một từ
'stag' là một từ
'giai đoạn' là một từ

Đầu vào

Mã của bạn nên lấy một từ và một từ điển làm đầu vào, ở bất kỳ định dạng hợp lý nào.

Đầu ra

Đầu ra phải là một giá trị để chỉ ra đúng hay sai, để cho chúng tôi biết nếu từ đó là một từ.

Để biết thêm thông tin về wordinians bấm vào đây .

Dưới đây là danh sách các từ mà tôi sẽ sử dụng làm đầu vào và từ khóa phụ. Ngoài ra, để đáp ứng với @xnor, nó phải chứa các từ khóa phụ theo từng độ dài, không phải là một chuỗi các từ khóa phụ. Lưu ý rằng chỉ có một từ sẽ được sử dụng làm đầu vào.

Pyth, 20 16 15 13 11 byte

Cảm ơn Leaky Nun vì đã tiết kiệm 4 byte! Thật không may, tôi đã thay đổi toàn bộ phương pháp sau đó, nhưng nó vẫn giúp ích.

gl{lM}#zQlz

Mong đợi đầu vào như từ điển theo sau bởi từ. Đầu ra Đúng hoặc Sai.

Hãy thử nó ở đây!

Giải trình:

        lz   Collects the length of the word  input
g             and compares it to:
 l             The length of the following:
     # Q        Select all words from the dictionary that
    } z         are contained within the input word.
  lM            Map them to their respective lengths, and
 {              then remove any duplicates.

Điều này không hoạt động nếu chuỗi trống ""là một từ hợp lệ.

Python, 52 byte

lambda w,d:len({len(x)for x in d if x in w})==len(w)

Một chức năng ẩn danh có một từ wvà từ điển d. Nó lấy các từ trong dđó là các chuỗi con w, tạo thành một tập hợp độ dài của chúng, và sau đó kiểm tra xem có nhiều độ dài khác nhau như có các chữ cái trong đó không w.

Python 3, 108 byte

lambda w,d,r=range:all(any(i in d for i in j)for j in[[w[i:i+s]for i in r(len(w)+1-s)]for s in r(1,len(w))])

Hàm ẩn danh lấy đầu vào, thông qua đối số, của một từ wdưới dạng chuỗi và từ điển dlàm danh sách các chuỗi và trả về Truehoặc False.

Làm thế nào nó hoạt động

Bước đầu tiên là một sự hiểu biết danh sách tạo ra một danh sách các danh sách của tất cả các chuỗi con wloại trừ w, được nhóm theo chiều dài. Ví dụ, cho 'stage', danh sách [['s', 't', 'a', 'g', 'e'], ['st', 'ta', 'ag', 'ge'], ['sta', 'tag', 'age'], ['stag', 'tage']]được tạo ra. Điều này đạt được bằng cách lặp qua tất cả các chỉ số bắt đầu hợp lệ icho mỗi độ dài chuỗi con svà cắt mọi schuỗi con thứ cấp bằng cách sử dụng w[i:i+s]. Đối với mỗi danh sách trong danh sách này, sự hiện diện của từng chuỗi con trong từ điển được kiểm tra; cuộc gọi anytrả về một lần truy cập nếu tìm thấy ít nhất một trận đấu trong một độ dài nhất định. Cuối cùng, gọi allkiểm tra nếu một trận đấu đã được tìm thấy cho tất cả các độ dài chuỗi con và kết quả của điều này được trả về.

Hãy thử nó trên Ideone

Ruby, 44 byte

• Giảm 7 byte nhờ @NotThatCharles và các thủ thuật điều hành thiết lập của anh ấy!
• Giảm 2 byte nhờ @Jordan với thủ thuật điều hành an toàn Ruby 2.3 w[x]&.size:)

->w,d{[*1..w.size]-d.map{|x|w[x]&.size}==[]}

Đó là một hàm ẩn danh có một từ wvà một từ điển (mảng các từ) d. Tạo hai mảng: Cái đầu tiên chứa các số từ 1 đến và bao gồm cả độ dài của w; Mảng thứ hai là dvới mỗi từ được ánh xạ tới kích thước của chúng nếu chúng là một chuỗi con của w, nếu không nil. Sau đó, nó thiết lập cơ chế để kiểm tra xem mảng thứ hai có chứa tất cả phần tử của mảng thứ nhất hay không.

PowerShell v3 + v2 +, 127 110 70 65 byte

param($a,$d)($d|?{$a-match$_}|select length -U).count-eq$a.length

(Bây giờ tôi thấy cách tiếp cận của tôi tương tự như của @ xnor, mặc dù tôi đã phát triển nó một cách độc lập)

Lấy từ $avà từ điển đầu vào $d, dự kiến $dlà một mảng (xem ví dụ bên dưới). Vòng lặp trong toàn bộ $dvà thực hiện a Where-Objectđể lấy ra các mục trong đó từ hiện tại $_là biểu thức chính -matchđối với từ đầu vào $a(nghĩa là từ hiện tại là một chuỗi con của từ đầu vào).

Chúng tôi thu thập tất cả các từ chuỗi con đó và đưa chúng Select-Objectvào lengththam số và -Uràng buộc nique. Điều đó sẽ kéo ra độ dài duy nhất của mỗi chuỗi con. Ví dụ, đối với từ đầu vào comb, đây sẽ là một mảng (4,2)cho ('comb','om').

Chúng tôi lấy .countmảng kết quả đó và so sánh nó với từ đầu vào .length. Nếu nó bằng, điều đó có nghĩa là mọi độ dài chuỗi con đều có trong từ điển, vì vậy $TRUE, nếu không, chúng ta sẽ thiếu ít nhất một, vì vậy $FALSE. Giá trị Boolean đó được để lại trên đường ống và đầu ra là ẩn.

NB - Điều này sẽ hoạt động trong v2 +, vì -innhà điều hành không còn nữa, nhưng tôi chưa thử nghiệm phiên bản đó.

Ví dụ

PS C:\Tools\Scripts\golfing> .\is-it-a-wordinian.ps1 'stage' (gc .\words.txt)
True

PS C:\Tools\Scripts\golfing> .\is-it-a-wordinian.ps1 'metal' (gc .\words.txt)
True

PS C:\Tools\Scripts\golfing> .\is-it-a-wordinian.ps1 'comb' (gc .\words.txt)
False

Perl, 86 byte

Yêu cầu -Ekhông có chi phí thêm.

chop(($s,@d)=<>);for$=(1..($x=length$s)){$-+=!!grep$s=~/$_/,grep$===y///c,@d}say$-==$x

Chấp nhận tất cả đầu vào thông qua STDIN. Đầu vào đầu tiên là từ mục tiêu, phần còn lại của đầu vào là từ điển. In 1thành công, chuỗi trống trên thất bại.

Sử dụng

perl -E 'chomp(($s,@d)=<>);for$=(1..($x=length$s)){$-+=!!grep$s=~/$_/,grep$===y///c,@d}say$-==$x' <<< 'stage
a
ta
age
stag
stage'
1
perl -E 'chomp(($s,@d)=<>);for$=(1..($x=length$s)){$-+=!!grep$s=~/$_/,grep$===y///c,@d}say$-==$x' <<< 'stage
a
at
age
stag
stage'

perl -E 'chomp(($s,@d)=<>);for$=(1..($x=length$s)){$-+=!!grep$s=~/$_/,grep$===y///c,@d}say$-==$x' <<< 'bin
i
in
bin'
1

Toán học, 90 byte

Sort[MemberQ[DictionaryWordQ/@StringPartition[#,t,1],True]~Table~{t,StringLength@#}][[1]]&

Sử dụng nội dung của Mathicala DictionaryWordQ.

Lấy đầu vào dlàm từ điển ngắn hơn 5 byte, nhưng chậm hơn nhiều cho danh sách dài:

m=MemberQ;Sort[m[d~m~#&/@StringPartition[#,t,1],True]~Table~{t,StringLength@#}][[1]]&

MATL , 15 byte

Lưu 1 byte bằng cách sử dụng một ý tưởng từ câu trả lời của @ xnor .

XXgc32>!suz1Gn=

Đầu ra 1hoặc 0cho sự thật hoặc giả.

Hãy thử trực tuyến!

XX      % Take the two inputs implicitly. Apply the second as a regex into the
        % first. Since the second input is a cell array, each of its contents is
        % applied separately as a regex. So for each dictionary word ("sub-word") 
        % this outputs the sub-word if found in the original word, or else an 
        % empty array. Gives a cell array of cells of strings
g       % Remove one level of nestedness
c       % Convert to char. This concatenates all found sub-words as rows of a 2D 
        % char array, padding with spaces as needed
32>!s   % For each row, count how many non-space characters there are. This is 
        % the length of each sub-word
uz      % Number of distinct non-zero elements
1Gn     % Push length of the original word
=       % Are they equal? Implicitly display

Perl, 42 41 byte

Bao gồm +2 cho -p0

Đưa ra từ theo sau bởi từ điển trên STDIN:

(echo stage; cat dictionary.txt) | ./wordinian.pl

(Khi kiểm tra trên unix, hãy đảm bảo dictionary.txt sử dụng \nlàm dấu kết thúc dòng, không \r\n)

wordinian.pl:

#!/usr/bin/perl -p0
s%\G.%!/^.*(.{$+[0]})\H*
\1
/%eg;$_=!//

JavaScript (Firefox 30-57), 68 byte

(w,a)=>new Set((for(x of a)if(~w.search(x))x.length)).size==w.length

Sử dụng một trình hiểu hiểu máy phát điện tránh việc tạo ra một mảng trung gian. Phiên bản ES6 73 byte:

(w,a)=>new Set(a.filter(x=>~w.search(x)).map(x=>x.length)).size==w.length

05AB1E , 8 byte

ŒÃ€gZLåP

Word là đầu vào đầu tiên, danh sách từ điển như đầu vào thứ hai.

Dùng thử trực tuyến hoặc xác minh thêm một vài trường hợp thử nghiệm .

Giải trình:

Π        # Get all possible substrings of the (implicit) input-string
 Ã        # Only keep the ones which are also in the (implicit) dictionary-list
  €g      # Get the length of each remaining string
    Z     # Push the maximum length (without popping the list)
     L    # Pop and push a list in the range [1, maximum-length]
      å   # Check for each value if it's in the list of lengths
       P  # And check if this is truthy for all
          # (then output the result implicitly as result)

Kotlin , 51 byte

{w,d->w.indices.all{w.windowed(it+1).any{it in d}}}

Hãy thử trực tuyến!

SQF , 147 byte

Sử dụng định dạng hàm dưới dạng tệp:

params["w","d"];a=[];c=count w;for"i"from 1 to c do{a=a+[""];for"j"from 0 to c-i do{q=w select[j,i];if(q in d)then{a set[i-1,q]}}};c==count(a-[""])

Gọi như: ["WORD", DICTIONARY] call NAME_OF_COMPILED_FUNCTION

Ung dung:

//name parameters
params["w", "d"];
a = []; c = count w;
//for each length of subword
for "i" from 1 to c do {
    //add entry to the `a`
    a = a + [""];
    //for each starting position for that length
    for "j" from 0 to c - i do {
        //get subword
        q = w select [j, i];
        //check if in dictionary
        if(q in d) then {
            //set the entry to the wubword
            a set [i - 1, q]
        }
    }
};
//check if length of word is equal to number of subwords
c == count (a - [""])