[Résolu] Base 9 sans nombre 0

[Micoute]

C'est très bon ton système et d'ailleurs G-Rom m'avait concocté une procédure utilisant une map, j'étais content de moi, car j'étais sûr que c'était ça la réponse, mais on m'a fait savoir : pas de liste, pas de map, pas d'appel à la procédure de codage, c'est pourquoi j'ai créé la procédure que je soumet à la bonne volonté de tous et j'ai vraiment hâte d'en finir.

[Réédit]
Il m'est venu une idée : Si on connaissait la valeur de certains repères, par exemple 100, 2000, 3000, ... 1000000, il nous suffirait de compter qu'à partir du nombre le plus proche d'un repère et d'y ajouter la valeur adéquate !!!

[graph100]

Moi ce que j'ai du mal à comprendre c'est ton truc de base 9 sans 0...
Es-ce que ça veut dire que c'est une base 8 mais décalée ?
Quelle est la valeur de "9", es-ce que ça remplace le 0 ?

lorsque tu comptes : 1 2 3 4 5 6 7 8 9 11 12 13 14 15 16 17 18 19 21 22 etc ??
je me trompe ou bien ?

Parce que tout vos algorithmes sont incrémentaux, pour un grand nombre c'est bcp trop long, la conversion doit être possible simplement.

[GallyHC]

Bonjour,

Ce que je comprend en relisant tout ce que tu as dit, c'est que tu as des trucs du genre

Code : Tout sélectionner

"18663401533905206495501220"

et cela te donne en décomposant :

Code : Tout sélectionner

"186634"
"15339"
"52"
"64955"
"122"

Maintenant ma question, tu dois faire quoi avec tout cela ?

Cordialement,
GallyHC

[Micoute]

Moi ce que j'ai du mal à comprendre c'est ton truc de base 9 sans 0...
Es-ce que ça veut dire que c'est une base 8 mais décalée ?
Quelle est la valeur de "9", es-ce que ça remplace le 0 ?

lorsque tu comptes : 1 2 3 4 5 6 7 8 9 11 12 13 14 15 16 17 18 19 21 22 etc ??
je me trompe ou bien ?

Parce que tout vos algorithmes sont incrémentaux, pour un grand nombre c'est bcp trop long, la conversion doit être possible simplement.

Bonjour graph100 et merci aussi à toi pour ton intéressement, non ce n'est pas une base 8 décalée, ce serait trop simple, on compte les chiffres normalement et chaque fois qu'il y à un 0 on le remplace par un 1, pour ça pas de problème la procédure est déjà faite, moi et tous ceux qui veulent bien s'impliquer, devons inventer la procédure inverse et ce n'est pas évident du tout, mais j'ai quand même remarqué que toute les neuvaines, on rajoute 10 de plus au résultat et tous les 9x9, on rajoute 100 au résultat.

[graph100]

@Dobro et Micoute :

Pour la procedure de codage de dobro, elle est sympa, mais une erreur s'y est glissée : pour de trop grand nombre comme 4 294 967 296, le résutltat était faux.
Il faut passer toutes les variables en .q :

Code : Tout sélectionner

Procedure.q  Coder(Nombre.q)
		
		; À toutes les dizaines on est décalé d'une unité, ça donne une Retenue
		Retenue.q = (Nombre - 1) / 9
		
		; On ajoute la Retenue au résultat
		Resultat.q = Nombre + Retenue
		
		; Pour l'instant on n'a modifié que les unités ajoutés toutes les dizaines, il faut aussi ajouter
		; tous les blocs de 0 qui apparaissent 10 fois toutes les centaines, 100 fois tous les milliers, etc.
		
		; Sans oublier qu'à chaque fois qu'on ajoute une Retenue celle-ci décale le résultat, il faut donc
		; calculer aussi la Retenue de la Retenue !
		
		; 1 = unités, 10 = dizaines, 100 = centaines...
		Rang.q = 1
		
		; On s'arrête quand il n'y a plus de Retenue à ajouter
		While Retenue > 0
				
				; Nouvelle Retenue à ajouter
				Retenue = (10 * Rang) * ((Retenue - 1) / (9 * Rang))
				
				; Ajout de la Retenue
				Resultat + Retenue
				
				; Passage au Rang suivant
				Rang * 10
		Wend
		
		ProcedureReturn Resultat
		
EndProcedure

Debug Str(Pow(256,4)) + " : " + Str(Coder(Pow(256,4)))

[graph100]

pour généraliser : à chaque puissance de 9 on ajoute la puissance de 10 correspondante. C'est pas bien du dans ce cas. Mais là j'ai a faire à coté. bon boulot à tous

[Micoute]

Merci beaucoup graph100, mais c'est exactement l'inverse qu'il faut faire car, il ne faut pas coder mais décoder, c'est à dire qu'on prend le nombre qui sort de ta procédure et on récupère celui que tu as entré. si j'entre 44, il doit ressortir 40.

