标签: nested-loops

我看了几个网站上的几个讨论,但没有一个给我一个解决方案.这段代码运行时间超过5秒:

for i in xrange(100000000):
  pass

我正在研究整数优化问题,我必须使用 O(n log n)算法编辑:一个O(n²/ 4)算法,其中n代表所有矩阵'项,即在下面的代码中, n*m个= 10000.因此,对于矩阵100*100与10000层的元件,这将导致在近25000000迭代....它的代码可以总结如下:

m = 100
n = 100
for i in xrange(m):
  for j in xrange(n):
    for i2 in xrange(i + 1, m):
      for j2 in xrange(j + 1, n):
        if myarray[i][j] == myarray[i2][j2] and myarray[i2][j] == myarray[i][j2]:
          return [i, j], [i2, j2]

我应该放弃Python并返回Java或C？

我使用Python 2.7并且Psyco不可用.PyPy不支持Tkinter开箱即用,我正在使用Tkinter.

那么,它们会提高循环速度吗？还有其他解决方案吗？

在下面的示例中,终止所有嵌套循环的最佳方法是什么.一旦if语句为true,我想终止外部for语句(使用I).换句话说,我需要整个循环停止.有没有比设置I更好的方法？

for (int I = 0; I < 10; I++)
{
    for (int A = 0; A < 10; A++)
    {
        for (int B = 0; B < 10; B++)
        {
            if (something)
                break;
        }
    }
}

如何在嵌套循环中访问grand parent的索引？

例如:

<div class="loop" data-bind="foreach: rows">
    <div class="nested-loop" data-bind="foreach: cells">
        <div class ="nested-nested-loop" data-bind="foreach: candidates, css : {selected : $root.isSelected($parentContext.$parentContext.$index(), $parentContext.$index(), $index())}">
            Candidate index: <span data-bind="text: $index()"></span>
            Cell index: <span data-bind="text: $parentContext.$index()"></span>
            Row index: <span data-bind="text: $parentContext.$parentContext.$index()"></span>
        </div>
    </div>
</div>

我试着像这样绑定:

css : {selected : $root.isSelected($parentContext.$parentContext.$index(), $parentContext.$index(), $index())}

我遇到了:

TypeError:$parentContext.$parentContext.$index不是函数

就像我们都知道的那样,break从外部循环中嵌套循环并不容易,没有:

• a goto(示例代码.)
• 外循环中的另一个条件检查(示例代码.)
• 将两个循环放在一个额外的函数中并返回而不是breaking(示例代码.)

虽然,你必须承认,所有这些都有点笨拙.特别是函数版本缺少,因为缺少调用循环的上下文,因为您需要将循环中所需的所有内容作为参数传递.
另外,第二个对于每个嵌套循环都会变得更糟.
所以,我个人仍然认为该goto版本是最干净的.

现在,考虑所有C++ 0x和东西,第三个选项带给我这个想法利用lambda表达式:

#include <iostream>

bool CheckCondition(){
  return true;
}

bool CheckOtherCondition(){
  return false;
}

int main(){
  [&]{while(CheckCondition()){
    for(;;){
      if(!CheckOtherCondition())
        return;
      // do stuff...
    }
    // do stuff...
  }}();
  std::cout << "yep, broke out of it\n";
}

(Ideone的例子.)

这允许return第三种选择提供的简单的语义美,同时不会遇到上下文问题并且(几乎)像goto版本一样干净.它比任何上述选项都更短(以字符为单位).

现在,我已经学会了在找到语言的美妙(ab)使用后保持喜悦,因为几乎总有一些缺点.这个有什么吗？或者甚至有更好的方法来解决这个问题？

在研究退出嵌套循环的方法后,我决定尝试使用goto,

private void example()
{
    for (int i = 0; i < 100; i++)
    {
        for (int ii = 0; ii < 100; ii++)
        {
            for (int iii = 0; iii < 100; iii++)
            {
                goto exitMethod;
            }                
        }             
    }

exitMethod:
}

但由于某种原因,如果我把goto标签放在方法的最后,Visual Studio 2012(Ultimate)会抱怨(并且它不会编译),

但是,如果我将代码更改为此,

