标签: nested-loops

我想知道当验证结束条件(不同于正确的迭代次数)时是否可以在C++中结束for循环.例如:

for (int i = 0; i < maxi; ++i)
    for (int j = 0; j < maxj; ++j)
        // But if i == 4 < maxi AND j == 3 < maxj, 
        // then jump out of the two nested loops.

我知道这可能在Perl中使用下一个LABEL或最后一个LABEL调用和标记的块,是否可以在C++中执行它或者我应该使用while循环？

谢谢.

我已经完成了类似的问题搜索,我对我应该做什么有一个模糊的想法:矢量化一切或使用apply()家庭.但我是R编程的初学者,上述两种方法都令人困惑.

这是我的源代码:

x<-rlnorm(100,0,1.6)
j=0
k=0
i=0
h=0
lambda<-rep(0,200)
sum1<-rep(0,200)
constjk=0
wj=0
wk=0
for (h in 1:200)
{
   lambda[h]=2+h/12.5
   N=ceiling(lambda[h]*max(x))
   for (j in 0:N)
   {
      wj=(sum(x<=(j+1)/lambda[h])-sum(x<=j/lambda[h]))/100
      for (k in 0:N)
      {
         constjk=dbinom(k, j + k, 0.5)
         wk=(sum(x<=(k+1)/lambda[h])-sum(x<=k/lambda[h]))/100
         sum1[h]=sum1[h]+(lambda[h]/2)*constjk*wk*wj
      }
   }
}

让我解释一下.我想收集200个sum1值(这是第一个循环),并且对于每个sum1值,它是总和(lambda[h]/2)*constjk*wk*wj,因此是其他两个循环.最乏味的是N随h变化,所以我不知道如何对j循环和k循环进行矢量化.但是当然我可以使用lambda<-seq()和矢量化h循环N<-ceiling(),这是我能做的最好的.有没有办法进一步简化代码？

我有一个多维数组（result），应该由一些嵌套循环填充。函数fun()是一个复杂且耗时的函数。我想以并行方式填充数组元素，因此我可以使用系统的所有处理能力。这是代码：

import numpy as np


def fun(x, y, z):
    # time-consuming computation...
    # ...

    return output


dim1 = 10
dim2 = 20
dim3 = 30

result = np.zeros([dim1, dim2, dim3])

for i in xrange(dim1):
    for j in xrange(dim2):
        for k in xrange(dim3):
            result[i, j, k] = fun(i, j, k)

我的问题是“我是否可以并行化此代码？如果可以，如何？”

我正在使用Windows 10 64位和python 2.7。

如果可以的话，请通过更改我的代码来提供您的解决方案。谢谢！

我有一个类似的清单：

[[16777230, 0], [16777226, 1], [16777252, 2], [16777246, 0]]

我想在 python 中为我的操作在循环（嵌套循环）中创建一个循环，这样内循环将始终从外循环的下一个元素开始。

例如，外循环将在每次迭代中遍历列表中从索引 0 到 3 的所有元素。但在外循环的第一次迭代中，内循环将从索引 1 开始并在索引 3 处结束。那么，在外循环的第二次迭代中，内循环应该遍历索引2到索引3。 依此类推... 外循环的最后一次迭代应该使内循环从索引n遍历到索引n，基本上只有最后一个元素，在本例中为索引 3 到索引 3。

问题是我在遍历时删除了列表的元素。因此，它在使用范围函数进行遍历时会产生列表索引超出范围等问题。

如何构建这些内循环和外循环？

我试过这个，但似乎不起作用：

for sub_list1 in yx:
    index_sl1 = yx.index(sub_list1)
    for sub_list2 in yx[index_sl1+1:]:
        Operations...

帮助将不胜感激。谢谢！！

我有一个循环通过一系列四个(或更少)字符串的脚本.例如:

aaaa
aaab
aaac
aaad

如果能够使用嵌套的for循环实现它,如下所示:

