In questa sfida, il tuo compito è individuare sottostringhe con una determinata struttura.

Ingresso

Il tuo input deve essere due stringhe alfanumeriche non vuote, un modello p e un testo t . L'idea è che ogni personaggio di prappresenta una sottostringa contigua non vuota di tcui si verificano uno accanto all'altro e prappresenta la loro concatenazione. I caratteri identici corrispondono a sottostringhe identiche; ad esempio, il modello aarappresenta qualsiasi quadrato non vuoto (una stringa ottenuta concatenando una stringa più corta a se stessa). Pertanto, il motivo aapuò corrispondere alla sottostringa byebye, con ogni acorrispondenza bye.

Produzione

Se il testo tcontiene una sottostringa che pcorrisponde, allora l'output deve essere quella sottostringa, con due punti :inseriti tra le stringhe che corrispondono ai caratteri di p. Ad esempio, se abbiamo t = byebyenowe p = aa, quindi bye:byeè un output accettabile. Potrebbero esserci diverse opzioni per la sottostringa corrispondente, ma ne dovrai produrre solo una.

Se tnon contiene una sottostringa corrispondente, l'output deve essere una faccia triste :(.

Regole e chiarimenti

Caratteri diversi di ppossono corrispondere a sottostringhe identiche, quindi p = abapossono corrispondere alla stringa AAA. Si noti che i caratteri devono corrispondere a stringhe non vuote; in particolare, se pè più lungo di t, l'output deve essere :(.

È possibile scrivere un programma completo o una funzione, nonché modificare l'ordine dei due ingressi. Vince il conteggio di byte più basso e non sono consentite scappatoie standard.

Casi test

Dato nel formato pattern text -> output. Si noti che potrebbero esistere altre uscite accettabili.

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

Chiama con g(pattern, string)

Utilizza il remodulo per eseguire la maggior parte del lavoro.

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

Da quando ES6 è stato rilasciato a giugno 2015, pubblico la versione ES5.1 del codice insieme all'equivalente ES6, ma dichiaro la versione ES5.1 come risposta principale.

Partita golosa, quindi il primo caso restituisce "Non" anziché "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(":"):":("}

Provalo online!

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

Provalo online!

Accetta gli argomenti nella sintassi del curry: f(a)(b)

Spiegazione (e non golfato):

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

Provalo online!

Su ingressi non abbastanza piccoli, molto lenti. Non ho ancora fatto il sesto test-case-ma-non-per-mancanza-di-tentativi lenti. (Probabilmente a causa di forzare brutalmente ogni partizione di ogni sottostringa, iniziando dal più grande, e quindi controllando se è una corrispondenza.) Accetta input come elenco[pattern,string] .

Spiegazione condensata e divisa:

sᵗ~cᵗX

X è il modello associato a una partizione di una sottostringa della stringa di input.

lᵛ

Il modello e la partizione hanno lo stesso numero di elementi.

Xzdz≠ʰ

Non esistono due pattern char, matched substringcoppie univoche che condividono un carattere modello. In altre parole, nessun carattere di motivo viene mappato su più sottostringhe, sebbene più caratteri di motivo possano essere mappati su una sottostringa.

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

L'output sono gli elementi della partizione uniti da due punti, a meno che non si possa fare qualcosa, nel qual caso lo è :( invece.

Spiegazione monolitica:

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