23

एक स्ट्रिंग sऔर एक सरणी / सूची को देखते हुए l, यह निर्धारित करें कि क्या sभागों से बनाया जा सकता है या नहीं l।

उदाहरण के लिए, यदि स्ट्रिंग है "Hello, world!"और सूची है [' world!', 'Hello,'], तो प्रोग्राम / फ़ंक्शन को एक सत्य मान वापस करना चाहिए, क्योंकि आप स्ट्रिंग बनाने के लिए सूची की व्यवस्था कर सकते हैं। निम्न सूची भी एक सत्य मान लौटाएगी ['l', 'He', 'o, wor', 'd!']:। बस 'l'भरने की कल्पना करें जहां उसे स्ट्रिंग में इसकी आवश्यकता है। तो हाँ, आप स्ट्रिंग बनाने के लिए सूची के तत्वों को दोहरा सकते हैं। यदि यह स्ट्रिंग नहीं बना सकता है, तो उसे एक गलत मान वापस करना चाहिए। आईओ के मानक तरीके, मानक खामियां लागू होते हैं।

परीक्षण के मामलों:

Input (In the form of s, l)
Output (1 if possible, 0 if impossible)

"Hello, world!", ["l", "He", "o, wor", "d!"]
1

"la lal al ", ["la", " l", "al "]
1

"this is a string", ["this should return falsy"]
0

"thi is a string", ["this", "i i", " a", " string"]
0

"aaaaa", ["aa"]
0

"foo bar foobar", ["foo", "bar", " ", "spam"]
1

"ababab", ["a","ba","ab"]
1

"", ["The string can be constructed with nothing!"]
1

— कॉमरेड स्पार्कलपनी
स्रोत

अगर मुख्य स्ट्रिंग के निर्माण के लिए सरणी से अधिक तार शामिल हैं, तो क्या इससे कोई फर्क नहीं पड़ता ?

— झबरा

उन मामलों में रिटर्न वैल्यू क्या होनी चाहिए?

— झबरा

@ शगी सच यदि अतिरिक्त है, तो सभी गैर-अतिरिक्त भागों के साथ स्ट्रिंग का निर्माण किया जा सकता है। मैं एक परीक्षण मामला जोड़ूंगा।

— कॉमरेड स्पार्कलपनी

3

मैं इस परीक्षण मामले को जोड़ने की सलाह देता हूं:"ababab", ["a","ba","ab"]

— गणित दीवाने

3

मेरा सुझाव है कि आप regex metacharacters युक्त एक परीक्षण मामला जोड़ें।

— जोई

11

ब्रेकीलॉग , 8 बाइट्स

~c¬{∋¬∈}

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

यह वास्तव में धीमी है। "हैलो, दुनिया!" के लिए लगभग 37 सेकंड का समय लिया। मेरे पीसी पर टेस्ट केस, और टीआईओ पर टाइम-आउट।

यह इनपुट चर के माध्यम से स्ट्रिंग और आउटपुट चर के माध्यम से सूची लेता है

व्याख्या

             String = ?, List = .

             It is possible to find…
~c           …a deconcatenation of ?…
  ¬{   }     …such that it is impossible…
    ∋¬∈      …that an element of that deconcatenation is not an element of .

— Fatalize
स्रोत

"ला लाल अल" 60 सेकंड से अधिक ...

— रोजलूपी

1

@RosLuP इस इनपुट के साथ और ["la", " l", "al "]सूची के रूप में, यह मेरे कंप्यूटर पर समाप्त हो गया और सही ढंग से false.6800 सेकंड के बाद उत्तर दिया गया, और "केवल" 113 बिलियन इनवॉइस।

— घातक

मुझे लगता है कि इस भाषा में कुछ भी लिखने से TIO haha पर कोई कार्यक्रम नहीं चलाया जा सकता है।

— मैजिक ऑक्टोपस Urn

@carusocomputing भाषा अधिकांश कार्यक्रमों के लिए इतनी धीमी नहीं है, यह सिर्फ इतना है कि कुछ मामलों में कार्यक्रम की घोषणा के कारण, यह बहुत धीमी गति से निष्पादन समय में परिणाम होता है (जो कोड लंबाई की लागत में काफी सुधार किया जा सकता है)

