débutant boucles imbriquées

"Nico" <lepro.nico@caramail.com> a écrit dans le message de
news:bqvtii$4g7$1@news-reader4.wanadoo.fr...

Je cherche à faire un compte à rebours qui foctionne chiffre par chiffre
en

précisant le nombre de chiffres que l'on veut ex :

avec 2chiffre :
9 9 | 9 8 | 9 7 | 9 6 | 9 5........................8 9 | 8 8 | 8 7
.............0 0

avec 3 chiffres
9 9 9 | 9 9 8 | 9 9 7 | ..............................9 8 9 | 9 8
8..............
bref vous aurez compris

je veux absolument faire ça chiffre par chiffre

l'utilisateur choisi donc le nombre de chiffres qu'il veut


J'ai commencé un truc et il me faudrait autant de boucles imbriqués que
possible
en fait il me faut autant de boucles imbriqués que de chiffres mais je
n'arrive à faire que des suites de boucles et non pas des boucles
imbriquées

Si quelqu'un comprends qqchose à ce uqe je viens d'écrire et à une idée,
je

suis preneur
Merci d'avance

Nico

je ne suis pas sûr de comprendre ce que tu veux...
Pourquoi chiffre par chiffre ?
Il serait + simple de le faire avec des nombres, quitte à convertir ton
nombre en suite de chiffres à chaque iteration...

int Nombre=1;
std::cout<<"nCombien de chiffres ?";
unsigned NbChif;
std::cin>>NbChif;
//--- boucle pour calculer le nombre de départ
for(int i=0;i<NbChif;i++)
Nombre *= 10;

//--- boucle pour le décompte...
for(int Nb = Nombre; Nb>=0; --Nb)
{
//--- affichage du nombre
std::cout<<"n"<<Nb;
//--- autre chose, conversion en chaine, etc...
}

et voila.
A++

Nico wrote:

Je cherche à faire un compte à rebours qui foctionne chiffre par chiffre en
précisant le nombre de chiffres que l'on veut ex :

avec 2chiffre :
9 9 | 9 8 | 9 7 | 9 6 | 9 5........................8 9 | 8 8 | 8 7
.............0 0

avec 3 chiffres
9 9 9 | 9 9 8 | 9 9 7 | ..............................9 8 9 | 9 8
8..............
bref vous aurez compris

Pourquoi ne pas compter, tout simplement ?
int nb_chiffres = ... ;
int compteur = pow(10, nb_chiffres) - 1; // 999 si (nb_chiffres == 3)
while( compteur != 0 ) {
...
compteur--;
}

Sinon, si tu tiens vraiment à t'embêter, tu peux faire un tableau
(std::vector) et décrémenter chacune des valeurs quand la précédente
arrive à 0... Mais c'est un "gros" travail pour pas grand chose...

Tu peux aussi le faire récursivement, ca ferait un bel exercice ça...

void compte_a_rebour( const std::string& prefixe, int compteurs ) {
//Prefixe est une chaine de caractère contenant les elements précédents
//Compteurs est le nombre de compteurs qu'il reste a afficher après
//celui ci

if( compteurs != 0 ) { //Condition de fin de recursion
for( int i = 9; i >= 0; i-- ) {
char my_char = (char) (i + '0'); //Pas trop joli, mais bon...
compte_a_rebour( prefixe + my_char, compteurs-1 );
}
} else {
std::cout << prefixe << std::endl;
}

}

compte_a_rebour( "", 3 );

Mais la première solution est la meilleure



--------------------------------------------
Benoît Rousseau : roussebe at spray dot se
Jouez en programmant : http://realtimebattle.sourceforge.net/

"Nico" <lepro.nico@caramail.com> a écrit dans le message de
news:bqvtii$4g7$1@news-reader4.wanadoo.fr...

J'ai commencé un truc et il me faudrait autant de boucles imbriqués que
possible
en fait il me faut autant de boucles imbriqués que de chiffres mais je
n'arrive à faire que des suites de boucles et non pas des boucles
imbriquées

