boucle while infinie

Version imprimable

1 pièce(s) jointe(s)

Bonjour,
j'ai un tableau pour le résultat:
divideBy = [ [], [], [0,0] ].

J'ai un autre tableau:
primes = [ 0, 0, 2, 3, 5, 7 ] // ne pas se préoccuper des 0, je ne m'en sert pas pour l'instant.
Puis je vais incrémenter sur une plage de chiffres de min à max en les factorisant sur les chiffre de "primes".

c'est à dire, en considérant min = 2 et max = 6, je vais tenter de de voir si 6 % 2 == 0, si oui, faire quelque chose. je voudrais que le code refasse ce même quelque chose tant que par exemple 6 % 2 == 0. En même temps un compteur compte le nombre de passage dans la boucle while. Enfin lorsque 6 % 2 == 1, il sortirait de la boucle en faisant un PUSH de la valeur du compteur dans le dernier tableau de divideBy.

Pour une liste de 2 à 6 voila ce que ça donnerait au final:
Pièce jointe 608057

voici mon code qui ne fonctionne pas, ou est le problème ?
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 let primes = [ 0, 0, 2, 3, 5, 7 ]; let dividedBy = [[],[]] let compte = 0; for (let n = min; n <= max; n++) { dividedBy.push([0,0]); // pour chaque n j'ajoute un nouveau sous tableau for (let k = 2; k <= primes.length; k++) { while (n % primes[k] == 0) { let n2 = n / primes[k]; compte += 1 n = n2; k--; } dividedBy[dividedBy.length-1].push(compte) compte = 0 } }

Bonjour,

min et max ne sont pas définis
c'est for(... k < primes.length (pas <=)
supprime k--;.

tu modifies n ici :

Code:

1
2
3
4
      while (n % primes[k] == 0) {
        let n2 = n / primes[k];
        compte += 1
        n = n2;

alors que n est défini dans for (let n = min; n <= max; n++).
:nono:Pas glop.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
"use strict";
 
function get_dividedBy( min=2, max=2 )
{
  let primes = [ 0, 0, 2, 3, 5, 7 ];
  let dividedBy = [];
  let compte = 0;
 
  for( let n=min; n<=max; n++ ) 
  {
    dividedBy.push([0,0]);   // pour chaque n j'ajoute un nouveau sous tableau
    for( let k=2; k<primes.length; k++ ) 
    {  
      let n2 = n;
      while( n2 % primes[k] == 0 ) 
      {
        n2 = Number( n2 / primes[k] );
        compte++;
      }
      dividedBy[dividedBy.length-1].push(compte);
      compte = 0;
    }
  }
  return dividedBy;
}
/* ------------ */
let dividedBy = get_dividedBy( 3, 17 );
console.log( JSON.stringify(dividedBy) );

Citation:

Envoyé par haddocks

J'ai un autre tableau:
primes = [ 0, 0, 2, 3, 5, 7 ] // ne pas se préoccuper des 0, je ne m'en sert pas pour l'instant.

Mauvaise idée, car le nom que tu donnes à ton tableau ne correspond pas à son contenu (à cause des 0 dont il ne faut pas se préoccuper justement). Tu aurais tout intérêt à avoir un tableau primes avec effectivement les nombres premiers:

Code:

const primes = [2, 3, 5, 7];

Puis, si par la suite tu as besoin d'un tableau commençant par 0, 0 suivi des nombres premiers, tu lui trouves un nom descriptif adéquate et tu peux le composer facilement comme ceci:

Code:

let nomdescriptif = [0, 0, ...primes];

L'avantage, en plus de la clarté, c'est que tu pourras remplacer ta boucle for (let k = 2; k <= primes.length; k++) avec un 2 parachuté tout droit de l'espace, par une boucle for...of: for (const prime of primes). Ainsi dans la suite du code, plus besoin d'écrire primes[k], plus besoin de k non plus, il suffit d'écrire prime.

Citation:

Enfin lorsque 6 % 2 == 1, il sortirait de la boucle en faisant un PUSH de la valeur du compteur dans le dernier tableau de divideBy.

Pour une liste de 2 à 6 voila ce que ça donnerait au final:
Pièce jointe 608057

Au vu du résultat attendu, je pense que les conditions pour sortir de la boucle (celle sur les nombres premiers) sont plutôt:
soit n2 === 1 (ce qui implique que n ne sera divisible par aucun des nombres premiers suivants celui qui vient d'être testé).
soit lorsque le nombre premier est supérieur à n (même combat).

Mais je reste persuadé qu'il y a une unique condition (qui regroupe les deux pré-citées) plus maline qu'il reste à trouver.

Citation:

Code:

dividedBy[dividedBy.length-1].push(compte)

Astuce: plutôt que de t'escrimer à calculer l'index du dernier élément de dividedBy pour pouvoir lui ajouter un nombre, crée un tableau temporaire dans ta boucle sur n, que tu ajoutes ensuite à dividedBy. C'est plus simple et plus lisible:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 for( let n=min; n<=max; n++ ) { let temp = [0, 0]; for(const prime of primes) { // ... temp.push(count); if ( n2 === 1 || n < prime ) break; } dividedBy.push(temp); }
(J'ai remplacé compte par count comme ça j'ai l'impression d'être super fort en anglais, tu vas voir, essaie, ça marche!)

Autre astuce: comme tu utilises un compteur compte et une boucle while, tu peux aussi opter pour une boucle for qui se chargera d'initialiser puis d'incrémenter le compteur, mais dont la condition d'arrêt sera celle de la boucle while (en effet aussi étrange que cela puisse paraître, rien n'oblige à ce que la condition d'une boucle for porte sur la variable qu'elle initialise).
Code:

1 2 3 4 5 6 7 let n2 = n, count; // important: la variable count doit être déclarer ici et pas dans la boucle for for (count=0; n2 % prime === 0; count++) { n2 /= prime; } temp.push(count); // pour qu'elle existe ici (et pas juste dans la boucle for)

05/11/2021, 16h24
jreaux62

Citation:

Envoyé par CosmoKnacki

(J'ai remplacé compte par count comme ça j'ai l'impression d'être super fort en anglais, tu vas voir, essaie, ça marche!)

Perso, par chauvinisme sans aucun doute, je préfère écrire tout en Français ;)

Cela dit... "MAKE FRANCE GREAT AGAIN" sonne mieux que "RENDRE LA FRANCE GRANDE ENCORE " :aie: (cf. traduction Gogole)
05/11/2021, 21h47
CosmoKnacki

Citation:

Envoyé par jreaux62

Perso, par chauvinisme sans aucun doute, je préfère écrire tout en Français ;)