— Fatalize

@ फ़ेट्रलाइज़ इर्रर ... मेरा कहने का मतलब था कि गोल्फिंग नहीं लिखना, कम निर्देशों की तरह लगता है, व्यापक "प्रश्न" बन जाता है और आपको जितनी गणना की आवश्यकता होती है। सैद्धांतिक गणित की समस्याओं के लिए एक भयानक लंगोटी की तरह लगता है।

— मैजिक ऑक्टोपस Urn

7

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

StringMatchQ[#,""|##&@@#2..]&

स्पष्टीकरण:

             #,               (* The first argument *)
StringMatchQ[                 (* matches the string pattern *)
               ""|##&         (*   Alternatives *)
                     @@       (*     applied to *)
                       #2     (*     the second argument *)
                         ..   (*   repeated *)
                           ]&

बॉर्डरलाइन धोखा समाधान, 21 बाइट्स

StringMatchQ[#,#2..]&

चूंकि मैथेमेटिका एक प्रतीकात्मक प्रोग्रामिंग भाषा है, इसलिए अभिव्यक्तियों List[a,b,...]और Alternatives[a,b,...]अन्य के बीच कोई अंतर नहीं है कि वे अन्य प्रतीकों के साथ कैसे बातचीत करते हैं और उन्हें कैसे प्रदर्शित किया जाता है ( {a,b,...}और a|b|..., क्रमशः)। जब दूसरे तर्क का उपयोग किया जाता है StringMatchQ, तो एक Alternativesअभिव्यक्ति को एक स्ट्रिंग पैटर्न के रूप में माना जाता है, और इस प्रकार हम 8दूसरे तर्क को एक Alternativesअभिव्यक्ति के रूप में लेते हुए मेरे उपरोक्त समाधान पर बाइट्स बचा सकते हैं ।

* तकनीकी रूप Listसे भी है Locked, जो उपयोगकर्ताओं को Unprotectआईएनजी से और उसके व्यवहार को बदलने से रोकता है।

— ngenisis
स्रोत

1

{x,y,z}x|y|zस्ट्रिंग पैटर्न मिलान के लिए समान माना जाता है । मुझे लगता है कि आप ""|##&@@#2..बस के साथ बदल सकते हैं #2..।

— पेड़ नहीं

5

पायथ, 23 बाइट्स

AQW&GhGJ.(G0Vf!xJTH aG>JlN;G

जैसे इनपुट लेता है [['string'],['list', 'of', 'parts']] । आउटपुट या तो एक खाली सूची है या एक सूची है जिसमें अंदर मान हैं। पायथ में, एक सूची जिसमें कुछ भी है, यहां तक कि एक नल स्ट्रिंग ( ['']), सच का मूल्यांकन करता है।

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

स्पष्टीकरण:

                             | Implicit: Q = eval(input())
AQ                           | Assign the first value of Q to G and the second to H
  W&GhG                      | While G is not empty and G doesn't contain an empty string:
       J.(G0                 |  Pop the first value of G and store into J
            Vf!xJTH          |  For N in elements in H that match the beginning of J:
                             |   Additional space for suppressing printing 
                    aG>JlN   |   Append to G the elements of J from the length of N to the end
                          ;  | End all loops
                           G | Print G

यह समाधान लगातार स्ट्रिंग की शुरुआत से हर संभावित भाग को निकालने की कोशिश करता है, और उन मूल्यों पर नज़र रखता है जिन्हें अभी भी देखने की जरूरत है।

यदि हम लूप के प्रत्येक पुनरावृत्ति के बाद Gपरीक्षण मामले के मूल्य को देखते हैं, तो [['ababab'],['a','ba','ab']]यही हमें मिलता है:

['ababab']
['babab', 'abab']
['abab', 'bab']
['bab', 'bab', 'ab']
['bab', 'ab', 'b']
['ab', 'b', 'b']
['b', 'b', '']
['b', '']
['']   <---Remember, this evaluates to True

और, परीक्षण के मामले में [['aaaaa'],['aa']], हमें यही मिलता है:

['aaaaa']
['aaa']
['a']
[]   <---And this evaluates to False

मैंने एक और टेस्ट केस बनाया, [['aaaaaa'],['a','aa','aaa']]और आउटपुट यह था:

['', 'aaa', 'aa', 'a', 'aa', 'a', '', 'a', '', 'aa', 'a', '', 'a', '', '', 'a', '', '']

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

— के झांग
स्रोत

5

पर्ल ५ , 39 बाइट्स

कोड + -pध्वज के 38 बाइट्स ।

map{chop;$v.="\Q$_\E|"}<>;$_=/^($v)*$/

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

इनपुट के लिए "Hello, world!", ["l", "He", "o, wor", "d!"](वास्तव में नईलाइन्स द्वारा अलग किया गया), यह पैटर्न का निर्माण करता है l|He|o, wor|d!|(मेटाचैकर्स बच गए, धन्यवाद के साथ \Q..\E), और फिर यह देखता है कि पहला स्ट्रिंग इस पैटर्न के साथ मेल खाता है या नहीं/^($v)*$/ ।

TryItOnline पर, ध्यान दें कि एक नई अनुगामी होने की आवश्यकता है।

— बापू
स्रोत

"हेलो, वर्ल्ड! एल हे, वर् डी!" "एल" के बाद एक जगह के साथ यह इनपुट कोई परिणाम नहीं उत्पन्न करता है

— RosLuP

@RosLuP क्या आप मुझे TryItOnline लिंक दे सकते हैं? (मुझे समझ में नहीं आ रहा है कि आपका वास्तव में क्या मतलब है। ध्यान दें कि "गलत" वास्तव में कुछ भी प्रिंट नहीं करता है क्योंकि यह पर्ल है)

— दादा

तो झूठे प्रिंट के लिए कुछ भी नहीं? इस मामले में मुझे माफ करना, लेकिन यह कोई उत्पादन मूल्य मुझे बहुत उपयोगी नहीं लगता है ...

— RosLuP

@RosLuP यह सही है। पर्ल में, undefज्यादातर बिलिन द्वारा लौटाए गए नकली मूल्य हैं। और इसे प्रिंट करते समय, यह वास्तव में कुछ भी नहीं छापता है। और ठीक यही मैं कर रहा हूं। C-जैसी भाषाओं के लिए "1/0" का मुद्रण स्वाभाविक है, लेकिन पर्ल के लिए, "1 / undef" प्राकृतिक तरीका है।

— दादा

किसी भी आउटपुट में एक अस्पष्टता नहीं है "यह चल रहा है या पहले से ही कार्यक्रम समाप्त हो गया है?"

— रोजलूपी

4

PHP, 69 बाइट्स

<?=($s=$_GET[0])>""?ctype_digit(strtr($s,array_flip($_GET[1])))?:0:1;

परीक्षण के मामलों

— जार्ग हुल्सरमैन
स्रोत

बहुत चालाक, मुझे समझने में एक मिनट लगा कि आप क्या कर रहे हैं। बॉक्स के बाहर सोच के लिए +1

— मार्टिज़न

उस पेसिक एज केस के लिए गलत नकारात्मक["", ["The string can be constructed with nothing!"]]

— जोनाथन एलन

@JonathanAllan एक रिक्त स्ट्रिंग एक स्ट्रिंग है?

— जोर्ग हल्सरमैन 20

हाँ, खाली विभाजन की समस्या कई समाधानों में एक मुद्दा है।

— जोनाथन एलन

3

पायथन 2, 141 बाइट्स

lambda s,l:s in[''.join(i)for r in range(len(s)+1)for j in combinations_with_replacement(l,r)for i in permutations(j)]
from itertools import*

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

अत्यंत अकुशल। TIO पर पहला टेस्ट केस टाइम आउट।

— गणित के दीवाने
स्रोत

3

जावास्क्रिप्ट (ईएस 6), 59 बाइट्स

सबस्ट्रिंग के सरणी aऔर sकरी सिंटैक्स में स्ट्रिंग लेता है (a)(s)। रिटर्न false/ true।

a=>g=s=>!s||a.some(e=>s.split(e)[0]?0:g(s.slice(e.length)))

टिप्पणी की गई

a =>                          // main function that takes 'a' as input
  g = s =>                    // g = recursive function that takes 's' as input
    !s ||                     // if 's' is empty, return true (success!)
    a.some(e =>               // else, for each element 'e' in 'a':
      s.split(e)[0] ?         //   if 's' doesn't begin with 'e':
        0                     //     do nothing
      :                       //   else:
        g(s.slice(e.length))  //     remove 'e' at the beginning of 's' and
    )                         //     do a recursive call on the remaining part

परीक्षण के मामलों

कोड स्निपेट दिखाएं

let f =

a=>g=s=>!s||a.some(e=>s.split(e)[0]?0:g(s.slice(e.length)))

console.log(f(["l", "He", "o, wor", "d!"])("Hello, world!"))        // true
console.log(f(["la", " l", "al "])("la lal al "))                   // true
console.log(f(["this should return falsy"])("this is a string"))    // false
console.log(f(["this", "i i", " a", " string"])("thi is a string")) // false
console.log(f(["aa"])("aaaaa"))                                     // false
console.log(f(["foo", "bar", " ", "spam"])("foo bar foobar"))       // true
console.log(f(["a","ba","ab"])("ababab"))                           // true

स्निपेट का विस्तार करें

— Arnauld
स्रोत

3

हास्केल , 35 बाइट्स

#एक Stringऔर Stringएस की सूची लेता है , और एक लौटाता है Bool।

s#l=elem s$concat<$>mapM("":)(l<$s)

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

सिर्फ टेस्ट केस से मुझे कोई आपत्ति नहीं है क्योंकि यह मेरे meager लैपटॉप की पिटाई करता है, यहाँ तक कि -O2 के साथ भी। मुझे संदेह है कि जीएचसी उस इंटरमीडिएट 30517578125 एलिमेंट लिस्ट को फ्यूज नहीं करता है, इसमें तेजी से कचरा इकट्ठा करने के लिए बहुत अधिक शेयरिंग है, और क्योंकि टेस्ट केस झूठा है इसलिए प्रोग्राम को यह सब उत्पन्न करना पड़ता है ... यदि आप कर सकते हैं तो बेझिझक करें। उसे संभालें।

mapM("":)(l<$s)length sतत्वों की एक सूची बनाने के सभी तरीकों की सूची है जो या तो खाली तार या तार हैं l।

— अर्जन जोहान्सन
स्रोत

3

पायथ, 17 15 11 14 बाइट्स

AQ|!G}Ym-dH./G

खाली स्ट्रिंग के लिए आवश्यकता बदल गई, 3 बाइट्स जोड़ना।

व्याख्या

AQ|!G}Ym-dH./G
AQ                     Save the input into G, H.
           ./G         Get all partitions of G.
       m-dH            Check if the parts are in H.
     }Y                The empty list should be present if and only
                           if the string can be made...
  |!G                  ... or the string might be empty.

पुराने संस्करणों

AQ}Ym-dH./G

