标签: sequence

意外行为:

我遇到了11g的Oracle序列的奇怪行为(适用于10g):

CREATE SEQUENCE test_sequence START WITH 1;
CREATE TABLE test_table ( val INT );

INSERT INTO test_table VALUES ( test_sequence.NEXTVAL );

即使序列以1开头,插入的第一个值为2:

SELECT * FROM test_table;

       VAL
----------
         2

预期行为:

NEXTVAL没有插入的选择按预期工作:

CREATE SEQUENCE test_sequence_2 START WITH 1;

SELECT test_sequence_2.NEXTVAL FROM dual

   NEXTVAL
----------
         1

题:

任何人都可以使用Oracle 11g重现这一点吗？这是一个已知的问题？

我正在使用
Oracle Database 11g Enterprise Edition Release 11.2.0.1.0 - 64bit Production.

我需要找到一个有效的（伪）代码来解决以下问题：

给定两个（不一定是不同的）整数序列(a[1], a[2], ..., a[n])和(b[1], b[2], ..., b[n])，找到最大值d使得a[n-d+1] == b[1]、a[n-d+2] == b[2]、 ... 和a[n] == b[d]。

这不是作业，我实际上是在尝试沿尽可能多的维度收缩两个张量时想到的。我怀疑存在一种有效的算法（也许O(n)？），但我无法想出不是O(n^2). 该O(n^2)方法将是明显的循环d，然后在项目上进行内部循环以检查所需的条件，直到达到最大值d。但我怀疑比这更好的事情是可能的。

如何生成包含所有可能排列的最短序列？

示例:对于长度2,答案为121,因为此列表包含12和21,这些都是可能的排列.

对于长度3,答案是123121321,因为该列表包含所有可能的排列:123,231,312,121(无效),213,132,321.

每个数字(在给定的排列中)可能只出现一次.

自从我开始编程以来,这一直是我一直很好奇的事情.但对我来说似乎太复杂了甚至尝试.

我很乐意看到解决方案.

1, 2, 3, 4, 5    // returns 6 (n + 1)
10, 20, 30, 40, 50   //returns 60 (n + 10)
10, 17, 31, 59, 115  //returns 227 ((n * 2) - 3)

我试图返回一个带有until循环的可变序列,但是我有一个不可变的seq返回(0到nbGenomes):

 def generateRandomGenome(nbGenomes:Int): IndexedSeq[GenomeDouble]={
    return ((0 until nbGenomes toSeq).map{e => generateRandomGenome}) 
  }

返回编译错误:

found   : scala.collection.immutable.IndexedSeq[org.openmole.tools.mgo.mappedgenome.genomedouble.GenomeDouble]
 required: scala.collection.mutable.IndexedSeq[org.openmole.tools.mgo.mappedgenome.genomedouble.GenomeDouble]
    return ((0 until nbGenomes toSeq).map{e => generateRandomGenome}) 

我如何强制until循环返回一个可变的seq？谢谢scala社区!

所以,在通过"Scala for the Impatient"的过程中,我发现自己在想:你能不使用Scala for循环吗？

例如,本书中有一个练习,要求您构建一个无法递增超过Integer.MAX_VALUE的计数器对象.为了测试我的解决方案,我编写了以下代码:

var c = new Counter
for( i <- 0 to Integer.MAX_VALUE ) c.increment()

这会引发错误:序列不能包含多个Int.MaxValue元素.在我看来,这意味着Scala首先分配和填充序列对象,值为0到Integer.MaxValue,然后在该序列对象上执行foreach循环.

我意识到我可以这样做:

var c = new Counter
while(c.value < Integer.MAX_VALUE ) c.increment()

但有没有办法用for语句做一个传统的C风格for循环？

我能想到的最好的是:

(defn dups [seq]
  (map (fn [[id freq]] id) 
       (filter (fn [[id freq]] (> freq 1))
               (frequencies seq))))

有更简洁的方法吗？

假设我有一个列表:

l = [0, 1, 2, 3]

如何迭代列表,从列表中获取每个项目及其补充？那是,

for item, others in ...
    print(item, others)

会打印

0 [1, 2, 3]
1 [0, 2, 3]
2 [0, 1, 3]
3 [0, 1, 2]

理想情况下,我正在寻找一个简洁的表达,我可以在理解中使用.

什么是从包含数字列表的"无"中选择关系的快速/可读方式.我想通过设置开始和结束值来定义哪些数字.我正在使用Postgres SQL和SQLite,并且会对可以在两个/多个平台上工作的通用解决方案感兴趣.

期望的输出关系:

# x
  0
  1
  2
  3
  4

我知道我可以从"无"中SELECT 0,1,2,3,4选择一行:但是这会选择值作为列而不是行,并且需要在查询中指定所有值,而不是仅使用我的开始值和结束值:0和4.

在Postgres中,你有一个generate_series针对这种情况的特殊功能:

SELECT * FROM generate_series(0,4) x;

这很好用但不标准.我也可以想象使用临时表的一些复杂的解决方案,但我希望有一些通用和简单的东西:

SELECT * FROM [0..4]

也许使用SEQUENCE声明或一些神奇的组合SELECT 0和SELECT 4？

假设我有这些数据:

  x = c(14,14, 6,  7 ,14 , 0 ,0  ,0 , 0,  0,  0 , 0 , 0,  0 , 0 , 0 , 0,  9  ,1 , 3  ,8  ,9 ,15,  9 , 8, 13,  8,  4 , 6 , 7 ,10 ,13,  3,
 0 , 0 , 0 , 0 , 0 , 0,  0,  0 , 0 , 0 , 0,  0,  0,  0,  0  ,0,  0 , 0 , 0,  0,  0,  0,  0 , …