Cela dit... "MAKE FRANCE GREAT AGAIN" sonne mieux que "RENDRE LA FRANCE GRANDE ENCORE " :aie: (cf. traduction Gogole)

Si ça ne tenait qu'à la défense de la langue française (ou par chauvinisme), je serais le premier à garder mes noms de variables et autres en français, mais si on doit reconnaître une qualité à l'anglais, c'est bien sa concision et son coté right to the point, ce qui est bien pratique dans un code dont les instructions sont de toute manière déjà en anglais.
Mais tant que Superdupont veillera sur notre pays, nous trouverons la force de contrer les projets démoniaques de l'Anti-France et de RENDRE À LA FRANCE SA GRANDEUR D'AUTREFOIS.
06/11/2021, 11h33
NoSmoking

Bonjour,

Citation:

Envoyé par CosmoKnacki

(en effet aussi étrange que cela puisse paraître, rien n'oblige à ce que la condition d'une boucle for porte sur la variable qu'elle initialise).

pas forcément étrange, les données d'initialisation étant optionnelle, elles le sont toutes d'ailleurs :

Citation:

Envoyé par ECMAScript

for ( Expression_opt ; Expression_opt ; Expression_opt ) Statement

et elles peuvent avoir été initialisées en amont ... mais cela reste effectivement une source de soucis.
06/11/2021, 18h21
CosmoKnacki

Citation:

Envoyé par NoSmoking

pas forcément étrange, les données d'initialisation étant optionnelle, elles le sont toutes d'ailleurs :

Oui, je disais "étrange" car généralement on apprend la boucle for avec comme exemple typique l'évolution de la valeur numérique d'une variable dont il est question dans les 3 paramètres (soit for(i=0; i<10; i++)); et on tombe un peu des nues lorsque qu'on se rend compte que les paramètres sont optionnels et assez libres.

Moi même, je suis passé du BASIC (Thomson) où si je ne m'abuse seules les variations numériques étaient possible: FOR I=0 TO 10 STEP 2:? I; " "; : NEXT I (le STEP facultatif permettant de changer le pas, le ? étant un raccourci pour PRINT), au langage C avec ces paramètres plus libres dont découle le Javascript et PHP. J'imagine donc que mon étonnement de l'époque ne devait pas être si différent.

Merci à tous pour votre aide, ça m'a vraiment été utile.
Désolé pour mon délais de réponse, j'ai fait un break.

Une dernière question pour la route, dans le poste de jreaux62:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
 
"use strict";
 
function get_dividedBy( min=2, max=2 )
{
  let primes = [ 0, 0, 2, 3, 5, 7 ];
  let dividedBy = [];
  let compte = 0;
 
  for( let n=min; n<=max; n++ ) 
  {
    dividedBy.push([0,0]);   // pour chaque n j'ajoute un nouveau sous tableau
    for( let k=2; k<primes.length; k++ ) 
    {  
      let n2 = n;
      while( n2 % primes[k] == 0 ) 
      {
        n2 = Number( n2 / primes[k] );
        compte++;
      }
      dividedBy[dividedBy.length-1].push(compte);
      compte = 0;
    }
  }
  return dividedBy;
}
/* ------------ */
let dividedBy = get_dividedBy( 3, 17 );
console.log( JSON.stringify(dividedBy) );

Je suppose que sur cette ligne:

Code:

n2 = Number( n2 / primes[k] )

"Number" sert à s'assurer qu'il s'agira bien d'un nombre, mais pourquoi cette précaution à ce moment précis ?

17/11/2021, 15h40
jreaux62

Bonjour,

Citation:

Envoyé par haddocks

"Number" sert à s'assurer qu'il s'agira bien d'un nombre, mais pourquoi cette précaution à ce moment précis ?

C'est justement parce que les calculs ne sont pas "précis" en JS (qui n'en est pas à un Number.EPSILON près) !

6/2 peut donner 3.0000000000000004 comme 2.99999999999999991
Et comme on a des comparaisons de nombres à faire, ça peut poser problème.

Number() n'est pas adapté ici (erreur de ma part, cf message suivant)
Voir math.Round().

:nono: ce n'est pas le rôle de l'objet Number :
Code:

1 2 3 4 console.log( .1 + .2); // > 0.30000000000000004 console.log(Number( .1 + .2)); // > 0.30000000000000004

17/11/2021, 16h36
jreaux62
Décidément... :calim2: (j'ai modifié mon précédent message)
- math.Round() alors ?
- Quid de parseInt() ?
(ça reste quand même bien pourri cet epsilon qui vient fausser les comparaisons...)