ब्रह्मांड के जीवन काल में भागते और भागते !

व्याख्या

AQ}Ym-dH./G
AQ                  Save the input into G, H.
        ./G         Get all partitions of G.
    m-dH            Check if the parts are in H.
  }Y                The empty list should be present if and only
                        if the string can be made.

AQ&G}GsMs.pMy*HlG

यह भयावह रूप से धीमा है, लेकिन यह मेरे (तुच्छ रूप से छोटे) परीक्षण मामलों के लिए काम करता है।

व्याख्या

AQ&G}GsMs.pMy*HlG
AQ                  Save the input into G, H.
             *HlG   Repeat the list of substrings for each character of G.
            y       Take the power set.
         .pM        Take every permutation of each set of substrings.
      sMs           Get a list of all the joined strings.
    }G              Check if G is one of them.
  &G                Make sure G is not empty.

3

जेली , 14 12 8 बाइट्स

;FŒṖḟ€Ạ¬

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

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

;FŒṖḟ€Ạ¬   - main function, left argument s, right argument l
;F         - concatenate to the string the list, flattened to deal with "" as string
  ŒṖ       - Get all partitions of s, that is, all ways to make s from substrings
     €     - For each partition...
    ḟ      -   Filter out (exclude) those elements which are not in... 
           -   (implicit right arg) the list l. This leaves the empty set (falsy) if the partition can be made of elements from the list
      Ạ    - If any element is falsy (thus constructable from l), return 0; else return 1
       ¬   - Apply logical not to this, to yield the proper 1 = constructable from list, 0 otherwise.

