（感谢下面的greg0ire帮助了解关键概念）
挑战： 构建一个程序，找到所有子字符串并使用颜色属性“标记”它们（在XML中有效地突出显示它们）。
规则：
<TAG#>theSubstring</TAG#>格式，其中#是该子字符串和相同子字符串唯一的正数。注意：以下示例中显示的标记顺序并不重要。 OP仅用于清晰度。
示例输入：
LoremIpsumissimplydummytextoftheprintingandtypesettingindustry.LoremIpsumhasbeentheindustry'sstandarddummytexteversincethe1500s,whenanunknownprintertookagalleyoftypeandscrambledittomakeatypespecimenbook.
部分正确的输出（OP在本例中可能没有完全完全替换）
<TAG1>LoremIpsum</TAG1>issimply<TAG2>dummytext</TAG2>of<TAG5>the</TAG5><TAG3>print</TAG3>ingand<TAG4>type</TAG4>setting<TAG6>industry</TAG6>.<TAG1>LoremIpsum</TAG1>hasbeen<TAG5>the</TAG5><TAG6>industry</TAG6>'sstandard<TAG2>dummytext</TAG2>eversince<TAG5>the</TAG5>1500s,whenanunknown<TAG3>print</TAG3>ertookagalleyof<TAG4>type</TAG4>andscrambledittomakea<TAG4>type</TAG4>specimenbook.
您的代码应该能够处理边缘情况，例如：
示例输入2：
hello!TAG!</hello.TAG.</
示例输出2：
<TAG1>hello</TAG1>!<TAG2>TAG</TAG2>!<TAG3></</TAG3><TAG1>hello</TAG1>.<TAG2>TAG</TAG2>.<TAG3></</TAG3>
获胜者：
轻微澄清：
答案 0 :(得分：4)
#New algorithm that produces correct ouputs for many cases
push@z,q/LoremIpsumissimplydummytextoftheprintingandtypesettingindustry.LoremIpsumhasbeentheindustry'sstandarddummytexteversincethe1500s,whenanunknownprintertookagalleyoftypeandscrambledittomakeatypespecimenbook/;
push@z,q/oktooktobookokm/;
push@z,q!dino1</dino2</!;
push@z,q!dino1TAG2dino3TAG!;
## loop for tests doesn't count
for $z(@z) {
print "input : $z\n";
$i=0;@r=();
#### begin count
$c=127;$l=length($_=$z);while($l>1){if(/(.{$l}).*\1/){push@r,$1;++$c;s/$1/chr($c)/eg}else{$l--}}$z=$_;map{++$i;$x=chr(127+$i);$z=~s:$x:<TAG$i>$_</TAG$i>:g}@r
#### end count 157 chars
## output doesn't count
;print "output : $z\n","="x80,"\n"
}
__END__
perl tags2.pl
input : LoremIpsumissimplydummytextoftheprintingandtypesettingindustry.LoremIpsumhasbeentheindustry'sstandarddummytexteversincethe15
00s,whenanunknownprintertookagalleyoftypeandscrambledittomakeatypespecimenbook
output : <TAG1>LoremIpsum</TAG1>i<TAG11>ss</TAG11><TAG12>im</TAG12>ply<TAG2>dummytext</TAG2><TAG6>oft</TAG6><TAG13>he</TAG13><TAG4>p
rint</TAG4><TAG7>ing</TAG7><TAG8>and</TAG8><TAG5>types</TAG5>e<TAG14>tt</TAG14><TAG7>ing</TAG7><TAG3>industry</TAG3>.<TAG1>LoremIpsu
m</TAG1>hasbe<TAG15>en</TAG15><TAG9>the</TAG9><TAG3>industry</TAG3>'<TAG11>ss</TAG11>t<TAG8>and</TAG8>ard<TAG2>dummytext</TAG2>ev<TA
G16>er</TAG16>since<TAG9>the</TAG9>1500s,w<TAG13>he</TAG13>nanunknown<TAG4>print</TAG4><TAG16>er</TAG16>t<TAG10>ook</TAG10>agal<TAG1
7>le</TAG17>y<TAG6>oft</TAG6>y<TAG18>pe</TAG18><TAG8>and</TAG8>scramb<TAG17>le</TAG17>di<TAG14>tt</TAG14>omakea<TAG5>types</TAG5><TA
G18>pe</TAG18>c<TAG12>im</TAG12><TAG15>en</TAG15>b<TAG10>ook</TAG10>
================================================================================
input : oktooktobookokm
output : <TAG1>okto</TAG1><TAG1>okto</TAG1>bo<TAG2>ok</TAG2><TAG2>ok</TAG2>m
================================================================================
input : dino1</dino2</
output : <TAG1>dino</TAG1>1<TAG2></</TAG2><TAG1>dino</TAG1>2<TAG2></</TAG2>
================================================================================
input : dino1TAG2dino3TAG
output : <TAG1>dino</TAG1>1<TAG2>TAG</TAG2>2<TAG1>dino</TAG1>3<TAG2>TAG</TAG2>
================================================================================
答案 1 :(得分：2)
s="LoremIpsumissimplydummytextoftheprintingandtypesettingindustry.LoremIpsumhasbeentheindustry'sstandarddummytexteversincethe1500s,whenanunknownprintertookagalleyoftypeandscrambledittomakeatypespecimenbook."
### ------------------------------------------------------------
import re
c=o=127
l={}
i=len(s)/2
while i>1:
r=re.search('(.{%d}).*\\1'%i,s)
if r:f=r.group(1);c+=1;l[c-o]=f;s=s.replace(f,chr(c))
else:i-=1
for i in l:s=re.sub(chr(i+o),'<TAG%d>%s</TAG%d>'%(i,l[i],i),s)
### ------------------------------------------------------------
print s
在示例输入上运行此结果，它选择以下单词（'LoremIpsum'，'dummytext'，'industry'，'print'，'types'，'oft'，'ing' ，'和'，'''，'ook'，'s'，'im'，'他'，'tt'，'en'，'er'，'le'，'pe'）和结果是：
<TAG1>LoremIpsum</TAG1>i<TAG11>ss</TAG11><TAG12>im</TAG12>ply<TAG2>dummytext</TAG2><TAG6>oft</TAG6><TAG13>he</TAG13><TAG4>print</TAG4><TAG7>ing</TAG7><TAG8>and</TAG8><TAG5>types</TAG5>e<TAG14>tt</TAG14><TAG7>ing</TAG7><TAG3>industry</TAG3>.<TAG1>LoremIpsum</TAG1>hasbe<TAG15>en</TAG15><TAG9>the</TAG9><TAG3>industry</TAG3>'<TAG11>ss</TAG11>t<TAG8>and</TAG8>ard<TAG2>dummytext</TAG2>ev<TAG16>er</TAG16>since<TAG9>the</TAG9>1500s,w<TAG13>he</TAG13>nanunknown<TAG4>print</TAG4><TAG16>er</TAG16>t<TAG10>ook</TAG10>agal<TAG17>le</TAG17>y<TAG6>oft</TAG6>y<TAG18>pe</TAG18><TAG8>and</TAG8>scramb<TAG17>le</TAG17>di<TAG14>tt</TAG14>omakea<TAG5>types</TAG5><TAG18>pe</TAG18>c<TAG12>im</TAG12><TAG15>en</TAG15>b<TAG10>ook</TAG10>.
这个wiki上的可读性更高，如下所示：
LoremIpsum 我 SS IM 帘布层 dummytext 经常 他< / KBD> 打印 荷兰国际集团 和 类型电子 TT 荷兰国际集团 业 LoremIpsum hasbe EN 的 业' SS < / KBD>吨和 ARD dummytext EV ER 自的 1500秒，W 他 nanunknown 打印 ER 吨 OOK AGAL 文件ý经常ý PE < / KBD> 和 scramb 文件二 TT omakea 类型 PE C IM EN b'KBD> OOK
PS。有人抱怨所以我添加了输入和输出语句。令我感到困惑的是道歉 - 这对我来说似乎很明显。显然不是，所以我添加了前缀/预告片语句，这些语句不是问题规范所要求的，不应计入代码长度。
答案 2 :(得分：1)
使用指数算法时字符数为343，而使用二次算法时字符数为344.
发布的代码是二次方。对于指数算法，请在代码中将inits=<<tails的一次更改为subsequences。
import Data.List
l=length
e=map$either id id
(&)=stripPrefix
y@(_:w)!x=l x>1&&maybe(w!x)(isInfixOf x)(x&y)
_!_=0<0
t@(x,i)?s@(y:z)=maybe(y:t?z)(((map Right$'<':v++e x++"</"++v)++).(t?))$x&s where v="TAG"++i++">"
_?_=[]
r s=e$foldr(?)s$zip(sortBy(\a b->compare(l a)$l b)$filter(s!)$inits=<<tails s)$map show[1..]
main=getLine>>=putStr.r.map Left
输入1：
LoremIpsumissimplydummytextoftheprintingandtypesettingindustry.LoremIpsumhasbeentheindustry'sstandarddummytexteversincethe1500s,whenanunknownprintertookagalleyoftypeandscrambledittomakeatypespecimenbook.
输出1：
<TAG338>LoremIpsum</TAG338>i<TAG72>ss</TAG72><TAG122>im</TAG122>ply<TAG336>dummytext</TAG336><TAG188>oft</TAG188><TAG91>he</TAG91><TAG275>print</TAG275><TAG153>ing</TAG153><TAG191>and</TAG191><TAG276>types</TAG276><TAG88>et</TAG88><TAG214>ting</TAG214><TAG328>industry</TAG328>.<TAG338>LoremIpsum</TAG338>hasbe<TAG123>en</TAG123><TAG183>the</TAG183><TAG328>industry</TAG328>'s<TAG73>st</TAG73><TAG191>and</TAG191>ard<TAG336>dummytext</TAG336>ev<TAG99>er</TAG99>s<TAG96>in</TAG96>ce<TAG183>the</TAG183>1500s,wh<TAG123>en</TAG123><TAG111>an</TAG111>unknown<TAG275>print</TAG275><TAG99>er</TAG99>t<TAG195>ook</TAG195>a<TAG103>ga</TAG103>l<TAG113>le</TAG113>y<TAG105>of</TAG105><TAG241>type</TAG241><TAG191>and</TAG191>scramb<TAG113>le</TAG113>dit<TAG115>to</TAG115>mak<TAG116>ea</TAG116><TAG276>types</TAG276><TAG121>pe</TAG121>c<TAG122>im</TAG122><TAG123>en</TAG123>b<TAG195>ook</TAG195>.
输入2：
hello!TAG!</hello.TAG.</
输出2：
<TAG28>hello</TAG28>!<TAG22>TAG</TAG22>!<TAG14></</TAG14><TAG28>hello</TAG28>.<TAG22>TAG</TAG22>.<TAG14></</TAG14>
答案 3 :(得分：0)
我认为您可以使用back references来执行此操作。看这篇文章：Regular Expression to detect repetition within a string
我做了很多尝试，目前我有这个表达式：＃（[a-zA-Z] +）。* \ 1＃，但我认为它找到了第一个重复的字符串，而不是最大的...
这是在我知道你不关心单词之前......
你应该做的是：
此页面描述了该步骤：http://en.wikipedia.org/wiki/Longest_common_substring_problem 这是一个PHP实现：http://www.davidtavarez.com/archives/longer-common-substring-problem-php-implementation/（你必须修复它，它包含html实体，注释说它返回一个整数，但我们不知道它代表什么...），如果它仍然不起作用，你可以尝试实现维基百科的伪代码。
答案 4 :(得分：0)
创建所有2个以上字符串的集M，然后迭代它们以贪婪的长度顺序分配它们
s="LoremIpsumissimplydummytextoftheprintingandtypesettingindustry.LoremIpsumhasbeentheindustry'sstandarddummytexteversincethe1500s,whenanunknownprintertookagalleyoftypeandscrambledittomakeatypespecimenbook."
#s="abcd1TAGabcd2TAG"
### ----
L,C,R=len,chr,range
M,l,T,t=set(),L(s),[],0
[[M.add(s[A:B])for B in R(A+2,l)]for A in R(l)]
while 1:
m,t=sorted([(L(m),m)if s.count(m)>1 else(0,"")for m in M])[-1][1],t+1
if m=="":break
T+=[(t,m)]
s=s.replace(m,C(t))
for(t,m)in T:
s=s.replace(C(t),"<TAG%d>%s</TAG%d>"%(t,m,t))
### ----
print s
输出，如预期：
<TAG1>LoremIpsum</TAG1>i<TAG11>ss</TAG11><TAG15>im</TAG15>ply<TAG2>dummytext</TAG2><TAG13>of</TAG13><TAG6>the</TAG6><TAG5>print</TAG5><TAG8>ing</TAG8><TAG9>and</TAG9><TAG4>types</TAG4>e<TAG10>tt</TAG10><TAG8>ing</TAG8><TAG3>industry</TAG3>.<TAG1>LoremIpsum</TAG1>hasbe<TAG17>en</TAG17><TAG6>the</TAG6><TAG3>industry</TAG3>'<TAG11>ss</TAG11>t<TAG9>and</TAG9>ard<TAG2>dummytext</TAG2>ev<TAG16>er</TAG16>since<TAG6>the</TAG6>1500s,wh<TAG17>en</TAG17>anunknown<TAG5>print</TAG5><TAG16>er</TAG16>t<TAG7>ook</TAG7>agal<TAG14>le</TAG14>y<TAG13>of</TAG13>ty<TAG12>pe</TAG12><TAG9>and</TAG9>scramb<TAG14>le</TAG14>di<TAG10>tt</TAG10>omakea<TAG4>types</TAG4><TAG12>pe</TAG12>c<TAG15>im</TAG15><TAG17>en</TAG17>b<TAG7>ook</TAG7>.
答案 5 :(得分：0)
不纯功能/不短/不好/很多副作用/
b = "LoremIpsumissimplydummytextoftheprintingandtypesettingindustry.\
LoremIpsumhasbeentheindustry'sstandarddummytexteversincethe1500s,\
whenanunknownprintertookagalleyoftypeandscrambledittomakeatypespecimen\
book."
i = 0
a = c = "@"
v = StringFreeQ@## &
w = StringReplace@## &
t = x__ ~~ y__ ~~ __ ~~ x__ ~~ y__ /; v[x <> y, c]
NestWhile[
w[#, (a = SortBy[StringCases[#, t -> x <> y,Overlaps -> True], -StringLength@# &][[1]]) -> c] &,
b,
(z = k@++i; b = w[b, a -> "<TAG" <> z <> ">" <> a <> "</TAG" <> z <> ">"] /. k -> IntegerString; True) && ! v[#, t] &]
答案 6 :(得分：0)
非常感谢Dennis Williamson通过回答我在shell脚本编写时遇到的一些相关问题帮助我实现了这种方法 - here和here。
以下已知问题：
正如你所看到的，它是一种巨大的蛮力方法 - 根本不是一种智能算法。我已经记录了几个样本文件的时间。
bytes time(s)
204 1.281
407 24.916
610 269.302
就像我在下面所做的那样，更多的是关于我的“思想挑战” - 在shell环境中以尽可能“完整”的方式执行此操作。而已。当然，正如结果所示，它的效率非常低，因此它完全不适合现实世界的应用。
filesize=`stat -c %s $1`
while [ $filesize -gt 1 ]
do
filesize=`expr $filesize - 1`
array=( "${array[@]}" $(cat $1 | sed -n ":a;/^.\{$filesize\}$/{p;b};s/.\{$filesize\}/&\n/;P;s/.//;s/\n//;ba" | sort | uniq -c | grep -v ' 1' | cut -c9-) )
done
sample=$(<$1)
tag=0;
for entry in ${array[@]};
do
test="<[^>/]*>[^>]*$entry[^<]*</";
if [[ ! $sample =~ $test ]];
then ((tag++));
sample=${sample//${entry}/<T$tag>$entry</T$tag>};
fi;
done;
echo $sample
用法如下：
sh tagwords4 sample2.txt