Qual è il modo più breve per vedere se un input è un wordiniano usando un linguaggio di programmazione?

Un wordiniano è una parola che contiene parole della lunghezza 1 della lunghezza della parola originale. Per esempio,

bidone

'I' è una parola
'in' è una parola
'bin' è una parola

O,

palcoscenico

'a' è una parola
'ta' è una parola ( sì, lo è )
'age' è una parola
'stag' è una parola
'stage' è una parola

Ingresso

Il tuo codice dovrebbe prendere una parola e un dizionario come input, in qualsiasi formato ragionevole.

Produzione

L'output dovrebbe essere un valore per indicare vero o falso, per dirci se la parola è wordiniana.

Per maggiori informazioni sui wordiniani clicca qui .

Ecco un elenco di parole che userò come input e parole chiave. Inoltre, in risposta a @xnor, deve contenere parole chiave di ogni lunghezza, non una catena di parole chiave. Si noti che verrà utilizzata solo una parola come input.

Pyth, 20 16 15 13 11 byte

Grazie a Leaky Nun per aver salvato 4 byte! Sfortunatamente, ho cambiato l'intero metodo in seguito, ma mi ha comunque aiutato.

gl{lM}#zQlz

Si aspetta un input come dizionario seguito da una parola. Output Vero o Falso.

Provalo qui!

Spiegazione:

        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.

Questo non funziona se la stringa vuota ""è una parola valida.

Python, 52 byte

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

Una funzione anonima che richiede una parola we un dizionario d. Prende le parole in dcui sono sottostringhe di w, crea un insieme delle loro lunghezze e quindi controlla che ci siano tante lunghezze distinte quante sono le lettere 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))])

Una funzione anonima che accetta input, tramite argomento, di una parola wcome stringa e di un dizionario dcome elenco di stringhe e ritorni Trueo False.

Come funziona

Il primo passo è una comprensione dell'elenco che genera un elenco di elenchi di tutte le sottostringhe di wesclusione w, raggruppate per lunghezza. Ad esempio, per 'stage', l'elenco [['s', 't', 'a', 'g', 'e'], ['st', 'ta', 'ag', 'ge'], ['sta', 'tag', 'age'], ['stag', 'tage']]viene generato. Ciò si ottiene eseguendo il loop su tutti gli indici di inizio validi iper ciascuna lunghezza della sottostringa se tagliando la ssottostringa di ogni lunghezza usando w[i:i+s]. Per ogni elenco in questo elenco, viene verificata la presenza di ogni sottostringa nel dizionario; la chiamata anyrestituisce un risultato se viene trovata almeno una corrispondenza per una determinata lunghezza. Infine, la chiamata allverifica se è stata trovata una corrispondenza per tutte le lunghezze della sottostringa e viene restituito il risultato.

Provalo su Ideone

Rubino, 44 ​​byte

• 7 byte di sconto grazie a @NotThatCharles e ai suoi trucchi con l'operatore impostato!
• 2 byte di sconto grazie a @Jordan con il trucco dell'operatore di navigazione sicura Ruby 2.3 w[x]&.size:)

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

È una funzione anonima che accetta una parola we un dizionario (matrice di parole) d. Crea due matrici: la prima contenente i numeri 1 fino alla lunghezza compresa w; Il secondo array è dcon ogni parola mappata alle loro dimensioni se sono una sottostringa di w, altrimenti nil. Quindi imposta la sottrazione per verificare se il secondo array contiene tutti gli elementi del primo array.

PowerShell v3 + v2 +, 127 110 70 65 byte

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

(Vedo ora che il mio approccio è simile a quello di @ xnor, anche se l'ho sviluppato in modo indipendente)

Accetta la parola $ae il dizionario di input $d, aspettandosi $dun array (vedere gli esempi seguenti). $dEsegue il ciclo per intero ed esegue a Where-Objectper estrarre le voci in cui la parola corrente $_è una regex -matchrispetto alla parola di input $a(ovvero, la parola corrente è una sottostringa della parola di input).

Raccogliamo tutte quelle parole di sottostringa e le inseriamo Select-Objectnel lengthparametro e nel -Uvincolo di nicchia. Ciò estrarrà le lunghezze uniche di ogni sottostringa. Ad esempio, per la parola di input comb, questo sarà un array di (4,2)per ('comb','om').

Prendiamo la .countmatrice risultante e la confrontiamo con la parola di input .length. Se è uguale a, ciò significa che ogni lunghezza della sottostringa è nel dizionario, quindi $TRUE, altrimenti ne manca almeno una, quindi $FALSE. Quel valore booleano viene lasciato sulla pipeline e l'output è implicito.

NB - Questo dovrebbe funzionare in v2 +, poiché l' -inoperatore non è più presente, ma non ho provato quella versione.

Esempi

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

Richiede -Esenza costi aggiuntivi.

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

Accetta tutti gli input tramite STDIN. Il primo input è la parola target, il resto dell'input è il dizionario. Stampa 1in caso di successo, stringa vuota in caso di errore.

uso

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 byte

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

Utilizza il built-in di MathematicaDictionaryWordQ .

Prendere input dcome dizionario è più corto di 5 byte, ma molto più lento per gli elenchi lunghi:

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

MATL , 15 byte

1 byte salvato usando un'idea dalla risposta di @ xnor .

XXgc32>!suz1Gn=

Output 1o 0per verità o falsità.

Provalo 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 byte

Include +2 per -p0

Dai la parola seguita dal dizionario su STDIN:

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

(Quando si esegue il test su unix, assicurarsi che dizionari.txt utilizzi \ncome terminatore di riga, non \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

L'uso della comprensione di un generatore evita la creazione di un array intermedio. Versione ES6 a 73 byte:

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

05AB1E , 8 byte

ŒÃ€gZLåP

Parola come primo input, elenco dei dizionari come secondo input.

Provalo online o verifica alcuni altri casi di test .

Spiegazione:

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

Provalo online!

SQF , 147 byte

Utilizzando il formato funzione-come-un-file:

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

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