Besoin d'aide pour une incrémentation spéciale

Version imprimable

10/07/2013, 13h52
Khalid89

Besoin d'aide pour une incrémentation spéciale

Bonjour à tous,

Voilà je suis en train de faire un projet en C et je suis bloqué sur un truc que je n'arrive pas à faire, s'il y a des gens qui peuvent m'aider ça serait super.
Voilà en fait je dois faire une boucle qui fait une incrémentation de la manière suivante :
00000
00001
00002
00003
00010
00011
00012
00013
00020
jusqu'a 33333, il faut que chaque chiffre soit stocké dans une case d'un tableau et il faut que la taille dans l'exemple (5) soit modifiable aussi.
Merci pour votre aide :ccool:
10/07/2013, 14h09
Franck.H

Peut-être faire une incrémentation standard (pas le choix de toute façon) et construire une chaîne avec le nombre de zéro qu'il faut puis le chiffre incrémenté. Je ne pense que pas que ces chiffres doivent être stockées dans un tableau de int par exemple car je ne vois pas comment d'ailleurs :aie:
10/07/2013, 14h13
alyma

Bonjour,

A priori, tu travailles en base 4.
Je te conseille tout d'abord te créer ta propre fonction d'incrémentation.
Petite aide:
tu ajoutes 1, si l'unité est supérieure à 3, tu mets 0 et ajoute 1 aux dixaines et tu poursuis par la gauche.
10/07/2013, 14h34
Khalid89

Merci pour vos réponses rapide,
Franck j'ai pas tout saisi, sinon je suis obliger de mettre chaque chiffres dans une case d'un tableau à 2 dimensions. pareille pour alyma. :cry:
Je doit implanter ce truc la dans le programme qui est déjà fait donc je suis un peut obliger de le faire comme ça

Un code dans le genre ?

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
31
32
33
34
35
36
37
38
39
40
41
42
43
44
#include <stdlib.h>
#include <stdio.h>
#include <stdint.h>
 
#define ARRAY_LENGTH        5
#define ARRAY_DATA_TYPE     unsigned char
#define INCREMENT_LIMIT     3
 
void print_array(ARRAY_DATA_TYPE *array, size_t len)
{
    for(size_t cell = 0; cell < len; cell++)
    {
        printf("%d ", array[cell]);
    }
    putchar('\n');
}
 
int main(void)
{
    ARRAY_DATA_TYPE array[ARRAY_LENGTH] = {0};
 
    // Initial state
    print_array(array, ARRAY_LENGTH);
 
    // Increment
    for(size_t cell = 1; cell < ARRAY_LENGTH; cell++)
    {
        while(array[cell] != INCREMENT_LIMIT)
        {
            for(unsigned int inc = 1; inc <= INCREMENT_LIMIT; inc++)
            {
                array[0] = inc;
                print_array(array, ARRAY_LENGTH);
            }
 
            array[0] = 0;
            array[cell] += 1;
            print_array(array, ARRAY_LENGTH);
        }
    }
 
    puts("DONE");
    return 0;
}

Ce n'est pas particulièrement clair sur la suite de ton incrémentation, est-ce que le résultat attendu est celui obtenu avec ce code ?

10/07/2013, 14h38
Khalid89

Bktero, je pense qu'il y'a un souci, quand tu incrémente il faut mettre toutes les valeurs précédentes à 0 et pas que la première.
10/07/2013, 14h41
mith06

C'est du C99 ;)
10/07/2013, 14h55
Bktero

Citation:

Envoyé par Khalid89

Bktero, je pense qu'il y'a un souci, quand tu incrémente il faut mettre toutes les valeurs précédentes à 0 et pas que la première.

Je ne dirais pas qu'il y a un soucis dans mon code, je dirais qu'il y a un soucis dans ton explication :mouarf: Montre nous plus clairement ce que tu veux faire, notamment au prochain changement de digit.

Citation:

Envoyé par mith06

C'est du C99 ;)

Khalid89 a édité son message où il demandait si mon code était du C++ et mith06 donne la bonne réponse : c'est du C, version C99 ! Si ça avait été du C++, on aurait notamment vu std::cout << "DONE" ;)
10/07/2013, 15h05
Khalid89

Merci BKtero,
J'ai bien expliquer avec un exemple mais il a été supprimé,
exemple:
pour une série de 3 chiffres je doit obtenir ça,
000,001,002,003,010,011,012,013,020,021,022,023,030,031,032,033,100,101,.....,333.
voila ^^j’espère que je suis plus clair
10/07/2013, 15h20
Bktero

J'ai retrouvé dans l'historique l'exemple que tu as supprimé :

Citation:

001
002
003
010
011
012
013
020
021
022
023
030
031
032
033
100
101
.....
333

C'est en effet bien plus clair comme ça :)

Je pense qu'avec ce qui t'a été donné, tu dois pouvoir commencer à construire toi même un algorithme pour solutionner ton problème.
10/07/2013, 15h29
Khalid89

Ça donnerai quoi ton code en C normale :lol:? car je ne comprend pas tout (je suis amateur)

J'ai réussis à le coder d'une manière simple, voila ce que ça donne :mrgreen: si vous aviez des propositions d'amélioration je suis preneur

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
31
32
33
34
35
36
37
38
39
40
#include<stdio.h>
#include<stdlib.h>
#include<math.h>
#include<string.h>
 
 
int main (){
    int v,i,j,k,l,m,n,pui;
    v=5;
    int tab[100]={0};
    i=0;
    k=0;
 
 
do{
    if(tab[k]==3 ){
        k++;
        if(tab[k]!=3){
        tab[k]++;
        for(i=0;i<k;i++){
            tab[i]=0;
        }
        k=0;
        }
    }
 
    if(tab[k]<3){
 
     //affichage:
        for(n=0;n<v;n++){
            printf("%d",tab[n]);
            }
            printf("\n");
 
            tab[k]++;
    }
}
      while (k<v);
    return 0;
}

Grâce à cette fonction, tu devrais t'en sortir:

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
31
32
33
34
35
36
37
38
39
40
41
42
43
44
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
#define TAILLE			5
#define VAL_ASCII_3		51
#define VAL_ASCII_0		'0'
 
//Incrémente de 1, renvoie 1 quand il ne peut plus incrémenter, 0 sinon
char increment_1(char* c)
{
	int i = 0;
	int n = (int) strlen(c);
	for(i=0;i<n;i++)
	{
		if(i==0){
			c[n-1-i] = c[n-1-i] + 1;
		}
		if(c[n-1-i]>51 && i!=(n-1))
		{
			c[n-1-i]	= VAL_ASCII_0;
			c[n-2-i] = c[n-2-i] + 1;
		}
		else if (c[n-1-i]>VAL_ASCII_3)
		{
			memset(c,VAL_ASCII_3,n);
			return 1;
		}
		else break;
	}
	return 0;
}
 
 
int main (void)
{
	char debut[5] = "0000";
 
	printf("%s\n",debut);
	while(!increment_1(debut)){
		printf("%s\n",debut);
	}
	system("pause"); 
}

10/07/2013, 16h07
Khalid89

Je te remercie alyma :ccool: je vais tester ça, et voir ce que ça donne