Groovy数列

如何在Groovy中获得给定数字的序列，例如：

def number = 169
// need a method in groovy to find the consecutive numbers that is, 1,6,9,16,69,169
// not 19!

Groovy中有一个名为

subsequences（）

的方法，但它并没有完全完成这项工作。谁能告诉我，我怎样才能用更常规的方式来做这件事？或者有什么内置的方法吗？

考虑到（它工作得很好），我提出了一个稍微有点Groovy的er版本：

def number = 181

number = number.toString() as List

def results = (0..<number.size()).inject([]) { res, numDigits ->
  res.addAll( (0..<number.size()-numDigits).collect { startPos ->
    number[startPos..startPos + numDigits].join() as int
  } )
  res
}

println results

def编号=181
number=number.toString（）作为列表
def结果=（0。。
res.addAll（（0。。
编号[startPos..startPos+numDigits].join（）为int
} )
物件
}
打印结果

在Groovy控制台中运行此命令

def number = 169
number = number.toString() as List

def results = []

0.upto(number.size()) {numDigits ->

  for(int startPos = 0; startPos + numDigits < number.size(); startPos++) {
    def result = number[startPos..startPos + numDigits]
    results << result.join().toInteger()
  }
}

assert results == [1, 6, 9, 16, 69, 169]

def编号=169
number=number.toString（）作为列表
def结果=[]
0.upto（number.size（））{numDigits->
对于（int startPos=0；startPos+numDigits结果。。。
你可以这样做：

num = 169
ar = []

while ( num >= 1 ) {
    str = num.toString()
    ar.add(str[str.indexOf('.')-1])
    num = num/10.toInteger()
}

len = ar.size()
for ( i in 1..len-1 ) {
    for (j in 0..len-i-1) {
        str = ""
        for ( k in 0..i) {
           str += ar.get(j+k)
        }
        ar.add(str)
    }
}

我想那应该行得通。
oneliner

(0..<n.size()).inject([]) {a,b -> (0..<n.size()-b).each {a << (n[it] as Integer)};a}

（0..（0..不需要使用join（）从整数到字符串再到列表，再回到字符串，因为字符串的行为已经非常类似于任何序列：

//为这个愚蠢的名字感到抱歉。想不出更好的名字了：）
def子整数（num）{
def str=num作为字符串
（1..str.length（））.inject（[]）{res，size->
res+=（0..str.length（）-size）。将{i->str[i..

除了转换少一点之外，这是的一个副本。希望能有所帮助。
虽然游戏进行得晚了，但这里有一个解决方案没有@tim的那么复杂，但也可以做到：

def str = 169 as String
def result = [] as SortedSet
(0..<str.length()).each { i ->
    (i..<str.length()).each { j ->
        result << str[i..j].toInteger()
    }
}

你能解释为什么19不属于该列表吗？我怀疑这是因为在原始编号
169
中，
1
和
9
被
6
隔开，因此不相邻。1444有问题：D@Ant是的，我的原始代码中有一个重复数字的问题…改成了一个稍微有点Groovy的代码-Dons的er版本现在真的是一个很好的答案你能解释一下它的功能吗？我是Groovy的新手：D@tim_yates谢谢，我很高兴终于找到了你：）@Don；-）并且断言可能正在比较字符串列表和整数列表……另外，我想展示一下你的算法的groovy er版本；-）无法抗拒…对不起，我不确定groovy是如何引用的，但是如果你在其他java环境中比较两个列表，你不是在比较列表中的值，而是在比较它们的内存地址，这是不相等的。要比较两个列表，你必须逐个元素进行比较。@tim_yates你完全正确，我已经更新了对代码进行分类，因此它会返回一个
列表
。它的工作原理非常简单：）但实际上我不希望
结果
作为
分类集
。如果您删除这个，那么它就完美了！
def str = 169 as String
def result = [] as SortedSet
(0..<str.length()).each { i ->
    (i..<str.length()).each { j ->
        result << str[i..j].toInteger()
    }
}

 1 6 9 
 -----
 0 1 2  <-- index
 =====
[1]6 9  (i=0; j=0)
[1 6]9  (i=0; j=1)
[1 6 9] (i=0; j=2)
 1[6]9  (i=1; j=1)
 1[6 9] (i=1; j=2)
 1 6[9] (i=2; j=2)