Đưa ra một chuỗi svà một mảng / danh sách l, xác định xem scó thể được thực hiện với các phần từ hay không l.

Ví dụ: nếu chuỗi là "Hello, world!"và danh sách là [' world!', 'Hello,'], thì chương trình / hàm sẽ trả về giá trị trung thực, bởi vì bạn có thể sắp xếp danh sách để tạo thành chuỗi. Danh sách sau đây cũng sẽ trả về một giá trị trung thực : ['l', 'He', 'o, wor', 'd!']. Chỉ cần tưởng tượng 'l'điền vào nơi nó cần trong chuỗi. Vì vậy, có, bạn có thể lặp lại các yếu tố của danh sách để tạo thành chuỗi. Nếu nó không thể tạo thành chuỗi, nó sẽ trả về giá trị giả. Phương pháp chuẩn IO, sơ hở tiêu chuẩn áp dụng.

Các trường hợp thử nghiệm:

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 byte

~c¬{∋¬∈}

Hãy thử trực tuyến!

Điều này thực sự chậm. Mất khoảng 37 giây cho "Xin chào, thế giới!" trường hợp thử nghiệm trên PC của tôi và hết thời gian trên TIO.

Điều này đưa chuỗi thông qua biến Đầu vào và danh sách thông qua biến Đầu ra

Giải trình

             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 .

Toán học, 29 byte

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

Giải trình:

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

Giải pháp gian lận biên giới, 21 byte

StringMatchQ[#,#2..]&

Vì Mathematica là ngôn ngữ lập trình biểu tượng, không có sự khác biệt * giữa các biểu thức List[a,b,...]và Alternatives[a,b,...]khác với cách chúng tương tác với các biểu tượng khác và cách chúng được hiển thị ( {a,b,...}và a|b|..., tương ứng). Khi được sử dụng trong đối số thứ hai của StringMatchQ, một Alternativesbiểu thức được coi là một mẫu chuỗi và do đó chúng ta có thể lưu 8byte qua giải pháp trên của tôi bằng cách lấy đối số thứ hai làm Alternativesbiểu thức.

* Về mặt kỹ thuật Listcũng vậy Locked, nó ngăn người dùng Unprotectxâm nhập và thay đổi hành vi của nó.

Bình thường, 23 byte

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

Đưa đầu vào như thế nào [['string'],['list', 'of', 'parts']]. Đầu ra là một danh sách trống hoặc một danh sách có các giá trị bên trong. Trong Pyth, một danh sách chứa bất cứ thứ gì, thậm chí là một chuỗi null ( ['']), ước tính là đúng.

Hãy thử trực tuyến!

Giải trình:

                             | 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

Giải pháp này liên tục cố gắng loại bỏ mọi phần có thể từ đầu chuỗi và theo dõi những giá trị nào nó vẫn cần xem qua.

Nếu chúng ta xem xét giá trị của Gtrong trường hợp thử nghiệm [['ababab'],['a','ba','ab']]sau mỗi lần lặp của vòng lặp while, thì đây là những gì chúng ta nhận được:

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

Và, trong trường hợp thử nghiệm [['aaaaa'],['aa']], đây là những gì chúng ta nhận được:

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

Tôi đã tạo một trường hợp thử nghiệm khác [['aaaaaa'],['a','aa','aaa']]và kết quả đầu ra là:

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

Danh sách đầu ra chứa một đống rác bên trong nó, nhưng nó vẫn là một giá trị trung thực.

Perl 5 , 39 byte

38 byte mã + -pcờ.

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

Hãy thử trực tuyến!

Đối với đầu vào "Hello, world!", ["l", "He", "o, wor", "d!"](thực sự được phân tách bằng các dòng mới), nó xây dựng mẫu l|He|o, wor|d!|(với các siêu ký tự được thoát, nhờ \Q..\E), và sau đó xem nếu chuỗi đầu tiên khớp với mẫu này /^($v)*$/.

Trên TryItOnline, lưu ý rằng cần phải có một dòng mới.

PHP, 69 byte

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

Tủ thử

Python 2, 141 byte

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*

Hãy thử trực tuyến!

Vô cùng kém hiệu quả. Trường hợp thử nghiệm đầu tiên hết thời gian trên TIO.

JavaScript (ES6), 59 byte

Lấy mảng các chuỗi con avà chuỗi strong cú pháp currying (a)(s). Trả về false/ true.

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

Đã bình luận

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

Các trường hợp thử nghiệm

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 byte

#lấy một Stringvà một danh sách Strings, và trả về a Bool.

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

Hãy thử trực tuyến!

Đừng bận tâm đến trường hợp thử nghiệm mà tôi đã bỏ đi vì nó đã làm hỏng máy tính xách tay ít ỏi của tôi, ngay cả với -O2. Tôi nghi ngờ GHC không hợp nhất danh sách phần tử trung gian 30517578125, nó có quá nhiều chia sẻ để thu gom rác nhanh chóng và vì trường hợp thử nghiệm là sai, chương trình phải tạo ra tất cả ... hãy thử nếu bạn có thể xử lý việc đó

mapM("":)(l<$s)là một danh sách tất cả các cách tạo length sdanh sách các phần tử là chuỗi rỗng hoặc chuỗi từ l.

Pyth, 17 15 11 14 byte

AQ|!G}Ym-dH./G