Si c'est pour un cours et si c'est une contrainte du prof, changer de prof.
Si c'est l'algorithme que tu comptes utiliser, évite les imbrications de
boucles quand elles ne sont pas nécessaires. En général, on de devrait pas
avoir besoin de plus de 3 niveaux d'imbrications dans la majorité des cas
( il existe évidemment des exceptions pour certains algorithmes ) ; cela
devient très confus à lire et à maintenir, et c'est pénalisant au niveau
perf.

pour le prefixe:

cout << setw(n) << setfill << i;

thomas

"Benoit Rousseau" <not.provided@no.spam> schrieb im Newsbeitrag
news:3fd37eab$0$3241$ba620e4c@reader0.news.skynet.be...

Nico wrote:

Je cherche à faire un compte à rebours qui foctionne chiffre par chiffre
en

précisant le nombre de chiffres que l'on veut ex :

avec 2chiffre :
9 9 | 9 8 | 9 7 | 9 6 | 9 5........................8 9 | 8 8 | 8 7
.............0 0

avec 3 chiffres
9 9 9 | 9 9 8 | 9 9 7 | ..............................9 8 9 | 9 8
8..............
bref vous aurez compris

Pourquoi ne pas compter, tout simplement ?
int nb_chiffres = ... ;
int compteur = pow(10, nb_chiffres) - 1; // 999 si (nb_chiffres == 3)
while( compteur != 0 ) {
...
compteur--;
}

Sinon, si tu tiens vraiment à t'embêter, tu peux faire un tableau
(std::vector) et décrémenter chacune des valeurs quand la précédente
arrive à 0... Mais c'est un "gros" travail pour pas grand chose...

Tu peux aussi le faire récursivement, ca ferait un bel exercice ça...

void compte_a_rebour( const std::string& prefixe, int compteurs ) {
//Prefixe est une chaine de caractère contenant les elements précédents
//Compteurs est le nombre de compteurs qu'il reste a afficher après
//celui ci

if( compteurs != 0 ) { //Condition de fin de recursion
for( int i = 9; i >= 0; i-- ) {
char my_char = (char) (i + '0'); //Pas trop joli, mais bon...
compte_a_rebour( prefixe + my_char, compteurs-1 );
}
} else {
std::cout << prefixe << std::endl;
}

}

compte_a_rebour( "", 3 );

Mais la première solution est la meilleure



--------------------------------------------
Benoît Rousseau : roussebe at spray dot se
Jouez en programmant : http://realtimebattle.sourceforge.net/

On Sun, 7 Dec 2003 20:04:00 +0100, "Nico" <lepro.nico@caramail.com>
wrote:

je veux absolument faire ça chiffre par chiffre

J'avais posté un code qui fait ce genre de trucs sur fca. Il
s'agissait de <news:gfaflvo802k27oci5dss41lcqolobrrt83@4ax.com>.

--
;-)

In article <bqvtii$4g7$1@news-reader4.wanadoo.fr>,
Nico <lepro.nico@caramail.com> wrote:

Je cherche à faire un compte à rebours qui foctionne chiffre par chiffre en
précisant le nombre de chiffres que l'on veut ex :

avec 2chiffre :
9 9 | 9 8 | 9 7 | 9 6 | 9 5........................8 9 | 8 8 | 8 7
.............0 0

avec 3 chiffres
9 9 9 | 9 9 8 | 9 9 7 | ..............................9 8 9 | 9 8
8..............
bref vous aurez compris

je veux absolument faire ça chiffre par chiffre

l'utilisateur choisi donc le nombre de chiffres qu'il veut


J'ai commencé un truc et il me faudrait autant de boucles imbriqués que
possible
en fait il me faut autant de boucles imbriqués que de chiffres mais je
n'arrive à faire que des suites de boucles et non pas des boucles imbriquées

Pour imbriquer des boucles, il suffit de les imbriquer...

for (int j = 9; j >= 0; j--)
for (int i = 9; i >= 0; i--)
std::cout << j << " " << i << "|";

Si on veut faire varier le nombre de boucles aussi, ca va etre un peu plus
chaud. Je ne vois guere que construire le bout de compte a rebours qui
ne change pas, et faire une fonction recursive pour avoir la boucle du
bout qui change.

