Dans cette challence, votre tâche consiste à localiser des sous-chaînes avec une structure donnée.

Contribution

Votre entrée doit être deux chaînes alphanumériques non vides, un modèle p et un texte t . L'idée est que chaque caractère de preprésente une sous-chaîne non vide contiguë tqui se produisent côte à côte et preprésente leur concaténation. Des caractères identiques correspondent à des sous-chaînes identiques; par exemple, le motif aareprésente tout carré non vide (une chaîne obtenue en concaténant une chaîne plus courte à lui-même). Ainsi, le motif aapeut correspondre à la sous-chaîne byebye, à chaque acorrespondance bye.

Production

Si le texte tcontient une sous-chaîne qui pcorrespond, alors votre sortie doit être cette sous-chaîne, avec des deux-points :insérés entre les chaînes qui correspondent aux caractères de p. Par exemple, si nous avons t = byebyenowet p = aa, alors bye:byeest une sortie acceptable. Il peut y avoir plusieurs choix pour la sous-chaîne correspondante, mais vous ne devez en sortir qu'un seul.

Si tne contient pas de sous-chaîne correspondante, votre sortie sera un visage triste :(.

Règles et clarifications

Différents caractères de ppeuvent correspondre à des sous-chaînes identiques, ils p = abapeuvent donc correspondre à la chaîne AAA. Notez que les caractères doivent correspondre à des chaînes non vides; en particulier, si elle pest plus longue que t, la sortie doit être :(.

Vous pouvez écrire un programme complet ou une fonction, et vous pouvez également changer l'ordre des deux entrées. Le nombre d'octets le plus bas l'emporte et les failles standard sont interdites.

Cas de test

Donné dans le format pattern text -> output. Notez que d'autres sorties acceptables peuvent exister.

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 octets

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

Appeler avec g(pattern, string)

Utilise le remodule pour effectuer la plupart du travail.

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

Depuis la sortie d'ES6 en juin 2015, je poste la version ES5.1 du code avec l'équivalent ES6, mais déclare la version ES5.1 comme réponse principale.

Match gourmand, donc le premier cas retourne "Non" au lieu de "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(":"):":("}

Essayez-le en ligne!

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

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

Essayez-le en ligne!

Prend les arguments de la syntaxe de curry: f(a)(b)

Explication (et non golfée):

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 octets

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

Essayez-le en ligne!

Sur des entrées pas assez petites, très lentes. Je n'ai pas vraiment fait le sixième cas de test, mais pas par manque d'essais. (Probablement en raison du forçage brutal de chaque partition de chaque sous-chaîne, en commençant par la plus grande, puis en vérifiant si c'est une correspondance.) Prend l'entrée comme une liste [pattern,string].

Explication condensée et divisée:

sᵗ~cᵗX

X est le modèle associé à une partition d'une sous-chaîne de la chaîne d'entrée.

lᵛ

Le motif et la partition ont le même nombre d'éléments.

Xzdz≠ʰ

Il n'y a pas deux pattern char, matched substringpaires uniques partageant un caractère de motif. En d'autres termes, aucun caractère de motif n'est mappé sur plusieurs sous-chaînes, bien que plusieurs caractères de motif puissent être mappés sur une sous-chaîne.

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

La sortie est constituée des éléments de la partition joints par des deux-points, sauf si quelque chose n'a pas pu être fait, auquel cas c'est à la :(place.

Explication monolithique:

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