Problème d'instruction break dans une boucle for

Version imprimable

Bonjour à tous et à toutes,

Dans le code suivant :

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
 
public static void syracuse(int debut, int fin){
        int value= 0;
        int counter = 0;
        if (debut != fin) {
            for (int n = debut; n <= fin; n++) {
                System.out.print(n + "");
                while(value!= 1) {
                    if(n%2 == 0) {
                        value= n/2;
                        System.out.print(" " + value);
                    } else {
                        value= n*3 + 1;
                        System.out.print(" " + value);
                    }
                    counter +=1;
                    if (value==1) {
                        System.out.println();
                        counter -=1;
                        System.out.println("Fly duration is : " + counter);
                        break;
                    }
                    n = value;
                }
            }
        }
    }

l'instruction break me permet de sortir du traitement while par contre l'itération dans le for ne se fait plus.

Merci d'avance.
Transact

J'ai modifié mon code de la façon suivante :
Code:

1 2 3 4 5 6 7 if (value ==1) { counter -=1; n = debut; System.out.println(" => Fly duration is : " + counter); break; }
en réinitialisant n, par contre l'itération ne se fait toujours pas.
En fait après la première itération, la valeur de value vaut 1 donc le traitement du while(value != 1) ne se fait jamais.

10/10/2015, 12h35
tchize_

Je ne comprends pas la logique de ton while.tu boucle pour n de début à fin. Mais dans ton while tu met n à 1 à chaque fois.
12/10/2015, 09h37
Alkhan

bonjour,

Comme tu l'as dis toi même et aussi tchize_, ta value vaut 1, donc après le 1er passage cela ne boucle plus !

C'était ce que tu cherchais ? as tu encore besoin d'aide ?

Je vais ressortir mon argument qui a tendance à créer un raz de marée de débats par forcément utile, mais en algorithmie, le break est une hérésie.
Si on a une condition/un cas de sortie, on l'attribue à une variable et à un test qui permet de sortir proprement de la boucle désirée.

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
30
 
public static void syracuse(int debut, int fin){
        int value= 0;
        int counter = 0;
 
        if (debut != fin) {
            for (int n = debut; n <= fin; n++) {
                boolean exitWhile = false;
                System.out.print(n + "");
                while(value!= 1 && !exitWhile) {
                    if(n%2 == 0) {
                        value= n/2;
                        System.out.print(" " + value);
                    } else {
                        value= n*3 + 1;
                        System.out.print(" " + value);
                    }
                    counter +=1;
                    if (value==1) {
                        System.out.println();
                        counter -=1;
                        System.out.println("Fly duration is : " + counter);
                        exitWhile = true;
                    } else {
                        n = value;
                    }
                }
            }
        }
    }

12/10/2015, 12h55
tchize_

Citation:

Envoyé par eulbobo

Je vais ressortir mon argument qui a tendance à créer un raz de marée de débats par forcément utile, mais en algorithmie, le break est une hérésie.

Tout à fait, c'est pour ça que j'utilise toujours un break <label>, moins de confusion :aie:. On ne va pas rentrer dans le débat, dans certains cas le break est plus lisible qu'un marqueur. Ca dépends de la complexité de la boucle. Et c'est le même débat qu'entre le return dans le code ou à la fin de fonction. Il y a les règles de bases et les exceptions dans des cas particuliers. C'est comme le copier coller de code: ça peut se faire, mais ça doit être vachement justifié :)

Au passage dans le code que tu donne, c'est un mauvais exemple, le exitWhile ne sert à rien. Il n'est à true que quand valeur==1, ce qui est déjà testé dans le while.

PS: je suis curieux de voir comment tu gère tes switch sans break :ptdr:
12/10/2015, 14h14
eulbobo

Citation:

Envoyé par tchize_

PS: je suis curieux de voir comment tu gère tes switch sans break :ptdr:

Je fais pas de switch :aie:
Et sinon, je mets des break dans mes switch mais on a pas trop le choix, c'est la forme du switch qui veut ça (même si des fois je n'en met pas... volontairement... puissant le switch !)

Citation:

Au passage dans le code que tu donne, c'est un mauvais exemple, le exitWhile ne sert à rien. Il n'est à true que quand valeur==1, ce qui est déjà testé dans le while.

Je n'ai fait que reprendre le code existant en reprenant exactement la logique et en ajoutant une condition de sortie, je sais pas ce que le code de base est censé faire, du coup j'ai posté son équivalent avec une condition de sortie... Ce qui permet de voir d'un coup qu'effectivement il y a un soucis.

Le break<label>, c'est violent, mais au moins, on est sûr de savoir où on retourne, donc je préfère à un break simple !
15/10/2015, 18h24
Rony Rauzduel

En effet, il est plus pertinent de créer un booléen qui permettra de sortir "proprement" de la boucle le cas échéant.
Cependant cela ne corrige pas mon problème , mais il s'agit davantage de l'écriture de la condition de continuité de la boucle while.
En fin de compte ce que je voudrais, c'est que la boucle while puisse continuer à effectuer le calcul de la conjecture pour les autres valeurs de l'intervalle.
Il faudrait qu'à la fin du premier élément de l'intervalle la valeur de value ne soit plus 1 mais soit réinitialisée.
16/10/2015, 10h50
thelvin

Le plus intelligent serait de faire une autre méthode, void syracuse(int n), et de l'appeler en boucle pour toutes les valeurs voulues. Plus d'imbrication, plus de confusion.
16/10/2015, 13h32
Rony Rauzduel

Cette méthode existe déjà mais dans cette deuxième partie de l'exercice , il faut créer un intervalle de valeurs ... l'objectif est de complexifier l'exercice.
16/10/2015, 13h51
Rony Rauzduel
Tout compte fait, je fais ré-utiliser ma méthode void syracuse(int n) en faisant une boucle for sur un intervalle mis en paramètre , voici ce que cela me donne :
Code:

1 2 3 4 5 6 public static void syracuse(int start, int end){ for (int i = start; i <end ; i++) { syracuse(i); } }
Plus court et plus concis.
Merci encore.
16/10/2015, 13h56
thelvin

Le problème étant bien sûr qu'on n'exploite pas les résultats déjà calculés d'un appel à l'autre.
Tu n'essayais déjà pas de le faire dans tes boucles imbriquées et je pensais donc que ça ne t'intéressait pas.

Mais si c'est un exercice, peut-être que la solution d'appeler la première méthode en boucle était évidente, et que donc il y avait encouragement à réfléchir pour ne pas calculer plusieurs fois la même chose. (Enfin, s'il faut vraiment indiquer toutes les étapes à chaque fois au lieu de juste le fly time, ce n'est pas vraiment possible de ne pas recalculer.)