标签: nested-loops

我的问题是使用嵌套for循环来创建此输出:

         |         |         |         |         |         |
123456789012345678901234567890123456789012345678901234567890

我无法弄清楚用0替换int 10的最佳方法.我尝试了几种方法,但它们都是花哨的,对我来说似乎不对.我希望我的问题很明显,这很难解释.有人能指出我正确的方向吗？

我已经实现了正确的输出,但有些东西告诉我有更好的方法来解决这个问题.这是我的代码:

int k = 0;  
for (int i=1; i<=6; i++){
   System.out.print("         |");
}
System.out.println();
for (int m=0; m<6; m++){
   for (int j=1; j<10; j++){
      System.out.print(j);
   }
   System.out.print(k);
}

大!Modulo是我一直在寻找的答案.我对此感到更舒服:

for (int i=1;i<=6;i++){
   System.out.print("         |");
}
System.out.println();
for (int m=0;m<6;m++){
   for (int j=1;j<=10;j++){
      System.out.print(j % 10);
   }
}

我有一个像这样的嵌套循环:

while(1){

    while($something){
        break & continue;
    }
    // More stuff that I don't want to process in this situation
}

我想突破第二个while循环并从头开始继续第一个循环(没有完成第一个循环).这可能不使用变量吗？

我是lambda表达式的新手,我正在尝试使用它们将以下代码减少为lambda等价物.我已经研究过reduce和flatMap以及forEach,以及其他一些东西,但我显然遗漏了一些东西,因为我尝试的一切都是语法不正确或者我没有参考我需要的东西.

我需要对集​​合中的所有其他元素执行每个元素的分析.我将其编码为带有条件的嵌套循环.一旦识别出非匹配元素,就使用两个元素进行计算.最后,我想要每个比较计算的结果集合.

所以,这是原始代码:

final List<Element> updated = new ArrayList<>(elements.size());

for (final Element first : elements) {
    Attribute newAttribute = first.getAttribute();

    for (final Element second : elements) {
        if (!first.equals(second)) {
            newAttribute = newAttribute.add(computeChange(first, second));
        }
    }
    final Element newElement = new Element(first.getEntry(), newAttribute, first.getValue());
    updated.add(newElement);
}

然后,我尝试了lambda表达式的许多变体,其中最简单的是:

elements.parallelStream()
         .map(first -> new Element(first.getEntry(), first.getAttribute().add(
         computeChange(first, second)), first
         .getValue())).collect(Collectors.toList()));

显然,这是错误的,因为没有第二个可用的参考,没有条件/过滤器第二个不等于第一个.

如何通过条件将集合返回到lambda表达式来减少此嵌套循环？

非常感谢任何帮助.

对于二变量问题，outer最有可能是最好的解决方案，如果循环空间足够小，那么我们可以expand.grid做我们的跑腿工作。然而，如果我们有两个以上的变量和一个大的空间来循环，这些就被排除了。outer不能处理两个以上的变量，并且expand.grid占用的内存比我见过的机器能够占用的内存多。

我最近发现自己在写这样的代码：

n<-1000
for(c in 1:n){
    for(b in 1:c){
        for(a in 1:b){
            if(foo(a,b,c))
            {
                bar(a,b,c)
            }
        }
    }
}

在这些情况下，嵌套循环似乎是自然的解决方案（例如，mapply不会这样做并且没有好的因素tapply可供使用），但是有更好的方法吗？这似乎是通往错误代码的道路。

我怀疑这combn可能会以某种方式做到这一点，但根据我的经验，它很快就会陷入与expand.grid. 如果没记错的话，我也知道它采取了不明智的步骤，告诉我更改递归限制的全局设置。

我有一个国家和年份级别的面板数据集，我想根据现有变量创建两个新变量。

我想做的是创建两个新的变量集：（1）每年（跨国家）平均值的变量集和（2）相对于年平均值的国家/地区值的变量集。例如，对于 var1(1) 将产生mean_var1和(2)relmean_var1，我希望这些用于所有其他变量。数据集中总共有超过 1000 个变量，但我只会将此函数应用于大约 6 个变量。