मामले पर बग सुधार "", ["The string can be constructed with nothing"]@JonathanAllan करने के लिए धन्यवाद

— fireflame241
स्रोत

के लिए गलत नकारात्मक"", ["The string can be constructed with nothing!"]

— जोनाथन एलन

यह बहुत धीमा ;FŒṖḟ⁹$€Ạ¬होगा, लेकिन इसे ठीक कर देगा।

— जोनाथन एलन

... और आप के लिए एक अंतर्निहित सही तर्क का उपयोग कर सकते ḟहैं ताकि आप की आवश्यकता नहीं है, $या ⁹: ;FŒṖḟ€Ạ¬।

— जोनाथन एलन

जीआर, यही मुझे हर एक टेस्टकेस का परीक्षण नहीं करने के लिए मिलता है। मैं ¬एक ऑपरेशन के साथ 8 बाइट्स को बनाए रखने में सक्षम हो सकता हूं जो हमेशा सही तर्क के साथ सच होता है ""।

— फायरफ्लेम 241

^ अच्छी तरह से मैं इसे वापस 8 :)

— जोनाथन एलन

2

आर, 49 बाइट्स

function(s,l)gsub(paste(l,collapse='|'),"",s)==""

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

— नील
स्रोत

2

के लिए असफल होना चाहिए ('x', '.'), लेकिन नहीं है।

