Bonjour,  
mon petit frère me demande de l'aider à trouver l'erreur qu'il a fait dans son programme (apparemment il ne marche pas!) j'en suis maintenant incapable.
Pourriez-vous l"aider?
Il s'agit du Codage binaire sur 16 bits d'un nombre entier relatif
Voilà son programme:
 
{$APPTYPE CONSOLE}
 
uses
SysUtils;
 
const  
taille=16;
 
type  Tabcode=array[1..taille] of integer;    
 
function LIRE_ENTIER:integer;
var nombre:integer;
begin
Writeln ('Quel nombre veux tu convertir en binaire?');  
Readln (nombre);
 
 While (nombre>32767) or (nombre<-32768) do
        begin
        Writeln ('Error!!! :-( Please try again!! Please enter another number!!!');
        Readln (nombre);
        end;
 
If nombre=0 then   //si l'entier à coder est nul, on donne directement le résultat
        begin
        Writeln ('Le nombre binaire est egal a 0000 0000 0000 0000');
        Readln;
        end;
 
Var
i : integer ;  
(puissance): integer;
(somme): integer;
 
Begin
i :=1;
(puissance) :=0;
(somme) :=0;
 
Repeat
i :=i*2  
(puissance) :=(puissance)+1
Until i>(nombre)
 
If i>(nombre) do
i :=i/2
(puissance) :=(puissance)-1
tabcode[puissance] :=1
 
tabcode[1;i]:=0
 
 
 
If i<(nombre) do
(somme) := i +i/2
 
 
Repeat
 
begin
If (somme)<(nombre)
then do tabcode[puissance] :=1
else        tabcode[puissance] :=0
 
(puissance) :=(puissance)-1
 
until (somme)=(nombre)
 
end
 
 
Merci de votre aide
 
 
 
 

Bonjour guigui97, je ne fait que rajouter la balise code=pascal pour que ce soit plus lisible.
Ceci dis, bien que je ne connaise pas grand chose au pascal, ça ne m'etonne  pas qu'il ne marche pas, qu'il ne compile pas, qu'il ne passe même pas la premiere epreuve que va lui infliger le compilateur.
 
J'ai retaper un peu la mise en page, l'indentation, et il y à des truc louche, amoins que je fabule
 
regarde !

{$APPTYPE CONSOLE}
 
uses SysUtils;
 
const taille=16;
 
type  Tabcode=array[1..taille] of integer;    
 
function LIRE_ENTIER : integer;
var nombre : integer;
begin
   Writeln ('Quel nombre veux tu convertir en binaire?');  
   Readln (nombre);
 
   While (nombre>32767) or (nombre<-32768) do
      begin
         Writeln ('Error!!! :-( Please try again!! Please enter another number!!!');
         Readln (nombre);
      end;
 
      If nombre=0 then   //si l'entier à coder est nul, on donne directement le résultat
         begin
            Writeln ('Le nombre binaire est egal a 0000 0000 0000 0000');
            Readln;
         end;
 
   Vari : integer ;  
   (puissance) : integer;
   (somme) : integer;
 
   Begin
      i :=1;
      (puissance) :=0;
      (somme) :=0;
 
      Repeat
         i :=i*2  
         (puissance) :=(puissance)+1
      Until i>(nombre)
 
      If i>(nombre) do
         i :=i/2
         (puissance) :=(puissance)-1
         tabcode[puissance] :=1
         tabcode[1;i]:=0
 
      If i<(nombre) do
         (somme) := i +i/2
 
      Repeat
         begin
            If (somme)<(nombre)  then do 
               tabcode[puissance] :=1
            else
               tabcode[puissance] :=0 
               (puissance) :=(puissance)-1
      until (somme)=(nombre)
         end

 
en plus, je ne sais si c'est normal, mais il y à des if avec des then et d'autre sans, bon, tu me dira, nous somme dans algo   , et en fin de code le end doit etre mal placé si je suis la logique du début de code.
 
N'y aurait-il pas moyen de faire un tableau de booléen au lieu d'un tableau d'entier comme resulta ? ce serais tout de même plus representatif.
 
Pour l'algo en lui même, je repasse dans un moment, si tu me permé.

Merci Jovalise, j'ai fait du turbopascal il y a déjà un petit moment; j'ai cru que je pourrai l'aider mais vraiment je n'arrive pas du tout à me remettre dedans.  

