View Full Version : [C] Rappresentazione binaria
Ciao a tutti!!! :)
Devo scrivere un programma che dato in input un numero intero < 128 restituisca la sua rappresentazione binaria (senza usare while)
Esempio
Input: 35
Output: 00100011
Il problema è che oltre a non usare while, non devo usare né puntatori né array. E qui sta il problema.... come faccio (dopo aver ripetutamente diviso per due il numero) a restituire i resti nell'ordine inverso? Grazie.
repne scasb
13-10-2005, 19:30
A meno di errori grossolani:
#include <stdio.h>
void main(void)
{
int i;
printf("Valore: ");
scanf("%d",&i);
switch (i)
{
case 0:
printf("0000000");
break;
case 1:
printf("0000001");
break;
case 2:
printf("0000010");
break;
case 3:
printf("0000011");
break;
case 4:
printf("0000100");
break;
case 5:
printf("0000101");
break;
case 6:
printf("0000110");
break;
case 7:
printf("0000111");
break;
case 8:
printf("0001000");
break;
case 9:
printf("0001001");
break;
case 10:
printf("0001010");
break;
case 11:
printf("0001011");
break;
case 12:
printf("0001100");
break;
case 13:
printf("0001101");
break;
case 14:
printf("0001110");
break;
case 15:
printf("0001111");
break;
case 16:
printf("0010000");
break;
case 17:
printf("0010001");
break;
case 18:
printf("0010010");
break;
case 19:
printf("0010011");
break;
case 20:
printf("0010100");
break;
case 21:
printf("0010101");
break;
case 22:
printf("0010110");
break;
case 23:
printf("0010111");
break;
case 24:
printf("0011000");
break;
case 25:
printf("0011001");
break;
case 26:
printf("0011010");
break;
case 27:
printf("0011011");
break;
case 28:
printf("0011100");
break;
case 29:
printf("0011101");
break;
case 30:
printf("0011110");
break;
case 31:
printf("0011111");
break;
case 32:
printf("0100000");
break;
case 33:
printf("0100001");
break;
case 34:
printf("0100010");
break;
case 35:
printf("0100011");
break;
case 36:
printf("0100100");
break;
case 37:
printf("0100101");
break;
case 38:
printf("0100110");
break;
case 39:
printf("0100111");
break;
case 40:
printf("0101000");
break;
case 41:
printf("0101001");
break;
case 42:
printf("0101010");
break;
case 43:
printf("0101011");
break;
case 44:
printf("0101100");
break;
case 45:
printf("0101101");
break;
case 46:
printf("0101110");
break;
case 47:
printf("0101111");
break;
case 48:
printf("0110000");
break;
case 49:
printf("0110001");
break;
case 50:
printf("0110010");
break;
case 51:
printf("0110011");
break;
case 52:
printf("0110100");
break;
case 53:
printf("0110101");
break;
case 54:
printf("0110110");
break;
case 55:
printf("0110111");
break;
case 56:
printf("0111000");
break;
case 57:
printf("0111001");
break;
case 58:
printf("0111010");
break;
case 59:
printf("0111011");
break;
case 60:
printf("0111100");
break;
case 61:
printf("0111101");
break;
case 62:
printf("0111110");
break;
case 63:
printf("0111111");
break;
case 64:
printf("1000000");
break;
case 65:
printf("1000001");
break;
case 66:
printf("1000010");
break;
case 67:
printf("1000011");
break;
case 68:
printf("1000100");
break;
case 69:
printf("1000101");
break;
case 70:
printf("1000110");
break;
case 71:
printf("1000111");
break;
case 72:
printf("1001000");
break;
case 73:
printf("1001001");
break;
case 74:
printf("1001010");
break;
case 75:
printf("1001011");
break;
case 76:
printf("1001100");
break;
case 77:
printf("1001101");
break;
case 78:
printf("1001110");
break;
case 79:
printf("1001111");
break;
case 80:
printf("1010000");
break;
case 81:
printf("1010001");
break;
case 82:
printf("1010010");
break;
case 83:
printf("1010011");
break;
case 84:
printf("1010100");
break;
case 85:
printf("1010101");
break;
case 86:
printf("1010110");
break;
case 87:
printf("1010111");
break;
case 88:
printf("1011000");
break;
case 89:
printf("1011001");
break;
case 90:
printf("1011010");
break;
case 91:
printf("1011011");
break;
case 92:
printf("1011100");
break;
case 93:
printf("1011101");
break;
case 94:
printf("1011110");
break;
case 95:
printf("1011111");
break;
case 96:
printf("1100000");
break;
case 97:
printf("1100001");
break;
case 98:
printf("1100010");
break;
case 99:
printf("1100011");
break;
case 100:
printf("1100100");
break;
case 101:
printf("1100101");
break;
case 102:
printf("1100110");
break;
case 103:
printf("1100111");
break;
case 104:
printf("1101000");
break;
case 105:
printf("1101001");
break;
case 106:
printf("1101010");
break;
case 107:
printf("1101011");
break;
case 108:
printf("1101100");
break;
case 109:
printf("1101101");
break;
case 110:
printf("1101110");
break;
case 111:
printf("1101111");
break;
case 112:
printf("1110000");
break;
case 113:
printf("1110001");
break;
case 114:
printf("1110010");
break;
case 115:
printf("1110011");
break;
case 116:
printf("1110100");
break;
case 117:
printf("1110101");
break;
case 118:
printf("1110110");
break;
case 119:
printf("1110111");
break;
case 120:
printf("1111000");
break;
case 121:
printf("1111001");
break;
case 122:
printf("1111010");
break;
case 123:
printf("1111011");
break;
case 124:
printf("1111100");
break;
case 125:
printf("1111101");
break;
case 126:
printf("1111110");
break;
case 127:
printf("1111111");
break;
default:
printf("Valore non valido\n");
}
}
Aaaah dovevo fare proprio in maniera "rudimentale" così? :D
Pensavo ci fosse qualche metodo... Grazie cmq ;)
void dec2bin(int numero){
int bin = 0, i = 0;
for(; numero > 0; numero /= 2, i++)
if(numero % 2)
bin += (int)pow((float)10, (float)i);
printf("%d", bin);
}
:cincin:
p.s. ovviamente va inclusa la libreria math.h
repne scasb
13-10-2005, 19:41
Pensavo ci fosse qualche metodo...
Ed infatti c'e'.
Ok ho capito che c'era il metodo però non pensavo fosse quello :D
x cj++:
Ho visto il tuo listato ma credo che quello che hai fatto tu non corrisponda alla conversione di un decimale in binario. Ad esempio 23 mi viene 10109. Cmq grazie.
x cj++:
Ho visto il tuo listato ma credo che quello che hai fatto tu non corrisponda alla conversione di un decimale in binario. Cmq grazie.
come no, bin contiene il numero in binario... se passi alla funzione 35 ti da 100011...
Se però passo ,ad esempio, 23 mi da 10109
Magari l'idea è anche giusta.... :)
con 23 a me da 10111, mi sa che ha qualche problema la tua macchina/IDE
Anche perche bin contiene solo potenze di 10 quindi il 9 fa fatica a saltar fuori
Corretto e sintetico ;)
edit: hai inizializzato bin = 0? E' essenziale che lo sia.
edit 2: repne se fossi il tuo prof e tu mi consegnassi una cosa del genere te lo fare per valori della x fino a 65535 :D
Boh non so che dirti a me tira fuori quel risultato.
Si si è inizializzato. Cmq uso il DevC++
Cmq uso il DevC++
Ecco questa è gia una potenziale causa :D
Cmq qlc di strano c'è perche bin puo assumere solo 0 e 1 come valori.
In ogni caso vai tranqui che è corretto ;)
repne scasb
13-10-2005, 20:45
edit 2: repne se fossi il tuo prof e tu mi consegnassi una cosa del genere te lo fare per valori della x fino a 65535
Premesso che il mio maestro di informatica e' deceduto nel 1991, non mi sognerei mai di scrivere un tale sorgente neanche fino a 16. Per questo motivo ho sviluppato un piccolo software che mi genera il sorgente, ossia un software che genera un software:
#include <stdio.h>
#include <stdlib.h>
#define N_BITS 16
void main(void)
{
long i;
char s[33];
for(i=1L<<N_BITS;i<((1L<<(N_BITS+1)));i++)
{
printf(" case %ld:\n",i-(1L<<N_BITS));
printf(" printf(\x22%s\x5Cn\x22);\n",itoa(i,s,2)+1);
printf(" break;\n");
}
}
P.S. itoa non e' ANSI.
---------------------------------------------------------------------------
Detto cio', questa e' una possibile variante (che avrebbe dovuto trovare l'utente Manugal):
#include <stdio.h>
void main(void)
{
int i,j;
printf("Valore: ");
scanf("%d",&i);
for(j=128;j;j>>=1)
printf("%c",i&j?'1':'0');
}
AnonimoVeneziano
13-10-2005, 22:25
Detto cio', questa e' una possibile variante (che avrebbe dovuto trovare l'utente Manugal):
#include <stdio.h>
void main(void)
{
int i,j;
printf("Valore: ");
scanf("%d",&i);
for(j=128;j;j>>=1)
printf("%c",i&j?'1':'0');
}
Geniale :eek:
Come al solito ;)
Ciao
un software che genera un software
...metaprogramming... :stordita:
Geniale Come al solito
Google rulez in effetti ;)
AnonimoVeneziano
13-10-2005, 22:46
Google rulez in effetti ;)
In che senso? C'è un link con lo stesso software?
Comunque repne si è sempre dimostrata in grado di trovare algoritmi efficientissimi per problemi molto + complicati di questo , quindi il suo valore è già consolidato a prescindere da tutto .
Ciao
repne scasb
13-10-2005, 23:07
Google rulez in effetti
Il codice e' assolutamente originale, e non copiato da altre fonti. Per completezza riporto anche il codice in assembly x86 la cui particolarita e' di non utilizzare salti condizionati (escluso l'uscita dal loop). Chi e' in grado di scrivere l'equivalente in C? (ossia senza IF).
mov al,_i
xor bx,bx
mov cx,8h
loop_bit:
rol al,1h
mov bl,al
and bl,1h
add bl,'0'
push bx
push si
call _printf
add sp,4h
dec cx
jne loop_bit
Il codice e' assolutamente originale, e non copiato da altre fonti. Per completezza riporto anche il codice in assembly x86 la cui particolarita e' di non utilizzare salti condizionati (escluso l'uscita dal loop). Chi e' in grado di scrivere l'equivalente in C? (ossia senza IF).
mov al,_i
xor bx,bx
mov cx,8h
loop_bit:
rol al,1h
mov bl,al
and bl,1h
add bl,'0'
push bx
push si
call _printf
add sp,4h
dec cx
jne loop_bit
E' un piacere leggerti, ti adoro rep, sei mitica............ ciao da okay ;)
Ciao a tutti!!! :)
Devo scrivere un programma che dato in input un numero intero < 128 restituisca la sua rappresentazione binaria (senza usare while)
Esempio
Input: 35
Output: 00100011
Il problema è che oltre a non usare while, non devo usare né puntatori né array. E qui sta il problema.... come faccio (dopo aver ripetutamente diviso per due il numero) a restituire i resti nell'ordine inverso? Grazie.
Se puoi usare la ricorsione, lo fai in poche righe... Ma mi sa che non puoi!
Ciao
^TiGeRShArK^
14-10-2005, 00:43
Il codice e' assolutamente originale, e non copiato da altre fonti. Per completezza riporto anche il codice in assembly x86 la cui particolarita e' di non utilizzare salti condizionati (escluso l'uscita dal loop). Chi e' in grado di scrivere l'equivalente in C? (ossia senza IF).
mov al,_i
xor bx,bx
mov cx,8h
loop_bit:
rol al,1h
mov bl,al
and bl,1h
add bl,'0'
push bx
push si
call _printf
add sp,4h
dec cx
jne loop_bit
sempre + spettacolare repne!!! :D
ke bello vedere ki nn t conosce ke fa certe insinuazioni! :rotfl:
Be' se non devi usare cicli potresti usare la ricorsione, ad es. :
#include <stdio.h>
void stampa_bin(unsigned char c)
{
static char cnt = 8;
if (cnt--) {
stampa_bin(c>>1);
putchar('0' + (c&1));
if (++cnt == 7)
putchar('\n');
}
}
int main()
{
unsigned char c = 35;
stampa_bin(c);
return 0;
}
Io lo farei così senza salti (escluso quelo del ciclo):
void dec2bin(unsigned int num)
{
unsigned int j = sizeof(int)*8;
for(;j--;)
printf("%d", (num & (1 << j)) >> j);
printf("\n");
}
repne scasb
14-10-2005, 22:49
Io lo farei così senza salti (escluso quelo del ciclo):
void dec2bin(unsigned int num)
{
unsigned int j = sizeof(int)*8;
for(;j--;)
printf("%d", (num & (1 << j)) >> j);
printf("\n");
}
Corretto. E (sempre piu' difficile) utilizzando una sola variabile?
Corretto. E (sempre piu' difficile) utilizzando una sola variabile?
while (num)
{
printf("%d", num & (1 << (sizeof(num)*8)));
num = num << 1;
}
Ho vinto quaccheccosa? :stordita:
while (num)
{
printf("%d", num & (1 << (sizeof(num)*8)));
num = num << 1;
}
Ho vinto quaccheccosa? :stordita:
No... scusate ma ho scritto una porcheria! Non l'ho editata per onesta'! :(
repne scasb
14-10-2005, 23:16
No... scusate ma ho scritto una porcheria! Non l'ho editata per onesta'! :(
Se fosse stato cosi' semplice non avrei posto il quesito.
Comunque, la tua onesta' ti fa onore.
repne scasb
14-10-2005, 23:44
Be' se non devi usare cicli potresti usare la ricorsione, ad es. : [CUT]
Mi era parso di capire che l'autore della discussione (Manugal), vietasse l'uso del solo 'while' oltre che di array e puntatori; ossia il 'for' sembrerebbe permesso.
Puoi sempre passare da un ciclo while a uno for, non ha senso vietare il primo e non il secondo.
Corretto. E (sempre piu' difficile) utilizzando una sola variabile?
Direi che è anche più facile, però bisogna fare una supposizione sul numero di cifre da visualizzare (ad esempio 8 bit), altrimenti va fatto ricorsivo:
void dec2bin(unsigned int num)
{
printf("%d", num & 128 >> 7);
printf("%d", num & 64 >> 6);
printf("%d", num & 32 >> 5);
printf("%d", num & 16 >> 4);
printf("%d", num & 8 >> 3);
printf("%d", num & 4 >> 2);
printf("%d", num & 2 >> 1);
printf("%d", num & 1);
}
repne scasb
15-10-2005, 10:51
Direi che è anche più facile, però bisogna fare una supposizione sul numero di cifre da visualizzare (ad esempio 8 bit), altrimenti va fatto ricorsivo:
void dec2bin(unsigned int num)
{
printf("%d", num & 128 >> 7);
printf("%d", num & 64 >> 6);
printf("%d", num & 32 >> 5);
printf("%d", num & 16 >> 4);
printf("%d", num & 8 >> 3);
printf("%d", num & 4 >> 2);
printf("%d", num & 2 >> 1);
printf("%d", num & 1);
}
Bello. Ma guarda questo:
#include <stdio.h>
void main(void)
{
short i;
printf("Valore: ");
scanf("%d",&i);
if((i<0)||(i>127))
printf("Valore non valido\n");
else
for(i|=0x0700;(i&0xFF00)!=0xFF00;i=(((i&0x00FF)<<1)&0x00FF)|(i&0xFF00),i-=0x0100)
printf("%c",((i&0x0080)>>0x0007)+'0');
}
repne scasb
15-10-2005, 10:58
Puoi sempre passare da un ciclo while a uno for, non ha senso vietare il primo e non il secondo.
Mi trovo d'accordo con te. Purtroppo cio' che non ha senso per noi, magari l'ha per l'insegnante dell'utente Manugal.
Bello. Ma guarda questo:
Avevo pensato anche io ad utilizzare la parte alta di un intero, ma il problema è sempre che bisogna limitare il tutto agli 8 bit più bassi.... Se è di ciò che ha bisogno allora la solzuioen è ammissibile :)
Suggerisco:
...
for(i |= 0xFF00; i; i = (i << 1)&(~0x0100))
printf("%c", '0' + ((i&0x0080) >> 7));
...
repne scasb
15-10-2005, 16:28
Suggerisco:
...
for(i |= 0xFF00; i; i = (i << 1)&(~0x0100))
printf("%c", '0' + ((i&0x0080) >> 7));
...
Bello. E cosi' (uso del bit 7 come stop):
for(i|=0xFF00;i<0;i<<=1)
printf("%d",(i>>7)&1);
Ziosilvio
15-10-2005, 19:29
come faccio (dopo aver ripetutamente diviso per due il numero) a restituire i resti nell'ordine inverso? Grazie.
Credo che dovresti usare gli operatori AND e OR bit-a-bit.
EDIT: ci aveva già pensato cionci.
Io però, anziché printf("%d",(num & ref)>>ind), avrei usato putchar(((num & ref)>>ind)+'0').
A proposito: attenzione, "num & ref >> ind" non equivale a "(num & ref) >> ind", ma a "num & (ref >> ind)".
for(i|=0xFF00;i<0;i<<=1)
printf("%d",(i>>7)&1);
Bello. Direi che difficilmente si puo' far meglio, perlomeno utilizzando la parte alta dell'intero...
repne scasb
17-10-2005, 09:25
Bello. Direi che difficilmente si puo' far meglio, perlomeno utilizzando la parte alta dell'intero...
Si puo' ancora risparmiare un AND:
for(i|=0xFF00;i<0;i<<=1)
printf("%d",(unsigned char)i>>7);
La cosa curiosa e' che tale routine e' (a parita' di printf) appena piu' rapida dell'analoga routine a due variabili, mentre mi sarei aspettata un'aumento della complessita' generale della routine a seguito dell'uso di una sola variabile, e quindi una prestazione piu' deficitaria.
vBulletin® v3.6.4, Copyright ©2000-2026, Jelsoft Enterprises Ltd.