क्या यह एक शब्द है?

Question

यह देखने का सबसे छोटा तरीका है कि क्या कोई इनपुट किसी भी प्रोग्रामिंग भाषा का उपयोग करते हुए एक शब्द है?

एक शब्दविद एक शब्द है जिसमें मूल शब्द की लंबाई 1 की लंबाई के शब्द होते हैं। उदाहरण के लिए,

बिन

'मैं' एक शब्द है
'में' एक शब्द है
'बिन' एक शब्द है

या,

मंच

'a ’एक शब्द है is
ta’ एक शब्द है ( हाँ यह है ) is
age ’एक शब्द है
ag stag’ एक शब्द है word
stage ’एक शब्द है

इनपुट

आपके कोड को एक शब्द और एक शब्दकोष को इनपुट के रूप में लेना चाहिए, किसी भी उचित प्रारूप में।

उत्पादन

आउटपुट को सही या गलत इंगित करने के लिए एक मूल्य होना चाहिए, हमें यह बताने के लिए कि क्या शब्द एक शब्द है।

Wordinians पर अधिक जानकारी के लिए यहां क्लिक करें ।

यहां उन शब्दों की एक सूची दी गई है, जिनका मैं इनपुट और सब-पासवर्ड के रूप में उपयोग करूंगा। इसके अलावा, @xnor की प्रतिक्रिया में, इसमें प्रत्येक लंबाई के सब-पासवर्ड शामिल होने चाहिए, न कि सब-पासवर्ड की एक श्रृंखला। ध्यान दें कि इनपुट के रूप में केवल एक शब्द का उपयोग किया जाएगा।

Comments

@FryAmTheEggman मैं यहाँ पर एक पूरा शब्दकोश नहीं डाल सकता। यदि यह कोई शब्द है जो मौजूद है तो क्या होगा?

— जैक्स मारैस

मैं इनपुट के रूप में एक शब्दकोश में पास करने की सलाह दूंगा। इस तरह, परीक्षण मामलों के साथ आना आसान है (जैसा कि आप अपना छोटा शब्दकोश बना सकते हैं)

— नाथन मेरिल

क्या इसके लिए बस प्रत्येक लंबाई के सब-पासवर्ड होना चाहिए, या क्या उन्हें एक श्रृंखला बनानी होगी, जहां प्रत्येक उप-समूह एक अक्षर को पिछले में जोड़ता है?

— 18

@FryAmTheEggman मैंने सभी शब्दों की सूची की आपूर्ति करने के लिए अपने प्रश्न को संपादित किया।

— जैक्स मारैस

@JacquesMarais की अवधारणा एक शब्द और एक शब्दकोश लेने के लिए है , और यह सच है अगर यह शब्द एक शब्दकोष है (शब्दकोष के अनुसार)

— नाथन मेरिल

Answer 1

पायथ, 20 16 15 13 11 बाइट्स

4 बाइट बचाने के लिए लीक नून को धन्यवाद! दुर्भाग्य से, मैंने बाद में पूरी विधि बदल दी, लेकिन फिर भी इससे मदद मिली।

gl{lM}#zQlz

शब्द के बाद शब्दकोश के रूप में इनपुट की उम्मीद है। सच या गलत आउटपुट।

यहाँ कोशिश करो!

स्पष्टीकरण:

        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.

यह कार्य नहीं करता है यदि खाली स्ट्रिंग ""एक मान्य शब्द है।

Comments

.Eके साथ प्रतिस्थापित किया जा सकता हैs

— लीक नून

m}kHके साथ प्रतिस्थापित किया जा सकता है}RH

— लीक नून

मैं आपको सिर्फ गोल्फ कोड

— लीकी नून

Answer 2

पायथन, 52 बाइट्स

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

एक अनाम फ़ंक्शन जो एक शब्द wऔर शब्दकोश लेता है d। इसमें उन शब्दों को लिया गया है dजो कि सबस्ट्रिंग हैं w, उनकी लंबाई का एक सेट बनाता है, और फिर जाँचता है कि वहाँ जितने अक्षर हैं उतने ही अलग-अलग हैं w।

Comments

