ในความท้าทายนี้งานของคุณคือการหาวัสดุพิมพ์ที่มีโครงสร้างที่กำหนด

อินพุต

ข้อมูลของคุณจะเป็นสองสายที่เป็นตัวเลขไม่ว่างเปล่าเป็นรูปแบบ pและข้อความ tแนวคิดก็คืออักขระแต่ละตัวจะpแทนซับสตริงที่ไม่ว่างเปล่าที่ต่อเนื่องกันtซึ่งเกิดขึ้นถัดจากกันและกันและpแสดงถึงการต่อกันของมัน อักขระที่เหมือนกันสอดคล้องกับสตริงย่อยที่เหมือนกัน ตัวอย่างเช่นรูปแบบaaหมายถึงสแควร์ที่ไม่ว่างเปล่า (สตริงที่ได้จากการต่อสตริงที่สั้นกว่าเข้ากับตัวเอง) ดังนั้นรูปแบบaaสามารถจับคู่สตริงย่อยbyebyeได้ด้วยการaจับคู่แต่ละbyeครั้ง

เอาท์พุต

หากข้อความที่tมีสตริงย่อยที่pการแข่งขันแล้วส่งออกของคุณจะเป็นสตริงย่อยที่มีทวิภาคแทรกระหว่างสตริงที่ตรงกับตัวละคร: pตัวอย่างเช่นถ้าเรามีt = byebyenowและp = aaก็bye:byeเป็นผลลัพธ์ที่ยอมรับได้ อาจมีหลายตัวเลือกสำหรับสตริงย่อยที่ตรงกัน แต่คุณจะส่งออกหนึ่งในพวกเขาเท่านั้น

ถ้าtไม่ได้มี substring :(จับคู่ของคุณออกจะเป็นหน้าเศร้า

กฎและคำชี้แจง

ตัวละครที่แตกต่างกันpสามารถสอดคล้องกับสตริงเหมือนกันเพื่อให้สามารถจับคู่สตริงp = aba 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

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 วางจำหน่ายในเดือนมิถุนายน 2558 ฉันโพสต์โค้ด ES5.1 พร้อมกับเทียบเท่ากับ ES6 แต่ประกาศว่า ES5.1 เป็นคำตอบหลัก

การจับคู่โลภดังนั้นกรณีแรกส่งคืน "Not" แทนที่จะเป็น "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(":"):":("}

ลองออนไลน์!

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

ลองออนไลน์!

รับอาร์กิวเมนต์ในรูปแบบ currying: f(a)(b)

คำอธิบาย (และ ungolfed):

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~ṇ{Ḷ∧":"|}ᵐ.∨":("

ลองออนไลน์!

บนอินพุตไม่ค่อนข้างเล็กช้ามาก ฉันยังไม่ได้ทำจริงทดสอบครั้งที่หก แต่ไม่ได้สำหรับการพยายามช้า (อาจเนื่องจากเดรัจฉานบังคับพาร์ทิชันของทุก substring ทุกเริ่มต้นด้วยการที่ใหญ่ที่สุดและจากนั้นตรวจสอบว่าเป็นการจับคู่.) [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
                               ":("    ":(".