文字列sと配列/リストlを指定すると、sからの部分で作成できるかどうかを判断しlます。

たとえば、文字列が"Hello, world!"でリストがの[' world!', 'Hello,']場合、プログラム/関数は真の値を返す必要があります。これは、文字列を形成するようにリストを配置できるためです。次のリストも真偽値を返します['l', 'He', 'o, wor', 'd!']。'l'ひもの中の必要な場所を埋めることを想像してください。そのため、リストの要素を繰り返して文字列を形成できます。文字列を形成できない場合、偽の値を返す必要があります。IOの標準的な方法、標準的な抜け穴が適用されます。

テストケース：

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

Brachylog、8バイト

~c¬{∋¬∈}

オンラインでお試しください！

これは本当に遅いです。「Hello、world！」のために約37秒かかった PCでテストケースを実行し、TIOでタイムアウトしました。

これは、入力変数を介して文字列を取得し、出力変数を介してリストを取得します

説明

             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 .

Mathematica、29バイト

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

説明：

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

ボーダーラインチートソリューション、21バイト

StringMatchQ[#,#2..]&

Mathematicaはシンボリックプログラミング言語であるため、式List[a,b,...]とAlternatives[a,b,...]他のシンボルとの相互作用と表示方法（{a,b,...}およびa|b|...それぞれ）以外に違いはありません* 。の2番目の引数で使用するStringMatchQと、Alternatives式は文字列パターンとして扱われるため8、2番目の引数をAlternatives式として使用することで、上記のソリューションよりもバイトを節約できます。

*技術的ListにもですLocked。これにより、ユーザーはUnprotectこれを実行したり、動作を変更したりできなくなります。

Pyth、23バイト

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

のような入力を受け取ります[['string'],['list', 'of', 'parts']]。出力は、空のリストか、値が内部にあるリストです。Pythでは、ヌル文字列（['']）でさえも何かを含むリストはtrueと評価されます。

オンラインでお試しください！

説明：

                             | 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

このソリューションは、文字列の先頭から考えられるすべての部分を継続的に削除しようと試み、まだどの値を調べる必要があるかを追跡します。

whileループの各反復後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', '', '']

出力リストには、その中に大量のゴミが含まれていますが、それでも真実の値です。

Perl 5、39バイト

38バイトのコード+ -pフラグ。

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

オンラインでお試しください！

入力"Hello, world!", ["l", "He", "o, wor", "d!"]（実際には改行で区切られている）の場合、パターンを構築しl|He|o, wor|d!|（メタ文字をエスケープしたため、のおかげで\Q..\E）、最初の文字列がでこのパターンに一致するかどうかを調べ/^($v)*$/ます。

TryItOnlineで、末尾に改行が必要であることに注意してください。

PHP、69バイト

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

テストケース

Python 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でタイムアウトします。

JavaScript（ES6）、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

Haskell、35バイト

#Stringとのリストを受け取りString、を返しますBool。

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

オンラインでお試しください！

-O2を使用しても、貧弱なラップトップをスラッシングしたため、私が省略したテストケースを気にしないでください。GHCは中間の30517578125要素リストを融合させず、ガベージコレクションを迅速に行うには共有が多すぎると思います。テストケースが偽であるため、プログラムはすべてを生成する必要があります。それを処理します。

mapM("":)(l<$s)はlength s空の文字列またはからの文字列である要素のリストを作成するすべての方法のリストですl。

Pyth、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.

ゼリー、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によるケースのバグ修正

R、49バイト

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

オンラインでお試しください！

Pyth、10 8バイト

f!-TQ./+zh

テストスイート

これは、STDINの最初の行にリストを取り、2番目に文字列（引用符なし）を取ります。

まず、リストはに保存されQ、文字列はに保存されzます。次に、の可能なすべてのパーティションを形成しますz。各パーティションfは、の断片のみを使用するかどうかをチェックするためにフィルターされます（）Q。これを行うには、パーティション化するパーティションQfromのすべての要素を削除し、すべての要素が含まれTているパーティション!のみQが保持されるように、結果を論理的に否定します。

''パーティションがない問題を修正するために、辞書の最初の単語をzに追加して、空の文字列にならないようにします。

PowerShell、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}  

Python 2、64バイト

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

これをオンラインで試してください！

PowerShell、78

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

かなり簡単な正規表現ベースのアプローチ。

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は（それ自体が空の文字列であっても真実の）配列です。

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％かどうかはわかりませんが、これは品質が悪い可能性があります。NULLで終わるアルゴリズムは簡単です。リスト内のすべての文字列が引数「a」文字列に適合する場合、線形性が試行するアルゴリズムが1つあります。

ungolf it、テストコードと結果はこちら

#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];}

Python、66バイト

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

ゴルフをしていない：

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

Microsoft SQL Server、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

C、140バイト

Cでこれを行うより短い方法があると確信していますが、通常の検索/置換メソッドの代わりに、サブストリングのすべての可能な組み合わせをテストするソリューションを作成したかったのです。

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;}

オンラインで試す

ゴルフをしていない：

#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));
}