private void example()
{
    for (int i = 0; i < 100; i++)
    {
        for (int ii = 0; ii < 100; ii++)
        {
            for (int iii = 0; iii …

有没有办法创建表单的for循环

for(int i = 0; i < 9; ++i) {
    for(int j = 0; j < 9; ++i) {
    //...
        for(int k = 0; k < 9; ++k) { //N-th loop

在编译时不知道N. 理想情况下,我试图找出一种循环通过数字向量的单独元素的方法,以便在用不同的数字替换一定数量的数字时创建每个可能的数字.

我有一类对象,需要将每个对象的一个​​属性与所有其他对象的相同属性进行比较.如果匹配,代码需要做一些事情.这导致两个'for循环'循环遍历对象以获取该属性,而在第二个'for循环'中,有第三个'for循环'遍历属性的元素(这是一个向量)来比较它们.如果它们匹配,我需要最外面的'for循环'来中止当前迭代并继续下一个(我只希望第一个匹配另一个对象被考虑​​).

我已经研究了'goto'语句并创建了一个do {} while()结构,但是却无法以获得所需结果的方式实现它们.我需要的是基于内部循环中条件语句中发生的事情,最外层循环的'continue'语句.

哪个是实现这一目标的好方法,它将如何实施？

编辑:在我接受的答案旁边,我也会推荐Martin Bonner的答案,这也很好,并且不依赖于goto.

for (int i = 0; i < max; i++){
Object & object1 = system.getAgent(i);
VectorOfStrings object_property1 = object1.getProperty();

    for (int j = i + 1; j < max; j++){
    Object & object2 = system.getObject(j);
    VectorOfStrings object_property2 = object2.getProperty();

        for (unsigned int k = 0; k < object_property1.size(); k++){

            if (object_property1[k] == object_property2[k]){

            //do something

            break; //this aborts the inner most loop
            //Additionally, I need the outer most loop to move on one iteration …

为了练习Java 8流,我尝试将以下嵌套循环转换为Java 8流API.它计算a ^ b(a,b <100)的最大数字总和,并在我的Core i5 760上占用~0.135s.

public static int digitSum(BigInteger x)
{
    int sum = 0;
    for(char c: x.toString().toCharArray()) {sum+=Integer.valueOf(c+"");}
    return sum;
}

@Test public void solve()
    {
        int max = 0;
        for(int i=1;i<100;i++)
            for(int j=1;j<100;j++)
                max = Math.max(max,digitSum(BigInteger.valueOf(i).pow(j)));
        System.out.println(max);
    }

我的解决方案,我希望由于并行性而更快,实际上需要0.25秒(0.19秒没有parallel()):

int max =   IntStream.range(1,100).parallel()
            .map(i -> IntStream.range(1, 100)
            .map(j->digitSum(BigInteger.valueOf(i).pow(j)))
            .max().getAsInt()).max().getAsInt();

我的问题

• 我做了正确的转换,还是有更好的方法将嵌套循环转换为流计算？
• 为什么流变种比旧变种慢得多？
• 为什么parallel()语句实际上将时间从0.19s增加到0.25s？

我知道微基准测试很脆弱,并行性只对大问题是值得的,但对于CPU来说,甚至0.1秒都是永恒的,对吗？

更新

我使用Eclipse Kepler中的Junit 4框架进行测量(它显示了执行测试所花费的时间).

我的结果为a,b <1000而不是100:

• 传统的循环186s
• 顺序流193s
• 并行流55s

更新2sum+=Integer.valueOf(c+"");用sum+= c - '0';(谢谢彼得!) 替换平行方法10秒,使其达到45秒.没想到这么大的性能影响!

此外,减少与CPU内核数量的并行性(在我的情况下为4)没有做太多,因为它将时间减少到44.8s(是的,它增加了a和b …

我设法解决了这个问题,下面是我的解决方案:

public class ProblemA001k {

public static void main(String[] args) {



        System.out.println("Sum from 1" + " to " + divQ + ":" + sum2);
        System.out.println();
        divQ += q;
        newQ += q;
        sum1 = 0;
        sum2 = 0;
        }

key.close();
}

}

现在我被告知要修改我的解决方案,以便它只使用一个循环.我在上面的代码中有3个循环,即使我尝试只使用2个循环,我也在努力.但是一圈？我不知道如何改进我的代码.请帮我.

我有一个对象列表A.此列表中的每个对象A包含对象B的列表,对象B包含对象C的列表.对象C包含我想用于使用java 8进行过滤的属性名称.

如何使用流编写java 8中的代码以避免嵌套循环:

C c1 = null;
String name = "name1"
for (A a: listOfAObjects) {
    for (B b: a.getList()) {
        for (C c: b.getPr()) {
            if (c.getName().equalsIgnoreCase(name)) {
                c1= c;
                break;
            }
        }
    }
}