我有适用于第一部分的代码，但我想将其尽可能有效地与第二部分结合起来。

library(dplyr)
library(purrr)
df<- df%>% 
            group_by(year) %>%
            mutate_at(.funs = list(mean = ~mean(.)), .vars = c("var1", "var1", "var1", "var4"))

此代码生成名为 var1_mean 的新变量（我更喜欢mean_var1：如何更改此名称？）

对于第二步，我尝试过：

df <- df %>%
map2_dfr(.x = d.test %>%
            select(var1, var2), …

在OpenMP中并行化多维尴尬并行循环的正确方法是什么？维度的数量在编译时是已知的,但是哪个维度是大的.他们中的任何一个可能是一,二或一百万.当然我不希望N omp parallel是一个N维循环......

思考:

• 问题在概念上很简单.只有最外层的"大"循环需要并行化,但循环维度在编译时是未知的并且可能会发生变化.

• 将动态设置omp_set_num_threads(1)和#pragma omp for schedule(static, huge_number)使某些环路并行化无操作？这会产生不良的副作用/开销吗？感觉像一个kludge.

• 在OpenMP规范(2.10,A.38,A.39)讲述整合及不符合要求的嵌套并行之间的差异,但没有提出解决这个问题的最好的办法.

• 可以重新排序循环,但可能会导致大量缓存未命中.展开是可能的,但不是重要的.还有另外一种方法吗？

这是我要并行化的内容:

for(i0=0; i0<n[0]; i0++) {
  for(i1=0; i1<n[1]; i1++) {
    ...
       for(iN=0; iN<n[N]; iN++) {
         <embarrasingly parallel operations>
       }
    ...
  }
}

谢谢!

我正在使用R中的一个大整数向量(大约1000万个整数),我需要从这个向量中找到每个不同的整数对,它们相差500或更少,并得出它们之间差异的直方图(即对于每对,第二个减去第一个).

这是完全未实现的代码,可以非常缓慢地执行我想要的操作:

# Generate some random example data
V <- round(rnorm(100) * 1000)

# Prepare the histogram
my.hist <- rep(0, 500)
names(my.hist) <- as.character(seq(1,500))
for (x1 in V) {
    for (x2 in V) {
        difference = x2 - x1
        if (difference > 0 && difference <= 500) {
            my.hist[difference] = my.hist[difference] + 1
        }
    }
}

(假设每个整数都是唯一的,因此该difference > 0位是正确的.这是允许的,因为我实际上并不关心差异为零的任何情况.)

这是一些矢量化内循环的代码:

my.hist2 <- rep(0, 500)
names(my.hist2) <- as.character(seq(1,500))
for (x1 in V) {
    differences <- V[V > x1 & …

到目前为止,如果我必须循环遍历多维数组,我会为每个维度使用foreach循环.

例如,对于两个维度

foreach($array as $key=>$value)
{
    foreach($value as $k2=>$v2)
    {
         echo
    }
}

当我不知道阵列的深度时我该怎么办？即深度是可变的.

我唯一能想到的是编写一堆循环并在下一个值不是数组的情况下打破循环.这看起来有点傻.

有没有更好的办法？

另一个大O符号问题...对于代码的大O是什么:

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

我的想法:所以打破它,我认为外部循环是O(log2(n)),然后每个内部循环O(n)将导致O(n^2 * log2(n)) 问题#1是正确的？

问题2:当组合嵌套循环时,它总是像每个循环的大O一样简单吗？

我试图以一种非常无效的方式打破嵌套循环:

BreakingPoint = false
a=["R1","R2","R3"]
b=["R2","R3","R4"]
for i in a
  for j in b
    if i == j
      BreakingPoint = true
      println("i = $i, j = $j.")
    end
    if BreakingPoint == true; break; end
  end
  if BreakingPoint == true; break; end
end

有更简单的方法吗？在我的实际问题,我没有什么是数组的想法a和b,除了他们是ASCIIString秒.数组名称(a以及b示例代码)也是通过元编程方法自动生成的.