Comme ca ressemble quand meme assez furieusement a un exercice donne en
cours, je m'en voudrais de donner toute la solution telle quelle.

"Nico" <lepro.nico@caramail.com> writes:

J'ai commencé un truc et il me faudrait autant de boucles imbriqués
que possible en fait il me faut autant de boucles imbriqués que de
chiffres mais je n'arrive à faire que des suites de boucles et non
pas des boucles imbriquées

La recursivite devrait te permettre de t'en sortir.

A+

--
Jean-Marc
FAQ de fclc++: http://www.cmla.ens-cachan.fr/~dosreis/C++/FAQ
C++ FAQ Lite en VF: http://www.ifrance.com/jlecomte/c++/c++-faq-lite/index.html
Site de usenet-fr: http://www.usenet-fr.news.eu.org

"Alexandre" <alex.g@netcourrier.com> wrote in message
news:<3fd37b50$0$17125$626a54ce@news.free.fr>...

"Nico" <lepro.nico@caramail.com> a écrit dans le message de
news:bqvtii$4g7$1@news-reader4.wanadoo.fr...

Je cherche à faire un compte à rebours qui foctionne chiffre par
chiffre en précisant le nombre de chiffres que l'on veut ex :

avec 2chiffre :
9 9 | 9 8 | 9 7 | 9 6 | 9 5........................8 9 | 8 8 | 8 7
.............0 0

avec 3 chiffres
9 9 9 | 9 9 8 | 9 9 7 | ..............................9 8 9 | 9 8
8..............
bref vous aurez compris

je veux absolument faire ça chiffre par chiffre

[...]

je ne suis pas sûr de comprendre ce que tu veux...
Pourquoi chiffre par chiffre ?

Sans doute parce que c'est ce que son prof a démandé.

Il serait + simple de le faire avec des nombres, quitte à convertir
ton nombre en suite de chiffres à chaque iteration...

C'est aussi très simple de le faire directement en code caractère. Le
mot clé de la solution, c'est récursion. Et c'est sans doute la
motivation derrière le devoir.

--
James Kanze GABI Software mailto:kanze@gabi-soft.fr
Conseils en informatique orientée objet/ http://www.gabi-soft.fr
Beratung in objektorientierter Datenverarbeitung
11 rue de Rambouillet, 78460 Chevreuse, France, +33 (0)1 30 23 45 16

Benoit Rousseau <not.provided@no.spam> wrote in message
news:<3fd37eab$0$3241$ba620e4c@reader0.news.skynet.be>...

Nico wrote:

Je cherche à faire un compte à rebours qui foctionne chiffre par
chiffre en précisant le nombre de chiffres que l'on veut ex :

[...]

Pourquoi ne pas compter, tout simplement ?

Parce que ce n'est pas ce que le prof a démandé.

int nb_chiffres = ... ;
int compteur = pow(10, nb_chiffres) - 1; // 999 si (nb_chiffres == 3)
while( compteur != 0 ) {
...
compteur--;
}

Sinon, si tu tiens vraiment à t'embêter, tu peux faire un tableau
(std::vector) et décrémenter chacune des valeurs quand la précédente
arrive à 0... Mais c'est un "gros" travail pour pas grand chose...

Tu peux aussi le faire récursivement, ca ferait un bel exercice ça...

Ce qui me semble être le but du devoir, non ?

void compte_a_rebour( const std::string& prefixe, int compteurs ) {
//Prefixe est une chaine de caractère contenant les elements précédents
//Compteurs est le nombre de compteurs qu'il reste a afficher après
//celui ci

if( compteurs != 0 ) { //Condition de fin de recursion
for( int i = 9; i >= 0; i-- ) {
char my_char = (char) (i + '0'); //Pas trop joli, mais bon...
compte_a_rebour( prefixe + my_char, compteurs-1 );
}
} else {
std::cout << prefixe << std::endl;
}

}

compte_a_rebour( "", 3 );

Mais la première solution est la meilleure

Vue que c'est pour un devoir, j'aurais vu plutôt quelque chose du genre :

