Très simple. Un exemple :
Convertir 23 en binaire, tu te sers des divisions euclidienne ->
23 = 2 * 11 + 1. Le premier bit (le bit de poids faible) est donc 1.
11 = 2 * 5 + 1. Le deuxième bit est donc 1.
5 = 2 * 2 + 1. Le troisième bit est donc 1.
2 = 2 * 1 + 0. Le quatrième bit est donc 0.
1 = 2 * 0 + 1. le cinquième bit est donc 1. Tu t'arrêtes là puisque le quotient est égal à 0.
Soit 23(10) = 10111(2). Pour vérifier, tu prend la puissance de ta base de chaque bit et tu fais la somme de l'ensemble. Le bit le plus faible à la puissance 0 :
1*2^0 + 1*2^1 + 1*2^2 + 0*2^3 + 1*2^4 = 23
Edit : Si ça peut aider, voici l'algo en C# permettant de faire ce type de conversion :
int quotient = 23;
StringBuilder sstr = new StringBuilder();
do
{
int reste = quotient % 2;
sstr.Insert(0, reste.ToString());
}
while ((quotient = quotient / 2) != 0);
Console.WriteLine(sstr.ToString());
La "difficulté" réside dans le fait que le reste en cours de calcul est toujours un bit de poids plus fort que le bit (reste) précédemment calculé.
tout d'abord merci pour votre aide, mais moi je veux un algorithme en langage naturel pour le cas général, pour les nombres entiers positifs et négatifs.
J'ai essayé de le faire par la division entière, voici qq étapes:
Q:=0;
TQ x >= 2 faire
debut
x:=x-2;
Q:=Q+1;
fin;
R:=x;
tel que: x c'est le divisé
Q c'est le quotient
R c'est le reste
2 c'est le diviseur car on veut convertir vers la base2.
mais j'ai trouvée la difficulté comment je puisse faire la division entière pour chaque quotient et au même temps sauvegarder le reste de la division entière de chaque quotient.
Il n'existe pas "un seul algorithme" valable pour tous les types d'entiers, à cause des multiples représentation qui peuvent être utilisées pour représenter un entier (Nombre non-signé = Entier positif, Nombre signé = Entier positif et négatif, Nombre signé en complément à 2 = Entier positif et négatif, IEEE 754 = Réel...). Qui plus est, en fonction de la représentation adoptée, le nombre de bits peut devenir obligatoire ou non (par exemple, pour convertir un entier signé, on est obligé de connaitre le nombre maximal de bit utilisable pour pouvoir définir correctement le bit de signe).
La représentation du nombre dépendant du contexte dans lequel tu effectues tes opérations, je vois mal comment c'est faisable...
on peut connaitre le nombre de bit par la relation:
pour un nombre entier non signé: x=2**n-1 tel que x: un entier non signé et n le nombre de bit
d'où n=ln(x+1)/ln(2)
et pour les entiers signés on a:
si x positif x=2**(n-1)-1 d'où n=1+ln(x+1)/ln(2) ;x<>0
si x négatif x=-2**n-1 d'où n=1+ln(-x)/ln(2) ;x<>0
exemple:
15=2**4-1 d'où le nombre de bit égale à 4
-7 , n=1+ln(-(-7))/ln(2)=4 -7(10)=1001(2)
Il n'existe pas "un seul algorithme" valable pour tous les types d'entiers, à cause des multiples représentation qui peuvent être utilisées pour représenter un entier (Nombre non-signé = Entier positif, Nombre signé = Entier positif et négatif, Nombre signé en complément à 2 = Entier positif et négatif, IEEE 754 = Réel...). Qui plus est, en fonction de la représentation adoptée, le nombre de bits peut devenir obligatoire ou non (par exemple, pour convertir un entier signé, on est obligé de connaitre le nombre maximal de bit utilisable pour pouvoir définir correctement le bit de signe).
La représentation du nombre dépendant du contexte dans lequel tu effectues tes opérations, je vois mal comment c'est faisable...
Je suppose qu'il bosse à un niveau d'abstraction qui lui permet de pas se préoccuper de ça. Sinon effectivement ça va être chiant...
En fait ton code, tu as un truc pour l'exécuter ou quelque chose ? Parce que si tu testes ça je pense pas que tu obtienne les résultats espérés.
J'ai codé ça vite fait en scheme, l'algo est basique : modulo, division, modulo, division, modulo... Je posterais le code plus tard si tu bloques vraiment fort, mais pas pour le moment pour plusieurs raisons (entre autres le code est sur mon laptop qui est éteint, il est en scheme et je sais pas si tu connais ce langage, l'algo utilisé est récursif et je sais pas si as déjà touché à ça...).
Si tu connais un langage de programmation, le plus simple est de tester tes solutions pour voir si elles donnent des résultats satisfaisants. des langages simple comme Python ou Scheme feront parfaitement l'affaire.
Mais avant tout, prend une feuille de papier et un crayon, c'est par là que tout doit commencer
Ça me semble déjà plus correct à première vue, faudrait le coder histoire de voir...
EDIT : Je l'ai codé vite fait en Python (pas tout, juste le coeur de l'algo dans une fonction pour tester facilement), j'ai trouvé juste un détail qui colle pas : la concaténation dans la boucle : si on colle le reste à droite de la chaîne, on obtient le résultat à l'envers, il faut le coller à gauche.
Le code :
def d2bin(x):
result = ""
if x < 2:
result = str(x)
else:
quotient = x
while quotient != 0:
reste = quotient % 2
result = ''.join([str(reste), result])
quotient = quotient/2
return result
ah ok j'y avais pas pensé sinon la j'essaie de le modifier pour qu'il me mette le reste de l'octet avec des 0,
une petite idée?
ah et 'ai trouvé ca aussi en html/js :
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="fr" >
<head>
<title>
Convertisseur Binaire-Décimal-Héxadécimal
</title>
<script language="JavaScript">
function decCompute(form) {
form.hex.value = hexfromdec(form.decimal.value);
form.binary.value = binfromdec(form.decimal.value);
}
function hexCompute(form) {
form.decimal.value = decfromhex(form.hex.value);
form.binary.value = binfromdec(form.decimal.value);
}
function binCompute(form) {
form.decimal.value = decfrombin(form.binary.value);
form.hex.value = hexfromdec(form.decimal.value);
}
function hexfromdec(num) {
if (num > 65535) { return ("overflow!") }
first = Math.round(num/4096 - .5);
temp1 = num - first * 4096;
second = Math.round(temp1/256 -.5);
temp2 = temp1 - second * 256;
third = Math.round(temp2/16 - .5);
fourth = temp2 - third * 16;
return (""+getletter(first)+getletter(second)+getletter(third)+getletter(fourth));
}
function getletter(num) {
if (num < 10) {
return num;
}
else {
if (num == 10) { return "A" }
if (num == 11) { return "B" }
if (num == 12) { return "C" }
if (num == 13) { return "D" }
if (num == 14) { return "E" }
if (num == 15) { return "F" }
}
}
function binfromdec(num) {
var bit16=0, bit15=0, bit14=0, bit13=0, bit12=0, bit11=0, bit10=0, bit9=0, bit8=0, bit7=0, bit6=0, bit5=0, bit4=0, bit3=0, bit2=0, bit1=0;
if (num > 65535) { return ("overflow!") }
if (num & 32768) { bit16 = 1 }
if (num & 16384) { bit15 = 1 }
if (num & 8192) { bit14 = 1 }
if (num & 4096) { bit13 = 1 }
if (num & 2048) { bit12 = 1 }
if (num & 1024) { bit11 = 1 }
if (num & 512) { bit10 = 1 }
if (num & 256) { bit9 = 1 }
if (num & 128) { bit8 = 1 }
if (num & 64) { bit7 = 1 }
if (num & 32) { bit6 = 1 }
if (num & 16) { bit5 = 1 }
if (num & 8) { bit4 = 1 }
if (num & 4) { bit3 = 1 }
if (num & 2) { bit2 = 1 }
if (num & 1) { bit1 = 1 }
return (""+bit16+bit15+bit14+bit13+bit12+bit11+bit10+bit9+bit8+bit7+bit6+bit5+bit4+bit3+bit2+bit1);
}
function decfromhex(num) {
while (num.length < 4) {
num = "0" + num;
}
return (eval(getnum(num.substring(3,4))) + eval(getnum(num.substring(2,3))) * 16 +
eval(getnum(num.substring(1,2))) * 256 + eval(getnum(num.substring(0,1))) * 4096);
}
function getnum(letter) {
if (letter <= "9") {
return letter;
}
else{
if ((letter == "a") || (letter == "A")) { return 10 }
if ((letter == "b") || (letter == "B")) { return 11 }
if ((letter == "c") || (letter == "C")) { return 12 }
if ((letter == "d") || (letter == "D")) { return 13 }
if ((letter == "e") || (letter == "E")) { return 14 }
if ((letter == "f") || (letter == "F")) { return 15 }
return 0;
}
}
function decfrombin(num) {
var decimal = 0;
while (num.length < 16) {
num = "0" + num;
}
if (num.substring(15,16) == "1") { decimal++ }
if (num.substring(14,15) == "1") { decimal = decimal + 2 }
if (num.substring(13,14) == "1") { decimal = decimal + 4 }
if (num.substring(12,13) == "1") { decimal = decimal + 8 }
if (num.substring(11,12) == "1") { decimal = decimal + 16 }
if (num.substring(10,11) == "1") { decimal = decimal + 32 }
if (num.substring(9,10) == "1") { decimal = decimal + 64 }
if (num.substring(8,9) == "1") { decimal = decimal + 128 }
if (num.substring(7,8) == "1") { decimal = decimal + 256 }
if (num.substring(6,7) == "1") { decimal = decimal + 512 }
if (num.substring(5,6) == "1") { decimal = decimal + 1024 }
if (num.substring(4,5) == "1") { decimal = decimal + 2048 }
if (num.substring(3,4) == "1") { decimal = decimal + 4096 }
if (num.substring(2,3) == "1") { decimal = decimal + 8192 }
if (num.substring(1,2) == "1") { decimal = decimal + 16384 }
if (num.substring(0,1) == "1") { decimal = decimal + 32768 }
return(decimal);
}
</script>
</head>
<body>
<form>
<table border=0>
<tr>
<TD ROWSPAN="3">
<td BGCOLOR="#CC99CC">
Décimal:
</td>
<td BGCOLOR="#CC99CC">
<input type="text" name="decimal" value="0" size=20 maxlength=20 onChange="decCompute(this.form)">
</td>
</tr>
<tr>
<td BGCOLOR="#FF9900">
Binaire:
</td>
<td>
<input type="text" name="binary" value="0000000000000000" size=20 maxlength=20 onChange="binCompute(this.form)">
</td>
</tr>
<tr BGCOLOR="#999999">
<td>
Hexadécimal:
</td>
<td>
<input type="text" name="hex" value="0000" size=20 maxlength=20 onChange="hexCompute(this.form)">
</td>
</tr>
</table>
</form>
</body>
</html>
En fait ton code, tu as un truc pour l'exécuter ou quelque chose ? Parce que si tu testes ça je pense pas que tu obtienne les résultats espérés.
J'ai codé ça vite fait en scheme, l'algo est basique : modulo, division, modulo, division, modulo... Je posterais le code plus tard si tu bloques vraiment fort, mais pas pour le moment pour plusieurs raisons (entre autres le code est sur mon laptop qui est éteint, il est en scheme et je sais pas si tu connais ce langage, l'algo utilisé est récursif et je sais pas si as déjà touché à ça...).
Si tu connais un langage de programmation, le plus simple est de tester tes solutions pour voir si elles donnent des résultats satisfaisants. des langages simple comme Python ou Scheme feront parfaitement l'affaire.
Mais avant tout, prend une feuille de papier et un crayon, c'est par là que tout doit commencer
je connais pas ce langage scheme mais je connais fortran et pascal j'essaye de l exécuter mais le problème c est au niveau de l'affichage car l affichage se fait inversement...
ah ok j'y avais pas pensé sinon la j'essaie de le modifier pour qu'il me mette le reste de l'octet avec des 0,
une petite idée?
ah et 'ai trouvé ca aussi en html/js :
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="fr" >
<head>
<title>
Convertisseur Binaire-Décimal-Héxadécimal
</title>
<script language="JavaScript">
function decCompute(form) {
form.hex.value = hexfromdec(form.decimal.value);
form.binary.value = binfromdec(form.decimal.value);
}
function hexCompute(form) {
form.decimal.value = decfromhex(form.hex.value);
form.binary.value = binfromdec(form.decimal.value);
}
function binCompute(form) {
form.decimal.value = decfrombin(form.binary.value);
form.hex.value = hexfromdec(form.decimal.value);
}
function hexfromdec(num) {
if (num > 65535) { return ("overflow!") }
first = Math.round(num/4096 - .5);
temp1 = num - first * 4096;
second = Math.round(temp1/256 -.5);
temp2 = temp1 - second * 256;
third = Math.round(temp2/16 - .5);
fourth = temp2 - third * 16;
return (""+getletter(first)+getletter(second)+getletter(third)+getletter(fourth));
}
function getletter(num) {
if (num < 10) {
return num;
}
else {
if (num == 10) { return "A" }
if (num == 11) { return "B" }
if (num == 12) { return "C" }
if (num == 13) { return "D" }
if (num == 14) { return "E" }
if (num == 15) { return "F" }
}
}
function binfromdec(num) {
var bit16=0, bit15=0, bit14=0, bit13=0, bit12=0, bit11=0, bit10=0, bit9=0, bit8=0, bit7=0, bit6=0, bit5=0, bit4=0, bit3=0, bit2=0, bit1=0;
if (num > 65535) { return ("overflow!") }
if (num & 32768) { bit16 = 1 }
if (num & 16384) { bit15 = 1 }
if (num & 8192) { bit14 = 1 }
if (num & 4096) { bit13 = 1 }
if (num & 2048) { bit12 = 1 }
if (num & 1024) { bit11 = 1 }
if (num & 512) { bit10 = 1 }
if (num & 256) { bit9 = 1 }
if (num & 128) { bit8 = 1 }
if (num & 64) { bit7 = 1 }
if (num & 32) { bit6 = 1 }
if (num & 16) { bit5 = 1 }
if (num & 8) { bit4 = 1 }
if (num & 4) { bit3 = 1 }
if (num & 2) { bit2 = 1 }
if (num & 1) { bit1 = 1 }
return (""+bit16+bit15+bit14+bit13+bit12+bit11+bit10+bit9+bit8+bit7+bit6+bit5+bit4+bit3+bit2+bit1);
}
function decfromhex(num) {
while (num.length < 4) {
num = "0" + num;
}
return (eval(getnum(num.substring(3,4))) + eval(getnum(num.substring(2,3))) * 16 +
eval(getnum(num.substring(1,2))) * 256 + eval(getnum(num.substring(0,1))) * 4096);
}
function getnum(letter) {
if (letter <= "9") {
return letter;
}
else{
if ((letter == "a") || (letter == "A")) { return 10 }
if ((letter == "b") || (letter == "B")) { return 11 }
if ((letter == "c") || (letter == "C")) { return 12 }
if ((letter == "d") || (letter == "D")) { return 13 }
if ((letter == "e") || (letter == "E")) { return 14 }
if ((letter == "f") || (letter == "F")) { return 15 }
return 0;
}
}
function decfrombin(num) {
var decimal = 0;
while (num.length < 16) {
num = "0" + num;
}
if (num.substring(15,16) == "1") { decimal++ }
if (num.substring(14,15) == "1") { decimal = decimal + 2 }
if (num.substring(13,14) == "1") { decimal = decimal + 4 }
if (num.substring(12,13) == "1") { decimal = decimal + 8 }
if (num.substring(11,12) == "1") { decimal = decimal + 16 }
if (num.substring(10,11) == "1") { decimal = decimal + 32 }
if (num.substring(9,10) == "1") { decimal = decimal + 64 }
if (num.substring(8,9) == "1") { decimal = decimal + 128 }
if (num.substring(7,8) == "1") { decimal = decimal + 256 }
if (num.substring(6,7) == "1") { decimal = decimal + 512 }
if (num.substring(5,6) == "1") { decimal = decimal + 1024 }
if (num.substring(4,5) == "1") { decimal = decimal + 2048 }
if (num.substring(3,4) == "1") { decimal = decimal + 4096 }
if (num.substring(2,3) == "1") { decimal = decimal + 8192 }
if (num.substring(1,2) == "1") { decimal = decimal + 16384 }
if (num.substring(0,1) == "1") { decimal = decimal + 32768 }
return(decimal);
}
</script>
</head>
<body>
<form>
<table border=0>
<tr>
<TD ROWSPAN="3">
<td BGCOLOR="#CC99CC">
Décimal:
</td>
<td BGCOLOR="#CC99CC">
<input type="text" name="decimal" value="0" size=20 maxlength=20 onChange="decCompute(this.form)">
</td>
</tr>
<tr>
<td BGCOLOR="#FF9900">
Binaire:
</td>
<td>
<input type="text" name="binary" value="0000000000000000" size=20 maxlength=20 onChange="binCompute(this.form)">
</td>
</tr>
<tr BGCOLOR="#999999">
<td>
Hexadécimal:
</td>
<td>
<input type="text" name="hex" value="0000" size=20 maxlength=20 onChange="hexCompute(this.form)">
</td>
</tr>
</table>
</form>
</body>
</html>
slt, ça c'est en en langage java script, il se fait les calculs sur 16 bit, il marche bien.merci ... A+
Bonsoir les zéros !
Je me permets de upper ce topic car je suis dans la même situation que son auteur, je suis en plein challenge depuis hier soir à essayer de trouver une solution à réaliser un algorithme de conversion décimal vers binaire. Et j'ai remarqué ceci :
Citation : daforiu
Salut j'ai essayé ca me donne ca sous un petit programme appelé algobox :
VARIABLES
E EST_DU_TYPE NOMBRE
I EST_DU_TYPE NOMBRE
R EST_DU_TYPE CHAINE
B EST_DU_TYPE NOMBRE
DEBUT_ALGORITHME
AFFICHER* "Quel est l'entier à traduire?"
LIRE E
SI (E<2) ALORS
DEBUT_SI
R PREND_LA_VALEUR E FIN_SI
SINON
DEBUT_SINON
I PREND_LA_VALEUR E
TANT_QUE (I!=0) FAIRE
DEBUT_TANT_QUE
B PREND_LA_VALEUR I%2
R PREND_LA_VALEUR R+B
I PREND_LA_VALEUR floor(I/2) FIN_TANT_QUE
FIN_SINON
AFFICHER* "Donc :"
AFFICHER E
AFFICHER "(10) = "
AFFICHER R
AFFICHER "(2)"
FIN_ALGORITHME
dites moi si ca vous parrait corect
Moi aussi je fais ça sous Algobox daforiu, et ton algorithme fonctionne seulement le résultat final R est affiché à l'envers. C'est à dire que le code binaire est inversé. Pour 18 par exemple on a 01001 au lieu de 10010. Connaitrais-tu une fonction ou un système permettant de changer l'ordre des chiffres du code?
Auparavant j'ai effectué quelques heures de réflexions et de testes personnels, et je n'ai pas abouti à grand chose, ou alors j'avais le même résultat : le code à l'envers.
C'était aussi simple que ça et je suis passé à côté... C'est vraiment stupide de ma part. Merci beaucoup LoupSolitaire, bon dimanche à tous, moi je vais m'amuser avec mon algorithme maintenant.
Salut, enfin le problème est résolu. Pour l’algorithme :
Je vais prendre l'exemple de 8 bits.
x >= 128 si oui alors écrire '1' sinon écrire '0'
le reste >= 64 si oui alors écrire '1' sinon écrire '0'
le reste >= 32 si oui alors écrire '1' sinon écrire '0'
le reste >= 16 si oui alors écrire '1' sinon écrire '0'
le reste >= 8 si oui alors écrire '1' sinon écrire '0'
le reste >= 4 si oui alors écrire '1' sinon écrire '0'
le reste >= 2 si oui alors écrire '1' sinon écrire '0'
le reste = 1 si oui alors écrire '1' sinon écrire '0'
et voila le programme pascal :
program conv_bin;
uses crt;
var bit:array[0..7]of integer;
x,i,j:integer;
begin
clrscr;
gotoxy(1,2);
writeln('Veuillez saisir un nombre binaire svp :');
x:=0;
j:=128;
pour i:=7 downto 0 do
begin
repeat
gotoxy(50-i,4);
readln(bit[i]);
if bit[i]=1 then
begin
write('1');
x:=x-j;
end
else if bit[i]=0 then write('0');
j:= j div 2;
until (bit[i]=1)or(bit[i]=0);
end;
readln
END.
Avant de poster un message, vérifiez la date du sujet dans lequel vous comptiez intervenir.
Si le dernier message sur le sujet date de plus de deux mois, mieux vaut ne pas répondre. En effet, le déterrage d'un sujet nuit au bon fonctionnement du forum, et l'informatique pouvant grandement changer en quelques mois il n'est donc que rarement pertinent de déterrer un vieux sujet.
Au lieu de déterrer un sujet il est préférable :
soit de contacter directement le membre voulu par messagerie privée en cliquant sur son pseudonyme pour accéder à sa page profil, puis sur le lien "Ecrire un message"
soit de créer un nouveau sujet décrivant votre propre contexte
ne pas répondre à un déterrage et le signaler à la modération
Blond, bouclé, toujours le sourire aux lèvres...
Blond, bouclé, toujours le sourire aux lèvres...
Blond, bouclé, toujours le sourire aux lèvres...
Blond, bouclé, toujours le sourire aux lèvres...
Blond, bouclé, toujours le sourire aux lèvres...