Bir dize sve bir dizi / liste göz önüne alındığında , parçalarla yapılıp yapılamayacağını lbelirleyin .sl

Örneğin, dize "Hello, world!"ve liste ise [' world!', 'Hello,'], program / işlev bir truthy değeri döndürmelidir, çünkü listeyi dize oluşturacak şekilde düzenleyebilirsiniz. Aşağıdaki liste, bir truthy değerini döndürür: ['l', 'He', 'o, wor', 'd!']. Sadece ipte 'l'olması gereken yeri doldurmayı hayal edin . Yani evet, dizeyi oluşturmak için listenin öğelerini tekrarlayabilirsiniz. Dizeyi oluşturamazsa, sahte bir değer döndürmelidir. Standart G / Ç yöntemleri, standart boşluklar uygulanır.

Test durumları:

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 bayt

~c¬{∋¬∈}

Çevrimiçi deneyin!

Bu gerçekten yavaş. "Merhaba dünya!" İçin yaklaşık 37 saniye sürdü Bilgisayarımdaki test durumu ve TIO'da zaman aşımına uğradı.

Bu, dizeyi Girdi değişkeni ve listeyi Çıktı değişkeni aracılığıyla alır.

açıklama

             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 bayt

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

Açıklama:

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

Borderline hile çözümü, 21 bayt

StringMatchQ[#,#2..]&

Mathematica sembolik bir programlama dili olduğundan, ifadeler arasında * fark yoktur List[a,b,...]veAlternatives[a,b,...] diğer sembollerle nasıl etkileşime girdiklerinden ve nasıl gösterildiklerinden ( {a,b,...}ve a|b|...sırasıyla) . İkinci argümanda kullanıldığında StringMatchQ, bir Alternativesifade bir dize deseni olarak değerlendirilir ve böylece 8ikinci argümanı bir Alternativesifade olarak alarak bayt'ı yukarıdaki çözümümden kurtarabiliriz .

* Teknik Listolarak da Locked, kullanıcıların engellerUnprotect ve davranışını değiştirmesini .

Pyth, 23 bayt

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

Gibi girdi alır [['string'],['list', 'of', 'parts']] . Çıktı boş bir liste veya içinde değerleri olan bir listedir. Pyth'ta, bir şey içeren bir liste, hatta boş bir string ( ['']) bile true olarak değerlendirilir.

Çevrimiçi deneyin!

Açıklama:

                             | 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

Bu çözüm, dizenin başından itibaren mümkün olan her bölümü sürekli olarak kaldırmaya çalışır ve hala araması gereken değerleri izler.

Biz değerine bakarsak Gtest durumda [['ababab'],['a','ba','ab']]iken her döngü tekrarında sonra, bu ne olsun:

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

Ve, test durumunda [['aaaaa'],['aa']], elde ettiğimiz şey şu:

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

Başka bir test senaryosu oluşturdum [['aaaaaa'],['a','aa','aaa']]ve çıktı şuydu:

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

Çıktı listesinde, içinde bir demet çöp bulunur, ancak yine de bir gerçek değer.

Perl 5 , 39 bayt

38 bayt kodu + -pbayrak.

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

Çevrimiçi deneyin!

Girdi için "Hello, world!", ["l", "He", "o, wor", "d!"](aslında newlines ile ayrılır), kalıbı oluşturur l|He|o, wor|d!|(sayesinde, meta karakterleri kaçar, teşekkürler \Q..\E) ve sonra ilk dizginin bu kalıba uyup uymadığına bakar /^($v)*$/.

TryItOnline'da, takip eden bir yeni satır olması gerektiğini unutmayın.

PHP, 69 Bayt

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

testcases

Python 2,141 bayt

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*

Çevrimiçi Deneyin!

Son derece verimsiz. İlk test davası TIO'da zaman aşımına uğradı.

JavaScript (ES6), 59 bayt

Karıştırma sözdiziminde alt dizelerin ave dizenin dizisini alır . Döndürür / .s(a)(s)falsetrue

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

Yorumlananlar

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

Test durumları

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 bayt

#a Stringve Strings listesini alır ve a ile döner Bool.

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

Çevrimiçi deneyin!

Sadece bıraktığım test olayına aldırış etmeyin, çünkü yetersiz dizüstü bilgisayarımı -O2 ile bile attı. GHC'nin bu ara 30517578125 element listesinin kaynaşmadığından şüpheleniyorum, hızlı bir şekilde çöp toplanacak çok fazla paylaşımı yok ve test durumu yanlış olduğu için programın hepsini oluşturmak zorunda kalması ... denemek için çekinmeyin Bunu hallet.

mapM("":)(l<$s)length sBoş dizeleri veya dizeleri olan bir elemanların listesini yapmanın tüm yollarının bir listesidir l.

Pyth, 17 15 11 14 bayt

AQ|!G}Ym-dH./G

