##############################################
# ADDITION DES VALEURS NON-NULLES SUR L'ENTREE
# R[1] CONTIENT LA MISE A JOUR DE LA SOMME
##############################################
LOAD #0  ; ACC ← 0
STORE 1  ; R[1] ← 0 // SOMME
READ     ; ACC ← ENTREE[i++]
JUMZ 8   ; SI ACC = 0 STOP
ADD 1    ; ACC ← ACC + R[1]
STORE 1  ; R[1] ← ACC
JUMP 2   ; ON RECOMMENCE
LOAD 1   ; ACC ← R[1]
WRITE    ; SORTIE[j++] ← ACC
STOP     ; ARRET

##############################################
# ADDITION DES VALEURS NON-NULLES SUR L'ENTREE
# AVEC COMPTAGE DU NOMBRE DE CES VALEURS
# R[1] CONTIENT LA MISE A JOUR DE LA SOMME
##############################################
LOAD #0  ; ACC ← 0
STORE 1  ; R[1] ← 0 // SOMME
STORE 2  ; R[2] ← 0 // COMPTEUR
READ     ; ACC ← ENTREE[i++]
JUMZ 9   ; SI ACC = 0 STOP
INC 2    ; R[2] ← R[2] + 1
ADD 1    ; ACC ← ACC + R[1]
STORE 1  ; R[1] ← ACC
JUMP 3   ; ON RECOMMENCE
LOAD 1   ; ACC ← R[1]
WRITE    ; SORTIE[j++] ← ACC
LOAD 2   ; ACC ← R[2]
WRITE    ; SORTIE[j++] ← ACC
STOP     ; ARRET

##############################################
# "CALCUL" DE LA FACTORIELLE
# R[1] CONTIENT LES VALEURS DECROISSANTES DE n
# R[2] CONTIENT LA MISE A JOUR DE n!
##############################################
LOAD #1  ; ACC ← 1
STORE 2  ; R[2] ← 1
READ     ; ACC ← ENTREE[i++]
STORE 1  ; R[1] ← n
LOAD 1   ; ACC ← R[1]
JUMZ 10  ; SI (n = 0) ECRITURE DE R[2]
MUL 2    ; ACC ← ACC * R[2]
STORE 2  ; R[2] ← ACC
DEC 1    ; R[1] ← R[1] - 1
JUMP 4   ; ON RECOMMENCE
LOAD 2   ; ACC ← R[2]
WRITE    ; SORTIE[j++] ← ACC
STOP     ; ARRET

##############################################
# "CALCUL" DE LA FACTORIELLE MODIFIE ARRETANT
# LE CALCUL SI n > 7
# R[1] CONTIENT LES VALEURS DECROISSANTES DE n
# R[2] CONTIENT LA MISE A JOUR DE n!
##############################################
LOAD #1  ; ACC ← 1
STORE 2  ; R[2] ← 1
READ     ; ACC ← ENTREE[i++]
STORE 1  ; R[1] ← n
LOAD #7  ; ACC ← 7
SUB 1    ; ACC ← 7 - R[1]
JUML 15  ; SI (ACC = 0) FIN  
LOAD 1   ; ACC ← R[1]
JUMZ 13  ; SI (n = 0) ECRITURE DE R[2]
MUL 2    ; ACC ← ACC * R[2]
STORE 2  ; R[2] ← ACC
DEC 1    ; R[1] ← R[1] - 1
JUMP 7   ; ON RECOMMENCE
LOAD 2   ; ACC ← R[2]
WRITE    ; SORTIE[j++] ← ACC
STOP     ; ARRET

##############################################
# "CALCUL" DE LA PLUS PETITE VALEUR ET SA
# POSITION SUR LA BANDE
# R[1] : INDICE COURANT i
# R[2] : L[i]
# R[3] : INDICE idxmin
# R[4] : L[idxmin]
##############################################
LOAD #0   ; ACC ← 0
STORE 1   ; R[1] ← 0 // i
STORE 3   ; R[3] ← 0 // idxmin
READ      ; ACC ← ENTREE[i++]
STORE 2   ; R[2] ← ACC // L[i] 
STORE 4   ; R[4] ← ACC // MINIMUM
JUMZ 23   ; SI (R[2] = 0) ALORS FIN
INC 1     ; R[1] ← R[1] + 1 // i ← i + 1 
READ      ; ACC ← ENTREE[i++]
JUMZ 19   ; SI (ACC = 0) ALORS ECRIRE RESULTAT
STORE 2   ; R[2] ← ACC 
SUB 4     ; ACC ← ACC - R[4]
JUML 14   ; SI (ACC < 0) ALORS VERS MISE A JOUR
JUMP 7    ; ON PASSE AU SUIVANT
LOAD 1    ; ACC ← R[1] // MISE A JOUR :
STORE 3   ; R[3] ← ACC // idxmin ← i
LOAD 2    ; ACC ← R[2] // MISE A JOUR :
STORE 4   ; R[4] ← ACC // MINIMUM
JUMP 7    ; ON PASSE AU SUIVANT
LOAD 4   ; ACC ← R[4] // ECRITURE DU MIN
WRITE    ; SORTIE[j++] ← ACC
LOAD 3   ; ACC ← R[3] // ECRITURE DE SON INDEX
WRITE    ; SORTIE[j++] ← ACC
STOP     ; ARRET

