이 challence에서, 당신의 임무는 주어진 구조를 가진 부분 문자열을 찾는 것입니다.

입력

입력은 비어 있지 않은 두 개의 영숫자 문자열, 패턴 p 및 텍스트 여야 합니다t . 아이디어는의 각 문자가 서로 옆에 p있는 연속 된 비어 있지 않은 하위 문자열을 나타내며 그 연결을 나타냅니다. 동일한 문자는 동일한 하위 문자열에 해당합니다. 예를 들어, 패턴 은 비어 있지 않은 정사각형 (더 짧은 문자열을 자체에 연결하여 얻은 문자열)을 나타냅니다. 따라서 패턴 은 각 일치하는 부분 문자열과 일치 할 수 있습니다 .tpaaaabyebyeabye

산출

텍스트 t에 p일치 하는 하위 문자열이 포함되어 있으면의 문자열에 콜론이 :삽입 된 하위 문자열이 출력 p됩니다. 예를 들어, 우리가있는 경우 t = byebyenow와 p = aa, 다음 bye:bye허용 출력된다. 일치하는 부분 문자열에 대한 몇 가지 선택 사항이있을 수 있지만 그 중 하나만 출력해야합니다.

경우 t일치하는 문자열을 포함하지 않는, 당신의 출력은 슬픈 얼굴이어야한다 :(.

규칙 및 설명

의 다른 문자는 p동일한 하위 문자열에 해당 할 p = aba수 있으므로 string과 일치 할 수 있습니다 AAA. 문자는 비어 있지 않은 문자열과 일치해야합니다. 특히, p보다 긴 경우 t출력은이어야합니다 :(.

전체 프로그램 또는 함수를 작성할 수 있으며 두 입력의 순서를 변경할 수도 있습니다. 바이트 수가 가장 적고 표준 허점이 허용되지 않습니다.

테스트 사례

형식으로 제공됩니다 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

파이썬, 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≠ʰ

두 개의 고유 pattern char, matched substring쌍은 패턴 문자를 공유 하지 않습니다 . 즉, 여러 패턴 문자가 하나의 하위 문자열에 매핑 될 수 있지만 패턴 문자는 여러 하위 문자열에 매핑되지 않습니다.

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