Chaînes avec contexte

Pour les besoins de ce défi, une chaîne avec contexte est un triple de chaînes, appelé le contexte gauche , la partie données et le contexte droit . Il représente une sous-chaîne d'une chaîne plus longue. Nous utilisons le tuyau vertical |comme séparateur, donc un exemple de chaîne avec contexte est cod|e-go|lf, où le contexte gauche est cod, les données sont e-goet le contexte droit est lf. Cet exemple représente la sous-chaîne e-gode code-golf.

Maintenant, pour concaténer deux chaînes avec le contexte, nous procédons comme suit, en utilisant aa|bcc|deeet cc|de|eeecomme exemples. On aligne les cordes comme dans le schéma

a a|b c c|d e e
      c c|d e|e e e

de sorte que leurs parties de données sont adjacentes. La partie données de la concaténation est la concaténation des parties données, dans ce cas bccde. Dans ce cas, le contexte de gauche est la partie qui étend le plus à gauche de la première partie de données aa. De même, le bon contexte est eee, donc la concaténation est la chaîne avec le contexte aa|bccde|eee. Pour un deuxième exemple, considérons a|bb|cdet aabb|cd|, où le deuxième mot a un contexte de droite vide. Le diagramme d'alignement est

  a|b b|c d
a a b b|c d|

où le contexte gauche du deuxième mot s'étend plus loin que celui du premier. La concaténation est aa|bbcd|.

Mais attendez, il y a un piège: si les lettres du diagramme d'alignement ne correspondent pas, la concaténation n'existe pas! Par exemple, le diagramme de aa|bb|ccet c|c|cest

a a|b b|c c
      c|c|c

où le b et csur la quatrième colonne ne sont pas d'accord, ils ne peuvent donc pas être concaténés.

La tâche

Votre travail consiste à écrire un programme qui prend en deux chaînes avec un contexte dont les parties sont séparées par | comme ci-dessus, et génère leur concaténation si elle existe, et autre chose sinon. "Quelque chose d'autre" peut être n'importe quelle valeur, y compris aucune sortie, tant que ce n'est pas une chaîne valide avec contexte, et c'est la même chose dans tous les cas. Cependant, le lancement d'une erreur n'est pas acceptable. Vous pouvez donner un programme STDIN à STDOUT ou une fonction, et les fonctions anonymes sont également acceptées. Le plus petit nombre d'octets gagne et les failles standard sont interdites.

Cas de test

aa|bcc|dee cc|de|eee -> aa|bccde|eee
a|bb|cd    aabb|cd|  -> aa|bbcd|
a|b|cccd   aab|cc|c  -> aa|bcc|cd
a|b|c      b||cd     -> a|b|cd
aa|bb|cc   c|c|c     -> None
aaa|b|c    abb|cd|d  -> None
|bb|cd     abb|c|ed  -> None
a|b|c      a||cd     -> None

Haskell, 184 182 201 199 155

s&t|(a,'|':b)<-f t,(x,'|':y)<-f$r s,x#b,a#y=r(y!r a)++b!r x|0<1=""
r=reverse
a!b=a++drop(length a-1)b
(#)a=and.zipWith(==)(r a).filter h
f=span h
h=(/='|')

exemple d'exécution:

"|a|"&"|b|" -- returns "|ab|"
"|a|x"&"|b|" -- returns ""

s'il n'y a pas de correspondance, une chaîne vide sera retournée. sinon le résultat serait retourné.

explication partielle:

# est une fonction qui obtient deux chaînes et renvoie si elles correspondent ou non.

! obtient deux chaînes et renvoie la première concaténée avec un caractère supplémentaire de la seconde (s'il y en a).

la fonction principale &utilise span (/='|')pour diviser les entrées en deux parties, a|b|cpoura, b|c , vérifie si les contextes correspondent, puis utilise !deux fois pour assembler la sortie.

Edit: le regolfing mage tardif semble être assez efficace.

Python (242 octets)

import itertools as i
s='|'
j=''.join
r=reversed
m=lambda a,b:j(j(*set(p+q))for p,q in i.izip_longest(a,b,fillvalue=''))
def c(A,B):
 u,v,w,x,y,z=(A+s+B).split(s)
 try:return j(r(m(r(u+v),r(x))))[:-len(v)]+s+v+y+s+m(w,y+z)[len(y):]
 except:0

Explication

La fonction lambda mrenvoie la plus longue de deux chaînes tant qu'elles partagent un préfixe commun. Elle le fait en concaténant la chaîne vide ''à la place des valeurs manquantes, se tournant alors le résultat (qui peut prendre les formes aa, ab, aou ben cas de bon / mauvais / longueurs inégales) dans un ensemble de caractères uniques à chaque position. joinattend un seul argument, donc décompresser un ensemble avec plus d'un élément le fera lever un TypeError.

La fonction principale alors

• utilise mpour combiner le contexte gauche et la partie données du premier mot avec le contexte gauche du second (de droite à gauche sur les chaînes inversées)
• concatène les parties de données,
• et utilise mà nouveau pour combiner le bon contexte du premier mot avec la partie de données et le bon contexte du second

Les parties de données des deux mots originaux sont découpées à partir des côtés droit et gauche des nouveaux contextes.

Puisque nous savons que les désalignements provoquent mune augmentation de a TypeError, dans ces cas, nous interceptons l'exception et retournons implicitementNone .

Essai

TESTCASES = [
    ('aa|bcc|dee', 'cc|de|eee', 'aa|bccde|eee'),
    ('a|bb|cd', 'aabb|cd|', 'aa|bbcd|'),
    ('a|b|cccd', 'aab|cc|c', 'aa|bcc|cd'),
    ('a|b|c', 'b||cd', 'a|b|cd'),
    ('aa|bb|cc', 'c|c|c', None),
    ('aaa|b|c', 'abb|cd|d', None),
    ('|bb|cd', 'abb|c|ed', None),
    ('a|b|c', 'a||cd', None),
]

for A, B, R in TESTCASES:
    print '{:<10} {:<9} -> {}'.format(A, B, c(A, B))

Production

aa|bcc|dee cc|de|eee -> aa|bccde|eee
a|bb|cd    aabb|cd|  -> aa|bbcd|  
a|b|cccd   aab|cc|c  -> aa|bcc|cd 
a|b|c      b||cd     -> a|b|cd    
aa|bb|cc   c|c|c     -> None      
aaa|b|c    abb|cd|d  -> None      
|bb|cd     abb|c|ed  -> None      
a|b|c      a||cd     -> None