c# : Convertions Nombre en lettre et vice et versa

**Donpi** · 10/10/2008, 11h12

Hello, je suis développeur C# depuis peu de temps et la je bloque sur un problème tout bête mais je suis super pris par le temps donc je m'adresse a vous pour savoir si qqun a déjà developper un truc du genre

Le but est simple, c'est de pouvoir convertir un nombre en successions de lettre du type des colonnes d'excel.
Par exemple :

1=A
2=B
26 = Z
27 = AA
52 = AZ

Etc...

Lettre vers nombre c'est OK mais en partant du nombre j'ai un problème a chaque fois que le résultat doit contenir un "Z"

Merci de votre aide a+

**Médinoc** · 10/10/2008, 12h08

Le problème, c'est que ça n'équivaut pas vraiment à une base 26, car le zéro change: Pour la lettre en ce moment la plus à gauche, le zéro est un espace et 'A' correspond à 1, mais pour toutes les autres lettres, A correspond au zéro...

En fait, on a une base 27 pour la lettre de gauche et une base 26 pour toutes les autres...

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
  A : 1
  B : 2
  |
  Y : 25
  Z : 26
 AA : 27
 AB : 28
 ||
 AZ : 52
 BA : 53
 ||
 ZZ : 702 ?
AAA : 703 ?

**Médinoc** · 10/10/2008, 18h04

Tiens, je me suis amusé un peu, mais en C:

Code C :

Sélectionner tout - Visualiser dans une fenêtre à part

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
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
/* Si ton compilo ne supporte pas long long,
   tu peux utiliser un simple long à la place. */
typedef unsigned long long unumber_t;
 
/* Fonction écrire un nombre comme Excel numérote ses colonnes
   -----------------------------------------------------------
Cette fonction écrit le nombre à la fin du buffer,
et retourne un pointeur vers le début du nombre dans le buffer.
C'est plus efficace comme ça. */
char * formatBase26And27(
 unumber_t uNumber,        /*[in] Nombre à convertir.*/
 char * const szBuffer,    /*[in/out] Buffer.*/
 size_t const nBufferSize, /*[in] Taille du buffer, caractère nul inclus.*/
 size_t * const pt_nLength /*[out/opt] taille de la chaîne, sans le caractère nul.*/
 )	/*Retourne le début du nombre dans le buffer.*/
{
	char * pt_currentChar = szBuffer + nBufferSize;
	size_t nLength = 0;
 
	/* Premièrement, mettre un caractère nul. */
	--pt_currentChar, *pt_currentChar = '\0';
	/* Pas de cas spécial pour le premier chiffre ici: Zéro est une chaîne vide. */
	while(uNumber != 0)
	{
		unumber_t uDigit;
		char value;
		if(uNumber > 26)
		{
			/*Ce n'est pas la lettre la plus à gauche:
			  J'ai du mal à décrire ce que je fais ici, je l'ai un peu pondu au hasard.
			  On compte en base 26 avec A comme zéro,
			  mais comme en plus on soustrait 1 à chaque fois... */
			uNumber--;
			uDigit = uNumber % 26;
			uNumber /= 26;
			value = (char)('A' + uDigit);
		}
		else
		{
			/*Lettre la plus à gauche: base 27 pure, avec "rien du tout" comme zéro.*/
			uDigit = uNumber;
			uNumber = 0;
			value = (char)(uDigit!=0
			 ? ('A'+uDigit-1)
			 : '\0'
			 );
		}
 
		if(value != '\0')
		{
			--pt_currentChar;
			if(pt_currentChar >= szBuffer)
				*pt_currentChar = value;
			++nLength;
		}
	}
	/* Calcule la longueur. */
	if(pt_nLength!=NULL)
	{
		assert((ptrdiff_t)nLength == (szBuffer+nBufferSize-1) - pt_currentChar);
		*pt_nLength = nLength;
	}
	/* Si on a tronqué, on le marque avec '~' */
	if(pt_currentChar < szBuffer)
	{
		pt_currentChar = szBuffer;
		*szBuffer = '~';
	}
	return pt_currentChar;
}
 
void TestLettres();
{
	char bufferLettres[10];
	int i;
	#define TESTLETTRES(x) printf("\"%s\" : %u\n", formatBase26And27(x, bufferLettres, 10, NULL), x)
 
	for(i=0 ; i<80 ; i++)
		TESTLETTRES(i);
	puts("  |");
	for(i=26*26-1 ; i<=27*26+1 ; i++)
		TESTLETTRES(i);
	puts("  |");
	TESTLETTRES(((26+1)*26+1)*26);
	TESTLETTRES(((26+1)*26+1)*26+1);
	puts("  |");
	TESTLETTRES((((26+1)*26+1)*26+1)*26);
	TESTLETTRES((((26+1)*26+1)*26+1)*26+1);
	puts("  |");
	TESTLETTRES(((((26+1)*26+1)*26+1)*26+1)*26);
	TESTLETTRES(((((26+1)*26+1)*26+1)*26+1)*26+1);
 
	{
		unumber_t cumul = 1;
		for(i=0 ; i<8 ; i++)
		{
			TESTLETTRES(cumul);
			cumul *= 26;
			cumul += 1;
		}
	}
	#undef TESTLETTRES
}

