Convertir un nombre Base 10 en Base 6

Version imprimable

21/07/2016, 14h44
Fundu31

Convertir un nombre Base 10 en Base 6

Bonjour,

Je cherche à savoir comment convertir un nombre qui est formater en Base 10 en Base 6, mais apparemment Visual Basic a une commande qui le permet :

Code:

TextBox1.Text = Convert.ToString(Integer.Parse(TextBox2.Text), 3)

Mais Voilà cette commande ne prend pas en charge la Base 6, donc je cherche toujours un moyen de convertir un nombre formater en base 10 en base 6 :)

Voilà merci d'avance :)
21/07/2016, 15h44
jopopmk

Salut,

Ce ne serait pas un exercice ? Le but serait alors justement de le coder soi-même.
En tout cas une telle fonction n'existe pas à ma connaissance.
21/07/2016, 15h47
Fundu31

Ouais je pense que je vais devoir le coder sans commande pour m'épauler ^^ :P
21/07/2016, 15h54
Sehnsucht

Convert.ToString ne permet le changement de base que pour celles les plus classiques (2, 8, 10 et 16) et renvoie une chaine (obligatoire pour la base 16) du coup obligé de le faire soi-même
Dans ton cas tu convertis vers une base inférieure à 10 (autrement dit "l'alphabet" [les chiffres nécessaires] est déjà existant [les chiffres de 0 à 5]) du coup tu peux très bien faire une méthode qui renvoie également un nombre (plutôt qu'une chaine)
Et si tu dois faire l'opération inverse cette même méthode pourra servir (exemple tu passes de la base 10 à la base 6 avec result = ChangeBase (nombre, 10, 6) et fais l'opération inverse avec result2 = ChangeBase (result, 6, 10) [avec nombre et result2 égaux au final])

Sans donner trop d'infos pour te laisser chercher (dans un premier temps) une méthode qui peut t'être utile est Math.DivRem
21/07/2016, 16h31
Fundu31

Déjà ce que je sais, c'est que pour convertir de la base 10 à la base 6, il faut à chaque fois qu'on compte 5 on ajoute 10
Par exemple (Base 10 / Base 6) : 1 / 1, 2 / 2, 3 / 3, 4 / 4, 5 / 5, 6/10

Mais après je sèche ^^
21/07/2016, 17h04
jopopmk

Pour voir comment écrire en base 6 tu peux t'aider de la méthode pour écrire en base 10 (écrire au sens informatique) :

* Pour écrire le premier digit tu vas prendre le reste de la division euclidienne par 10, ex. :

123 %10 = 3 -> tu peux écrire '3' pour le premier digit.
* pour passer au digit suivant on retranche le reste trouvé précédemment à notre nombre, puis on le diviser par 10, et à nouveau appliqué ce module 10 :

123 -3 = 120, 120 /10 = 12, 12 %3 = 2 -> tu peux écrire '2' pour le deuxième digit.
* et ainsi de suite jusqu'à ce qu'on ait consommé tout notre nombre d'origine.

Maintenant tu transposes le procédé pour la base 6 et tu as ton algo.
J'ai fait un petit test de code (en C) et le principe semble fonctionné comme voulu.
21/07/2016, 18h53
Fundu31

Citation:

jopopmk
Pour voir comment écrire en base 6 tu peux t'aider de la méthode pour écrire en base 10 (écrire au sens informatique) :

* Pour écrire le premier digit tu vas prendre le reste de la division euclidienne par 10, ex. :
123 %10 = 3 -> tu peux écrire '3' pour le premier digit.
* pour passer au digit suivant on retranche le reste trouvé précédemment à notre nombre, puis on le diviser par 10, et à nouveau appliqué ce module 10 :
123 -3 = 120, 120 /10 = 12, 12 %3 = 2 -> tu peux écrire '2' pour le deuxième digit.
* et ainsi de suite jusqu'à ce qu'on ait consommé tout notre nombre d'origine.

Maintenant tu transposes le procédé pour la base 6 et tu as ton algo.
J'ai fait un petit test de code (en C) et le principe semble fonctionné comme voulu.

