Discussion :

[camjea]

Bonour,

je fais comme option isn en terminale et j'ai comme consigne de programmer un algoritme sur algobox permettant d'effectuer des additions en binaire.
Je n'y arrive pas du tout, pouvez vous m'aider ?

Merci

[Flodelarab]

Bonjour

Fabrique un demi-additionneur, c'est-à-dire un additionneur de 1 bit. Ça peut prendre la forme de 2 fonctions: une pour le résultat, et une pour la retenue.

Résultat:
0+0->0
0+1->1
1+0->1
1+1->0
(Tiens, ça ressemble à la fonction logique XOR, "ou exclusif")

Retenue:
0+0->0
0+1->0
1+0->0
1+1->1
(Tiens, ça ressemble à la fonction logique ET)

Ensuite, il suffit de les enchaîner. N'oublie pas qu'à chaque étape (chiffre de A et B), il y a a_i, b_i mais aussi r_i, retenue de la demi-addition précédente.

[e-ric]

Bonour,

je fais comme option isn en terminale et j'ai comme consigne de programmer un algoritme sur algobox permettant d'effectuer des additions en binaire.
Je n'y arrive pas du tout, pouvez vous m'aider ?

Merci

Quel rapport avec Pascal ? Je ne suis pas sûr qu'il y ait beaucoup de spécialistes AlgoBox ici. Cela a l'air assez verbeux.
Tu veux faire une addition en binaire ? comment la ferais-tu en décimal ? Ben, c'est la même chose mais avec moins de chiffres, il te faut additionner les chiffres un à un en tenant compte de la retenue, en partant de l'unité (je parle de nombres entiers) jusqu'à l'ordre de grandeur le plus grand des tes nombres.

Il faut ramener les deux nombres à la même longueur, en complétant le plus petit avec des 0 à gauche. Tu initialises la retenue à 0.

Pour chaque rang de chiffres, tu applique la règle suivante :

Retenue	Chiffre 1	Chiffre 2	Somme	Nouvelle retenue
0	0	0	0	0
0	0	1	1	0
0	1	0	1	0
0	1	1	0	1
1	0	0	1	0
1	0	1	0	1
1	1	0	0	1
1	1	1	1	1

Du fait du report de la retenue, la taille de ton nombre binaire résultat doit être égale à celle du plus grand des deux nombre + 1.

Avec cela je pense que tu peux déjà avancer.

Cdlt

[Roland Chastain]

Pour illustrer les explications d'e-ric, une proposition en Pascal. Au lieu de choisir un type plus grand pour le résultat, j'ai prévu une variable "erreur".

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
program AdditionBinaire;
{$MODE OBJFPC}
 
{
       111 
    10101010
  + 00001111
  ----------
    10111001
}
 
procedure Addition(const aNombre1, aNombre2: byte; var aResultat: byte; var aErreur: boolean);
var
  lRetenue: boolean;
  i, j: integer;
begin
  aResultat := 0;
  aErreur := FALSE;
  lRetenue := FALSE;
 
  for i := 1 to 8 do
  begin
    j := 0;
 
    if lRetenue then Inc(j);
    if aNombre1 and (1 shl (i - 1)) > 0 then Inc(j);
    if aNombre2 and (1 shl (i - 1)) > 0 then Inc(j);
 
    if j in [1, 3] then
      aResultat := aResultat or (1 shl (i - 1));
 
    lRetenue := j >= 2;
 
    if i = 8 then
      aErreur := lRetenue;
  end;
end;
 
procedure Test(const aNombre1, aNombre2, aResultatAttendu: byte; const aErreurAttendue: boolean);
var
  lResultat: byte;
  lErreur: boolean;
begin
  Addition(aNombre1, aNombre2, lResultat, lErreur);
  if (lErreur = aErreurAttendue) or (lResultat = aResultatAttendu) then
    WriteLn('OK');
end;
 
begin
  Test(%00000001, %00000001, %00000010, FALSE);
  Test(%00000001, %00000010, %00000011, FALSE);
  Test(%10101010, %00001111, %10111001, FALSE);
  Test(%11111111, %00000001, %00000000, TRUE);
 
  ReadLn;
end.

AlgoBox en soi, c'est un produit très bien fait, on ne dit pas le contraire, mais c'est un peu comme faire du vélo sur un vélo d'appartement. On ne risque pas de tomber, mais on ne risque pas non plus de s'amuser. Au lieu d'apprendre à utiliser AlgoBox, on pourrait apprendre à utiliser un compilateur Basic, ou C, ou Pascal... Un vrai vélo.

[e-ric]

Salut Roland,

Je n'ai pas approfondi le sujet d'Algobox, je ne veux pas me dissiper avec cela et je pense que ce genre d'outil n'apporte pas grand chose.
Tôt ou tard, il faut passer à un outil "sérieux" et perdre une partie de l'expérience acquise avec ce genre d'ersatz... mais camjea n'a sans doute pas trop le choix. Les profs sont comme tout le monde, ils ne font pas toujours des choix judicieux.