La partie sans doute la plus dure pour la conversion en C#, c'est que j'écris à l'envers dans le buffer.

**Médinoc** · 10/10/2008, 18h24

Et voici la version C#!

Code C# :

Sélectionner tout - Visualiser dans une fenêtre à part

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
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
static String FormatBase26And27(ulong uNumber)
{
	StringBuilder buffer = new StringBuilder();
	while(uNumber != 0)
	{
		ulong uDigit;
		char value;
		if(uNumber > 26)
		{
			/*Ce n'est pas la lettre la plus à gauche:
			  J'ai du mal à décrire ce que je fais ici, je l'ai un peu pondu au hasard.
			  On compte en base 26 avec A comme zéro,
			  mais comme en plus on soustrait 1 à chaque fois... */
			uNumber--;
			uDigit = uNumber % 26;
			uNumber /= 26;
			value = (char)('A' + uDigit);
		}
		else
		{
			/*Lettre la plus à gauche: base 27 pure, avec "rien du tout" comme zéro.*/
			uDigit = uNumber;
			uNumber = 0;
			value = (char)(uDigit!=0
			 ? ('A'+uDigit-1)
			 : '\0'
			 );
		}
		if(value!='\0')
			buffer.Append(value);
	}
	return ReverseString(buffer);
}
 
static String ReverseString(StringBuilder str)
{
	StringBuilder buffer = new StringBuilder(str.Length);
	buffer.Length = str.Length;
	for(int i=str.Length ; i>0 ; i--)
	{
		int i0 = i-1;
		buffer[str.Length-i] = str[i0];
	}
	return buffer.ToString();
}
 
static String ReverseString(String str)
{
	StringBuilder buffer = new StringBuilder(str.Length);
	for(int i=str.Length ; i>0 ; i--)
	{
		int i0 = i-1;
		buffer[str.Length-i] = str[i0];
	}
	return buffer.ToString();
}
 
static void TESTLETTRES(ulong x) { Console.WriteLine("\"{0}\" : {1}", FormatBase26And27(x), x); }
 
static void TestLetters()
{
	ulong u;
 
	for(u=0 ; u<80 ; u++)
		TESTLETTRES(u);
	Console.WriteLine("  |");
	for(u=26*26-1 ; u<=27*26+1 ; u++)
		TESTLETTRES(u);
	Console.WriteLine("  |");
	TESTLETTRES(((26+1)*26+1)*26);
	TESTLETTRES(((26+1)*26+1)*26+1);
	Console.WriteLine("  |");
	TESTLETTRES((((26+1)*26+1)*26+1)*26);
	TESTLETTRES((((26+1)*26+1)*26+1)*26+1);
	Console.WriteLine("  |");
	TESTLETTRES(((((26+1)*26+1)*26+1)*26+1)*26);
	TESTLETTRES(((((26+1)*26+1)*26+1)*26+1)*26+1);
 
	{
		ulong cumul = 1;
		for(int i=0 ; i<8 ; i++)
		{
			TESTLETTRES(cumul);
			cumul *= 26;
			cumul += 1;
		}
	}
}

PS: Peux-tu me renvoyer l'ascenseur en postant la fonction en sens inverse, puisque tu dis que de ton côté elle marche bien?

**Donpi** · 23/10/2008, 10h58

Yes desolé du retard je poste ça dans 5

**Donpi** · 23/10/2008, 11h04

Voila me deux codes. j'avais effectivement un soucis avec le 0 qui vaut 1 mais qu'une fois lol.

Depuis les lettres

Code C# :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
        public int LettreChiffre(string Param)
        {
            int iTemp = 0;
            try
            {
                for (int iIdLettre = Param.Length; iIdLettre >= 1; iIdLettre--)
                {
                    iTemp += (int)((Char.Parse(Param.ToUpper().Substring(iIdLettre-1, 1)) - 64) * Math.Pow(26, Param.Length - iIdLettre));
                }
                return iTemp;
            }
            catch (Exception oE)
            {
                throw oE;
            }
        }

Depuis les chiffres

Code C# :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
        public string ChiffreLettre(int Param)
        {
            string sTemp = "";
            int iTemp = Param;
            int Puissance26;
            int NbPuissance;
            try
            {
                while (iTemp > 26)
                {
                    Puissance26 = 0;
                    for (int i = 0; i < 100; i++)
                    {
                        if (Math.Pow(26, i) > iTemp - (Math.Pow(26, i-1)))
                        {
                            Puissance26 = i - 1;
                            break;
                        }
                    }
                    NbPuissance = 0;
                    while (iTemp >= (int)Math.Pow(26, Puissance26))
                    {
                        NbPuissance++;
                        iTemp -= (int)Math.Pow(26, Puissance26);
                    }
 
                    sTemp += Convert.ToChar(NbPuissance + 64);
                }
                sTemp += Convert.ToChar(iTemp + 64);
                return sTemp;
            }
            catch (Exception oE)
            {
                throw oE;
            }
        }

**Médinoc** · 23/10/2008, 11h40

Merci.

c# : Convertions Nombre en lettre et vice et versa

Windows

Vue hybride

Discussions similaires

Partager

Partager