[GallyHC]

Si tu donner un exemple de quoi retrouver avec par exemple :

Code : Tout sélectionner

(58) = 64 Retenue = 6
(59) = 65 Retenue = 6
(60) = 66 Retenue = 6
(61) = 67 Retenue = 6
(62) = 68 Retenue = 6
(63) = 69 Retenue = 7
(64) = 71 Retenue = 7
(65) = 72 Retenue = 7
(66) = 73 Retenue = 7
(67) = 74 Retenue = 7
(68) = 75 Retenue = 7
(69) = 76 Retenue = 7
(70) = 77 Retenue = 7
(71) = 78 Retenue = 7
(72) = 79 Retenue = 8
(73) = 81 Retenue = 8

qu'elle est la finalite ? Par exemple si tu dit que si tu as comme valeur 74 tu doit avoir 67 ou un truc comme cela ce sera plus simple.

Cordialement,
GallyHC

[Micoute]

les nombres que je donne sont des exemples, le premier entre parenthèses est le nombre codé en fausse base 9, puisqu'en fait c'est une base qui n'utilise que les chiffres 1 à 9 exclusivement, le second est le nombre décodé en décimal et la retenue est faite pour que je sache ou j'en suis quand le nombre attendu n'est pas le bon, par exemple 1000 alors que j'attend 1111 puisque le zéro n'existe pas dans la base 9 et si je recalcule les nombres en bases 9, c'est juste pour voir si la concordance est bonne, car quand la procédure sera au point, si je rentre 6585837139636825189, il doit ressortir 999999999999999999 et si je rentre 1151689, il doit ressortir 624591.

[graph100]

Merci beaucoup graph100, mais c'est exactement l'inverse qu'il faut faire car, il ne faut pas coder mais décoder, c'est à dire qu'on prend le nombre qui sort de ta procédure et on récupère celui que tu as entré. si j'entre 44, il doit ressortir 40.

Je sais bien, mais si tu as lu ce que j'ai écris dans ce post, c'était pour corriger la procedure de Dobro qui ne fonctionnais pas pour les grands nombres (les quad)
La correction est minime : uniquement les types de variables, mais ça change tout !

Sinon, je pense que tu vas pouvoir clôturer le topic
J'ai mis la procedure de codage corrigée, celle de décodage que je viens de finaliser, et une partie pour tester.
Ton 999999999999999999 que t'as mis tout à l'heure ne fonctionnera pas. Ça dépasse la capacité des Quad.
Si tu veux vraiment le faire fonctionner avec, faut se prendre la tête avec une méthode de calcul de Grand nombre.

Enfin, j'ai eu quelques soucis avec la commande Pow() qui ne fonctionne pas avec des quad. ça faussait les résultats. d'ou les boucles for : next pour le calcul des puissances.
Tu remarqueras que la puissance n'est pas calculé à l'intérieur de l'autre boucle for : next , de façon à accélérer le calcul.

Voilou

Code : Tout sélectionner

Procedure.q  Coder(Nombre.q)
	Protected.q Retenue, Resultat, Rang
	
	; À toutes les dizaines on est décalé d'une unité, ça donne une Retenue
	Retenue = (Nombre - 1) / 9
	
	; On ajoute la Retenue au résultat
	Resultat = Nombre + Retenue
	
	; Pour l'instant on n'a modifié que les unités ajoutés toutes les dizaines, il faut aussi ajouter
	; tous les blocs de 0 qui apparaissent 10 fois toutes les centaines, 100 fois tous les milliers, etc.
	
	; Sans oublier qu'à chaque fois qu'on ajoute une Retenue celle-ci décale le résultat, il faut donc
	; calculer aussi la Retenue de la Retenue !
	
	; 1 = unités, 10 = dizaines, 100 = centaines...
	Rang = 1
	
	; On s'arrête quand il n'y a plus de Retenue à ajouter
	While Retenue > 0
		
		; Nouvelle Retenue à ajouter
		Retenue = (10 * Rang) * ((Retenue - 1) / (9 * Rang))
		
		; Ajout de la Retenue
		Resultat + Retenue
		
		; Passage au Rang suivant
		Rang * 10
	Wend
	
	ProcedureReturn Resultat
	
EndProcedure


Procedure.q  Decoder(Nombre.q)
	Protected.q res, div10, mul9, c1, c2, reste, chiffre
	Protected i.l, j.l
	
	res = Nombre
	nb_chiffre = IntQ(Log10(Nombre)) + 1
	
	Macro PowQ(nombre_q, puissance, resultat_q)
		resultat_q = 1
		For j = 1 To puissance
			resultat_q * nombre_q
		Next
	EndMacro
	
	; 	div10 = Pow(10, nb_chiffre); ne fonctionne pas avec des Quad
	PowQ(10, nb_chiffre, div10)
	
	;	mul9 = Pow(9, nb_chiffre - 1); ne fonctionne pas avec des Quad
	PowQ(9, nb_chiffre - 1, mul9)
	
	For i = nb_chiffre - 1 To 1 Step -1
		div10 / 10
		
		c1 = Nombre / div10
		chiffre = IntQ(c1) - IntQ(c1 / 10) * 10
		
		mul9 / 9
		res = res - i * mul9 * (chiffre + reste)
		
		reste = reste * 10 + chiffre
	Next
	
	ProcedureReturn res
