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
Je ne sais pas comment utiliser les structures de contrôle, ainsi cette étape p> 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) `
14 Réponses :
Compte tenu du maximum Regardons l'ensemble de 1 à 20. Tout d'abord, il contient un nombre de nombres premiers, nommément: p> 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> N code>, vous souhaitez renvoyer le plus petit numéro qui est divisé par 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;
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.
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 p >
a '= A * X_I / (GCD (A, X_I)) P>
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. p>
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 Les nombres premiers apparaissant sont Voici une implémentation relativement simple. P> 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> 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> Enter an integer: 20
Answer: 232792560
Je savais que cela avait quelque chose à voir avec les nombres premiers, mais j'ai complètement manqué le bateau. :(
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 Remarque: méfiez-vous des débordements. P> code (en python): p>
indice: p>
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. P>
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 ...
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 vous souhaitez seulement remplacer la longue condition, vous pouvez l'exprimer plus bien en une boucle: < / p> devient: p> Le style n'est pas génial mais je pense que c'est ce que vous cherchiez. P > p> si code> condition dans votre code d'origine.
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 code> est de quitter la boucle sur Diviseur code> lorsque l'un des numéros en 2..20 ne divise pas num code>. Le si (diviseur! = 21) code> est de vérifier si la boucle a été sortie avec une telle pause code> ou normalement (car tous les numéros 2..20 divisé code>).
Je pense que vous voulez dire Int Diviseur; pour (diviseur = 2; diviseur <= 20; diviseur ++) code>; Si vous placez la déclaration de diviseur code> à l'intérieur de la relève pour code>, 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.
Cela peut vous aider http://www.matwarehouse.com/ Arithmétique / Numéros / Nombre Premier / Premier-Factorisation.php? Numéro = 232792560 P>
la factorisation principale de 232 792 560 p>
2 ^ 4 • 3 ^ 2 • 5 • 7 • 11 • 13 • 17 • 19 P>
Est-ce que je manque quelque chose? Ceci n'est utile que si vous connaissez déjà la réponse.
Le nombre en question est le multiple le moins courant des nombres 1 à 20. p>
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. P>
Les nombres premiers inférieurs ou égaux à 20 sont 2, 3, 5, 7, 11, 13 et 17. Le LCM est, P>
Parce que SQRT (20) <5, nous savons que Kapow (I, 20) pour I> = 5 est 1. En inspection, le LCM est P>
LCM = 2
Kapow (2,20) * 3 fort> Kapow (3,20) * 5 * 7 * 11 * 13 * 17 * 19 P> blockQuote> qui est p>
LCM = 2 4 * 3 fort> 2 * 5 * 7 * 11 * 13 * 17 * 19 P> blockQuote>
ou p>
LCM = 16 * 9 * 5 * 7 * 11 * 13 * 17 * 19 p> blockQuote>
triche rubis:
Ceci est écrit en C } p> p>
#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.
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 code>:
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;
}
code en JavaScript:
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 code> condition de la question dans unpour code> 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.