[C] Problemi conversione numero in binario

[Ov3rLo4d]

Questo è il testo del problema:



/* Scrivere un programma per convertire un numero intero positivo
* minore di 255 in binario. Non si possono usare vettori.
*
* Suggerimento : sapendo che il numero e' minore di 256
* dividere per tutte le potenze da 2^7 a 1 ...
*
* L'output del programma, seguendo questo approccio, sara'
* sempre su 8 bit:
* Es. 25 = 00011001
*/



che non ho capito nemmeno molto bene la parte del suggerimento...


cmq io per ora ho fatto questo... pensavo venisse ma a quanto pare mi prende il resto della divisione sbagliato:


#include <stdio.h>
#include <stdlib.h>

#define MAX 255

int num,bit8,bit7,bit6,bit5,bit4,bit3,bit2,bit1;

main()
{
printf("Inserisci il numero da convertire in Binario: ");
scanf("%d",&num);
if(num<=MAX)
{
bit8=num/2;
bit8=bit8%2;
bit7=bit8/2;
bit7=bit7%2;
bit6=bit7/2;
bit6=bit6%2;
bit5=bit6/2;
bit5=bit5%2;
bit4=bit5/2;
bit4=bit4%2;
bit3=bit4/2;
bit3=bit3%2;
bit2=bit3/2;
bit2=bit2%2;
bit1=bit2/2;
bit1=bit1%2;
printf("%d%d%d%d%d%d%d%d",bit8,bit7,bit6,bit5,bit4 ,bit3,bit2,bit1);
}
}





cosa devo fare???

Grazie a tutti...

[mondobimbi]

per determinare se il primo bit a sinistra si trova nello stato 1 devi fare una divisione intera per 128. La parte intera varrà 1 se il numero è maggiore di 128, 0 altrimenti.
Calcoli poi il resto della divisione e passi al bit destro successivo, fai la stessa operazione utiizzando come divisore il resto della divisione precedente e come dividendo il numero 64, cioè 2 elevato alla sesta.
Vai avanti così fino al primo bit di sinistra.
ciao
sergio

[menphisx]

Prova a ragionare su questo codice:

/*
 *Convert into binary a number
 */

#include <stdio.h>
#include <stdlib.h>

struct BinaryNumber {

  unsigned int bit0 : 1;
  unsigned int bit1 : 1;
  unsigned int bit2 : 1;
  unsigned int bit3 : 1;
  unsigned int bit4 : 1;
  unsigned int bit5 : 1;
  unsigned int bit6 : 1;
  unsigned int bit7 : 1;

};

int main(void){

  struct BinaryNumber number;
  unsigned int n;

  scanf("%d", &n);

  number.bit7 = n >> 7;
  number.bit6 = n >> 6;
  number.bit5 = n >> 5;
  number.bit4 = n >> 4;
  number.bit3 = n >> 3;
  number.bit2 = n >> 2;
  number.bit1 = n >> 1;
  number.bit0 = n >> 0;
/*   number = *((struct BinaryNumber*)&n); */

  printf("%d%d%d%d%d%d%d%d\n", number.bit7, number.bit6, number.bit5, number.bit4, number.bit3, number.bit2, number.bit1, number.bit0);

  return 0;

}

ed usa i tag CODE ed indenta :rollo:

[MacApp]

Guarda anche questo:

#include <stdio.h>

typedef struct{
  unsigned int bit0 : 1;
  unsigned int bit1 : 1;
  unsigned int bit2 : 1;
  unsigned int bit3 : 1;
  unsigned int bit4 : 1;
  unsigned int bit5 : 1;
  unsigned int bit6 : 1;
  unsigned int bit7 : 1;

}SBinaryNumber;

typedef union{
    unsigned char fNumber;
    SBinaryNumber fBinary;
} UBinaryNumber;

int main (void){
    UBinaryNumber aBinaryNumber;
    aBinaryNumber.fNumber = 25;
    
      printf("%d%d%d%d%d%d%d%d\n",
          aBinaryNumber.fBinary.bit7,
          aBinaryNumber.fBinary.bit6,
          aBinaryNumber.fBinary.bit5,
          aBinaryNumber.fBinary.bit4,
          aBinaryNumber.fBinary.bit3,
          aBinaryNumber.fBinary.bit2,
          aBinaryNumber.fBinary.bit1,
          aBinaryNumber.fBinary.bit0);
    
    return 0;
} 

[mondobimbi]

Originariamente inviato da Ov3rLo4d
Questo è il testo del problema:



/* Scrivere un programma per convertire un numero intero positivo
* minore di 255 in binario. Non si possono usare vettori.
*
* Suggerimento : sapendo che il numero e' minore di 256
* dividere per tutte le potenze da 2^7 a 1 ...
*
* L'output del programma, seguendo questo approccio, sara'
* sempre su 8 bit:
* Es. 25 = 00011001
*/



che non ho capito nemmeno molto bene la parte del suggerimento...

...

ma scusate, siete sicuri che abbia la conoscenza per comprendere quello che gli proponete?

Segui la via più semplice

#include <stdio.h>
int main ()
{
	int num = 4;

	// bit 8
	// se la divisione per 128 vale 1 allora è 1, altrimenti 0
	int bit8;
	if (num / 128 == 1) bit8 = 1;
	else bit8 = 0;
	
	// prendi il resto della divisione
	num = num % 128;

	// bit 7
	// se la divisione per 64 vale 1 allora è 1, altrimenti 0
	int bit7;
	if (num / 64 == 1) bit7 = 1;
	else bit7 = 0;
	
	// prendi il resto della divisione
	num = num % 64;

	// bit 6
	// se la divisione per 32 vale 1 allora è 1, altrimenti 0
	int bit6;
	if (num / 32 == 1) bit6 = 1;
	else bit6 = 0;
	
	// prendi il resto della divisione
	num = num % 32;

	// bit 5
	// se la divisione per 16 vale 1 allora è 1, altrimenti 0
	int bit5;
	if (num / 16 == 1) bit5 = 1;
	else bit5 = 0;
	
	// prendi il resto della divisione
	num = num % 16;

	// bit 4
	// se la divisione per 8 vale 1 allora è 1, altrimenti 0
	int bit4;
	if (num / 8 == 1) bit4 = 1;
	else bit4 = 0;
	
	// prendi il resto della divisione
	num = num % 8;

	// bit 3
	// se la divisione per 4 vale 1 allora è 1, altrimenti 0
	int bit3;
	if (num / 4 == 1) bit3 = 1;
	else bit3 = 0;
	
	// prendi il resto della divisione
	num = num % 4;

	// bit 2
	// se la divisione per 2 vale 1 allora è 1, altrimenti 0
	int bit2;
	if (num / 2 == 1) bit2 = 1;
	else bit2 = 0;
	// prendi il resto della divisione
	num = num % 2;

	// bit 1
	// se la divisione per 1 vale 1 allora è 1, altrimenti 0
	int bit1;
	if (num / 1 == 1) bit1 = 1;
	else bit1 = 0;
	
	printf("%d%d%d%d%d%d%d%d\n",bit8,bit7,bit6,bit5,bit4,bit3,bit2,bit1);

	return (0);

}

ciao
sergio

[Ov3rLo4d]

Thk sergio... così è super meglio... quelli di prima gli capivo però non sarei mai stato in grado di farlo dasolo...

questo è fattibilissimo ^^