TP Ordinapoche

Préliminaires

  1. Créer le répertoire Ordinapoche dans votre répertoire de travail (man mkdir).
  2. Faire d'Ordinapoche votre répertoire de travail (man cd).
  3. Lancer l'exécutable ordinapoche.py.

Exercice 1. Langage machine vs langage Python

Soit le programme suivant :

====  ===========  ============
Adr.  Instruction  Commentaires
====  ===========  ============
00    INP N
01    CLA N
02    STO N
03    TAC 06
04    OUT N        divisible
05    HRS
06    SUB un
07    TAC 10
08    OUT N        non divisible
09    HRS
10    SUB un
11    TAC 14
12    OUT N        non divisible
13    HRS
14    SUB un
15    JMP 02
...   ...
20    1            un
21                 N
====  ===========  ============
  1. Exécuter le programme ci-dessus pour les valeurs successives suivantes : 10, 27 et 0.
  2. A partir du peu de commentaires associés au programme et des jeux d'essais ci-dessus, déterminer le rôle de ce programme. Quelle est la double fonction de la variable N ?

Exercice 2. Décomposition d'une opération simple

L'Ordinapoche n'intègre pas l'opérateur arithmétique de multiplication X. Pour réaliser la multiplication de a par b (avec b >= 1) on doit donc effectuer b-1 additions en effet :

a x b = a + a + ... + a (b fois)

On procède de la façon suivante :

1. on saisit au clavier les valeurs respectives de a et de b et on les stocke en mémoire
2. on initialise un mot-mémoire (une variable P) à la valeur de a
3. on initialise un mot-mémoire (un compteur C) à b-1
4. si le compteur C est strictement supérieur à zéro alors

   a. on calcule P+a et on stocke ce résultat dans le mot-mémoire correspondant à P
   b. on décrémente le contenu du mot-mémoire correspondant au compteur C (C décroît de 1)
   c. on recommence à l'étape 4

5. on affiche la valeur du mot-mémoire correspondant à P
  1. Ecrire le programme correspondant pour l'Ordinapoche.
  2. Exécuter votre programme pour a=6 et b=13, quel est le résultat obtenu ?
  3. Exécuter votre programme pour a=237 et b=8, quel est le résultat ? Est-il correct ? Expliquer ce qui s'est passé.
  4. pour a=2 et b=0, lancer l'exécution pas à pas et surveiller le contenu des cases mémoires correspondant à C et P. Que se passe-t-il ? Expliquer. Corriger le programme s'il ne traitait pas ce cas.

Exercice 3. Variations sur les entiers

Il y a deux difficultés dans cette suite d'exercices : la première c'est la programmation d'une structure répétitive, la seconde c'est la traduction de la condition d'arrêt en n'ayant à sa disposition que l'instruction TAC.

Pour des raisons de simplicité, on supposera que les données entrées respectent les énoncés.

  1. Ecrire un programme qui demande un entier N pair (1 < N < 999) et qui affiche tous les entiers pairs compris entre 1 et N (inclu) dans cet ordre.
  2. Ecrire un programme qui demande deux entiers A et B (avec B > A) et qui affiche tous les entiers compris entre A et B (inclus) dans cet ordre. Conseil : prendre garde à éviter toute soustraction qui ne donnerait pas un résultat positif ou nul.
  3. Ecrire un programme qui demande un entier N (0 < N < 1000) et qui affiche 1 si N est impair ou qui affiche 2 si N est pair. Conseil : progresser à petits pas (unitaire).

Exercice 4. Minimum de deux entiers.

Ecrire un programme qui demande deux entiers A et B (0 < A, B < 999) et qui détermine puis affiche le plus petit des deux.

Exercice 5. Le nombre secret

Ce petit jeu consiste à deviner un nombre compris entre 1 et 999 préalablement mémorisé par l'Ordinapoche (à l'adresse 50 par exemple, ce nombre est donc une donnée prédéfinie du programme). En fonction de la proposition de l'utilisateur, l'Ordinapoche doit afficher 0 si le nombre proposé est plus petit que le nombre à deviner ou afficher 1 si le nombre proposé est plus grand que le nombre à deviner.

  1. La principale difficulté de cet exercice est l'existence d'une seule instruction conditionnelle (TAC) et l'incapacité qu'à l'Ordinapoche de traiter les nombres négatifs ; il faut donc adopter l'algorithme suivant qui traite une proposition (nb_o est le nombre à chercher, nb_u est le nombre proposé par l'utilisateur) :
cpt = 1
si nb_o - cpt == 0 alors
    si nb_u - cpt == 0 alors
        afficher("trouvé")
    sinon
        afficher("trop grand")
sinon
    si nb_u - cpt == 0 alors
        afficher("trop petit")
    sinon
        cpt = cpt + 1

Ecrire le programme correspondant.

  1. Modifier le programme de tel sorte que le nombre s'affiche ainsi que le nombre de coups qui vous ont été nécessaire pour le trouver.

Exercice 6. Instructions vs données

Soit le programme suivant, exécutable par l'Ordinapoche :

====  ====  ===========  ===========
Adr.  Code  Instruction  Explication
====  ====  ===========  ===========
00    702   JMP 02
01    002
02    200   CLA 00
03    501   SUB 01
04    305   STO 05
05    900   HRS
====  ====  ===========  ===========

Commenter et expliquer ce programme.

Exercice 7. Calcul de moyenne

Ecrire un programme qui calcule la moyenne (entière par valeur inférieure) d'une suite de nombres, chacun d'eux compris entre 1 et 20, dont le premier terme est à l'adresse 50 et dont le dernier terme précède la valeur 0 (qui marque la fin de la suite et qui est d'adresse maximale 99).

On procèdera de la façon suivante : calcul de la somme de tous les termes de la suite ainsi que du nombre de termes, puis calcul de la moyenne en effectuant une soustraction successive du total par le nombre de terme (en prenant une nouvelle fois garde de ne pas dépasser la valeur 0).

Exercice 8. Racine carrée entière

Ecrire un programme qui calcule le plus grand carré d'entier inférieur ou égal à un nombre compris entre 2 et 999 entré au clavier et qui affiche la racine carrée entière correspondant.

Pour écrire un programme efficace, on s'appuiera sur la propriété suivante :

racine carrée