Trong trường hợp này, nhiệm vụ của bạn là xác định vị trí các chuỗi con với một cấu trúc nhất định.

Đầu vào

Đầu vào của bạn phải là hai chuỗi chữ và số không trống, một mẫu p và một văn bản t . Ý tưởng là mỗi ký tự pđại diện cho một chuỗi con không trống liền kề nhau txảy ra cạnh nhau và pđại diện cho sự kết hợp của chúng. Các ký tự giống hệt nhau tương ứng với các chuỗi con; ví dụ, mẫu aađại diện cho bất kỳ hình vuông không trống nào (một chuỗi có được bằng cách nối một chuỗi ngắn hơn với chính nó). Do đó, mẫu aacó thể khớp với chuỗi con byebye, với mỗi akhớp bye.

Đầu ra

Nếu văn bản tchứa một chuỗi con pphù hợp, thì đầu ra của bạn sẽ là chuỗi con đó, với các dấu hai chấm :được chèn giữa các chuỗi tương ứng với các ký tự của p. Ví dụ, nếu chúng ta có t = byebyenowvà p = aa, thì đó bye:byelà một đầu ra chấp nhận được. Có thể có một số lựa chọn cho chuỗi con phù hợp, nhưng bạn sẽ chỉ xuất một trong số chúng.

Nếu tkhông chứa một chuỗi con phù hợp, đầu ra của bạn sẽ là một khuôn mặt buồn :(.

Quy tắc và làm rõ

Các ký tự khác nhau pcó thể tương ứng với các chuỗi con giống nhau, do đó p = abacó thể khớp với chuỗi AAA. Lưu ý rằng các ký tự phải tương ứng với các chuỗi không trống; đặc biệt, nếu pdài hơn t, đầu ra phải được :(.

Bạn có thể viết một chương trình đầy đủ hoặc một hàm và bạn cũng có thể thay đổi thứ tự của hai đầu vào. Số byte thấp nhất sẽ thắng và các sơ hở tiêu chuẩn không được phép.

Các trường hợp thử nghiệm

Đưa ra trong định dạng pattern text -> output. Lưu ý rằng các đầu ra chấp nhận được khác có thể tồn tại.

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 byte

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ọi với g(pattern, string)

Sử dụng các remô-đun để làm hầu hết các công việc.

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

Kể từ khi ES6 được phát hành vào tháng 6 năm 2015, tôi đăng phiên bản mã ES5.1 cùng với ES6 tương đương, nhưng tuyên bố phiên bản ES5.1 là câu trả lời chính.

Trận đấu tham lam, vì vậy trường hợp đầu tiên trả về "Không" thay vì "N".

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

Hãy thử trực tuyến!

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

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

Hãy thử trực tuyến!

Đưa ra các đối số trong cú pháp currying: f(a)(b)

Giải thích (và không được phép):

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 byte

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

Hãy thử trực tuyến!

Trên đầu vào không khá nhỏ, rất chậm. Tôi-chưa-thực sự-thực hiện-thứ sáu-thử-nghiệm-nhưng-không-vì-thiếu-cố gắng chậm. (Có lẽ do phải vũ phu buộc mọi phân vùng của mọi chuỗi con, bắt đầu bằng chuỗi lớn nhất, sau đó kiểm tra xem đó có phải là một kết quả khớp không.) Lấy đầu vào làm danh sách [pattern,string].

Giải thích cô đọng và chia rẽ:

sᵗ~cᵗX

X là mẫu được ghép nối với một phân vùng của chuỗi con của chuỗi đầu vào.

lᵛ

Mẫu và phân vùng có cùng số lượng phần tử.

Xzdz≠ʰ

Không có hai pattern char, matched substringcặp duy nhất chia sẻ một nhân vật mẫu. Đó là, không có bản đồ ký tự mẫu cho nhiều chuỗi con, mặc dù nhiều ký tự mẫu có thể ánh xạ tới một chuỗi con.

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

Đầu ra là các thành phần của phân vùng được nối bởi dấu hai chấm, trừ khi điều gì đó không thể được thực hiện, trong trường hợp đó là :(thay thế.

Giải thích nguyên khối:

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