Was ist der kürzeste Weg, um zu sehen, ob eine Eingabe mit einer Programmiersprache ein Wordinian ist?

Ein Wordinian ist ein Wort, das Wörter der Länge 1 bis zur Länge des ursprünglichen Wortes enthält. Beispielsweise,

Behälter

"Ich" ist ein Wort
"in" ist ein Wort
"bin" ist ein Wort

Oder,

Bühne

'a' ist ein Wort
'ta' ist ein Wort ( ja es ist )
'age' ist ein Wort
'stag' ist ein Wort
'stage' ist ein Wort

Eingang

Ihr Code sollte ein Wort und ein Wörterbuch als Eingabe in einem angemessenen Format enthalten.

Ausgabe

Die Ausgabe sollte ein Wert sein, der "wahr" oder "falsch" anzeigt, um uns mitzuteilen, ob das Wort ein Wortinier ist.

Weitere Informationen zu Wordinians finden Sie hier .

Hier ist eine Liste von Wörtern , die ich als Eingaben und Unterwörter verwenden werde. Als Antwort auf @xnor muss es auch Unterwörter jeder Länge enthalten, keine Kette von Unterwörtern. Beachten Sie, dass nur ein Wort als Eingabe verwendet wird.

Pyth, 20 16 15 13 11 Bytes

Vielen Dank an Leaky Nun für das Speichern von 4 Bytes! Leider habe ich die gesamte Methode nachträglich geändert, aber es hat trotzdem geholfen.

gl{lM}#zQlz

Erwartet die Eingabe als Wörterbuch, gefolgt von einem Wort. Gibt True oder False aus.

Probieren Sie es hier aus!

Erläuterung:

        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.

Dies funktioniert nicht, wenn die leere Zeichenfolge ""ein gültiges Wort ist.

Python, 52 Bytes

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

Eine anonyme Funktion, die ein Wort wund ein Wörterbuch benötigt d. Es nimmt die Wörter d, die Teilzeichenfolgen von sind w, nimmt eine Menge ihrer Längen vor und prüft dann, ob es so viele unterschiedliche Längen gibt, wie Buchstaben enthalten w.

Python 3, 108 Bytes

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

Eine anonyme Funktion, die die Eingabe eines Wortes wals Zeichenfolge und eines Wörterbuchs dals Liste von Zeichenfolgen akzeptiert und Trueoder zurückgibt False.

Wie es funktioniert

Der erste Schritt ist ein Listenverständnis, das eine Liste von Listen aller wauszuschließenden Teilzeichenfolgen w, gruppiert nach Länge , generiert . Beispielsweise wird für 'stage'die Liste [['s', 't', 'a', 'g', 'e'], ['st', 'ta', 'ag', 'ge'], ['sta', 'tag', 'age'], ['stag', 'tage']]generiert. Dies wird erreicht, indem alle gültigen Startindizes ifür sjede sTeilzeichenfolgenlänge durchlaufen werden und jede -lange Teilzeichenfolge mit in Scheiben geschnitten wird w[i:i+s]. Für jede Liste in dieser Liste wird das Vorhandensein jeder Teilzeichenfolge im Wörterbuch überprüft. Aufrufen anygibt einen Treffer zurück, wenn mindestens eine Übereinstimmung für eine bestimmte Länge gefunden wird. Abschließend wird beim Aufrufen allgeprüft, ob für alle Teilzeichenfolgenlängen eine Übereinstimmung gefunden wurde, und das Ergebnis wird zurückgegeben.

Probieren Sie es auf Ideone

Ruby, 44 Bytes

• 7 Bytes weniger dank @NotThatCharles und seinen Set-Operator-Tricks!
• 2 Bytes weniger dank @Jordan mit dem Trick des sicheren Navigationsoperators Ruby 2.3 w[x]&.size:)

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

Es handelt sich um anonyme Funktionen, die ein Wort wund ein Wörterbuch (eine Reihe von Wörtern) enthalten d. Erstellt zwei Arrays: Das erste enthält die Zahlen 1 bis einschließlich der Länge von w; Das zweite Array wird dmit jedem Wort auf seine Größe abgebildet, wenn es sich um eine Teilzeichenfolge handelt w, andernfalls nil. Dann setzt es eine Subtraktion, um zu prüfen, ob das zweite Array alle Elemente des ersten Arrays enthält.

PowerShell v3 + v2 +, 127 110 70 65 Byte

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

(Ich sehe jetzt, dass mein Ansatz dem von @ xnor ähnelt, obwohl ich ihn unabhängig entwickelt habe.)

Nimmt Eingangswort $aund das Wörterbuch $d, erwartet $dals Array (siehe Beispiele unten). Durchläuft die Gesamtheit von $dund führt ein aus Where-Object, um die Einträge herauszuziehen, bei denen das aktuelle Wort $_ein regulärer Ausdruck -matchgegenüber dem Eingabewort ist $a(dh, das aktuelle Wort ist eine Teilzeichenfolge des Eingabeworts).

Wir sammeln alle diese Teilworte und leiten sie Select-Objectan den lengthParameter und die -UNique-Einschränkung weiter. Dadurch werden die eindeutigen Längen der einzelnen Teilzeichenfolgen herausgezogen. Für das Eingabewort combist dies beispielsweise ein Array von (4,2)for ('comb','om').

Wir nehmen das .countresultierende Array und vergleichen es mit dem Eingabewort .length. Wenn es gleich ist, bedeutet dies, dass jede Teilzeichenfolgenlänge im Wörterbuch enthalten ist $TRUE, andernfalls fehlt mindestens eine $FALSE. Dieser Boolesche Wert verbleibt in der Pipeline und die Ausgabe ist implizit.

NB - Dies sollte in v2 + funktionieren, da der -inOperator nicht mehr vorhanden ist, aber ich habe diese Version nicht getestet.

Beispiele

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 Bytes

Benötigt -Ekeine zusätzlichen Kosten.

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

Akzeptiert alle Eingaben über STDIN. Die erste Eingabe ist das Zielwort, der Rest der Eingabe ist das Wörterbuch. Druckt 1bei Erfolg, leere Zeichenfolge bei Fehler.

Verwendung

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

Mathematica, 90 Bytes

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

Verwendet das eingebaute von MathematicaDictionaryWordQ .

Die Eingabe dals Wörterbuch ist 5 Byte kürzer, bei langen Listen jedoch viel langsamer:

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

MATL , 15 Bytes

1 Byte gespeichert mit einer Idee aus der Antwort von @ xnor .

XXgc32>!suz1Gn=

Ausgänge 1oder 0für wahr oder falsch.

Probieren Sie es online!

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 Bytes

Beinhaltet +2 für -p0

Geben Sie ein Wort gefolgt vom Wörterbuch auf STDIN ein:

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

(Stellen Sie beim Testen unter Unix sicher, dass dictionary.txt \nals Zeilenabschluss verwendet wird, nicht \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

Durch die Verwendung eines Generatorverständnisses wird das Erstellen eines Zwischenarrays vermieden. 73 Byte ES6-Version:

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

05AB1E , 8 Bytes

ŒÃ€gZLåP

Wort als erste Eingabe, Wörterbuchliste als zweite Eingabe.

Probieren Sie es online aus oder überprüfen Sie ein paar weitere Testfälle .

Erläuterung:

Π        # 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 Bytes

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

Probieren Sie es online!

SQF , 147 Bytes

Verwenden des Formats "Funktion als Datei":

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-[""])

Anrufen als: ["WORD", DICTIONARY] call NAME_OF_COMPILED_FUNCTION

Ungolfed:

//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 - [""])