Quel est le moyen le plus court pour voir si une entrée est un wordinian utilisant un langage de programmation?

Un wordinian est un mot qui contient des mots de longueur 1 à la longueur du mot d'origine. Par exemple,

poubelle

«Je» est un mot
«dans» est un mot
«bin» est un mot

Ou,

étape

'a' est un mot
'ta' est un mot ( oui c'est le cas )
'age' est un mot
'stag' est un mot
'stage' est un mot

Contribution

Votre code doit prendre un mot et un dictionnaire comme entrées, dans n'importe quel format raisonnable.

Production

La sortie doit être une valeur pour indiquer vrai ou faux, pour nous dire si le mot est un wordinien.

Pour plus d'informations sur les wordinians, cliquez ici .

Voici une liste de mots que j'utiliserai comme entrées et sous-mots. De plus, en réponse à @xnor, il doit contenir des sous-mots de chaque longueur, pas une chaîne de sous-mots. Notez qu'un seul mot sera utilisé comme entrée.

Pyth, 20 16 15 13 11 octets

Merci à Leaky Nun d'avoir économisé 4 octets! Malheureusement, j'ai changé toute la méthode par la suite, mais cela a quand même aidé.

gl{lM}#zQlz

Attend la saisie sous forme de dictionnaire suivi d'un mot. Sorties True ou False.

Essayez-le ici!

Explication:

        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.

Cela ne fonctionne pas si la chaîne vide ""est un mot valide.

Python, 52 octets

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

Une fonction anonyme qui prend un mot wet un dictionnaire d. Il prend les mots dqui sont des sous-chaînes de w, fait un ensemble de leurs longueurs, puis vérifie qu'il y a autant de longueurs distinctes qu'il y a de lettres w.

Python 3, 108 octets

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

Une fonction anonyme qui prend en entrée, via un argument, un mot wsous forme de chaîne et un dictionnaire dsous forme de liste de chaînes et renvoie Trueou False.

Comment ça fonctionne

La première étape est une compréhension de liste qui génère une liste de listes de toutes les sous-chaînes d' wexclusion w, regroupées par longueur. Par exemple, pour 'stage', la liste [['s', 't', 'a', 'g', 'e'], ['st', 'ta', 'ag', 'ge'], ['sta', 'tag', 'age'], ['stag', 'tage']]est générée. Ceci est obtenu en bouclant sur tous les indices de début valides ipour chaque longueur de sous-chaîne set en découpant chaque ssous- chaîne de longueur en utilisant w[i:i+s]. Pour chaque liste de cette liste, la présence de chaque sous-chaîne dans le dictionnaire est vérifiée; appeler anyrenvoie un hit si au moins une correspondance pour une longueur donnée est trouvée. Enfin, l'appel allvérifie si une correspondance a été trouvée pour toutes les longueurs de sous-chaîne et le résultat est renvoyé.

Essayez-le sur Ideone

Rubis, 44 octets

• 7 octets grâce à @NotThatCharles et ses astuces d'opérateur de set!
• 2 octets de moins grâce à @Jordan avec l'astuce de l'opérateur de navigation sécurisée Ruby 2.3 w[x]&.size:)

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

C'est une fonction anonyme qui prend un mot wet un dictionnaire (tableau de mots) d. Crée deux tableaux: le premier contenant les nombres 1 jusqu'à et y compris la longueur de w; Le deuxième tableau correspond dà chaque mot mappé à sa taille s'il s'agit d'une sous-chaîne de w, sinon nil. Ensuite, il définit la soustraction pour vérifier si le deuxième tableau contient tous les éléments du premier tableau.

PowerShell v3 + v2 +, 127 110 70 65 octets

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

(Je vois maintenant que mon approche est similaire à @ xnor, bien que je l'ai développée indépendamment)

Prend le mot d'entrée $aet le dictionnaire $d, en attendant $dun tableau (voir les exemples ci-dessous). Effectue une boucle sur l'intégralité de $det exécute un Where-Objectpour extraire les entrées où le mot actuel $_est une expression rationnelle par -matchrapport au mot d'entrée $a(c'est-à-dire que le mot actuel est une sous-chaîne du mot d'entrée).

Nous collectons tous ces mots de sous-chaîne et les redirigeons vers Select-Objectle lengthparamètre et la -Ucontrainte nique. Cela extraira les longueurs uniques de chaque sous-chaîne. Par exemple, pour le mot d'entrée comb, ce sera un tableau de (4,2)for ('comb','om').

Nous prenons le .countde ce tableau résultant et le comparons avec le mot d'entrée .length. Si elle est égale à, cela signifie que chaque longueur de sous-chaîne est dans le dictionnaire, donc $TRUE, sinon il nous en manque au moins une, donc $FALSE. Cette valeur booléenne est laissée sur le pipeline et la sortie est implicite.

NB - Cela devrait fonctionner en v2 +, puisque l' -inopérateur n'est plus présent, mais je n'ai pas testé cette version.

Exemples

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 octets

Nécessite -Esans frais supplémentaires.

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

Accepte toutes les entrées via STDIN. La première entrée est le mot cible, le reste de l'entrée est le dictionnaire. Imprime 1en cas de succès, chaîne vide en cas d'échec.

Usage

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 octets

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

Utilise la fonction intégrée de Mathematica DictionaryWordQ.

Prendre l'entrée en dtant que dictionnaire est 5 octets plus court, mais beaucoup plus lent pour les longues listes:

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

MATL , 15 octets

1 octet enregistré en utilisant une idée de la réponse de @ xnor .

XXgc32>!suz1Gn=

Sorties 1ou 0pour véridique ou fausse.

Essayez-le en ligne!

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 octets

Comprend +2 pour -p0

Donnez le mot suivi du dictionnaire sur STDIN:

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

(Lors des tests sur unix, assurez-vous que dictionary.txt utilise \ncomme terminateur de ligne, pas \r\n)

wordinian.pl:

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

JavaScript (Firefox 30-57), 68 octets

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

L'utilisation d'une compréhension de générateur évite de créer un tableau intermédiaire. Version ES6 73 octets:

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

05AB1E , 8 octets

ŒÃ€gZLåP

Word comme première entrée, dictionnaire-liste comme deuxième entrée.

Essayez-le en ligne ou vérifiez quelques cas de test supplémentaires .

Explication:

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

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

Essayez-le en ligne!

SQF , 147 octets

Utilisation du format de fonction en tant que fichier:

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

Appelez comme: ["WORD", DICTIONARY] call NAME_OF_COMPILED_FUNCTION

Non golfé:

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