Déjà merci pour m'avoir apporté plus de précision sur le sujet, mais je ne comprend pas le "jusqu'à ce qu'on ait consommé tout notre nombre d'origine."
Cette méthode marche pour tout les nombres voulues ? :)
21/07/2016, 19h28
Sehnsucht

Reprenons ce qu'est un nombre dans une base quelconque n
Un nombre est constitué de chiffres (il y a n chiffres différents dans une base n).
Un nombre est constitué d'unités, de dizaines de centaines etc. toute représentées par un chiffre.Lorsque un chiffre dépasse le dernier chiffre de notre base et on augmente le "cran supérieur" (les dizaines par exemple) au chiffre suivant de son état actuel et on repart du premier chiffre dans le "cran actuel" (les unités ici).

Voilà avec tout ça on peut écrire un nombre dans n'importe quelle base (même très exotique genre la base constitué des chiffres "toto" et "tata")

un exemple très mécanique avec une base connue, la base 10 ; si je veux représenter une quantité en base 10 par exemple 14 je parcours les chiffres de cette base et à chaque "cran" je décrémente ma quantité j'ai donc

quantité unités dizaines

14 0 0

13 1 0

12 2 0

11 3 0

10 4 0

9 5 0

8 6 0

7 7 0

6 8 0

5 9 0

Là on arrive au passage au "cran supérieur" (on pourrait aussi appeler ça une retenue), on applique simplement ce qui a été dit et on continue
4 0 1

3 1 1

2 2 1

1 3 1

0 4 1

Et là heureusement on retombe bien sur notre nombre en base 10 qui a 1 dizaine et 4 unités soit 14.

Maintenant on refais exactement la même chose mais en base 6 :

quantité unités dizaines

14 0 0

13 1 0

12 2 0

11 3 0

10 4 0

9 5 0 X

8 0 1

7 1 1

6 2 1

5 3 1

4 4 1

3 5 1 X

2 0 2

1 1 2

0 2 2

J'ai marqué d'un X les passages de crans.

Ce que l'on peut constater c'est que dans le cas de la base 10 on fait une retenue tous les 10 chiffres et en base 6 tous les 6 chiffres.

Je sais que c'est un peu une évidence d'écrire cela vu qu'une base n a n chiffres

La conséquence de cela c'est qu'on peut automatiser le processus que j'ai réalisé avec mes tableaux (même si on pourrait très bien faire un algorithme qui fonctionne aussi avec cette méthode).
Si on fait la division euclidienne (donc avec quotient et reste) de notre quantité par notre base nous obtenons donc son nombre d'unités (le reste) et son total de dizaines (le quotient)
avec 14 pour la base 10 on a bien reste = 4 et quotient = 1 et avec la base 6 on a reste = 2 et quotient = 2

Maintenant pour une quantité plus grande, 1234 par exemple si on fait la même chose on a :
division de 1234 par 10: reste = 4 et quotient = 123 (il y a 123 dizaines dans 1234)
on a donc notre chiffre des unités (4) mais la quantité de dizaines n'est pas un chiffre de notre base il nous faut donc répéter le processus
division de 123 par 10: reste = 3 et quotient = 12
on a maintenant notre chiffre des dizaines (3) mais la quantité de centaines (12) n'est toujours pas un chiffre on continue donc
division de 12 par 10: reste = 2 et quotient = 1
on a notre chiffre des centaines (2) et la quantité de millier (1) est un chiffre donc on a fini est notre quantité 1234 représente donc le nombre 1234 en base 10 (soit 1 millier 2 centaines 3 dizaines et 4 unités)

En appliquant la même méthodologie en utilisant la base 6 on aurait le nombre représentant la quantité 1234 en base 6 (5414)

on a donc un algorithme qui dit (en français) tant que notre quantité n'est pas représentable par un chiffre de notre base ; on fait la division euclidienne de cette quantité par la base on garde le reste, et on recommence avec le quotient (le quotient devient la nouvelle quantité)

si arrivé aux milliers j'avais continué que ce serait-il passé ?
(...)
division de 12 par 10: reste = 2 et quotient = 1
on a notre chiffre des centaines (2) et la on répète le processus avec le quotient (1)
division de 1 par 10: reste = 1 et quotient = 0
on a notre chiffre des milliers (1) et le quotient vaut 0 on a consommé toute la quantité initiale (pour faire le lien avec le post de jopopmk)