— जोई

2

अजगर, 10 8 बाइट्स

f!-TQ./+zh

परीक्षण सूट

यह सूची को STDIN की पहली पंक्ति पर ले जाता है, और दूसरे पर स्ट्रिंग (बिना उद्धरण के)।

शुरू करने के लिए, सूची में संग्रहीत किया जाता है Q, और स्ट्रिंग में संग्रहीत किया जाता है z। अगला, हम सभी संभव विभाजन बनाते हैं z। प्रत्येक विभाजन को फ़िल्टर किया जाएगा ( f) यह जांचने के लिए कि क्या वह केवल टुकड़ों में उपयोग करता है Q। ऐसा करने के लिए, हम के सभी तत्वों को दूर Qसे T, विभाजन हम विभाजन, और तार्किक साथ परिणाम नकारना !, ताकि केवल विभाजन जहां हर तत्व में थाQ रखा जाता है।

उस समस्या को ठीक करने के लिए ''जिसमें कोई विभाजन नहीं है, हम शब्दकोश के पहले शब्द को z में जोड़ते हैं, ताकि यह एक खाली स्ट्रिंग न हो।

— isaacg
स्रोत

परीक्षण सूट नीचे पंक्ति (एक खाली स्ट्रिंग) को याद करता है - क्या इसे उद्धृत करने की आवश्यकता है? एक खाली रेखा के साथ या ""उस मामले को विफल करने के लिए लगता है।

— जोनाथन एलन

एक खाली स्ट्रिंग में कोई विभाजन नहीं है, इसलिए यह वास्तव में यहां गलत उत्तर देता है। डार, मैं इसे ठीक करने की कोशिश करूंगा।

— isaacg

जेली के लिए मैंने जो फिक्स सुझाव दिया था, वह इनपुट स्ट्रिंग को समतल करने के लिए इनपुट सरणी के साथ समतल था, शायद आप भी ऐसा कर सकते हैं?

— जोनाथन एलन

@JonathanAllan मैंने कुछ ऐसा ही किया, धन्यवाद।

— isaacg

के मामलों "", [""]और "", []है कवर नहीं किया गया - नहीं चलते हैं वहाँ :)

— जोनाथन एलन

2

पावरशेल, 61 58 57 बाइट्स

{$s,$l=$_;$l|sort -d length|%{$s=$s.replace($_,'')};+!$s}

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

पुराने समाधान:

{$s,$l=$_;$l|sort -d length|%{$s=$s.replace($_,'')};[int]!$s}
{$s,$l=$_;$l|sort -d length|%{$s=$s.replace($_,'')};0+!$s}