##############################################
# ALGORITHME DU TRI SELECTION D'UNE LISTE L
# REGISTRES R[1] 1 R[5] RESERVES POUR CALCUL
# VALEURS L[i] RANGEES EN R[5+i]
# R[5] JOUE LE RÔLE DE i DANS L[i]
##############################################
LOAD #6     ; ACC ← 6 (IDX DU 1ER REGISTRE DE L)
STORE 5     ; R[5] ← ACC (1ER IDX DE L DANS R[5])
READ        ; ACC ← ENTREE[i++] (LECTURE DE LA LISTE)
STORE @5    ; R[R[5]] ← ACC (R[IDX] ← L[i] POUR IDX = i + 6)  
INC 5       ; R[5] ← R[5] + 1 (IDX ← IDX + 1) 
JUMG 2      ; SI ACC > 0 POURSUIVRE LECTURE DE L
JUMZ 2      ; SI ACC = 0 POURSUIVRE LECTURE DE L
LOAD 5      ; ON VA TESTER SI |L| < 2
SUB #8      ; ON SOUSTRAIT 8 
JUML 32     ; SI |L| < 2 => L'AFFICHER
LOAD #6     ; ACC ← 6 (IDX 1ER REGISTRE DE L)
STORE 5     ; R[5] ← 6 (1ER IDX DE L DANS R[5])
LOAD 5      ; ACC ← R[5] CHARGEMENT DE IDXMIN
STORE 4     ; R[4] ← R[R[5]]  R[4] = IDX
LOAD 4      ; ACC  ← IDX  CHARGEMENT IDX
STORE 3     ; R[3] ← IDX  MISE A JOUR IDXMIN ← IDX
INC 4       ; IDX ← IDX + 1
LOAD @4     ; ACC ← R[4] ON VA TESTER SI FIN DE LISTE
JUML 22     ; SI FIN DE LISTE > SUITE
SUB @3      ; ACC ← R[IDX] - R[IDXMIN]
JUML 14     ; SI ACC < 0 ALORS NOUVEAU MIN ET MISE A JOUR
JUMP 16     ; SINON ON CONTINUE
LOAD @5     ; ACC ← R[5] (CHARGE L'ELEMENT EN TETE DE LISTE RESTANTE)
STORE 2     ; ON LE RANGE DANS R[2]
LOAD @3     ; ACC ← MINIMUM (CHARGE LE MINIMUM)
STORE @5    ; R[R[5]] ← MININUM
LOAD 2      ; ON RECUPERE LA VALEUR
STORE @3    ; ON A FINI DE PERMUTER AVEC LE MIN
INC 5       ; LA POSITION DE DEPART DU PROCHAIN BALAYAGE AVANCE
LOAD @5     ; ACC ← VALEUR A TESTER POUR FIN DE LISTE
JUML 32     ; SI ACC < 0 ALORS FIN DE LA LISTE => ON L'AFFICHE
JUMP 12     ; SINON ON RECOMMENCE
LOAD #6     ; ACC ← 6 (ON CHARGE L'INDEX DU DEBUT DE LA LISTE)
STORE 4     ; R[4] ← 6 (ON LE RANGE DANS R[4] = IDX)
LOAD @4     ; ACC ← R[R[4]] (ON CHARGE R[IDX])
JUML 39     ; SI ACC < 0 => FIN DE LISTE ON ARRETE
WRITE       ; SORTIE[j++] ← ACC SINON ON ECRIT
INC 4       ; IDX ← IDX + 1 (ELEMENT SUIVANT DE LA LISTE)
JUMP 34     ; ON RECOMMENCE
STOP        ; FIN DU PROGRAMME