Je n'ai pas terminé, mais voici un code qui compile cher moi avec fpc (Free Pascal compiler)
j'ai fait quelque correction de bon sens à priori, tu refera les modifications que tu souhaitera !  

//{$APPTYPE CONSOLE}
 
 
program main;
uses SysUtils;
const taille  = 16;
type  Tabcode = array[1..taille] of integer;    
 
 
var nombre : integer;
i      : integer ;
puissance : integer;
somme      : integer;
   tab      : tabcode;   
 
begin       
   Writeln ('Quel nombre veux tu convertir en binaire?');  
   Readln (nombre);
   While (nombre>32767) or (nombre<-32768) do
      
      Writeln ('Error!!! :-( Please try again!! Please enter another number!!!');
      Readln (nombre);
   ;
   If nombre = 0 then   //si l'entier à coder est nul, on donne directement le résultat
 
      Writeln ('Le nombre binaire est egal a 0000 0000 0000 0000');
      Readln;
 
   i :=1;
   puissance :=0;
   somme :=0;
   Repeat
      i :=i*2;
      puissance :=puissance+1;
   Until i>nombre;
   If i>nombre then
      i :=i div 2;
   puissance :=puissance-1;
   tab[puissance] :=1;
   tab[i]:=0;
 
   If i<nombre then
      somme := i + i div 2;
   Repeat
      If (somme)<nombre  then
         tab[puissance] :=1
       else
         tab[puissance] :=0 ;
      puissance :=puissance-1;
 
   until somme=nombre;
end.

 
je me met à l'algo. ... mois aussi, ça fait 10 ans que je n'ai pas fait de Pascal  

Ah, au fait, que doit faire ce petit programme exactement ?

C'est pas evident à corriger pour un beaotien, mais j'en suis la, le programme donne des resultats divers en fonction du nombre entré. Peut-tu regardé si ça correspond à peut près à ce que tu as voulu ecrire ?

//{$APPTYPE CONSOLE}
program main;
uses SysUtils;
const taille     = 16;
type  Tabcode    = array[1..taille] of integer;    
 
var
   nombre    : integer;
   i         : integer ;
   puissance : integer;
   somme     : integer;
   tab         : tabcode;   
 
begin       
   Write ('Quel nombre veux tu convertir en binaire?');
   Readln (nombre);
   While (nombre > 32767) or (nombre<-32768) do
      begin
     Writeln ('Error!!! :-( Please try again!! Please enter another number!!!');
     Readln (nombre);
      end;
   ;
   If nombre = 0 then   //si l'entier à coder est nul, on donne directement le résultat
      Writeln ('Le nombre binaire est egal a 0000 0000 0000 0000')
   else
     begin
       i :=1;
       puissance :=0;
       somme :=0;
       Repeat
         i :=i*2;
         puissance :=puissance+1;
 
       Until i>nombre;
 
       If i>nombre then
         begin
           i :=i div 2;
           puissance :=puissance-1;
           tab[puissance] :=1;
     end;
 
       tab[i]:=0;
 
       If i<nombre then
       begin
         somme := i + i div 2;
         Repeat
           If somme < nombre  then
              tab[puissance] :=1
            else
              tab[puissance] :=0
            ;
            puissance :=puissance-1;
     until somme=nombre;
       end;
       Write ('; Le nombre binaire est egal a : ');
       for i := 0 to 15 do
         write (tab[i]);
     end;
   ;
end.

Voici les 16 resultats pour les 16 premiers entier naturel 1..16
les ligne vide corresponde à un ctrl-C pour interrompre le programme qui tourne dans le vide ou plante. Le resultat pour 3, 6  est stupefiant   Quant à celui du 12 c'est de la moquerie je crois      
 

 
Pour la representation des negatifs, je suis pas sur que ce code le preine en concideration  

C'est vraiment sympa d'avoir travaillé sur ce programme   Merci
Je ne peux pas le tester ici.
Si je comprends bien, il ne marche pas pour tous les nombres

Non, en effet, mon algo est incorrecte.
Si tu pouvais relire mon code pour voir si je ne me suis pas planté à la premiere retouche ??
j'ai traduit tout simplement par exemple "Tabcode[1;i] := 0" par "Tab[i] := 0;" car je ne connais pas, comme mon compilateur, l'expression '[1;i]'. Vas y de bon coeur sur tes remarques éventuelles.