Boş dize için gereksinim değiştirildi, 3 bayt eklendi.

açıklama

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.

Eski versiyonlar

AQ}Ym-dH./G

Daha kısa ve evrenin ömründe koşuyor!

açıklama

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

Bu korkunç derecede yavaştır, ancak (önemsiz derecede küçük) test durumlarım için işe yarar.

açıklama

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.

Jöle , 14 12 8 bayt

;FŒṖḟ€Ạ¬

Çevrimiçi deneyin!

Nasıl çalışır

;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"]sayesinde davada bugfix

R, 49 bayt

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

Çevrimiçi deneyin!

Pyth, 10 8 bayt

f!-TQ./+zh

Test odası

Bu, STDIN'in ilk satırındaki listeyi ve ikincideki (tırnak işaretleri olmadan) dizeyi alır.

Başlamak için, liste içinde saklanır Qve dize içinde saklanır z. Sonra, tüm olası bölümlerini oluştururuz z. Her bölüm fyalnızca parçaların kullanılıp kullanılmadığını kontrol etmek için filtrelenir ( ) Q. Bunu yapmak için, biz tüm unsurları kaldırmak Qgelen T, bölüm Bizler bölümleme ve mantıksal ile sonucu etkisiz hale! yalnızca bölümleri her eleman içinde nerede böylece, Qtutulur.

''Hiçbir bölümü olmayan sorunu çözmek için , sözlüğün ilk kelimesini z'ye ekleriz, böylece boş bir dize olmaz.

PowerShell, 61 58 57 bayt

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

Çevrimiçi deneyin!

Eski çözümler:

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

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

Bunu çevrimiçi deneyin!

PowerShell, 78

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

Oldukça basit regex tabanlı bir yaklaşım.

CJam (16 bayt)

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

Bu, dizeyi ve yığın dizelerinin dizisini alan isimsiz bir bloktur (fonksiyon). Çevrimiçi demo .

Açık bir algoritma kullanır:

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

Dönüş değeri, yapılamazsa boş bir dizi / dize (sahte) strveya yapılabilirse, içeren bir dizidir str( strkendisi boş bir dize olsa bile ).

C ++ (Bcc), 287 bayt

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

çünkü ben yazmam ya da çok fazla kullandım next_permutation () bilmiyorum her şey yolunda mı. % 100 bilmiyorum eğer bu bir çözümse, bunun kalitesi çok düşük ... Bir dize listesi, burada char için bir işaretçi dizisidir; NULL sonlandırıldı Algo kolaydır, listedeki tüm dizgilerin "a" dizgisine uyması durumunda doğrusallığın denemesi için bir algoritma vardır, böylece dizginin dizininin dizgesine izin veren ve olası tüm kombinasyonları deneyen başka bir algo vardır.

ungolf, test kodu ve sonuçları burada

#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

bu gcc C ++ derleyicisinde derlenirdi

#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 bayt

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

Microsoft SQL Server, 353 bayt

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

Çevrimiçi olarak test edin.

Okunabilir sürüm:

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 bayt

C'de bunu yapmanın daha kısa bir yolu olduğundan eminim, ancak normal bulma / değiştirme yöntemi yerine tüm olası alt dizgi bileşimlerini test eden bir çözüm oluşturmak istedim.

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

Çevrimiçi deneyin

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