因此，社区，我想请您给我一次第三次给您惊喜的机会，在我以前使用python的决定中，我想我会引起这里专家的注意，他们会立即告诉我为什么这样做，通常有正则表达式-我做到了，并且一切都可以肯定将起作用，这是我们的python可以发出的速度更快的结果。

本文的下一个主题应该是另外一个任务，但是不，第一个任务没有离开我，可以做些什么来获得更快的解决方案，因为该站点的胜利是另一场比赛的加冕。

我编写的实现平均速度是这样的，这意味着仍然有90％的解决方案我没有注意到有人知道如何更快地解决它，而他却保持沉默 ，在看了前两篇文章后，我没有说：哦，如果性能问题，那么一切都清楚了-这里的序言不合适。 但是，现在一切都在性能上正常了，无法想象一个程序将在较弱的硬件上运行，“最后，为什么要考虑它？”

挑战赛

为了更快地解决问题，有一个python，而且有时间，并且在python上有更快的解决方案吗？

我被告知“运行时：2504毫秒，比通配符匹配的Python3在线提交的1.55％快。”

我警告您，此外，网上还有很多想法。

1个常规吗？

也许这里是仅使用正则表达式编写更快程序的选项。

显然，python可以创建一个正则表达式对象，该对象将检查输入行，并最终在该行上运行，该文件位于网站上用于测试程序的沙箱中。
只是import re ，我可以导入这样的模块，这很有趣，我必须尝试。

很难理解创建快速解决方案并不容易。 我们将必须搜索，尝试并创建类似于以下内容的实现：

1.使这种规律性成为对象，
2.放下由所选图书馆的常规图书馆规则纠正的模板，
3.比较并准备好答案
瞧：

import re def isMatch(s,p): return re.match(s,pat_format(p))!=None def pat_format(pat): res="" for ch in pat: if ch=='*':res+="(.)*" if ch=='?':res+="." else: res+=ch return res 

这是一个非常简短的解决方案，好像是正确的。

我正在尝试运行，但它不在这里，并不完全正确，某些选项不合适，您需要测试到模板的转换。

事实很有趣，我将模板和字符串混合在一起，但是解决方案走到了一起，我通过了1058次测试，但都失败了，仅在这里。

我再说一遍，在这个站点上，他们正在认真地进行测试，碰巧，以前的所有参数都很好，但是这里混合了两个主要参数，显示出来了，这是TDD的优点...

而且在如此美妙的文字上，我仍然会出错

 import re def isMatch(s,p): return re.match(pat_format(p),s)==None def pat_format(pat): res="" for ch in pat: if ch=='*':res+="(.)*" else: if ch=='?':res+="." else:res+=ch return res 

辛苦

看来，此任务特别是与测试重叠在一起的，因此，那些想要使用正则表达式的人会遇到更多的困难，在此解决方案之前，我在程序中没有逻辑错误，但是在这里我们必须考虑很多事情。

因此，正则表达式匹配，并且第一个结果应等于我们的行。

胜利的
要让他使用正则表达式并不容易，但是尝试失败了，这不是一个简单的诱骗正则表达式的决定。 广度优先搜索解决方案工作更快。

这是一个实现，

 import re def isMatch(s,p): res=re.match(pat_format(p),s) if res is None: return False else: return res.group(0)==s def pat_format(pat): res="" for ch in pat: if ch=='*':res+="(.)*" else: if ch=='?':res+="." else:res+=ch return res 

导致此：

上诉

亲爱的居民，请尝试检查一下，它使python变为3 ，他无法快速完成此任务：

 import re def isMatch(s,p): res=re.match(pat_format(p),s) if res is None: return False else: return res[0]==s def pat_format(pat): res="" for ch in pat: if ch=='*':res+="(.)*" else: if ch=='?':res+="." else:res+=ch return res ##test 940 import time pt=time.time() print(isMatch("aaaabaaaabbbbaabbbaabbaababbabbaaaababaaabbbbbbaabbbabababbaaabaabaaaaaabbaabbbbaababbababaabbbaababbbba","*****b*aba***babaa*bbaba***a*aaba*b*aa**a*b**ba***a*a*")) print(time.time()-pt) “***** B * ABA ***巴巴* bbaba ***一个* AABA * b *表AA ** A * B ** *** BA A * A *”） import re def isMatch(s,p): res=re.match(pat_format(p),s) if res is None: return False else: return res[0]==s def pat_format(pat): res="" for ch in pat: if ch=='*':res+="(.)*" else: if ch=='?':res+="." else:res+=ch return res ##test 940 import time pt=time.time() print(isMatch("aaaabaaaabbbbaabbbaabbaababbabbaaaababaaabbbbbbaabbbabababbaaabaabaaaaaabbaabbbbaababbababaabbbaababbbba","*****b*aba***babaa*bbaba***a*aaba*b*aa**a*b**ba***a*a*")) print(time.time()-pt) 