chars = string.digits + string.uppercase + string.lowercase

for a in chars:
    print '%s' % a   
    for b in chars:
        print '%s%s' % (a, b)
        for c in chars:
            print '%s%s%s' % (a, b, c)
            for d in chars:
                print '%s%s%s%s' % (a, b, c, d)

这种循环是一种坏事,如果是这样,那么完成我正在做的事情的更好方法是什么？

Big O表示法对于以下嵌套循环有什么作用？

     for (int i = n; i > 0; i = i / 2){
        for (int j = n; j > 0; j = j / 2){
           for (int k = n; k > 0; k = k / 2){
              count++;
           }
        }
     }

我的想法是:每个循环都是O(log2(n))如此简单到繁殖

O(log2(n)) * O(log2(n)) * O(log2(n))  =  O(log2(n)^3)

我正在阅读有关循环转换技术的内容,我很难理解循环偏移如何使循环可并行化这里有两个循环,初始循环和第二个循环,两者之间有什么区别？它们中的两个取决于i和j上的前一次迭代,是什么使得第二个循环可以进行？或者为什么我们可以在第二个而不是第一个进行交换？它们都依赖于i和j

for(int i =2; i < 5; i++){
            for(int j =2; j < 5; j++){
                A[i][j] = A[i-1][j] + A[i][j-1];
            }
        }
for(int i =2; i < 5; i++){
            for(int j =2+i; j < 5+i; j++){
                A[i][j-i] = A[i-1][j-i] + A[i][j-1-i];
            }
        }

我有一个对象数组,以及一个特定方法的可接受返回值数组.如何将对象数组减少到只有那些方法在我的可接受值数组中返回值的对象？

现在,我有这个:

my @allowed = grep {
    my $object = $_;
    my $returned = $object->method;
    grep {
        my $value = $_;
        $value eq $returned;
    } @acceptableValues;
} @objects;

问题是这是一个复合循环,我想避免.该程序旨在扩展到任意大小,我想最小化运行的迭代次数.

最好的方法是什么？

我有一个数据框，基于名为“originator”的列中的字符串，我想检查该字符串是否包含位于另一个列表中的单词。如果该字符串包含位于所述列表中的单词，则将列 originator_prediction 更新为“org”。

有一个更好的方法吗？我是按照以下方式做的，但速度很慢。

for row in df['ORIGINATOR'][1:]:
    string = str(row)
    splits = string.split()
    for word in splits:
        if word in COMMON_ORG_UNIGRAMS_LIST:
            df['ORGINATOR_PREDICTION'] = 'Org'
        else:
            continue

df  = pd.DataFrame({'ORIGINATOR':  ['JOHN DOE', 'APPLE INC', 'MIKE LOWRY'],
        'ORGINATOR_PREDICTION': ['Person', 'Person','Person']})

COMMON_ORG_UNIGRAMS_LIST = ['INC','LLC','LP']

具体来说，如果您查看我们的数据框“APPLE INC”中的第 2 行，应该有一个 originator_prediction = 'ORG' 而不是 person。

原因是，我们遍历了常见的 org unigrams 列表，里面有 INC 这个词。

假设我们有以下嵌套循环：

MyClass myobject;

for (const std::array<int,16>& arr : myobject)
{
    for (int i : arr)  {  /* do something with i */  }
}

例如， whereMyClass可以迭代 16 个整数的数组。

现在，我想要一个循环来迭代所有数组的所有整数myobject：

for (int i : MagicClass(myobject))  {  /* do something with i */  }

MagicClass我想要设计的课程在哪里。我知道MagicClass应该实现begin/end返回特定迭代器的方法，即。就像是：

class MagicClass
{
public:
    MagicClass (MyClass obj) : obj_(obj) {}

    struct iterator 
    {
        // the hard part comes here...
    };

    iterator begin()  { return iterator (obj_.begin()); }
    iterator …