Un autre algorithme possible est donc (toujours en français) tant que notre quantité est non nulle (non entièrement consommée) ; on fait la division euclidienne de cette quantité par la base on garde le reste, et on recommence avec le quotient (le quotient devient la nouvelle quantité)

Une "difficulté" possible risque d'être que l'on va obtenir les chiffres en ordre inverse de la manière dont on les écrit (d'abord les unités puis les dizaines etc.)
mais si on fait attention on constate que
au 1er "niveau" on cherche les unités (donc un truc qui aura la forme X, exemple 4 [= 4 x 1])
au 2ème "niveau" on cherche les dizaines (donc un truc qui aura la forme X., exemple 40 [= 4 x 10])
au 3ème "niveau" on cherche les centaines (donc un truc qui aura la forme X.., exemple 400 [= 4 x 100 = 4 x 10 x 10])
etc.

Si on arrivait à trouver un lien (une formule) qui lit le "niveau" (1, 2, 3) au "multiplicateur" (1, 10, 100 [ou 10 * 10]) ça serait sûrement utile ;)

J'ai à peu près fait le tour ; en donnant le plus d'infos sans trop dévoiler la solution, j'espère que ça sera pas trop confus :)

Merci infiniment pour tout vos conseils, j'ai enfin réussis à m'en coder un ^^
Résultat :

Code:

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
Public Class Form1
    Public Function convertToBase(ByVal value As Int32, base As Int32) As String
 
        Dim chars As String = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
        Dim r As Int32
        Dim newNumber As String
 
        If (base < 2 Or base > chars.Length) Then
            Return ""
        End If
 
        newNumber = ""
 
        While value >= base
            r = value Mod base
            newNumber = chars.Substring(r, 1) & newNumber
            value = Convert.ToInt32(Math.Floor(value / base))
        End While
        If value > 0 Then
            newNumber = chars.Substring(value, 1) & newNumber
        End If
 
        If String.IsNullOrEmpty(newNumber) Then
            newNumber = "0"
        End If
 
        r = Nothing
        chars = Nothing
 
        Return newNumber
 
    End Function
 
    Private Sub Button1_Click(sender As Object, e As EventArgs) Handles Button1.Click
        TextBox3.Text = convertToBase(TextBox1.Text, 6)
        TextBox4.Text = convertToBase(TextBox2.Text, 6)
    End Sub
End Class

Je vous remercie tous mille fois ^^ :P

Quelque petites choses améliorables :