— आंद्रेई ओडेगो
स्रोत

यह एक लगभग अपठनीय है, इसलिए मैं इसे थोड़ा बदलने की कोशिश करूंगा। मैं काफी निश्चित हूं कि अधिकांश अन्य लोग सहमत होंगे।

— R।

मेरे समाधान के आपके सुधार के कारण की व्याख्या के लिए धन्यवाद।

— आंद्रेई ओडेगो

1

पायथन 2, 64 बाइट्स

lambda s,l:len(re.findall("^("+"|".join(l)+")*$",s))>0
import re

यह ऑनलाइन कोशिश करो!

— नील
स्रोत

मुझे लगता है कि यह पूरी तरह से काम नहीं करता है, कोशिश करो ("aaaaaaa",["aa","aaa"])।

— xnor

@xnor मैंने इसे अपडेट किया है। पता लगाने के लिए आओ, रेगेक्स इसके लिए एकदम सही है।

— नील

4

के लिए असफल होना चाहिए ('x', '.'), मुझे लगता है, लेकिन नहीं है।

— जॉय

1

@nfnneil क्या आपने? आपका अंतिम संपादन 10 घंटे पहले हुआ था।

— डेनिस

1

... या "Hello", ["\w"]आदि

— जोनाथन एलन

1

पॉवरशेल, 78

$s,$l=$args;!($s-creplace(($l|sort -d length|%{[regex]::escape($_)})-join'|'))

बहुत सीधा सीधा रेक्सक्स-आधारित दृष्टिकोण।

— एक छोटा सा सिक्का
स्रोत

1

CJam (16 बाइट्स)

{Ma+1$,m*:e_\a&}

यह एक गुमनाम ब्लॉक (फ़ंक्शन) है जो स्टैक पर स्ट्रिंग और स्ट्रिंग के सरणी को ले जाता है। ऑनलाइन डेमो ।

यह स्पष्ट एल्गोरिथ्म का उपयोग करता है:

{        e# Declare a block. Call the args str and arr
  Ma+    e#   Add the empty string to the array
  1$,m*  e#   Take the Cartesian product of len(str) copies of (arr + [""])
  :e_    e#   Flatten each element of the Cartesian product into a single string
  \a&    e#   Intersect with an array containing only str
}

रिटर्न वैल्यू एक खाली एरे / स्ट्रिंग (मिथ्या) है यदि strनहीं बनाया जा सकता है, या एक एरे युक्त str(सत्य है, भले strही खुद खाली स्ट्रिंग हो) अगर यह बनाया जा सकता है।

— पीटर टेलर
स्रोत

@RosLuP, मुझे यकीन नहीं है कि आपका क्या मतलब है। वह विशेष परीक्षण मामला इतनी तेजी से निष्पादित होता है कि मैं वास्तव में इसे समय नहीं दे सकता। अन्य परीक्षण मामलों को निष्पादित करने में लंबा समय लगता है, लेकिन कल्पना में किसी भी समय की कमी शामिल नहीं है।

— पीटर टेलर

@RosLuP, ऑनलाइन डेमो । लेकिन मुझे समझ नहीं आ रहा है कि आपकी शिकायत क्या है।

— पीटर टेलर

1

C ++ (Bcc), 287 बाइट्स

#include<algorithm.h>
f(a,b)char*a,**b;{int i,j,k,v,p[256];if(!a||!b||!*b)return-1;for(v=0;v<256&&b[v];++v)p[v]=v;if(v>=256)return-1;la:for(i=0,j=0;j<v&&a[i];){for(k=0;b[p[j]][k]==a[i]&&a[i];++i,++k);j=b[p[j]][k]?(i-=k),j+1:0;}if(a[i]&&next_permutation(p,p+v)) goto la;return i&&!a[i];}

क्योंकि मैंने लिखा नहीं है या बहुत ज्यादा इस्तेमाल किया है next_permutation () मुझे नहीं पता कि क्या सब ठीक है। मुझे नहीं पता कि 100% अगर यह एक समाधान है, तो संभवतः यह गुणवत्ता से बाहर है ... स्ट्रिंग की एक सूची यहां एक बिंदु है चार करने के लिए; पूर्ण रूप से समाप्त किया गया एल्गो आसान है, एक ऐसा अहंकार है कि यदि सूची में सभी स्ट्रिंग तर्क के साथ फिट होते हैं, तो "स्ट्रिंग" एक "अन्य" है जो स्ट्रिंग की सूची के सूचकांक को अनुमति देता है, इसलिए यह सभी संभव संयोजन का प्रयास करता है।

