문자열 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 .

매스 매 티카, 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,...]이외 의 표현 과 표현 사이에는 차이가 없습니다 . 의 두 번째 인수에 사용하는 경우 , 표현식은 문자열의 패턴으로 처리되고, 따라서 우리는 절약 할 수 있습니다 int로서 두 번째 인수를 취함으로써 내 위의 솔루션을 통해 바이트를 표현.{a,b,...}a|b|...StringMatchQAlternatives8Alternatives

기술적으로 List는 또한 Locked사용자가 Unprotect이를 사용하고 동작을 변경 하지 못하게합니다 .

Pyth, 23 바이트

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

같은 입력을 [['string'],['list', 'of', 'parts']]받습니다. 출력은 빈 목록이거나 내부에 값이있는 목록입니다. Pyth에서는 null 문자열 ( ['']) 까지 포함하는 목록 이 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', '', '']

출력 목록에는 그 안에 많은 쓰레기가 들어 있지만 여전히 진실 된 가치입니다.

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

테스트 케이스

파이썬 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에서 시간 초과됩니다.

자바 스크립트 (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

하스켈 , 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.

@JonathanAllan "", ["The string can be constructed with nothing"]덕분 에 사례 에 버그 수정

R, 49 바이트

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

온라인으로 사용해보십시오!

Pyth, 10 8 바이트

f!-TQ./+zh

테스트 스위트

STDIN의 첫 번째 행에 목록을, 두 번째에 따옴표없이 문자열을 사용합니다.

시작하려면 목록이에 저장되고 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}  

파이썬 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 %를 모르겠습니다. 품질이 떨어집니다 ... 문자열 목록은 여기 char에 대한 포인터 배열입니다. NULL 종결 됨 algo는 쉽습니다.리스트의 모든 문자열이 "a"문자열과 일치하는 경우 선형성을 시도하는 하나의 algo가 있습니다. 문자열 목록의 인덱스를 permute하는 다른 algo가 있으므로 가능한 모든 조합을 시도하십시오.

그것을 풀고 여기에 테스트 코드와 결과

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

파이썬, 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));
}