能被1到20之间的所有数整除的最小数？ 我做了这个问题，但是编程的方式很糟糕，参见C++中的代码， #include<iostream> using namespace std; // to find lowest divisble number till 20 int main() { int num = 20, flag = 0; while(flag == 0) { if ((num%2) == 0 && (num%3) == 0 && (num%4) == 0 && (num%5) == 0 && (num%6) == 0 && (num%7) == 0 && (num%8) == 0 && (num%9) == 0 && (num%10) == 0 && (num%11) == 0 && (num%12) ==0 && (num%13) == 0 && (num%14) == 0 && (num%15) == 0 && (num%16) == 0 && (num%17) == 0 && (num%18)==0 && (num%19) == 0 && (num%20) == 0) { flag = 1; cout<< " lowest divisible number upto 20 is "<< num<<endl; } num++; } }

如何以适当的方式对此进行编码

这个问题的答案是：

abhilash@abhilash:~$ ./a.out 
 lowest divisible number upto 20 is  232792560

---

给定最大值

n

，您希望返回可除以1到20的最小数字

float primenumbers[] = { 19, 17, 13, 11, 7, 5, 3, 2; };

float num = 20;

while (1)
{
   bool dividable = true;
   for (int i = 0; i < 8; i++)
   {
      if (num % primenumbers[i] != 0)
      {
         dividable = false;
         break;
      }
   }

   if (dividable) { break; }
   num += 1;
}

std::cout << "The smallest number dividable by 1 through 20 is " << num << std::endl;

让我们看一组1到20。首先，它包含许多素数，即：

2
3
5
7 
11
13
17
19

---

所以，因为它必须除以19，你只能检查19的倍数，因为19是一个素数。然后，你检查它是否能被下面的那个除，等等。如果这个数能被所有的素数成功除，它就可以被1到20的数除

float primenumbers[] = { 19, 17, 13, 11, 7, 5, 3, 2; };

float num = 20;

while (1)
{
   bool dividable = true;
   for (int i = 0; i < 8; i++)
   {
      if (num % primenumbers[i] != 0)
      {
         dividable = false;
         break;
      }
   }

   if (dividable) { break; }
   num += 1;
}

std::cout << "The smallest number dividable by 1 through 20 is " << num << std::endl;

float primenumbers[]={19,17,13,11,7,5,3,2；}；
float num=20；
而(1)
{
布尔可分=真；
对于（int i=0；i<8；i++）
{
if（num%primenumbers[i]！=0）
{
可分割=假；
打破
}
}
如果（可分割）{break；}
num+=1；
}
标准：：cout见
给定两个数字a和b，你可以计算gcd（a，b），可被这两个数字整除的最小数字是a*b/gcd（a，b）。接下来要做的一件事就是保持一个总的运行量，并且把你关心的数字一一加进去：你有一个答案到目前为止A，你把下一个数字Xi i加进去，考虑放

A'=A*X_i/（gcd（A，X_i））

你可以看到，考虑到你得到的东西，如果你把所有的东西都分解，并把它们写成素数的乘积，这实际上是可行的。这几乎可以让你手工计算出答案
 将1到20之间的所有整数进行素因子分解。例如，系数18为18=3^2*2。现在，对于出现在1到20范围内某个整数的素数分解中的每个素数，求出它在所有素数分解中的最大指数。例如，素数
3
将具有指数
2
，因为它在18的因式分解中显示为3^2，如果它在任何素数因式分解中显示为指数为3（即，3^3），则该数字必须至少大至3^3=27，超出范围1到20。现在收集所有这些素数及其相应的指数，你就有了答案

例如，让我们找到一个最小的数，它可以被1到4的所有数整除

2 = 2^1
3 = 3^1
4 = 2^2

出现的素数是
2
和
3
。我们注意到
2
的最大指数是
2
，而
3
的最大指数是
1
。因此，可以被从1到4的所有数字平均整除的最小数字是2^2*3=12

