Bu zorlukta, göreviniz belirli bir yapıya sahip alt dizeleri bulmaktır.

Giriş

Girişiniz boş olmayan iki alfasayısal karakter dizisi, bir desen p ve bir metin olmalıdır t . Buradaki fikir, her karakterinin yan yana gerçekleşen pbitişik, boş olmayan bir alt dizeyi temsil tetmesi ve pbunların birleşmesini temsil etmesidir. Özdeş karakterler özdeş alt dizelere karşılık gelir; örneğin, desen aaboş olmayan herhangi bir kareyi (daha kısa bir dizeyi kendine birleştirerek elde edilen bir dize) temsil eder. Böylece desen aa, byebyeher bir aeşleşmeyle alt dizeyle eşleşebilir bye.

Çıktı

Metin eşleşen tbir alt dize içeriyorsa p, çıktınız :karakterlerin karşılık gelen dizeleri arasına iki nokta üst üste konacak şekilde o dize olacaktır p. Örneğin, varsa t = byebyenowve p = aadaha sonra bye:byekabul edilebilir bir çıkıştır. Eşleşen alt dize için birkaç seçenek olabilir, ancak bunlardan yalnızca birini çıkartabilirsiniz.

Eğer tbir eşleşen alt içermiyor, çıktı üzgün bir yüz olmalıdır :(.

Kurallar ve Açıklamalar

Farklı karakterleri paynı alt dizelere karşılık gelebilir, bu nedenle dizeyle p = abaeşleşebilir AAA. Karakterlerin boş olmayan dizelere karşılık gelmesi gerektiğini unutmayın; özellikle, çıkış pdaha uzunsa t, çıktı olmalıdır :(.

Tam bir program veya işlev yazabilir ve iki girişin sırasını da değiştirebilirsiniz. En düşük bayt sayısı kazanır ve standart boşluklara izin verilmez.

Test Durumları

Biçimde verilir pattern text -> output. Kabul edilebilir diğer çıktıların olabileceğini unutmayın.

a Not -> N
aa Not -> :(
abcd Not -> :(
aaa rerere -> re:re:re
xx ABAAAB -> A:A
MMM ABABBAABBAABBA -> ABBA:ABBA:ABBA
x33x 10100110011001 -> 10:1001:1001:10
abcacb 0a00cca0aa0cc0ca0aa0c00c0aaa0c -> c:a0aa:0c:c:0c:a0aa
abccab 0a00cca0aa0cc0ca0aa0c00c0aaa0c -> a:a:0c0:0c0:a:a
abcbcab 0a00cca0aa0cc0ca0aa0c00c0aaa0c -> :(
abcbdcab 0a00cca0aa0cc0ca0aa0c00c0aaa0c -> 00:c:ca0aa0c:c:0:ca0aa0c:00:c

Python, 207 bayt

import re
h=lambda x:"a"+str(ord(x))
def g(a,b):
 c,d="",set()
 for e in a:
  c+=["(?P<"+h(e)+">.+)","(?P="+h(e)+")"][e in d]
  d.add(e)
 f=re.search(c,b)
 return f and":".join(f.group(h(e))for e in a)or":("

İle ara g(pattern, string)

İşin reçoğunu yapmak için modülü kullanır .

JavaScript (SpiderMonkey) (ES5.1), 198 bayt

ES6, Haziran 2015'te piyasaya sürüldüğünden, ES6 eşdeğerini ES6 eşdeğeri ile birlikte gönderiyorum, ancak ES5.1 sürümünü ana cevap olarak ilan ediyorum.

Açgözlü eşleşme, bu nedenle ilk durum "N" yerine "Not" değerini döndürür.

function(a,b){c=[o="indexOf"];r=a.split("");return(m=RegExp(r.map(function(i){return(e=c[o](i))>0?"\\"+e:(c.push(i),"(.+)")}).join("")).exec(b))?r.map(function(x){return m[c[o](x)]}).join(":"):":("}

Çevrimiçi deneyin!

JavaScript (Node.js) (ES6), 141 bayt

a=>b=>(c=[o="indexOf"],r=[...a],m=RegExp(r.map(i=>(e=c[o](i))>0?"\\"+e:(c.push(i),"(.+)")).join``).exec(b))?r.map(x=>m[c[o](x)]).join`:`:":("

Çevrimiçi deneyin!

Sözdizimi curry ile ilgili argümanları alır: f(a)(b)

Açıklama (ve çözülmemiş):

function matchPattern(a, b) {                   // Main function
 var c = ["indexOf"];                           // Array used for the capturing groups
 var r = [...a];                                // Split the pattern first
 var m = RegExp(r.map(function(i) {             // Create the regex
  var e = c.indexOf(i);                         // Check if the character is found before
  if (e > 0)                                    // If so
   return "\\" + e;                             // Append the back reference to the regex
  else {                                        // If not
   c.push(i);                                   // Append the character to the array
   return "(.+)";                               // Append a capturing group to the regex
  }             
 }).join("")).exec(b);                          // Execute the regex
 if (m != null)                                 // If the pattern matches the string
  return r.map(function(x) {                    // Replace each letter
   return m[c.indexOf(x)];                      // With the corresponding substring
  }).join(":");                                 // And join them with ":"
 else                                           // If there is no match
  return ":(";                                  // Return ":("
}

Brachylog , 35 bayt

sᵗ~cᵗXlᵛ∧Xzdz≠ʰ∧Xt~ṇ{Ḷ∧":"|}ᵐ.∨":("

Çevrimiçi deneyin!

Çok küçük olmayan girdilerde, çok yavaş. Altıncı sınama örneğini henüz yapmadım ama yavaş denememe için değil. (Muhtemelen her alt dizenin her bölümünü en büyüğünden başlayarak kaba bir şekilde zorlaması ve ardından bir eşleşme olup olmadığını kontrol etmesi nedeniyle.) Girişi liste olarak alır[pattern,string].

Özet ve bölünmüş açıklama:

sᵗ~cᵗX

X, giriş dizesinin bir alt dizesinin bir bölümü ile eşlenen modeldir.

lᵛ

Desen ve bölüm aynı sayıda öğeye sahiptir.

Xzdz≠ʰ

İki benzersiz değil pattern char, matched substring çift, bir desen karakteri paylaşmaz. Diğer bir deyişle, birden çok desen dizisi bir alt dizeyle eşleşebilse de, desen karakteri birden çok alt dizeyle eşleşmez.

Xt~ṇ{Ḷ∧":"|}ᵐ.∨":("

Çıktı, bir şey yapılamadığı sürece iki nokta üst üste ile birleştirilen bölümün öğeleridir, bu durumda bunun :(yerine.

Monolitik açıklama:

                                       The input
 ᵗ  ᵗ                                  with its last element replaced with
  ~c                                   a list which concatenates to
s                                      a substring of it
     X                                 is X,
       ᵛ                               the elements of which all have the same
      l                                length.
        ∧                              And,
         X                             X
          z                            zipped
           d                           with duplicate pairs removed
            z                          and zipped back
              ʰ                        has a first element
             ≠                         with no duplicate values.
               ∧                       Furthermore,
                 t                     the last element of
                X                      X
                  ~ṇ                   with its elements joined by newlines
                    {      }ᵐ          where each character of the joined string
                     Ḷ                 is a newline
                      ∧                and
                          |            is replaced with
                       ":"             a colon
                          |            or is passed through unchanged
                             .         is the output.
                              ∨        If doing any part of that is impossible,
                                       the output is
                               ":("    ":(".