Bonjour,

Alors voila mon problème, l'utilisateur doit pouvoir entrer un  nombre entier non signé. Le programme doit le convertir en binaire sur  32 bits puis le découper en 4 parties (couleur, x, y, z) et les convertir en décimal. 

Exemple :

n= 2140000000

binaire = 01111111 10001101 11001111 00000000

résultat =

couleur : 127

x : 141

y : 207

z : 0

J'ai réussi à le faire mais maintenant je dois faire l'inverse (à partir de couleur, x, y, z on retrouve l'entier). Et là j'ai pas trop d'idées.

Pas le droit d'utiliser d'opérateur binaire/de tableau/de fonction/ou de librairie externe.

#include <stdio.h>
#include <math.h>

int main(int argc,char **argv)
{
    int rest;
    int bin;
    int i;
    int j;
    int deci;
    int count = 0;
    int z;
    int y;
    int x;
    int color;
    unsigned int nb;

    printf("NB : ");
    scanf("%d", &nb);

    while (count < 4){

        i = 1;
        bin = 0;
        deci = 0;
        count += 1;
        for (j=0; j<8; j++){
            rest = nb%2;
            nb = nb/2;
            bin += rest*i;
            deci += pow(2,j) * rest;
            i= i*10;
        }

        if (count == 1){
            printf("Z : %d en binaire soit %d en decimal\n", bin, deci);
        }

        else if (count == 2){
            printf("Y : %d en binaire soit %d en decimal\n", bin, deci);
        }

        else if (count == 3){
            printf("X : %d en binaire soit %d en decimal\n", bin, deci);
        }

        else if (count == 4){
            printf("Couleur : %d en binaire soit %d en decimal\n", bin, deci);
        }
    }


    return 0;
}

-
Edité par JakeFrost 1 novembre 2019 à 14:12:07

Bonjour, ben moi j'avais cette solution:

    unsigned int x,y,z,couleur;
    unsigned int entier;
    x=141;
    y=207;
    z=0;
    couleur=127;
    entier=couleur<<24 | x<<16 | y<<8 | z;

Après si t'as pas le droit d'utiliser << et | , je ne comprend pas trop l'intérêt...

Salut,

Une petite astuce : chaque bloc de 8 bits permet au total la représentation de 255 valeurs différentes.  Chaque fois que tu ajoute un bloc de 8 bits à une valeur numérique entière, tu multiplie le nombre de valeurs possibles par 255.

Si tu as quatre blocs de 8 bits, chaque bloc peut donc représenter 255 à l'exposant X sous la forme de

11111111 - 11111111 - 11111111 - 11111111

255^3      255^2      255^1      255^0

Ok, j'ai compris. Je viens de vérifier et j'obtiens bien 0*256^0 + 207*256^1 + 141*256^2 + 127*256^3= 2140000000.

Merci beaucoup pour l'astuce !

-
Edité par JakeFrost 29 octobre 2019 à 18:01:00

Hello,

Comme je ne vois pas d'interdiction d'utiliser les structures / unions

#include <stdio.h>

struct px_val {
	unsigned char z;
	unsigned char y;
	unsigned char x;
	unsigned char color;
};
	

union px {
	unsigned int v;
	struct px_val pxval;
};


int main(void) {
	union px pixel;
	
	pixel.v=2140000000;
	printf("x=%d y=%d z=%d color=%d\n",pixel.pxval.x,pixel.pxval.y,pixel.pxval.z,pixel.pxval.color);

	pixel.v=0;
	printf("x=%d y=%d z=%d color=%d\n",pixel.pxval.x,pixel.pxval.y,pixel.pxval.z,pixel.pxval.color);
	
	pixel.pxval.x=141;
	pixel.pxval.y=207;
	pixel.pxval.z=0;
	pixel.pxval.color=127;
	printf("v=%u\n",pixel.v);
	
	return(0);
}

-
Edité par edgarjacobs 29 octobre 2019 à 18:56:33

edgarjacobs a écrit:

Hello,

Comme je ne vois pas d'interdiction d'utiliser les structures / unions

Edité par edgarjacobs il y a 11 minutes

Houla. Probleme d'ordre des octets (Endianness) en vue....

// dans un sens

n = couleur * 256*256*256
    + x     * 256*256
    + y     * 256
    + z     ;


// dans l'autre

couleur = n / (256 * 256 * 256);
x = (n / (256*256)) % 256;
y = (n / 256)       % 256;
z = n               % 256 

C'est con, ces exercices où "on a pas le droit". Remplacer des décalages par des multiplications et divisions par des puissances de 2, ça n'a rien d'intéressant.

-
Edité par michelbillaud 29 octobre 2019 à 19:22:12