这里是一个相对简单的实现

#include <iostream>
#include <vector>

std::vector<int> GetPrimes(int);
std::vector<int> Factor(int, const std::vector<int> &);

int main() {
    int n;
    std::cout << "Enter an integer: ";
    std::cin >> n;
    std::vector<int> primes = GetPrimes(n);
    std::vector<int> exponents(primes.size(), 0);

    for(int i = 2; i <= n; i++) {
        std::vector<int> factors = Factor(i, primes);
        for(int i = 0; i < exponents.size(); i++) {
            if(factors[i] > exponents[i]) exponents[i] = factors[i];
        }
    }

    int p = 1;
    for(int i = 0; i < primes.size(); i++) {
            for(int j = 0; j < exponents[i]; j++) {
            p *= primes[i];
        }
    }

    std::cout << "Answer: " << p << std::endl;
}

std::vector<int> GetPrimes(int max) {
    bool *isPrime = new bool[max + 1];
    for(int i = 0; i <= max; i++) {
        isPrime[i] = true;
    }
    isPrime[0] = isPrime[1] = false;
    int p = 2;
    while(p <= max) {
        if(isPrime[p]) {
            for(int j = 2; p * j <= max; j++) {
                isPrime[p * j] = false;
            }
        }
        p++;
    }

    std::vector<int> primes;

    for(int i = 0; i <= max; i++) {
        if(isPrime[i]) primes.push_back(i);
    }

    delete []isPrime;
    return primes;
}

std::vector<int> Factor(int n, const std::vector<int> &primes) {
    std::vector<int> exponents(primes.size(), 0);
    while(n > 1) {
        for(int i = 0; i < primes.size(); i++) {
        if(n % primes[i] == 0) { 
        exponents[i]++;
            n /= primes[i];
        break;
        }
            }
    }
    return exponents;
}

可被两个数整除的最小数是这两个数之和。实际上，被一组N个数x1..xN整除的最小数是这些数的LCM。计算两个数字的LCM很容易（请参阅wikipedia文章），您可以利用以下事实扩展到N个数字：

LCM(x0,x1,x2) = LCM(x0,LCM(x1,x2))

注意：小心溢出

代码（Python）：

提示：

您可以将num增加20，而不是在每一步增加1（这会更快）。当然，可能还有其他的改进，如果我有时间的话，我会考虑一下。希望我能帮你一点忙。
有一种更快的方法来回答这个问题，使用数论。其他答案包含如何做到这一点的指示。这个答案只是关于在原始代码中编写
if
条件的更好方法

如果您只想替换long条件，可以在for循环中更好地表达它：

 if ((num%2) == 0 && (num%3) == 0 && (num%4) == 0    && (num%5) == 0 && (num%6) == 0 
&& (num%7) == 0 && (num%8) == 0 && (num%9) == 0 && (num%10) == 0 && (num%11) == 0 && (num%12) ==0   
&& (num%13) == 0 && (num%14) == 0 && (num%15) == 0 && (num%16) == 0 && (num%17) == 0 && (num%18)==0
&& (num%19) == 0    && (num%20) == 0)     
{ ... }

变成：

{
  int divisor; 
  for (divisor=2; divisor<=20; divisor++)
    if (num%divisor != 0)
      break;
  if (divisor != 21)
  { ...}
}