chars ne sera jamais modifié autant donc en faire un Const à la place, et là on sera sûr qu'on ne la modifiera pas par erreur depuis le code d'une part et en plus la chaine ne sera pas recréé à chaque appel (pour faire simple les éléments constant sont stockés dans un endroit à part et donc n'existe qu'une fois et sont réutilisés à chaque fois [vu que de toute façon il ne seront jamais modifiés)

N'utilise Or (ou And) que lorsque tu veux t'en servir comme opérateurs binaires (exemple 2 Or 3 'ce qui donne 3) et préfère utiliser OrElse (ou AndAlso) lorsque tu enchaines des conditions ; ce sont des opérateurs logiques dit court-circuitants, ils arrêter d'évaluer dès que le résultat est déterminé sans ambiguité (exemple True Or FaitUneOperationSuperLourdeQuiRenvoieUnBoolean() l'opération super lourde sera faite alors que peu importe si elle renvoie True ou False le résultat final sera True alors qu'avec OrElse, il voit le premier True et se dit ça sera forcément True au final donc pas besoin d'aller plus loin)
À ce propos il serait sans doute plus judicieux de lancer une exception dans le cas où base est invalide plutôt qu'un "résultat spécial" (la chaine vide ici)

Evite si possible les While / End While et choisi à la place Do While / Loop dans le fonctionnement c'est pareil mais Do Loop est plus souple on peut faire :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 Do While condition ' boucle tant que la condition est vraie ' ... Loop 'ou Do Until condition ' boucle jusqu'à ce que la condition soit fausse ' ... Loop ' ou Do ' ... Loop While condition ' ou Do ' ... Loop Until condition
Concernant la différence entre Do While/Until et Loop While/Until ; pour les premiers on évalue la condition avant d'entrer dans la boucle pour les autres on évalue la condition avant de recommencer la boucle ; autrement dit on fera au moins une fois le code contenu dans la boucle. Ça peut être utile par exemple quand tu demandes une saisie à l'utilisateur et que tu vérifies qu'il a bien entré un truc valide il faudra forcément au moins une saisie, si elle est bonne direct pas besoin de recommencer, sinon on recommence tant qu'elle n'est pas bonne (While) ou jusqu'à ce quelle soit bonne (Until)

Ne fait pas chars.Substring (r, 1) quand il s'agit d'un seul caractère ; une chaine est indexable comme un tableau du coup si tu veux l'élément à la position r utilise chars (r). Attention Substring renvoie une chaine (un String) alors que le résultat de l'indéxeur sera un Char

Au lieu de transformer le résultat de la division flottante (truc / machin) qui te renvoie un Double que tu es obligé d'arrondir puis de convertir (ce qui montre au moins qu'a priori tu es en Option Strict On ce qui est très bien :D) utilise directement la division euclidienne soit en VB.Net (truc \ machin) antislash au lieu de slash :)
Mais sur le même sujet du fait à la fois x \ y et x Mod y autant directement utilise Math.DivRem (dont j'avais parlé plus tôt) et qui fait exactement ça diviser (division euclidienne) x par y et renvoyer également le reste (le résultat du modulo) dans un argument supplémentaire.

Tu fais ton tant que ta quantité (value) est supérieure ou égale à la base et après tu es obligé de tester si tu as encore quelque chose dans value pour le rajouter ce qui correspond à l'algorithme que j'avais décrit

Citation:

on a donc un algorithme qui dit (en français) tant que notre quantité n'est pas représentable par un chiffre de notre base ; on fait la division euclidienne de cette quantité par la base on garde le reste, et on recommence avec le quotient (le quotient devient la nouvelle quantité)

Mais ensuite j'ai aussi complété par ceci

Citation:

Un autre algorithme possible est donc (toujours en français) tant que notre quantité est non nulle (non entièrement consommée) ; on fait la division euclidienne de cette quantité par la base on garde le reste, et on recommence avec le quotient (le quotient devient la nouvelle quantité)

en utilisant ça tu simplifierais ton code et t'éviterais ce test (ça serait la boucle qui s'en occuperait) et t'aurais plus besoin de tester le cas String.IsNullOrEmpty : le cas du 0 serait déjà traité ;)

Ça ne sert à rien de mettre les variables à Nothing en fin de méthode ; une fois sorti de leur portée (de la méthode ici) les variables n'existent plus

Si je combine tout cela (avec 2-3 bricoles perso en plus) voilà ce que donne le code :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 Function ConvertToBase(quantity As Integer, base As Integer) As String Const digits = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ" Static builder As New StringBuilder If base < 2 OrElse base > digits.Length Then Throw New ArgumentOutOfRangeException(NameOf(base), "must be within [2; 36]") builder.Clear() Dim isNegativeQuantity = quantity < 0 quantity = Math.Abs(quantity) Do Until quantity = 0 Dim remainder% quantity = Math.DivRem(quantity, base, remainder) builder.Insert(0, remainder) Loop If isNegativeQuantity Then builder.Insert(0, "-"c) Return builder.ToString End Function
Au niveau des trucs en plus ; je réassigne directement le résultat de DivRem (le quotient) à quantity il m'a fallu une variable remainder pour stocker le contenu du reste (le résultat du modulo, ton r) que j'ai déclaré directement dans la boucle on en a pas besoin ailleurs (c'est souvent mieux de déclarer les choses avec la portée la plus réduite possible ; qu'ils n'existent pas là où on a pas besoin d'eux)
Comme précisé j'ai choisi de lancer une exception.

J'ai ajouté quelques trucs pour gérer correctement une quantité négative (parce qu'un modulo peut renvoyer un nombre négatif et tu vas te mettre à rajouter des "-" avec ton Substring ^^)
je teste au début si c'est une quantité négative et je stocke ça dans un booléen ; puis j'assigne à quantité sa valeur absolue pour être sûr qu'elle soit positive pour le reste et à la fin si j'avais eu un nombre négatif je rajoute un signe moins devant. Une "chaine" avec un c derrière (comme "-"c) c'est comme ça qu'on défini un littéral de type Char