ओह मैं सिर्फ लिखा सटीक एक ही बात को छोड़कर मैं एक्स के बजाय डब्ल्यू था और [बजाय {। +1

— डैनियल

यदि आप [इसके बजाय उपयोग करते हैं तो @ काम करें {। {...}एक समुच्चय बोध है (जैसा है set([...]))।

— mbomb007

@ mbomb007, ओह सही, एक सेट की आवश्यकता होगी

— डैनियल

@xnor इस उत्तर का चयन न करने के लिए क्षमा करें, लेकिन जैसा कि यह एक कोड गोल्फ है, मुझे सबसे छोटा चयन करना है ...

— जैक्स मारैस

Answer 3

पायथन 3, 108 बाइट्स

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

एक अनाम फ़ंक्शन जो इनपुट लेता है, तर्क के माध्यम से, wएक स्ट्रिंग के रूप में एक शब्द और dस्ट्रिंग और रिटर्न की सूची के रूप में एक शब्दकोश Trueया False।

यह काम किस प्रकार करता है

पहला कदम एक सूची समझ है, उन सभी सबस्ट्रिंग की सूची की एक सूची बनाता है wको छोड़कर w, लंबाई के आधार पर वर्गीकृत। उदाहरण के लिए, 'stage'सूची के लिए , [['s', 't', 'a', 'g', 'e'], ['st', 'ta', 'ag', 'ge'], ['sta', 'tag', 'age'], ['stag', 'tage']]उत्पन्न होता है। यह iप्रत्येक प्रतिस्थापन लंबाई के लिए सभी मान्य प्रारंभ सूचकों पर लूपिंग द्वारा प्राप्त किया जाता है s, और प्रत्येक s-length का उपयोग करते हुए प्रत्येक स्लाइसिंग को स्लाइस किया जाता है w[i:i+s]। इस सूची में प्रत्येक सूची के लिए, शब्दकोश में प्रत्येक स्थानापन्न की उपस्थिति की जाँच की जाती है; कॉलिंग anyहिट देता है अगर किसी दिए गए लंबाई के लिए कम से कम एक मैच पाया जाता है। अंत में, कॉलिंग allचेक यदि सभी सबरिंग लंबाई के लिए एक मैच पाया गया है, और इसका परिणाम वापस आ गया है।

Ideone पर इसे आज़माएं

Answer 4

रूबी, 44 बाइट्स

• 7 बाइट्स @NotThatCharles और उनके सेट ऑपरेटर ट्रिक्स के लिए धन्यवाद!
• रूबी 2.3 सुरक्षित नेविगेशन ऑपरेटर चाल के साथ @ जोर्डन के लिए 2 बाइट्स धन्यवाद w[x]&.size:)

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

यह एक अनाम कार्य है जो एक शब्द wऔर एक शब्दकोश (शब्दों की सरणी) लेता है d। दो सरणियों को बनाता है: पहले नंबर जिसमें 1 तक की लंबाई और शामिल है w; दूसरा सरणी dप्रत्येक शब्द के साथ उनके आकार के लिए मैप किया जाता है यदि वे एक विकल्प हैं w, अन्यथा nil। फिर यह जांचने के लिए कि क्या दूसरे सरणी में पहले सरणी के सभी तत्व हैं, सबस्टक्शन सेट करता है।

Comments

रूबी 2.3 में "सुरक्षित नेविगेशन ऑपरेटर" के साथ आप एक युगल बाइट बचा सकते हैं: के w[x]&.size==iबजाय x.size==i&&w[x]।

— जॉर्डन

अरे वाह, धन्यवाद @ जोर्डन। पता नहीं था कि एक, भयानक :)

— daniero

आप अपने अनाम फ़ंक्शन (और शायद पूरा कार्यक्रम) को छोड़ने uniqऔर -[p]इसके बजाय सेट घटाव का उपयोग करके एक और बाइट बचा सकते हैं :[*1..w.size]-d.map{...}==[]

— नहीं कि चार्ल्स

@NhathatCharles यह शानदार है! धन्यवाद :)

— daniero

Answer 5

PowerShell v3 + v2 +, 127 110 70 65 बाइट्स

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

(मैं अब देख रहा हूं कि मेरा दृष्टिकोण @ xnor के समान है, हालांकि मैंने इसे स्वतंत्र रूप से विकसित किया है)

इनपुट शब्द $aऔर शब्दकोश लेता है $d, $dएक सरणी के रूप में उम्मीद है (नीचे उदाहरण देखें)। संपूर्ण के माध्यम से लूप $dकरता है और Where-Objectउन प्रविष्टियों को बाहर निकालने के लिए प्रदर्शन करता है जहां वर्तमान शब्द $_एक रेगीक्स है-match इनपुट शब्द के विरुद्ध है $a(यानी, मौजूदा शब्द इनपुट शब्द का एक विकल्प है)।

हम उन सब सब्स्टीट्यूटिंग वर्ड्स को इकट्ठा करते हैं और उन्हें पैरामीटर और एनआईसी बाधा Select-Objectपर पाइप करते हैं । यह प्रत्येक घटता की अनूठी लंबाई खींच लेगा। उदाहरण के लिए, इनपुट शब्द के लिए , यह एक सरणी होगीlength-Ucomb(4,2) के लिए ('comb','om')।

हम .countउस परिणामी सरणी को लेते हैं और इसकी तुलना इनपुट शब्द के खिलाफ करते हैं .length। यदि यह बराबर है, तो इसका मतलब है कि हर प्रतिस्थापन लंबाई शब्दकोश में है, इसलिए$TRUE , अन्यथा हम कम से कम एक को याद कर रहे हैं, इसलिए $FALSE। कि बूलियन मूल्य पाइपलाइन पर छोड़ दिया गया है और आउटपुट निहित है।

एनबी - यह v2 + में काम करना चाहिए , चूंकि-in ऑपरेटर अब मौजूद नहीं है, लेकिन मैंने उस संस्करण का परीक्षण नहीं किया है।

उदाहरण

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

Answer 6

पर्ल, 86 बाइट्स

आवश्यक -Eकोई अतिरिक्त कीमत पर।

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

STDIN के माध्यम से सभी इनपुट को स्वीकार करता है। पहला इनपुट लक्ष्य शब्द है, बाकी इनपुट डिक्शनरी है। 1सफलता पर प्रिंट , विफलता पर खाली स्ट्रिंग।

प्रयोग

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

Answer 7

गणितज्ञ, 90 बाइट्स

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

मैथेमेटिका के बिलिन का उपयोग करता है DictionaryWordQ।

इनपुट dको शब्दकोश के रूप में लेना 5 बाइट्स छोटा है, लेकिन लंबी सूचियों के लिए बहुत धीमा:

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

Answer 8

MATL , 15 बाइट्स

1 बाइट @ xnor के उत्तर से एक विचार का उपयोग करके बचाया गया ।

XXgc32>!suz1Gn=

आउटपुट 1या 0सत्य या झूठ के लिए।

इसे ऑनलाइन आज़माएं!

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

Answer 9

पर्ल, 42 41 बाइट्स

के लिए +2 शामिल है -p0

STDIN पर शब्दकोश के बाद शब्द दें:

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

(जब यूनिक्स पर परीक्षण करना सुनिश्चित करें कि Dictionary.txt \nलाइन टर्मिनेटर के रूप में उपयोग करता है , नहीं \r\n)

wordinian.pl:

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

Answer 10

जावास्क्रिप्ट (फ़ायरफ़ॉक्स 30-57), 68 बाइट्स

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

एक जनरेटर समझ का उपयोग एक मध्यवर्ती सरणी बनाने से बचा जाता है। 73 बाइट ES6 संस्करण:

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

Answer 11

05AB1E , 8 बाइट्स

ŒÃ€gZLåP

पहले इनपुट के रूप में शब्द, दूसरी इनपुट के रूप में शब्दकोश-सूची।

इसे ऑनलाइन आज़माएं या कुछ और परीक्षण मामलों को सत्यापित करें ।

स्पष्टीकरण:

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

Answer 12

कोटलिन , 51 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Answer 13

SQF , 147 बाइट्स

फंक्शन-ए-ए-फाइल फॉर्मेट का उपयोग करना:

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

इस रूप में कॉल करें: ["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 - [""])