带上下文的字符串

出于此挑战的目的，具有上下文的字符串是字符串的三元组，称为左上下文，数据部分和右上下文。它表示较长字符串的子字符串。我们使用垂直管道|作为分隔符，因此具有上下文的字符串的示例为cod|e-go|lf，其中左侧上下文为cod，数据为e-go，右侧上下文为lf。本实施例代表子串e-go的code-golf。

现在，要使用上下文将两个字符串连接起来，我们使用aa|bcc|dee和cc|de|eee作为示例，进行如下操作。我们按照图中的对齐字符串

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

以便它们的数据部分相邻。在这种情况下，串联的数据部分是数据部分的串联bccde。在这种情况下，左边的上下文是进一步延伸到第一数据部分左边的部分aa。同样，正确的上下文是eee，因此串联是带有context的字符串aa|bccde|eee。对于第二个示例，请考虑a|bb|cd和aabb|cd|，其中第二个单词的权利上下文为空。对齐图是

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

第二个单词的左上下文比第一个单词的左上下文延伸得更多。的串联是aa|bbcd|。

但是，等等，有一个陷阱：如果对齐图的字母不匹配，则表示串联不存在！作为一个例子，对图aa|bb|cc和c|c|cIS

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

第四列的b和c不一致，因此无法将它们串联在一起。

任务

您的工作是编写一个程序，该程序使用上下文中包含两个字符串的字符串，它们的各部分之间的分隔|符如上所述，如果存在则输出其串联，否则将其串联。“其他”可以是任何值，包括没有输出，只要它不是带上下文的有效字符串，并且在所有情况下都相同。但是，抛出错误是不可接受的。您可以提供STDIN-to-STDOUT程序或函数，也可以接受匿名函数。最小的字节数获胜，并且不允许出现标准漏洞。

测试用例

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=(/='|')

示例运行：

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

如果没有匹配项，则将返回一个空字符串。否则将返回结果。

部分说明：

# 是一个获取两个字符串并返回它们是否匹配的函数。

! 获取两个字符串，并返回第一个字符串，该字符串与第二个字符串中的多余字符连接在一起（如果有的话）。

main函数&用于span (/='|')将输入分为两部分，a|b|c到a, b|c，检查上下文是否匹配，然后使用!两次来组合输出。

编辑：法师后期翻新似乎很有效。

Python（242字节）

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

说明

lambda函数m返回两个字符串中的较长者，只要它们共享一个公共前缀。它通过连接空字符串执行此''代替任何缺失值，然后转动结果（其可以采取的形式aa，ab，a，或b在匹配/不匹配/不相等的长度的情况下）转换成在每个位置的一组唯一的字符。join期望有一个参数，因此解开包含多个元素的集合将导致它引发TypeError。

然后主要功能

• 用于m将第一个单词的左上下文和数据部分与第二个单词的左上下文组合（在反向字符串中从右到左）
• 连接数据部分，
• 并再次用于m将第一个单词的正确上下文与数据部分和第二个单词的正确上下文进行组合

两个原始单词的数据部分从新上下文的右侧和左侧进行修剪。

由于我们知道不对齐会m引起a的上升TypeError，因此在这些情况下，我们会捕获异常并隐式返回None。

测试中

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))

输出量

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