यह ungolf, परीक्षण कोड और परिणाम यहाँ

#include<stdio.h>
g(a,b)char*a,**b;
{int i,j,k,v,p[256];
 if(!a||!b||!*b) return -1;
 for(v=0;v<256&&b[v];++v) p[v]=v;
 if(v>=256)      return -1; // one array of len >256 is too much
la: 
 for(i=0,j=0;j<v&&a[i];)
   {for(k=0;b[p[j]][k]==a[i]&&a[i];++i,++k); 
    j=b[p[j]][k]?(i-=k),j+1:0;
   } 
 if(a[i]&&next_permutation(p,p+v)) goto la;
 return i&&!a[i];  
}

#define F for
#define P printf

test(char* a, char** b)
{int i;
 P("f(\"%s\",[",a);
 F(i=0;b[i];++i) 
       P("\"%s\"%s", b[i], b[i+1]?", ":"");
 P("])=%d\n", f(a,b));
}

main()
{char *a1="Hello, world!",    *b1[]={"l","He", "o, worl", "d!",      0};//1
 char *a2="la lal al ",       *b2[]={"la", " l", "al ",              0};//1
 char *a3="this is a string", *b3[]={"this should return falsy",     0};//0
 char *a4="thi is a string",  *b4[]={"this", "i i", " a", " string", 0};//0
 char *a5="aaaaa",            *b5[]={"aa",                           0};//0
 char *a6="foo bar foobar",   *b6[]={"foo","bar"," ","spam",         0};//1
 char *a7="ababab",           *b7[]={"a","ba","ab",                  0};//1
 char *a8="",                 *b8[]={"This return 0 even if has to return 1", 0};//0
 char *a9="ababc",            *b9[]={"a","abc", "b", 0};//1

  test(a1,b1);test(a2,b2);test(a3,b3);test(a4,b4);test(a5,b5);test(a6,b6);
  test(a7,b7);test(a8,b8);test(a9,b9);
}

f("Hello, world!",["l", "He", "o, worl", "d!"])=1
f("la lal al ",["la", " l", "al "])=1
f("this is a string",["this should return falsy"])=0
f("thi is a string",["this", "i i", " a", " string"])=0
f("aaaaa",["aa"])=0
f("foo bar foobar",["foo", "bar", " ", "spam"])=1
f("ababab",["a", "ba", "ab"])=1
f("",["This return 0 even if has to return 1"])=0
f("ababc",["a", "abc", "b"])=1

यह gcc C ++ कंपाइलर में संकलित होगा

#include<algorithm>

int f(char*a,char**b){int i,j,k,v,p[256];if(!a||!b||!*b)return -1;for(v=0;v<256&&b[v];++v)p[v]=v;if(v>=256)return -1;la:;for(i=0,j=0;j<v&&a[i];){for(k=0;b[p[j]][k]==a[i]&&a[i];++i,++k);j=b[p[j]][k]?(i-=k),j+1:0;}if(a[i]&&std::next_permutation(p,p+v))goto la;return i&&!a[i];}

— RosLuP
स्रोत

होगा प्यार सी ++! :)

— मेमार्क

1

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

lambda s,l:s==''or any(x==s[:len(x)]and f(s[len(x):],l)for x in l)

Ungolfed:

def f(s,l):
    if s=='': 
        return 1
    for x in l:
        if s.startswith(x) and f(s[len(x):],l):
            return 1
    return 0

— RootTwo
स्रोत

0

Microsoft Sql सर्वर, 353 बाइट्स

u as(select s.n,s collate Latin1_General_BIN s,l collate Latin1_General_BIN l,
row_number()over(partition by l.n order by len(l)desc)r from s,l where s.n=l.n),
v as(select n,s,l,replace(s,l,'')c,r from u where r=1 union all
select u.n,u.s,u.l,replace(v.c,u.l,''),u.r from v,u where v.n=u.n and v.r+1=u.r)
select s,iif(min(c)='',1,0)u from v group by n,s