EndProcedure

test$ = "1,5,8,9,10,11,12,18,19,20,21,22,36,37,38,39,40,41,42,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,624591,4294967296"


For i = 1 To CountString(test$, ",") + 1
	
	nb.q = Val(StringField(test$, i, ","))
	
	res.q = Coder(nb)
	Debug Str(nb) + " : " + Str(res) + " : " + Str(DeCoder(res))
	
	
Next

[Backup]

c'était pour corriger la procedure de Dobro qui ne fonctionnais pas pour les grands nombres (les quad)

hum , c'est pas ma procedure , mais celle de Micoute que j'ai ajouté sans rien changer .... (dans le 2eme listing)

[graph100]

Ah, autant pour moi

[Micoute]

Bonjour graph100 et merci beaucoup, mais cette procédure est interdite, car elle fait appel à la procédure Coder(), hors quand on décode les nombres on ne doit absolument pas savoir ce qu'il étaient avant le codage, mais on sait seulement que les nombres codés ne comportent pas de 0, qu'ils sont dans l'ordre logique, mais que 10 devient 11 ce qui décale la suite, 20 devient 21, 100 devient 121, tandis que notre sortie doit être dans le système décimal et il faudrait trouver une corrélation entre ces 2 bases, il y a une logique c'est certain, mais qu'elle est-elle ?

J'ai remarqué avec mes essais que quand on arrive à (9+1) on rajoute 10 à la retenue, 20 quand on arrive à (2x9)+1, 30 à (3x9)+1 ...
et que la retenue est égale au nombre de fois 9 que notre nombre est divisible et que si notre nombre est aussi divisible par 10 on ajoute le nombre de fois que c'est divisible par 10, mais il faut penser à 100, 1000, 10000, ..., et tout autre nombre contenant au moins un zéro; il y a peut-être à creuser l'idée.

Le problème c'est que je ne sais pas dire à l'ordinateur "est-ce que ce nombre est divisible par 9 et par 10 ?" "et combien de fois ?"

Je vous remercie tous pour l'aide que chacun m'apporte.

[GallyHC]

Bonjour,

Si on part du principe que tu as les valeurs "Codées" et que tu doits décoder, ta fonction fonctionne alors? La tu code et décode c'est pour cela que tu as besoin de la fonction "Coder".

Code : Tout sélectionner

Procedure.q  Decoder(Nombre.q)
   Protected.q res, div10, mul9, c1, c2, reste, chiffre
   Protected i.l, j.l
   
   res = Nombre
   nb_chiffre = IntQ(Log10(Nombre)) + 1
   
   Macro PowQ(nombre_q, puissance, resultat_q)
      resultat_q = 1
      For j = 1 To puissance
         resultat_q * nombre_q
      Next
   EndMacro
   
   ;    div10 = Pow(10, nb_chiffre); ne fonctionne pas avec des Quad
   PowQ(10, nb_chiffre, div10)
   
   ;   mul9 = Pow(9, nb_chiffre - 1); ne fonctionne pas avec des Quad
   PowQ(9, nb_chiffre - 1, mul9)
   
   For i = nb_chiffre - 1 To 1 Step -1
      div10 / 10
      
      c1 = Nombre / div10
      chiffre = IntQ(c1) - IntQ(c1 / 10) * 10
      
      mul9 / 9
      res = res - i * mul9 * (chiffre + reste)
      
      reste = reste * 10 + chiffre
   Next
   
   ProcedureReturn res
EndProcedure

test$ = "1, 5, 8, 9, 11, 12, 13, 1151689, 11968657454"
For i = 1 To CountString(test$, ",") + 1
   
   nb.q = Val(StringField(test$, i, ","))   
   Debug Str(nb) + " : " + Str(DeCoder(nb))
   
Next

Enfin voila je comprend de moins en moins personnellement le but de tout cela.

Cordialement,
GallyHC

[Micoute]

Bonjour GallyHC et merci aussi, la procédure Coder(), comme son nom l'indique, est faite pour coder et la procédure Decoder(), pour l'inverse, mais ne seront jamais mise dans le même programme, sauf pour la mise au point du système et c'est tout, pour donner un exemple tu vas dans une pharmacie et tu présente ta carte vitale, elle possède un code que l'ordinateur du pharmacien reconnaît, pareil pour ta carte bleue, bien que sur ces cartes, il n'y a pas le système de codage ou de décodage, mais seulement des grouoes de nombres codés.