Sur le site d'Algobox, j'ai adoré les arguments de "vente" (je blague, c'est gratuit):
- "L'utilisateur n'a donc pas à apprendre toute une syntaxe complexe", il suffit de regarder l'exemple pour douter, Python et Pascal ont des syntaxes bien plus légères.
- "un logiciel centré sur l'algorithmique (et pas sur l'apprentissage d'une syntaxe spécifique à un langage particulier);" il faut néanmoins apprendre la syntaxe de ce langage algorithmique qui n'a pas d'autre finalité que les programmes de l'Education Nationale, on est en plein délire marketing.

Plus une perte de temps qu'un réel atout... Le seul avantage est le grapheur intégré, c'est toujours amusant.

Pour débuter, j'aurais privilégié Python, syntaxe moderne et simple, des constructions pratiques qui boostent la vitesse de codage. L'environnement interprété permet de tester rapidement des bouts de code. Les mots-clés sont en anglais mais en petit nombre, ce qui ne devrait pas gêner des lycéens. On va me reprocher de ne pas promouvoir Pascal, je le pratique toujours (un peu moins depuis quelques temps) et j'aime bien cela.

Pour ton exemple, tu aurais dû éviter de passer par des opérateurs binaires, camjea risque de trouver cela compliqué, vue sa question. J'aurais utilisé des chaînes de caractères.

Bon, on va attendre la suite avec camjea, il pourra peut-être donner des précisions sur le type de données à mettre en oeuvre.

Cdlt

[camjea]

Merci beaucoup pour toutes vos réponses,
En fait en fin de cours le prof nous a donné comme consigne de faire un algorithme sur l'addition binaire et le programmer soit dans Algobox, soit en Python, soit sur notre calculatrice. Cependant je ne comprends pas encore très bien python j'ai plus utilisé allo px pour l'instant
je sais comment additionner en binaire "manuellement", sans programme mais je n'arrive pas a programmer un algorithme pour cela..

[e-ric]

Salut,

Entre Python et AlgoBox, Python sans hésitation. Ce langage est bien implanté et sa communauté est très vivante, il évolue constamment et possède énormément de bibliothèques pour des besoins très variés. Des outils comme AlgoBox sont trop limités. Python te demandera un effort au début mais on s'y fait très vite, le fait qu'il soit un interpréteur est d'une grande aide pour les débutants. En outre, ce que tu auras appris sur Python pourra toujours te servir plus tard même si tu ne deviens pas informaticien, c'est toujours pratique pour faire des calculs. Je te conseille les tutoriels du site pour commencer dont le réputé Swinnen.

Si tu choisis Python, il faudra passer cette discussion dans le forum python. Avec AlgoBox, le mieux serait de passer dans le forum http://www.developpez.net/forums/f60...algorithmique/.

Pour revenir à ton problème, il te faut déjà déterminer avec quel type de donnée tu vas travailler, de là découleront les opérations (fonction, opérateur) que tu pourras utiliser pour résoudre ton problème. Cela peut être :
- une chaîne de caractères
- une liste ou un tableau de chiffre
- ou un nombre en accédant à ses bits comme l'a fait Roland

Ecris en français sur papier ensuite la méthode pour additionner, trouves ensuite les instructions qui remplaceront les mots en français dans le langage choisi.

Cdlt

[Roland Chastain]

C'est vrai qu'avec des caractères le code est plus parlant.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
program AdditionBinaire2;
{$MODE OBJFPC}
 
type
  octet = array[1..8] of '0'..'1';
 
procedure Addition(const aNombre1, aNombre2: octet; var aResultat: octet; var aErreur: boolean);
var
  lRetenue: boolean;
  i, j: integer;
begin
  aResultat := '00000000';
  aErreur := FALSE;
  lRetenue := FALSE;
 
  for i := 1 to 8 do
  begin
    j := 0;
 
    if lRetenue then Inc(j);
    if aNombre1[9 - i] = '1' then Inc(j);
    if aNombre2[9 - i] = '1' then Inc(j);
 
    if j in [1, 3] then
      aResultat[9 - i] := '1';
 
    lRetenue := j >= 2;
 
    if i = 8 then
      aErreur := lRetenue;
  end;
end;
 
procedure Test(const aNombre1, aNombre2, aResultatAttendu: octet; const aErreurAttendue: boolean);
var
  lResultat: octet;
  lErreur: boolean;
begin
  Addition(aNombre1, aNombre2, lResultat, lErreur);
  if (lErreur = aErreurAttendue) or (lResultat = aResultatAttendu) then
    WriteLn('OK');
end;
 
begin
  Test('00000001', '00000001', '00000010', FALSE);
  Test('00000001', '00000010', '00000011', FALSE);
  Test('10101010', '00001111', '10111001', FALSE);
  Test('11111111', '00000001', '00000000', TRUE);
  ReadLn;
end.