इसे ऑनलाइन टेस्ट करें।

पठनीय संस्करण:

with s as(
  select n,s
  from(values(1,'Hello, world!'),
             (2,'la lal al '),
             (3,'this is a string'),
             (4,'thi is a string'),
             (5,'aaaaa'),
             (6,'foo bar foobar'),
             (7,'ababab'),
             (8,''))s(n,s)),
l as(
  select n,l
  from(values(1,'l'),(1,'He'),(1,'o, wor'),(1,'d!'),
             (2,'la'),(2,' l'),(2,'al '),
             (3,'this should return falsy'),
             (4,'this'),(4,'i i'),(4,' a'),(4,' string'),
             (5,'aa'),
             (6,'foo'),(6,'bar'),(6,' '),(6,'spam'),
             (7,'a'),(7,'ba'),(7,'ab'),
             (8,'The string can be constructed with nothing!'))l(n,l)),
--The solution starts from the next line.
u as(
  select s.n,
    s collate Latin1_General_BIN s,
    l collate Latin1_General_BIN l,
    row_number()over(partition by l.n order by len(l)desc)r
  from s,l
  where s.n=l.n),
v as(
  select n,s,l,replace(s,l,'')c,r from u where r=1
    union all
  select u.n,u.s,u.l,replace(v.c,u.l,''),u.r
  from v,u
  where v.n=u.n and v.r+1=u.r
)
select s,iif(min(c)='',1,0)u from v group by n,s

— आंद्रेई ओडेगो
स्रोत

0

सी, 140 बाइट्स

मुझे यकीन है कि सी में ऐसा करने का एक छोटा तरीका है, लेकिन मैं एक समाधान बनाना चाहता था जो सामान्य खोज / प्रतिस्थापन विधि के बजाय सबस्ट्रिंग के सभी संभावित संयोजनों का परीक्षण करता है।

char p[999];c,o;d(e,g,l,f)int*e,**g,**l;{c=f&&c;for(l=g;*l;)strcpy(p+f,*l++),(o=strlen(p))<strlen(e)?d(e,g,0,o):(c|=!strcmp(e,p));return c;}

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

Ungolfed:

#include <string.h>
#include <stdio.h>

char buf[999];
int result;
int temp;

int test(char *text, char **ss, char **ptr, int length) 
{
    if (length == 0)
        result = 0;

    for(ptr = ss; *ptr; ptr++)
    {
        strcpy(buf + length, *ptr);
        temp = strlen(buf);
        if (temp < strlen(text))
        {
            // test recursivly
            test(text, ss, 0, temp);
        }
        else
        {
            if (strcmp(buf, text) == 0)
                result = 1;
        }
    }
    return result;
}

int main()
{
    char *text = "Hello,World";
    char *keywords[] = { "World", "Hello", ",", 0 };
    printf("%d", test(text, keywords, 0, 0));
}

— जोहान डू टिट
स्रोत

टेस्ट अगर एक स्ट्रिंग को सबस्ट्रिंग के साथ बनाया जा सकता है!

ब्रेकीलॉग , 8 बाइट्स

व्याख्या

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

स्पष्टीकरण:

बॉर्डरलाइन धोखा समाधान, 21 बाइट्स

पायथ, 23 बाइट्स

पर्ल ५ , 39 बाइट्स

PHP, 69 बाइट्स

पायथन 2, 141 बाइट्स

जावास्क्रिप्ट (ईएस 6), 59 बाइट्स

टिप्पणी की गई

परीक्षण के मामलों

हास्केल , 35 बाइट्स

पायथ, 17 15 11 14 बाइट्स

जेली , 14 12 8 बाइट्स

आर, 49 बाइट्स

अजगर, 10 8 बाइट्स

पावरशेल, 61 58 57 बाइट्स

पायथन 2, 64 बाइट्स

पॉवरशेल, 78

CJam (16 बाइट्स)

C ++ (Bcc), 287 बाइट्स

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

Ungolfed:

Microsoft Sql सर्वर, 353 बाइट्स

सी, 140 बाइट्स