{
整数除数；
对于（除数=2；除数这可以帮助您

232792560的素因子分解

2^4•3^2•5•7•11•13•17•19
所讨论的数字是数字1到20中最不常见的倍数

float primenumbers[] = { 19, 17, 13, 11, 7, 5, 3, 2; };

float num = 20;

while (1)
{
   bool dividable = true;
   for (int i = 0; i < 8; i++)
   {
      if (num % primenumbers[i] != 0)
      {
         dividable = false;
         break;
      }
   }

   if (dividable) { break; }
   num += 1;
}

std::cout << "The smallest number dividable by 1 through 20 is " << num << std::endl;

因为我很懒，所以让**表示指数运算。让kapow（x，y）表示日志的整数部分到y的基x（例如，kapow（2,8）=3，kapow（2,9）=3，kapow（3,9）=2）

小于或等于20的素数为2、3、5、7、11、13和17。LCM为

因为sqrt（20）<5，我们知道i>=5的kapow（i，20）为1。通过检查，LCM为

LCM=2kapow（2,20）*3kapow（3,20）
*5*7*11*13*17*19

那是

LCM=24*32*5*7*11*13*
17*19

或

LCM=16*9*5*7*11*13*17*
十九,

Ruby作弊：

require 'rational'

def lcmFinder(a = 1, b=2)
  if b <=20
    lcm = a.lcm b
    lcmFinder(lcm, b+1)
  end
  puts a
end


lcmFinder()

需要“rational”
def lcmFinder（a=1，b=2）
如果b这是用c写的

#include<stdio.h>
#include<conio.h>
void main()
{

int a,b,flag=0;

for(a=1; ; a++)
{
    for(b=1; b<=20; b++)
    {
        if (a%b==0)
            {
                flag++;
            }

    }
    if (flag==20)
        {
            printf("The least num divisible by 1 to 20 is = %d",a);
            break;
        }
        flag=0;
}


getch();

#包括
#包括
void main（）
{
int a，b，flag=0；
对于（a=1；a++）
{
对于（b=1；b
#包括
使用std：：vector；
无符号整数Pow（无符号整数基，无符号整数索引）；
无符号整数minDiv（无符号整数n）
{
向量指数（n，0）；
对于（unsigned int i=2；i这是@MAK答案的C#版本，C#中可能有列表缩减方法，我在网上找到了一些东西，但没有快速的示例，所以我只是使用for循环代替Python的
reduce
：

static void Main(string[] args)
    {
        const int min = 2;
        const int max = 20;
        var accum = min;

        for (var i = min; i <= max; i++)
        {
            accum = lcm(accum, i);
        }

        Console.WriteLine(accum);
        Console.ReadLine();
    }

    private static int gcd(int a, int b)
    {
        return b == 0 ? a : gcd(b, a % b);
    }

    private static int lcm(int a, int b)
    {
        return a/gcd(a, b)*b;
    }

static void Main（字符串[]args）
{
常数int min=2；
常数int max=20；
var accum=最小值；
对于（var i=min；i这就是为什么编写这样一个函数会让您受益的原因：

long long getSmallestDivNum(long long n)
{
    long long ans = 1;
    if( n == 0)
    {
        return 0;
    }
    for (long long i = 1; i <= n; i++) 
        ans = (ans * i)/(__gcd(ans, i)); 
    return ans; 
}

long-long getSmallestDivNum（long-long n）
{
长ans=1；
如果（n==0）
{
返回0；
}
对于（长i=1；iJavaScript代码：

var i=1，j=1；
对于（i=1；；i++）{
（j＝1；j i猜测在网上搜索C++教程（包括控制结构）是个好主意。我知道控制，但是没有找到解决的办法……这就是我问的原因。我现在得到了很多提示，我只想替换我的IF循环。每个人都在解决问题。
static void Main(string[] args)
    {
        const int min = 2;
        const int max = 20;
        var accum = min;

        for (var i = min; i <= max; i++)
        {
            accum = lcm(accum, i);
        }

        Console.WriteLine(accum);
        Console.ReadLine();
    }

    private static int gcd(int a, int b)
    {
        return b == 0 ? a : gcd(b, a % b);
    }

    private static int lcm(int a, int b)
    {
        return a/gcd(a, b)*b;
    }

long long getSmallestDivNum(long long n)
{
    long long ans = 1;
    if( n == 0)
    {
        return 0;
    }
    for (long long i = 1; i <= n; i++) 
        ans = (ans * i)/(__gcd(ans, i)); 
    return ans; 
}