
Vous avez remarqué, en tout cas pour les nombres à 4 chiffres, souvent, la suite se termine par 6174
EDIT: une petite stats qui ne sert à rien, mais dans 99% des cas, on trouve 6174! Plus exactement, on retrouve 8923 le chiffre 6174 sur les 9000
Modérateur : Politburo
Il est excellent ce petit programme !zpalm a écrit : ↑22 août 2018 16:13Je viens de mettre à jour mon programme pour 41C: passage de 52 à 47 pas et ajout de commentaires.
Ce n'etait pas vraiment un MPO car il n'appartient pas a la rubrique, mais il y a deja eu des codes assembleurs comme pour ce challenge.
Et aussi une version en microcode HP 41!
Code : Tout sélectionner
01 LBL A
02 0 // Indice du premier registre
03 X<>Y
04 SDR 001 // Première boucle: extraction des chiffres
05 IP // Nombre amputé du premier chiffre à droite
06 RCL L
07 FP // Premier chiffre à droite au format 0.a
// Boucle de sauvegarde par ordre décroissant
08 STO->Z // Sauvegarde du chiffre courant dans le registre courant
09 INC Z // Registre suivant
10 RDN // On récupère le nombre amputé
11 X#0? // S’il reste des chiffres à extraire
12 BACK 008 // on boucle
// A la sortie de boucle on a 0 dans X, et le nombre de registres dans Y
13 x<>Y
14 SDR 002 // Compteur de registres pour R-SORT
15 R-SORT // On trie les registres par valeur croissante
16 RCL L // On récupère le nombre de registres
17 <>ZZXX // X=Y=0, Z=T=nombre de registres
18 DEC T // On décrémente T pour en faire un index du registre courant
// Boucle de génération des nombres c et d de la formule
// Y va contenir d (le nombre avec les chiffres par ordre décroissant)
// X va contenir c (le nombre avec les chiffres par ordre croissant) au format 0.N
19 SDR 001 // On divise par 10 la valeur de c pour faire de la place pour le prochain chiffre : 0.0N
20 RCL+->T // On ajoute à c le chiffre courant (par ordre décroissant) au format 0.a -> 0.aN
21 X<>Y // On permute c et d
22 RCL+->T // On ajoute à d le chiffre courant -> N.a
23 SDL 001 // On multiplie d par 10 -> Na
24 X<>Y // On permute c et d
25 DSL T // On passe au chiffre suivant
26 BACK 007
27 SDL->Z // On décale à gauche 0.c du nombre de chiffres pour obtenir c
28 – // On soustrait pour obtenir K(n)
29 END // Le programme s’arrête avec le résultat dans X. Une pression sur A le relance
Bof, je le trouve un poil un peu long et il utilise un peu trop de registres et surtout des modules ou des HP-41 bien chères. Ah! Non zut, je confonds avec le listing ci-dessus pour la WPS !cgh a écrit : ↑22 août 2018 21:24Il est excellent ce petit programme !zpalm a écrit : ↑22 août 2018 16:13Je viens de mettre à jour mon programme pour 41C: passage de 52 à 47 pas et ajout de commentaires.
Dans ton programme, tu ne tries pas les chiffres mais tu comptes les occurences de ceux-ci et tu "recompose" les 2 nombres avec les chiffres en ordre decroissant et croissant. C'est ce que j'ai fait dans le programme assembleur pour PC-1500C.Ret a écrit : ↑23 août 2018 19:44Je propose 45 pas (avec le END final inclus comme il se doit), n'utilisant les registres R00 à R11 (soit douze registres) et ne nécessitant aucun module particulier, y compris module mémoire, même si vous ne possédez qu'une très modeste HP-41C. (Il vous faudra éventuellement 4 piles LR1 - mais bon tout le monde sait qu'il en faut 4 et pas 3 comme pour un HP-28S)
Ah! Ah! Et avec des nombres à trois chiffres, que disent les statistiques ?
Tu as bien raison, mon programme est trop long et utilise trop de registres. Un petit coup de MPOisation et voici une version allégée pour 41C de base: 44 pas et 10 registres (R00 à R09) maximum*.C.Ret a écrit : ↑23 août 2018 19:44Bof, je le trouve un poil un peu long et il utilise un peu trop de registres et surtout des modules ou des HP-41 bien chères. Ah! Non zut, je confonds avec le listing ci-dessus pour la WPS !![]()
Je propose 45 pas (avec le END final inclus comme il se doit), n'utilisant les registres R00 à R11 (soit douze registres) et ne nécessitant aucun module particulier, y compris module mémoire, même si vous ne possédez qu'une très modeste HP-41C.
Code : Tout sélectionner
01 LBL "K"
02 ENTER
03 LOG
04 INT // Nombre de chiffres du nombre en entrée -1
05 1 E-3
06 * // Conversion en compteur de boucles
07 CLRG // Efface les registres - à remplacer par CLRGX sur une 41CX*
09 X<>Y
09 LBL 01 // Première boucle: extraction des chiffres
10 10
11 /
12 INT // Nombre amputé du premier chiffre à droite
13 LASTx
14 FRC // Premier chiffre à droite au format 0.a
15 RCL Z // On récupère le compteur de boucles
16 STO L // On le stocke dans L pour la boucle suivante
17 LBL 02 // Boucle de sauvegarde par ordre décroissant dans les registres de 0 à 9
18 X<> IND L // On permute le registre courant avec la valeur initiale du compteur de boucles
19 X<=Y ? // Si le chiffre courant est > au nombre dans le registre courant
20 X<>Y // on permute
21 X<> IND L // pour stocker dans le registre courant le plus grand des deux et récupérer le compteur de boucles
22 ISG L // On passe au registre suivant
23 GTO 02 // Boucle autant de fois que le nombre initial a de chiffres
24 RCL Z // On récupère le nombre amputé
25 X#0? // S’il reste des chiffres à extraire
26 GTO 01 // on boucle
27 X<>Y // A la sortie de la boucle on a 0 dans X,Z,T et le compteur de boucles dans Y,
28 * // on prépare la pile pour la boucle finale :
29 10 // X=10, Y=0, Z=0, L=compteur de boucles
30 LBL 03 // Boucle de génération des nombres c et d de la formule
// Y/Z va contenir d (le nombre avec les chiffres par ordre décroissant)
// Z/T va contenir c (le nombre avec les chiffres par ordre croissant) au format 0.N
31 ST/ Y // On divise par 10 la valeur de c pour faire de la place pour le prochain chiffre : 0.0N
32 RCL IND L // On récupère le chiffre courant (par ordre décroissant) au format 0.a
33 ST+ Z // On l’ajoute à c -> N.a
34 ST+ T // et d -> 0.aN
35 RDN
36 ST* Z // On multiplie d par 10 -> Na
37 ISG L // On passe au chiffre suivant
38 GTO 03
39 LASTx // A la fin de la boucle on a le nombre de chiffres dans la partie entière du compteur
40 INT
41 Y^X
42 * // On multiplie .c par 10^nombre de chiffres pour obtenir c
43 – // On soustrait c de d pour obtenir K(n)
44 END // Le programme s’arrête avec le résultat dans X. Une pression sur Enter le relance
Pour l'alimentation en électricité de la 41, j'ai acheté ceci.
Code : Tout sélectionner
Min02 Sauf le monbre dans Mem02
1 Min06 Mem06 = 0 Coeff de multiplication par 10
20 MinF MemF=20 Borne du tableau pour le tri (0 à 9 +10)
0 Min04 Min05 Mem04 nombre chiffres croissant Mem05 Chiffres décroissants
LBL1 MR02 / 10 = INT * 10 = Min00 Mem00 Travail, contient le dernier chiffre du nombre
MR02 - MR00 + 10 = Min00 Tableau commence à la Mem10 (0=Mem10, 1=Mem11, ...)
1 IND M+00 Sert d'indexe pour ajouter 1 au tableau
MR02 / 10 = INT Min02 Enlève 1 chiffre au nombre
x=0 GOTO2 GOTO1
LBL2 10 Min00 Indexe du tableau
LBL3 IND MR00 x=0 GOTO4 Si la valeur du tableau =0 on passe
LBL5 MR04 * 10 + MR00 - 10 = Min04 Calcul la valeur du nombre en croissant
(MR00 - 10) * MR06 + MR05 = Min05 Calcul la valeur du nombre en décroissant
MR06 * 10 = Min06 Multiplie par 10 le Coeff
1 IND M-00 Soutrait 1 au tableau
IND MR00 x=0 GOTO4 GOTO5 Test si la valeur du tableau est à 0
LBL4 1 M+00 MR00 x=F GOTO6 GOTO3 Ajout 1 à l'indexe, jusqu'à 20
LBL6 MR05 - MR04 = Affiche le résultat