8
votes

Le plus petit nombre qui est uniformément divisible par tous les nombres de 1 à 20?

J'ai fait ce problème [ Project Euler Problème 5 ], mais très Mauvaise mode de programmation, voir le code en C ++,

abhilash@abhilash:~$ ./a.out 
 lowest divisible number upto 20 is  232792560
  • considérons num = 20 et divisez-le par des nombres de 1 à 20 li>
  • Vérifiez si tous les restes sont zéro, li>
  • Si oui, quittez et affichez la sortie num li>
  • ou bien num ++ li> ul>

    Je ne sais pas comment utiliser les structures de contrôle, ainsi cette étape p> xxx pré>

    comment coder cela de manière appropriée? p> Réponse de ce problème est la suivante: P>

    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) `
    


6 commentaires

Je suppose que la recherche sur Internet des tutoriels C ++ (y compris les structures de contrôle) serait une bonne idée.


Je sais sur les contrôles, mais je n'ai trouvé aucun moyen de résoudre ce problème ...... c'est pourquoi j'ai demandé ici.


J'ai eu beaucoup de notes maintenant, je voulais juste un remplaçant à ma boucle si .......


Tout le monde va dans des solutions à partir de la théorie des numéros, que quelqu'un pourrait-il au moins montrer comment réécrire la multiline si condition de la question dans un pour boucle?


Il est amusant que vous avez 3 réponses très différentes introduisant un mot-clé différent et tous basé sur le même concept!


Ceci est un problème de projet Euler.


14 Réponses :


-3
votes

Compte tenu du maximum N code>, vous souhaitez renvoyer le plus petit numéro qui est divisé par 1 à 20.

Regardons l'ensemble de 1 à 20. Tout d'abord, il contient un nombre de nombres premiers, nommément: p> xxx pré>

Ainsi, car il doit être divisé par 19, vous ne pouvez vérifier que des multiples de 19, car 19 est un nombre premier. Après cela, vous vérifiez si cela peut être divisé par celui ci-dessous, etc. Si le nombre peut être divisé par tous les nombres premiers avec succès, il peut être divisé par les chiffres 1 à 20. P>

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;


3 commentaires

C'est une buggie (ne peut pas utiliser% sur des flotteurs) et ne renvoie pas le numéro 232792560. Le retour de votre méthode est 9699690 n'est pas divisé par 18.


"Parce qu'il doit être divisible d'ici 19, vous ne pouvez vérifier que des multiples de 19, car 19 est un nombre premier" -> Je ne sais pas ce que cela a à voir avec 19 étant une prime?


C'est faux, vous n'avez pas vérifié que le résultat était divisible de 16.



4
votes

voir http://fr.wikipedia.org/wiki/greatest_common_divisor Compte tenu de deux nombres A et B, vous pouvez calculer GCD (A, B) et le plus petit nombre divisible par les deux est un * B / GCD (A, B). La chose évidente alors de faire est de conserver une sorte de cycle de fonctionnement et d'ajouter les chiffres que vous vous souciez d'un par un: vous avez une réponse jusqu'à présent A et vous ajoutez dans le numéro suivant X_I à considérer en mettant

a '= A * X_I / (GCD (A, X_I))

Vous pouvez voir que cela fonctionne réellement en considérant ce que vous obtenez si vous mettez en compte tout et écrivez comme des produits de nombres premiers. Cela devrait à peu près vous permettre de déterminer la réponse à la main.


0 commentaires

15
votes

facteur tous les entiers de 1 à 20 dans leurs factorisations primordiales. Par exemple, le facteur 18 comme 18 = 3 ^ 2 * 2. Maintenant, pour chaque numéro de choix P code> qui apparaît dans la factorisation principale de certains entier compris entre 1 et 20, trouvez l'exposant maximal qu'il contient a parmi toutes ces factorisations primordiales. Par exemple, le premier 3 code> aura l'exposant 2 code> car il apparaît dans la factorisation de 18 comme 3 ^ 2 et s'il est apparu dans une factorisation principale avec un exposant de 3 ( C'est-à-dire 3 ^ 3), ce nombre devrait être au moins aussi grand que 3 ^ 3 = 27 qu'il en dehors de la plage 1 à 20. Récupérez maintenant tous ces nombres premiers avec leur exposant correspondant et vous avez la réponse. Ainsi, à titre d'exemple, trouvons le plus petit nombre de manière uniformément divisible par tous les nombres de 1 à 4. p> xxx pré>

Les nombres premiers apparaissant sont 2 code > et 3 code>. Nous notons que l'exposant maximum de 2 code> est 2 code> et l'exposant maximal de 3 code> est 1 code>. Ainsi, le plus petit numéro qui est uniformément divisible par tous les nombres de 1 à 4 est 2 ^ 2 * 3 = 12. P>

Voici une implémentation relativement simple. P>

Enter an integer: 20
Answer: 232792560


1 commentaires

Je savais que cela avait quelque chose à voir avec les nombres premiers, mais j'ai complètement manqué le bateau. :(



19
votes

Le plus petit numéro divisible par deux numéros est le LCM de ces deux numéros. En fait, le plus petit nombre divisible par un ensemble de n chiffres x1..xn est le LCM de ces nombres. Il est facile de calculer le LCM de deux nombres (voir l'article Wikipedia) et vous pouvez étendre aux n chiffres en exploitant le fait que xxx

Remarque: méfiez-vous des débordements.

code (en python): xxx


0 commentaires

2
votes

indice:

Au lieu d'incrémenter num par 1 à chaque étape, vous pouvez l'incrémenter de 20 (fonctionnera beaucoup plus rapidement). Bien sûr, il peut également y avoir d'autres améliorations, y penserai plus tard si j'ai le temps. J'espère que je vous ai aidé un peu.


1 commentaires

Nice approche non-théorique. Une généralisation est d'abord calculer le GCD de 19 et 20 (par force brute, mais incrémentation de 20 comme vous le suggérez). Lorsque ce numéro est trouvé (appelez-le x), trouvez le GCD Y de ce numéro avec 18, incrémentation par X à chaque fois, car la solution est nécessairement un multiple de x. quand on trouve ...



10
votes

Il y a un moyen plus rapide de répondre au problème, en utilisant la théorie des numéros. D'autres réponses contiennent des indications comment faire cela. Cette réponse est uniquement à propos d'une meilleure façon d'écrire le si condition dans votre code d'origine.

Si vous souhaitez seulement remplacer la longue condition, vous pouvez l'exprimer plus bien en une boucle: < / p> xxx

devient: xxx

Le style n'est pas génial mais je pense que c'est ce que vous cherchiez.


4 commentaires

Oui, quand j'ai essayé cela plus tôt, chaque fois (num% diviseur == 0) J'ai oublié d'utiliser la pause, maintenant sa simple. Merci


Notez que je suis trompé la première fois. Le Break est de quitter la boucle sur Diviseur lorsque l'un des numéros en 2..20 ne divise pas num . Le si (diviseur! = 21) est de vérifier si la boucle a été sortie avec une telle pause ou normalement (car tous les numéros 2..20 divisé ).


Je pense que vous voulez dire Int Diviseur; pour (diviseur = 2; diviseur <= 20; diviseur ++) ; Si vous placez la déclaration de diviseur à l'intérieur de la relève pour , il ne sera pas dans la portée lorsque vous le testez lorsque la boucle se termine.


@James Darn, tu as raison. La seule fonctionnalité introduite dans C ++ que je trouve utile et je l'abuffe mal. C'est tout, je suis en train de rester en C à partir de maintenant.



0
votes

Cela peut vous aider http://www.matwarehouse.com/ Arithmétique / Numéros / Nombre Premier / Premier-Factorisation.php? Numéro = 232792560

la factorisation principale de 232 792 560

2 ^ 4 • 3 ^ 2 • 5 • 7 • 11 • 13 • 17 • 19


1 commentaires

Est-ce que je manque quelque chose? Ceci n'est utile que si vous connaissez déjà la réponse.



1
votes

Le nombre en question est le multiple le moins courant des nombres 1 à 20.

Parce que je suis paresseux, laissez ** représenter l'exponciation. Laissez Kapow (x, y) représenter la partie entière du journal à la base x de y. (Par exemple, Kapow (2,8) = 3, Kapow (2,9) = 3, Kapow (3,9) = 2.

Les nombres premiers inférieurs ou égaux à 20 sont 2, 3, 5, 7, 11, 13 et 17. Le LCM est,

Parce que SQRT (20) <5, nous savons que Kapow (I, 20) pour I> = 5 est 1. En inspection, le LCM est

LCM = 2 Kapow (2,20) * 3 Kapow (3,20) * 5 * 7 * 11 * 13 * 17 * 19

qui est

LCM = 2 4 * 3 2 * 5 * 7 * 11 * 13 * 17 * 19

ou

LCM = 16 * 9 * 5 * 7 * 11 * 13 * 17 * 19


0 commentaires

0
votes

triche rubis: xxx


0 commentaires

0
votes

Ceci est écrit en C xxx

}


0 commentaires

0
votes
#include<vector>
using std::vector;
unsigned int Pow(unsigned int base, unsigned int index);

unsigned int minDiv(unsigned int n)
{
     vector<unsigned int> index(n,0);
     for(unsigned int i = 2; i <= n; ++i)
     {
         unsigned int test = i;
         for(unsigned int j = 2; j <= i; ++j)
         {
             unsigned int tempNum = 0;
             while( test%j == 0)
             {
                 test /= j;
                 tempNum++;
             }
             if(index[j-1] < tempNum)
                 index[j-1] = tempNum;
         }
     }
     unsigned int res =1;
     for(unsigned int i = 2; i <= n; ++i)
     {
         res *= Pow( i, index[i-1]);
     }
     return res;
 }

unsigned int Pow(unsigned int base, unsigned int index)
{
    if(base == 0)
        return 0;
    if(index == 0)
        return 1;
    unsigned int res = 1;
    while(index)
    {
        res *= base;
        index--;
    }
    return res;
}
The vector is used for storing the factors of the smallest number.

0 commentaires

1
votes

Voici une version C # de la réponse @ Mak's, il peut y avoir une liste de la méthode de réduction de la liste en C #, j'ai trouvé quelque chose en ligne mais pas d'exemples rapides, je n'ai donc pas utilisé de boucle à la place du de Python : xxx


0 commentaires

0
votes

C'est pourquoi vous bénéficierez d'écrire une fonction comme celle-ci:

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; 
}


0 commentaires

1
votes

code en JavaScript: xxx


0 commentaires