Je pense en effet que ce n'est tabcode[1;i] mais peut être tabcode[1..i]

C'est pour initialisation ? n'est-ce pas ?

Enfin pour introduire des valeurs dans un tableau

Comme je ne pensais pas que ton algo calculait la valeur de plusieur bit à la fois, et que tu souhaitais affecter le tableau de 1 à i, je me disais que c'était pour l'initialiser
ça s'écrit ainsi à priori ::=

tab       : tabcode  = (false,false,false,false,false,false,false,false,false,false,false,
false,false,false,false,false);

mon algo ne calcule pas plusieurs bit à la fois, mais il les calcule bit par bit. En commencant par le premier bit à 1. En partant vers la droite il complète soit par 0 soit par 1. Et à la fin, ce serait bien que chaque case vide corresponde à un 0.

Voila, donc, en initialisant le tableau avec des 0, nous n'avons pas à nous soucier des bits non traité et même, nous pouvons ne rien faire lorsque le bit doit rester à 0.
 
Mais à vrai dire, l'algorithme en lui même me pose problème,
j'ai oublier comment convertir une representation base10 en représentation base2  

Désolé de ne pouvoir répondre, je n'arrive pas à joindre mon frère....il doit être en cours.
Avec un peu de chance, il aura avancé!

Bonjour guigui97, bonjour à tous
Petite question ... sais-tu ... ou quelq'un pourait-il dire, quelles sont les representations binaire possibles de nombre signé ?
je sais qu'il y a grand et petit boutiste, mais je ne sais pas exactement comment est codé un nombre negatif.
Comment s'ecrive 32767 et -32768 en binaire en notation signée ?
 
Merci,

La question reste entiere !!
 
 
 
A part ça, j'ai fais ça en Ada ::=  

for I in reverse 0..15 loop
     if Nombre_A_Convertir - 2**I >= 0 then
         Resultat(I+1) := True;
         Nombre_A_Convertir := Nombre_A_Convertir - 2**I;
     end if;
 end loop;

 
Ce qui colle avec ça (que je viend de decouvrir, c'est cool   , merci djobidjoba et consort)::=

 
 
Il n'y a plus qu'à l'ecrire en Pascal  

Donc, voila pour les positif en notation non signé à priori
 

repeat   
          begin
            if (nombre - 2**i) >= 0 then
              begin
                tab[i+1] := true;
                nombre := nombre - 2**i;
              end;
          end;
          i := i - 1;
       until i < 0;
       ;

Bonjour, c'est pour une representation !    
 
Comment représente t-on un entier relatif en binaire petit et/ou gros boutiste ?    
 
(j'ai prèté mon bouquin ... à une copine   )  
 
Merci  
 
Edit ::= je vous prie de bien vouloir m'excuser, j'ai pas encore pris la bonne abitude de demander à google ...
 
je vien de trouver ça donc ::=

 
Mais alors, on perd un bit  

Ce qui nous amène à ça "finalement" (si je ne m'abuse):=
 

// Pour un entier relatif codable sur 15 bits (16 moins 1 bit de perdu, bref) 
    i := 13
    repeat   
            if nombre < 0 then
              begin
                tab[1] := true;
                nombre := nombre * (-1);
              end;
            if (nombre - 2**i) >= 0 then
              begin
                tab[i+3] := true;
                nombre := nombre - 2**i;
              end;
          end;
          i := i - 1;
    until i < 0;

 
Mais c'est louche parce que 2**14 (16 - 1 bit de perdu - 1 bit de signe) = 16384 et non 32767.
En plus je n'ai jamais compris pourquoi sur 16 bits nous pouvions, a priori, coder 32767 max ou -32768 min   , c'est que je ne suis pas une fleche en math peut-etre  

 
Sur 16 bits on a 2**16 valeurs (nb pair) donc avec le zéro, tu ne peux pas avoir autant de valeurs supérieures et inférieures à zéro.
Il faut donc choisir de quel côté tu en met un de plus, et ça c'est le boulot des commités de normalisation.
Dans ce cas précis, en complément à 2, tu as un négatif de plus que les strictements positifs.
 
ps: ce topic, c'est plus du pascal que de l'algo...

Merci apprentitux !
le zero, je n'y pensais pas   .
 

 
C'est de l'algo Pascalien    

en C: