algo pour faire la division entre 2 entier positifs sans MOD/DIV Fermé

Question

Bonjour, 

je veux un algo/programme qui permet de faire la division entre 2 entier positifs sans utiliser le DIV et le MOD (trouver le quotient de la division et son reste)

Merci

j'ai essayer avec cette algo mais j'ai un problème pour 24/2 j'obtiens qt=11.5 et reste=1: 
 program division;
 uses wincrt;
 var x,y,i,reste:integer;
           qt:real;
  begin

writeln('entre 2 nombre entier positifs');
   readln(x,y);

if y>x then begin
                x:=x+y;
                y:=x-y;
                x:=x-y;
                end;
          
    if x=y then
                         begin
                            qt:=1;
                            reste:=0;
                         end;
   for i:=1 to x do
    begin
  
                if (x/i)=y then
                         begin
                            qt:=x/y;
                            reste:=0;
                         end
            else
                         begin
                            qt:=(x-1)/y;
                            reste:=1;
                         end;
           end;
      writeln('le quotient de la division est ',qt:0:2,' et le reste est ',reste);     
   end.

nicocorico · Accepted Answer

Bonjour, 

Heeu, le but est de se passer de la division ou bien de réellement éviter "div"? Car la fonction "/" est un div en virgule flottante, la division est donc toujours là...

Si l'idée est bien de se passer de la division, il ne reste plus qu'à compter le nombre d'occurrences de cette manière: 

program division; uses wincrt; var x,y, qt:integer;  begin  writeln('entre 2 nombre entier positifs');   readln(x,y);  Qt:= 0;// On calcule x/y par itération en comptant simplement le nombre de passages   While x >= y do   begin      Dec(x, y);      Inc(Qt);   end;// x contient le reste et Qt le quotient.      writeln('le quotient de la division est ',qt,' et le reste est ', x);        end.

nicocorico · Answer

Ha oui d'accord, mais bon div ou "/", ça revient un peu au même! En fait il faut surtout se passer de l'utilisation de "mod" alors... mais dans ce cas pas de soucis non plus, il suffit de calculer le quotient tronqué comme tu as fais et de soustraire à la valeur initiale, et on peut simplifier le calcul du reste au passage: 

program division;uses wincrt;var a,b,qt:integer;         r:real;  { r est le reste de la division }    Begin        writeln('entrer 2 nombres entiers positifs a et b');        readln(a,b);        qt:= trunc(a/b);   { le quotient est egale a la partie entier de a/b }        r := a - qt*b;      { le reste est égal a la différence entre a et le quotient multiplié par b}        writeln('le quotient est ',qt,' le reste est ',r:0:0);    End.

Sinon en plus original et probablement hors de propos, tu peux le faire très facilement en assembleur, sachant que les langages de haut niveau utilisent très mal l'instruction de division puisque cette dernière permet de calculer le quotient et le reste d'un seul coup, mais eux n'ont pas d'astuce permettant de récupérer les deux résultats.
   Xor edx,edx  Mov eax,A  Div B  // Eax contient le quotient et edx le reste.


Quant à la méthode itérative, hé bien, on se contente de compter le nombre fois que l'on trouve b entier dans a, ce qui nous donne le quotient et le reste...

Algo pour faire la division entre 2 entier positifs sans MOD/DIV

2 réponses

Discussions similaires