Maintenant le changement le plus important : le StringBuilder ; il faut savoir qu'un String en .Net est immuable (on ne peut pas le modifier) quand tu fais tes concaténations ça créé une nouvelle chaine et la met dans newNumber et l'ancienne est jetée ; ça n'insère pas juste le substring au début. Au final ça peut faire beaucoup de chaines jetées pour rien (même si ici c'est limité). Un StringBuilder sert comme son nom l'indique à construire une chaine ; il fait sa tambouille interne pour être modifiable (pour résumer, si tu fais beaucoup de concaténations [dans une boucle par exemple] utiliser un StringBuilder peut être une bonne idée ; là ça change pas grand chose mais comme ça je le montre :))
Du coup à la fin faut bien que je retourne une chaine quand même donc j'appelle le ToString du StringBuilder qui renvoie la chaine construite (si t'as besoin de plus d'infos, je te renvoie à la documentation)

Dernière chose il est déclaré comme Static qu'il ne faut pas confondre avec le static d'autres langages (C#, C++, java entre autres) auquel correspond Shared en VB.Net ; Static sert à étendre la durée de vie d'une variable au delà de sa portée normale. Précédemment j'ai écrit que tu n'avais pas besoin "d'effacer" tes variables, elles l'étaient automatiquement en fin de portée (fin de méthode) ; une variable déclarée avec Static continue d'exister et donc conserve sa valeur entre différent appel (ça revient en gros au même que si je l'avais déclaré au niveau de la classe ou du module ; mais elle ne reste visible [donc utilisable] que dans cette méthode, elle ne pollue donc pas le module ou la classe [là aussi c'est surtout pour montrer]). En l'état ça évite d'avoir à créer une nouvelle instance de StringBuilder à chaque fois, on garde le même et on efface son contenu (avec Clear).

Ah oui ; j'ai failli oublier :aie: le % après remainder ; on dirait là que je n'ai pas typé cette variable mais en fait si le % indique le type (c'est très peu utilisé et tant mieux mais je le montre pour le jour où on tombe dessus et qu'on comprend pas ce que ça fait là) je n'en parlerais pas trop, je renvoie juste à la documentation là

Eh ben j'en fais des gros pavés aujourd'hui :aie:

Impressionnant comme il faut tartiner pour expliquer un algo qui tient en 10 lignes :mrgreen:
Comme t'es arrivé au bout je mets mon implémentation en C pour qui veut :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
#define BASE 6
// fonctionne pour toutes les bases inférieurs à 10
// (il faudrait lui passer un alphabet en param pour les autres bases)
char *baseX(int val, char *buffer, int len) {
	int pos = len - 1, rest = val;
	buffer[pos] = 0;
	do {
		int tmp = rest % BASE;
		buffer[--pos] = tmp + '0';
		rest = (rest - tmp) / BASE;
	} while (rest > 0 && pos > 0);
	return &buffer[pos];
}

22/07/2016, 09h30
Sehnsucht

Citation:

Envoyé par jopopmk

Impressionnant comme il faut tartiner pour expliquer un algo qui tient en 10 lignes :mrgreen:

J'avoue :aie: j'ai tenté d'être exhaustif pour le coup (et puis quand je me lance je me rends pas compte ; je dois sûrement avoir des messages plus long encore en cherchant bien :lol:)
22/07/2016, 19h49
jopopmk

Citation:

Envoyé par Sehnsucht

J'avoue :aie: j'ai tenté d'être exhaustif pour le coup (et puis quand je me lance je me rends pas compte ; je dois sûrement avoir des messages plus long encore en cherchant bien :lol:)

Et c'était très bien, Fundu31 a réussi à pondre lui-même un code fonctionnel avec tes explications ;)

quantité	unités	dizaines
14	0	0
13	1	0
12	2	0
11	3	0
10	4	0
9	5	0	X
8	0	1
7	1	1
6	2	1
5	3	1
4	4	1
3	5	1	X
2	0	2
1	1	2
0	2	2