查找字符串中的模式


17

在这种挑战下,您的任务是找到具有给定结构的子字符串。

输入项

您的输入应为两个非空的字母数字字符串,一个模式 p和一个text t。这个想法是,的每个字符都p代表一个连续的非空子字符串,t该子字符串彼此相邻出现,并p表示它们的串联。相同的字符对应于相同的子字符串。例如,模式aa代表任何非空正方形(通过将较短的字符串与其自身连接而获得的字符串)。因此,模式aa可以匹配子字符串byebye,并且每次a匹配bye

输出量

如果文本t包含p匹配的子字符串,则您的输出应为该子字符串,并:在与的字符相对应的字符串之间插入冒号p。例如,如果我们有t = byebyenowp = aa,那么bye:bye它是可接受的输出。匹配子字符串可能有多个选择,但是您只能输出其中之一。

如果t不包含匹配的子字符串,则您的输出将是悲伤的表情:(

规则和说明

的不同字符p可以对应相同的子字符串,因此p = aba可以匹配字符串AAA。请注意,这些字符必须对应于非空字符串;特别是,如果p长于t,则输出必须为:(

您可以编写完整的程序或函数,还可以更改两个输入的顺序。最低字节数获胜,并且不允许出现标准漏洞。

测试用例

以格式给出pattern text -> output。注意,可能存在其他可接受的输出。

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

1
所有子串的功率集?为什么不!
orlp 2015年

1
@orlp仅有O(2^((n * (n + 1))/2)):P
ThreeFx 2015年

模式字符串中的数字表示什么?
feersum

@feersum这是一个字符,因此与其他任何字符基本相同。
ThreeFx

@ThreeFx我不确定,因为第一段仅引用模式中的“字母”。
feersum

Answers:


6

Python,207个字节

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

致电 g(pattern, string)

使用re模块来完成大部分工作。


1

JavaScript(SpiderMonkey)(ES5.1),198字节

自2015年6月发布ES6以来,我将代码的ES5.1版本和等效的ES6一起发布,但将ES5.1版本声明为主要答案。

贪婪匹配,因此第一种情况返回“ Not”而不是“ 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(":"):":("}

在线尝试!

JavaScript(Node.js)(ES6),141个字节

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

在线尝试!

采用currying语法中的参数: f(a)(b)

解释(不公开):

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

1

Brachylog,35个字节

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

在线尝试!

在非小输入上,非常慢。我实际上没有完成第六个测试案例,但是并没有因为缺乏尝试而变慢。(可能是由于对每个子字符串的每个分区进行了强行强制,从最大的分区开始,然后检查是否匹配。)将输入作为list [pattern,string]

简明扼要的解释:

sᵗ~cᵗX

X是与输入字符串的子字符串的分区配对的模式。

lᵛ

模式和分区具有相同数量的元素。

Xzdz≠ʰ

没有两个唯一的pattern char, matched substring对共享模式字符。即,尽管多个图案字符可以映射到一个子字符串,但是没有图案字符映射到多个子字符串。

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

输出是由冒号连接的分区的元素,除非无法执行某些操作,在这种情况下 :(

整体说明:

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

已经一个多小时了,它仍然没有完成第六个测试用例……也许实际上不起作用?它使用的处理器数量不止于它的份额……
不相关的字符串

好吧,要么我低估了使用多层硬蛮力的时间复杂性,要​​么以某种方式被打破了,因为它仍然没有完成第六个测试用例
不相关的字符串

我现在将其关闭,因为如果要花三个小时,我不确定我愿意等待多长时间
不相关的字符串
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.