この挑戦では、あなたの仕事は、与えられた構造を持つ部分文字列を見つけることです。

入力

入力は、空ではない2つの英数字文字列、パターン p、およびテキスト tです。の考え方は、の各文字がp連続して空でない部分文字列を表し、その部分文字列tが隣り合って出現し、pそれらの連結を表すことです。同一の文字は同一の部分文字列に対応します。たとえば、パターンaaは空でない正方形（短い文字列をそれ自体に連結することによって取得される文字列）を表します。したがって、パターンaaは部分文字列byebyeとa一致し、それぞれ一致しbyeます。

出力

テキストtにp一致する部分文字列が含まれている場合、出力はその部分文字列になり、の文字に:対応する文字列の間にコロンが挿入されますp。例えば、我々が持っている場合t = byebyenowとp = aa、その後、bye:bye許容出力されます。一致する部分文字列にはいくつかの選択肢がありますが、そのうちの1つだけを出力します。

t一致する部分文字列が含まれていない場合、出力は悲しい顔になり:(ます。

規則と説明

の異なる文字はp同一の部分文字列に対応できるためp = aba、文字列と一致できますAAA。文字は空でない文字列に対応する必要があることに注意してください。特に、pがより長い場合t、出力はでなければなりません:(。

完全なプログラムまたは関数を記述できます。また、2つの入力の順序を変更することもできます。最小のバイトカウントが優先され、標準の抜け穴は許可されません。

テストケース

形式で与えられますpattern text -> output。他の受け入れ可能な出力が存在する可能性があることに注意してください。

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バイト

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":("

で呼び出す g(pattern, string)

reモジュールを使用してほとんどの作業を行います。

JavaScript（SpiderMonkey）（ES5.1）、198バイト

ES6は2015年6月にリリースされたので、ES5.1バージョンのコードをES6の同等のものと一緒に投稿しますが、主な回答としてES5.1バージョンを宣言します。

貪欲な一致。したがって、最初のケースは「N」ではなく「Not」を返します。

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(":"):":("}

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

JavaScript（Node.js）（ES6）、141バイト

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`:`:":("

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

カリー化構文の引数を取ります： f(a)(b)

説明（および未追加）：

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バイト

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

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

非常に小さくない入力では、非常に遅くなります。私は実際に6番目のテストケースを実行していませんが、試行不足のために遅くはありません。（おそらく、すべての部分文字列のすべてのパーティションを総当たり攻撃し、最大のものから始めて、それが一致するかどうかをチェックするためです。）入力をリストとして受け取ります[pattern,string]。

簡潔で分割された説明：

sᵗ~cᵗX

Xは、入力文字列の部分文字列のパーティションとペアになっているパターンです。

lᵛ

パターンとパーティションの要素数は同じです。

Xzdz≠ʰ

2つの一意のpattern char, matched substringペアがパターン文字を共有することはありません。つまり、複数のパターン文字が1つのサブストリングにマップされる場合もありますが、パターン文字は複数のサブストリングにマップされません。

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

出力は、何かができなかった場合を除き、コロンで結合されたパーティションの要素であり、その場合は:(代わりになります。

モノリシックの説明：

                                       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
                               ":("    ":(".