C++ 如何仅在父循环的所有迭代都为true时执行嵌套if语句？

我正在尝试欧拉计划。我需要找到能被前20个自然数整除的最小整数

我的想法是将

最小的

变量初始化为2520（如问题中所给出的），并从11开始循环，然后将

最小的

除以11到20的数字。如果它可被i的所有值整除，则系统应打印

最小值

。否则，它应将

最小值

增加1。下面是到目前为止我的代码

#include <iostream>
using namespace std;

int main(int argc, const char * argv[]) {
    int smallest = 2520;
    for(int i = 11; i<=20; i++){
        if(smallest%i==0){
            cout<<smallest;  //I want this statement to be executed only when the if statement is true for all values of i.
            break;
        } else {
                smallest++; //In case the if statement is false for any value of i, then do this.
            }
    }
    return 0;
}

#包括
使用名称空间std；
int main（int argc，const char*argv[]{
int=2520；
对于（inti=11；i我想你想做这样的事情

#include <iostream>
using namespace std;
int main(int argc, const char * argv[]) {
    int smallest = 2520;
    while(true){
        int i;
        for(i = 11 ; i<=20 ; i++)
            if(smallest%i != 0) break;
        if(i == 21){
            cout<<smallest;
            break;
        }
        smallest ++ ;
    }
    return 0;
}

#包括
使用名称空间std；
int main（int argc，const char*argv[]{
int=2520；
while（true）{
int i；
对于（i=11；i我想你想做这样的事情

#include <iostream>
using namespace std;
int main(int argc, const char * argv[]) {
    int smallest = 2520;
    while(true){
        int i;
        for(i = 11 ; i<=20 ; i++)
            if(smallest%i != 0) break;
        if(i == 21){
            cout<<smallest;
            break;
        }
        smallest ++ ;
    }
    return 0;
}

#包括
使用名称空间std；
int main（int argc，const char*argv[]{
int=2520；
while（true）{
int i；
对于（i=11；i，您可以使用下面给出的内容。
如果11到20之间的任何数字不除以最小值，则增加最小变量并将计数器设置回原来的值（我将其设置为10，因为for循环的终止条件会将其增加到11）。只有当所有以前的计数器将其除以时，计数器才会达到20。因此，如果20也将其除以，则打印它

#include <iostream>
using namespace std;

int main(int argc, const char * argv[]) {
    int smallest = 2520;
    for(int i = 11; i<=20; i++){
        if(i==20 && smallest%20==0){
            cout<<smallest;  //I want this statement to be executed only when the if statement is true for all values of i.
            break;
        } else if(smallest%20==0){
            continue; 
        } else {
                i=10;
                smallest++; //In case the if statement is false for any value of i, then do this.
            }
    }
    return 0;
}

#包括
使用名称空间std；
int main（int argc，const char*argv[]{
int=2520；
对于（inti=11；i，您可以使用下面给出的内容。
如果11到20之间的任何数字不除以最小值，则增加最小变量并将计数器设置回原来的值（我将其设置为10，因为for循环的终止条件会将其增加到11）。只有当所有以前的计数器将其除以时，计数器才会达到20。因此，如果20也将其除以，则打印它

#include <iostream>
using namespace std;

int main(int argc, const char * argv[]) {
    int smallest = 2520;
    for(int i = 11; i<=20; i++){
        if(i==20 && smallest%20==0){
            cout<<smallest;  //I want this statement to be executed only when the if statement is true for all values of i.
            break;
        } else if(smallest%20==0){
            continue; 
        } else {
                i=10;
                smallest++; //In case the if statement is false for any value of i, then do this.
            }
    }
    return 0;
}

#包括
使用名称空间std；
int main（int argc，const char*argv[]{
int=2520；
对于（int i=11；i#1，我必须指出这一点。我个人强烈建议不要使用
使用名称空间std
，因为它违背了拥有名称空间的目的（当然，在这种情况下有点过分）

#2对于良好的实践，您应该测试1到20之间的所有整数，因为被整数11到20整除并不一定意味着它们可以被1到10整除（但在本例中它们是）

#3您可以为除
最小值
的数字添加某种计数器，例如
numDivisible
，当计数器达到20时，您将中断循环。否则，您将其重置为0并递增
最小值

另一种方法：在条件的
if
分支中，可以添加：

if(i==20) {
    //Whatever else you need to do
    break;
}

#1我必须指出这一点。我个人强烈建议不要使用
使用名称空间std
，因为它违背了拥有名称空间的目的（当然，在这种情况下有点过分）

#2对于良好的实践，您应该测试1到20之间的所有整数，因为被整数11到20整除并不一定意味着它们可以被1到10整除（但在本例中它们是）

#3您可以为除
最小值
的数字添加某种计数器，例如
numDivisible
，当计数器达到20时，您将中断循环。否则，您将其重置为0并递增
最小值

另一种方法：在条件的
if
分支中，可以添加：

if(i==20) {
    //Whatever else you need to do
    break;
}

既然您已经获得了代码方面的帮助，我将尝试探究您的算法

试着回想一下你的数学课，记住素数分解（10=2*5，12=2*2*3，等等）。然后回想一下，一个数字可以被一个数字整除，当且仅当它可以被它分解成的所有素数整除时（在它们的最高幂次下——如果它可以被2^2和3整除，那么一个数字可以被12整除）

在这种情况下，这意味着什么？与其循环使用232000000个数字，不如尝试将素数分解为1-20，并记录每个素数的最大幂。然后将所有这些数字相乘，得到你的答案

示例1-10分解如下：

1   1
2   2
3   3
4   2^2
5   5
6   2*3
7   7
8   2^3
9   3^2
10  2*5

如你所见，这里的最高权力是：

2^3
3^2
5
7

如果我们乘以这些，那么：
2^3*3^2*5*7=2520
，这就是你在问题中得到的示例答案

对接下来的10个数字进行分解，我们得出：
2^4*3^2*5*7*11*13*17*19=232792560

再看下一个10，我们会发现：
2^4*3^3*5^2*7*11*13*17*19*23*29=2329089562800
——循环这么高可能需要一段时间

无论如何，这与您的代码没有多大关系，但弄清楚如何编写此素分解解决方案可能是一个很好的挑战，我认为，如果您正在处理Project Euler问题，您可能希望看到另一种方法。：）
既然您已经获得了代码方面的帮助，我将尝试探讨一下您的算法

试着回想一下你的数学课，记住素数分解（10=2*5，12=2*2*3，等等）。然后回想一下，一个数字可以被一个数字整除，当且仅当它可以被它分解成的所有素数整除时（在它们的最高幂次下——如果它可以被2^2和3整除，那么一个数字可以被12整除）

在这种情况下，这意味着什么？与其循环使用232000000个数字，不如尝试将素数分解为1-20，并记录每个素数的最大幂。然后将所有这些数字相乘，得到你的答案

示例1-10分解如下：

1   1
2   2
3   3
4   2^2
5   5
6   2*3
7   7
8   2^3
9   3^2
10  2*5

如你所见，这里的最高权力是：

2^3
3^2
5
7

如果我们乘以这些，那么：
2^3*3^2*5*7=2520
，这就是你在问题中得到的示例答案

对接下来的10个数字进行分解，我们得出：
2^4*3^2*5*7*11*13*17*19=232792560