您可以在家尝试。 奇迹，不仅解决了很长时间，而且还冻结了，哦。

正则表达式是表现式表现look脚的子集吗？
这种说法很奇怪，它们存在于所有流行的语言中，因此应该提高生产率，但是这里没有有限的状态机是完全不现实的，在一个无休止的循环中会发生什么？

去吧

我读了一本书，但是已经很久了……Go的最新语言很快就起作用了，但是正则表达式呢？

我将测试他：

 func isMatch(s string, p string) bool { res:=strings.Replace(p, "*", "(.)*", -1) res2:=strings.Replace(res, "?", ".", -1) r, _ := regexp.Compile(res2) fr:=r.FindAllString(s,1) return !(len(fr)==0 || len(fr)!=0 && fr[0]!=s) } 

我承认，要获得如此简洁的文本并不容易，语法也不是琐碎的，即使有了si的知识，也很难弄清楚……

这是一个了不起的结果，速度确实达到了60毫秒左右，但是令人惊讶的是，该解决方案比同一站点上仅15％的响应速度快。

序幕在哪里

我发现这种被遗忘的正则表达式语言为我们提供了一个基于Perl兼容正则表达式的库 。

这是可以实现的方式，但是使用单独的谓词对模板字符串进行预处理。

 pat([],[]). pat(['*'|T],['.*'|Tpat]):-pat(T,Tpat),!. pat(['?'|T],['.'|Tpat]):-pat(T,Tpat),!. pat([Ch|T],[Ch|Tpat]):-pat(T,Tpat). isMatch(S,P):- atom_chars(P,Pstr),pat(Pstr,PatStr),!, atomics_to_string(PatStr,Pat), term_string(S,Str), re_matchsub(Pat, Str, re_match{0:Str},[bol(true),anchored(true)]). 

运行时很好：

 isMatch(aa,a)->ok:0.08794403076171875/sec isMatch(aa,*)->ok:0.0/sec isMatch(cb,?a)->ok:0.0/sec isMatch(adceb,*a*b)->ok:0.0/sec isMatch(acdcb,a*c?b)->ok:0.0/sec isMatch(aab,c*a*b)->ok:0.0/sec isMatch(mississippi,m??*ss*?i*pi)->ok:0.0/sec isMatch(abefcdgiescdfimde,ab*cd?i*de)->ok:0.0/sec isMatch(zacabz,*a?b*)->ok:0.0/sec isMatch(leetcode,*e*t?d*)->ok:0.0009980201721191406/sec isMatch(aaaa,***a)->ok:0.0/sec isMatch(b,*?*?*)->ok:0.0/sec isMatch(aaabababaaabaababbbaaaabbbbbbabbbbabbbabbaabbababab,*ab***ba**b*b*aaab*b)->ok:0.26383304595947266/sec isMatch(abbbbbbbaabbabaabaa,*****a*ab)->ok:0.0009961128234863281/sec isMatch(babaaababaabababbbbbbaabaabbabababbaababbaaabbbaaab,***bba**a*bbba**aab**b)->ok:0.20287489891052246/sec 

但是，有一些限制，接下来的测试带来了：

 Not enough resources: match_limit Goal (directive) failed: user:assert_are_equal(isMatch(aaaabaaaabbbbaabbbaabbaababbabbaaaababaaabbbbbbaabbbabababbaaabaabaaaaaabbaabbbbaababbababaabbbaababbbba,'*****b*aba***babaa*bbaba***a*aaba*b*aa**a*b**ba***a*a*'),false) 

结论

只剩下问题了。 一切都可以实现，但是速度很差。
透明的解决方案无效吗？

有人实现了声明式正则表达式，有什么样的机制？

您如何看待这些挑战，是否有可以解决的问题，但是最佳解决方案在哪里？