void
display( int, std::string const& value )
{
std::cout << value << 'n' ;
}

void
counter( int depth, std::string const& sofar = std::string() )
{
-- depth ;
for ( int i = 0 ; i < 10 ; ++ i ) {
(depth == 0 ? display : counter)( depth, sofar + i[ "9876543210" ] ) ;
}
}

Il faut bien montrer qu'on maîtrise les subtilités du langage, n'est-ce
pas ?

(En passant, ma version a un avantage sur la tienne : en mettant le
paramètre avec la chaîne en deuxième position, on peut lui donner une
valeur par défaut, et l'appel se fait tout naturellement avec un seul
paramètre.)

--
James Kanze GABI Software mailto:kanze@gabi-soft.fr
Conseils en informatique orientée objet/ http://www.gabi-soft.fr
Beratung in objektorientierter Datenverarbeitung
11 rue de Rambouillet, 78460 Chevreuse, France, +33 (0)1 30 23 45 16

espie@tetto.gentiane.org (Marc Espie) wrote in message
news:<br0ssb$2elc$1@biggoron.nerim.net>...

In article <bqvtii$4g7$1@news-reader4.wanadoo.fr>,
Nico <lepro.nico@caramail.com> wrote:

Je cherche à faire un compte à rebours qui foctionne chiffre par
chiffre en précisant le nombre de chiffres que l'on veut ex :

avec 2chiffre :
9 9 | 9 8 | 9 7 | 9 6 | 9 5........................8 9 | 8 8 | 8 7
.............0 0

avec 3 chiffres
9 9 9 | 9 9 8 | 9 9 7 | ..............................9 8 9 | 9 8
8..............
bref vous aurez compris

je veux absolument faire ça chiffre par chiffre

l'utilisateur choisi donc le nombre de chiffres qu'il veut

J'ai commencé un truc et il me faudrait autant de boucles imbriqués
que possible en fait il me faut autant de boucles imbriqués que de
chiffres mais je n'arrive à faire que des suites de boucles et non
pas des boucles imbriquées

Pour imbriquer des boucles, il suffit de les imbriquer...

for (int j = 9; j >= 0; j--)
for (int i = 9; i >= 0; i--)
std::cout << j << " " << i << "|";

Si on veut faire varier le nombre de boucles aussi, ca va etre un peu
plus chaud.

Mais non, mais non. Un certain Duff a trouvé la solution il y a
longtemps :

int
main( int argc, char** argv )
{
int width = 2 ;
if ( argc > 1 )
width = atoi( argv[ 1 ] ) ;
static char buffer[ 5 ] ;
switch ( width )
case 4 :
for ( buffer[ 0 ] = '9' ; buffer[ 0 ] >= '0' ; buffer[ 0 ] -- )
case 3 :
for ( buffer[ 1 ] = '9' ; buffer[ 1 ] >= '0' ; buffer[ 1 ] -- )
case 2 :
for ( buffer[ 2 ] = '9' ; buffer[ 2 ] >= '0' ; buffer[ 2 ] -- )
case 1 :
for ( buffer[ 3 ] = '9' ; buffer[ 3 ] >= '0' ; buffer[ 3 ] -- )
std::cout << buffer + 4 - width << 'n' ;
return 0 ;
}

Ce n'est pas parce que ça s'appelle C++ qu'on a perdu la souplesse de C.
(Et pour ceux qui ne s'y connaît pas Duff, le code ci-dessus est tout ce
qu'il y a de plus légal et de défini en C++.)

Comme ca ressemble quand meme assez furieusement a un exercice donne
en cours, je m'en voudrais de donner toute la solution telle quelle.

Soyons généreux. Je lui permets d'utiliser celui ci-dessus. Je lui en
autorise même de dire que c'est lui-même qui l'a fait. (En revanche, je
préfère qu'on n'y associe pas mon nom.)

--
James Kanze GABI Software mailto:kanze@gabi-soft.fr
Conseils en informatique orientée objet/ http://www.gabi-soft.fr
Beratung in objektorientierter Datenverarbeitung
11 rue de Rambouillet, 78460 Chevreuse, France, +33 (0)1 30 23 45 16