Yêu cầu cho chuỗi rỗng đã thay đổi, thêm 3 byte.

Giải trình

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.

phiên bản cũ

AQ}Ym-dH./G

Ngắn hơn và chạy trong tuổi thọ của vũ trụ!

Giải trình

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

Điều này là chậm khủng khiếp, nhưng nó hoạt động cho các trường hợp thử nghiệm (tầm thường nhỏ) của tôi.

Giải trình

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.

Thạch , 14 12 8 byte

;FŒṖḟ€Ạ¬

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

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

sửa lỗi trong trường hợp "", ["The string can be constructed with nothing"]nhờ @Jonathan ALLan

R, 49 byte

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

Hãy thử trực tuyến!

Bình thường, 10 8 byte

f!-TQ./+zh

Bộ kiểm tra

Cái này lấy danh sách trên dòng đầu tiên của STDIN và chuỗi (không có dấu ngoặc kép) ở dòng thứ hai.

Để bắt đầu, danh sách được lưu trữ Qvà chuỗi được lưu trữ trong z. Tiếp theo, chúng tôi hình thành tất cả các phân vùng có thể của z. Mỗi phân vùng sẽ được lọc ( f) để kiểm tra nếu nó chỉ sử dụng các phần trong Q. Để làm điều này, chúng tôi xóa tất cả các thành phần Qtừ T, phân vùng chúng tôi đang phân vùng và phủ nhận một cách hợp lý kết quả với !, để chỉ các phân vùng chứa mọi phần tử được Qgiữ.

Để khắc phục sự cố ''không có phân vùng, chúng tôi thêm từ đầu tiên của từ điển vào z, để nó không phải là một chuỗi trống.

PowerShell, 61 58 57 byte

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

Hãy thử trực tuyến!

Giải pháp cũ:

{$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 byte

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

Hãy thử trực tuyến này!

PowerShell, 78

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

Cách tiếp cận dựa trên regex khá đơn giản.

CJam (16 byte)

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

Đây là một khối ẩn danh (hàm) lấy chuỗi và mảng chuỗi trên ngăn xếp. Bản demo trực tuyến .

Nó sử dụng thuật toán rõ ràng:

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

Giá trị trả về là một mảng / chuỗi rỗng (falsy) nếu strkhông thể được tạo hoặc một mảng chứa str(trung thực, ngay cả khi strchính nó là chuỗi rỗng) nếu nó có thể được thực hiện.

C ++ (Bcc), 287 byte

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

bởi vì tôi không viết hoặc sử dụng quá nhiều next_permuting () tôi không biết liệu tất cả có ổn không. Tôi không biết 100% nếu đó là một giải pháp quá có thể đây là chất lượng ... Một danh sách các chuỗi ở đây là một mảng các con trỏ tới char; Kết thúc NULL Algo rất dễ, có một thuật toán tuyến tính thử nếu tất cả các chuỗi trong danh sách phù hợp với đối số "a" chuỗi có một thuật toán khác cho phép chỉ số của danh sách chuỗi để nó thử tất cả các kết hợp có thể.

ungolf nó, mã kiểm tra và kết quả ở đây

#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

cái này sẽ biên dịch trong trình biên dịch 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 byte

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

Ung dung:

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

Máy chủ Microsoft Sql, 353 byte

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

Kiểm tra nó trực tuyến.

Phiên bản dễ đọc:

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 byte

Tôi chắc chắn có một cách ngắn hơn để làm điều này trong C nhưng tôi muốn tạo ra một giải pháp kiểm tra tất cả các kết hợp có thể có của các chuỗi thay vì phương pháp tìm / thay thế thông thường.

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

Dùng thử trực tuyến

Ung dung:

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