该表用于存储会话(事件):
CREATE TABLE session (
id int(11) NOT NULL AUTO_INCREMENT
, start_date date
, end_date date
);
INSERT INTO session
(start_date, end_date)
VALUES
("2010-01-01", "2010-01-10")
, ("2010-01-20", "2010-01-30")
, ("2010-02-01", "2010-02-15")
;
我们不希望范围之间发生冲突.
假设我们需要在2010-01-05到2010-01-25之间插入一个新会话.
我们想知道冲突的会话.
这是我的查询:
SELECT *
FROM session
WHERE "2010-01-05" BETWEEN start_date AND end_date
OR "2010-01-25" BETWEEN start_date AND end_date
OR "2010-01-05" >= start_date AND "2010-01-25" <= end_date
;
结果如下:
+----+------------+------------+
| id | start_date | end_date |
+----+------------+------------+
| 1 | 2010-01-01 | …我需要C#字符串搜索算法,它可以匹配多个模式的出现.例如,如果pattern为'AA'且string为'BAAABBB'Regex产生匹配结果Index = 1,但我需要结果Index = 1,2.我可以强制Regex给出这样的结果吗？
我有以下代码:
test :: String -> Bool
test "g" = True
test "global" = True
test _ = False
当我加载到GHCi(7.0.3)时,我得到:
Warning: Pattern match(es) are overlapped
In an equation for `test': test "g" = ...
这是一个错误还是我错过了什么？
以下举行:
test "" == False
test "g" == True
test "gl" == False
test "global" == True
test "globalx" == False
更新:
我在用{-# LANGUAGE OverloadedStrings #-}.
我正在寻找解决这个问题的最有效内存的方法.
我有一个元组列表,表示句子中的部分字符串匹配:
[(0, 2), (1, 2), (0, 4), (2,6), (23, 2), (22, 6), (26, 2), (26, 2), (26, 2)]
每个元组的第一个值是匹配的起始位置,第二个值是长度.
我们的想法是折叠列表,以便仅报告最长的继续字符串匹配.在这种情况下,它将是:
[(0,4), (2,6), (22,6)]
我不想只是最长的范围,比如在算法中找到最长的非重叠序列,但我希望所有范围最长时间折叠.
万一你想知道,我正在使用Aho-Corasick的纯python实现来将静态字典中的术语与给定的文本片段进行匹配.
编辑:由于这些元组列表的性质,应单独打印重叠但不是自包含的范围.例如,在单词betaz和zeta词典中,匹配betazeta是[(0,5),(4,8)].由于这些范围重叠,但没有一个包含在另一个中,答案应该是[(0,5),(4,8)].我还修改了上面的输入数据集,以便涵盖这种情况.
谢谢!
我目前对Haskell中模式重叠的理解是,如果传递给函数的某些参数值可以由多个模式匹配,则认为2个模式是重叠的.
鉴于:
last :: [a] -> a
last [x] = x
last (_ : xs) = last xs
传递参数值[1]将匹配第一个模式[x]和第二个模式(_:xs) - 这意味着该函数具有重叠模式,即使两个模式都可以匹配.
令人困惑的是,虽然模式(通过上面的定义)重叠,但GHC没有显示任何关于它们重叠的警告.
恢复last函数中的2个模式匹配确实显示重叠警告:
last :: [a] -> a
last (_ : xs) = last xs
last [x] = x
警告:
src\OverlappingPatterns.hs:6:1: Warning:
Pattern match(es) are overlapped
In an equation for `last': last [x] = ...
如果先前的模式使得无法匹配稍后发生的模式,那么GHC几乎就会考虑模式重叠.
确定函数是否具有重叠模式的正确方法是什么？
更新
我正在寻找overlapping patternfp101x课程中使用的定义.
根据fp101x中使用的定义,以下函数具有overlapping patterns:
last :: [a] -> a
last [x] = x
last (_ : …我想找到每个ID的重叠日期,并创建一个重叠日期的新行,并组合行的字符(char).我的数据可能有> 2个重叠,需要> 2个字符组合.例如.ERM
数据:
ID date1 date2 char
15 2003-04-05 2003-05-06 E
15 2003-04-20 2003-06-20 R
16 2001-01-02 2002-03-04 M
17 2003-03-05 2007-02-22 I
17 2005-04-15 2014-05-19 C
17 2007-05-15 2008-02-05 I
17 2008-02-05 2012-02-14 M
17 2010-06-07 2011-02-14 V
17 2010-09-22 2014-05-19 P
17 2012-02-28 2013-03-04 R
输出我想:
ID date1 date2 char
15 2003-04-05 2003-04-20 E
15 2003-04-20 2003-05-06 ER
15 2003-05-06 2003-06-20 R
16 2001-01-02 2002-03-04 M
17 2003-03-05 2005-04-15 I
17 2005-04-15 2007-02-22 IC
17 2005-04-15 2007-05-15 …我将使用Scala语法提出这个问题,即使这个问题确实与语言无关.
假设我有两个列表
val groundtruth:List[Range]
val testresult:List[Range]
我想找到所有与元素testresult重叠的元素groundtruth.
我可以这样做:
def overlaps(x:Range,y:Range) = (x contains y.start) || (y contains x.start)
val result = testresult.filter{ tr => groundtruth.exists{gt => overlaps(gt,tr)}}
但这需要O(testresult.size * groundtruth.size)时间来运行.
是否有更快的算法来计算这个结果,或者是一个可以提高exists测试效率的数据结构？
PS该算法应该使用如下表达式进行处理groundtruth和testresult生成.换句话说,不保证列表中的范围之间的关系,Ranges的平均大小为100或更大.
(1 to 1000).map{x =>
val midPt = r.nextInt(100000);
((midPt - r.nextInt(100)) to (midPt + r.nextInt(100)));
}.toList
我正在探索正则表达式的强大功能,所以我只是想知道这样的事情是否可行:
public class StringSplit {
public static void main(String args[]) {
System.out.println(
java.util.Arrays.deepToString(
"12345".split(INSERT_REGEX_HERE)
)
); // prints "[12, 23, 34, 45]"
}
}
如果可能的话,那么只需提供正则表达式(以及对其如何工作的先发制人的解释).
如果它只能用于Java以外的一些正则表达式,那么也可以随意提供它们.
如果不可能,请解释原因.
奖金问题
同样的问题,但有一个find()循环,而不是split:
Matcher m = Pattern.compile(BONUS_REGEX).matcher("12345");
while (m.find()) {
System.out.println(m.group());
} // prints "12", "23", "34", "45"
请注意,并不是因为我有一个具体的任务来完成这种或那种方式,而是我想要了解正则表达式.我不需要做我想要的代码; 我想要正则表达式,如果它们存在,我可以在上面的代码中使用它来完成任务(或者使用其他版本的正则表达式,将代码"直接翻译"成另一种语言).
如果它们不存在,我想要一个很好的解释原因.
情况是,我想在字符串"cccd"中找到满足"c + d"的字符串.我的代码如下,
String str="cccd";
String regex="c+d";
Pattern pattern = Pattern.compile(regex);
Matcher matcher =pattern.matcher(str);
While(matcher.find()){
System.out.println(matcher.group())
}
结果只是"cccd".但我想要的是获得所有可能的结果,包括嵌套的结果,即cd,ccd和cccd.我应该如何解决它,提前谢谢.