Section courante

A propos

Section administrative du site

Aussitôt l'arriver du binaire dans le monde des ordinateurs, les «Bases numérique» font partie des algorithmes mathématiques de base pour le dénombrement et la quantification d'information.

Les bases sont très variés, les plus populaires sont Binaire (2), Ternaire (3), Quintale (5), Octale (8), Décimale (10), Hexadécimale (16),.. La seule limite est l'imagination du programmeur...

Voici tout d'abord une table des bases les plus populaires :

Base 2 (Binaire) Base 3 (Ternaire) Base 8 (Octale) Base 10 (Décimal) Base 16 (Hexadécimal) Base 62
0 0 0 0 0 0
1 1 1 1 1 1
10 2 2 2 2 2
11 10 3 3 3 3
100 11 4 4 4 4
101 12 5 5 5 5
110 20 6 6 6 6
111 21 7 7 7 7
1000 22 10 8 8 8
1001 100 11 9 9 9
1010 101 12 10 A A
1011 102 13 11 B B
1100 110 14 12 C C
1101 111 15 13 D D
1110 112 16 14 E E
1111 120 17 15 F F
10000 121 20 16 10 G
10001 122 21 17 11 H
10010 200 22 18 12 I
10011 201 23 19 13 J
10100 202 24 20 14 K
10101 210 25 21 15 L
10110 211 26 22 16 M
10111 212 27 23 17 N
11000 220 30 24 18 O
11001 221 31 25 19 P
11010 222 32 26 1A Q
11011 1000 33 27 1B R
11100 1001 34 28 1C S
11101 1002 35 29 1D T
11110 1010 36 30 1E U
11111 1011 37 31 1F V
100000 1012 40 32 20 W
100001 1020 41 33 21 X
100010 1021 42 34 22 Y
100011 1022 43 35 23 Z
100100 1100 44 36 24 a
100101 1101 45 37 25 b
100110 1102 46 38 26 c
100111 1110 47 39 27 d
101000 1111 50 40 28 e
101001 1112 51 41 29 f
101010 1120 52 42 2A g
101011 1121 53 43 2B h
101100 1122 54 44 2C i
101101 1200 55 45 2D j
101110 1201 56 46 2E k
101111 1202 57 47 2F l
110000 1210 60 48 30 m
110001 1211 61 49 31 n
110010 1212 62 50 32 o
110011 1220 63 51 33 p
110100 1221 64 52 34 q
110101 1222 65 53 35 r
110110 2000 66 54 36 s
110111 2001 67 55 37 t
111000 2002 70 56 38 u
111001 2010 71 57 39 v
111010 2011 72 58 3A w
111011 2012 73 59 3B x
111100 2020 74 60 3C y
111101 2021 75 61 3D z

Ternaire

Voici un programme permettant d'effectuer une conversion d'une valeur décimal à ternaire en Turbo C :

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4.  
  5. char ReturnString[255];
  6.  
  7. char * DecimalToTernaire(int value) {
  8.  int base;
  9.  if(0 == value) {
  10.   return "0";
  11.  }
  12.  strcpy(ReturnString,"");
  13.  base = value;
  14.  while(base > 0) {
  15.     char Temp[255];
  16.     sprintf(&Temp,"%i",(int)(base % 3));
  17.     strcat(&Temp,&ReturnString);
  18.     strcpy(&ReturnString,&Temp);
  19.     base = (int)(base / 3);
  20.  }
  21.  return ReturnString;
  22. }
  23.  
  24. int main()
  25. {
  26.     int I;
  27.     for(I=0; I <= 20; I++) {
  28.         printf("%i = %s\n",I,DecimalToTernaire(I));
  29.     }
  30.     return 0;
  31. }

on obtiendra le résultat suivant :

0 = 0
1 = 1
2 = 2
3 = 10
4 = 11
5 = 12
6 = 20
7 = 21
8 = 22
9 = 100
10 = 101
11 = 102
12 = 110
13 = 111
14 = 112
15 = 120
16 = 121
17 = 122
18 = 200
19 = 201
20 = 202

Hexadécimal

Voici un programme très performant permettant d'effectuer une conversion d'une valeur d'un octet à hexadécimal en Turbo C :

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3.  
  4. char ReturnString[255];
  5.  
  6. char * ByteHex2Str(unsigned char value) {
  7.     char matrix[16] = {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
  8.     ReturnString[0] = matrix[(value >> 4) & 0x0F];
  9.     ReturnString[1] = matrix[value & 0xF];
  10.     ReturnString[2] = 0;
  11.     return ReturnString;
  12. }
  13.  
  14. int main()
  15. {
  16.     printf("00h = %s\n",ByteHex2Str(0x00));
  17.     printf("01h = %s\n",ByteHex2Str(0x01));
  18.     printf("02h = %s\n",ByteHex2Str(0x02));
  19.     printf("0Ah = %s\n",ByteHex2Str(0x0A));
  20.     printf("0Fh = %s\n",ByteHex2Str(0x0F));
  21.     printf("10h = %s\n",ByteHex2Str(0x10));
  22.     printf("20h = %s\n",ByteHex2Str(0x20));
  23.     printf("56h = %s\n",ByteHex2Str(0x56));
  24.     printf("73h = %s\n",ByteHex2Str(0x73));
  25.     printf("EFh = %s\n",ByteHex2Str(0xEF));
  26.     printf("FFh = %s\n",ByteHex2Str(0xFF));
  27.     return 0;
  28. }

on obtiendra le résultat suivant :

00h = 00
01h = 01
02h = 02
0Ah = 0A
0Fh = 0F
10h = 10
20h = 20
56h = 56
73h = 73
EFh = EF
FFh = FF

Base62

Voici un programme permettant d'effectuer une conversion d'une valeur décimal à «Base62» en Turbo C :

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4.  
  5. char ReturnString[255];
  6.  
  7. char * DecimalToBase62(int value) {
  8.     char TBase[62] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
  9.     if(0 == value) {
  10.         return "0";
  11.     } else {
  12.         strcpy(ReturnString,"");
  13.         while(value > 0) {
  14.             char Temp[255];
  15.             sprintf(&Temp,"%c",TBase[value % 62]);
  16.             strcat(&Temp,&ReturnString);
  17.             strcpy(&ReturnString,&Temp);
  18.             value /= 62;
  19.         }
  20.     return ReturnString;
  21.     }
  22. }
  23.  
  24. int main()
  25. {
  26.     char I;
  27.     for(I = 60; I <= 80; I++) {
  28.         printf("%i = %s\n",I,DecimalToBase62(I));
  29.     }
  30.     return 0;
  31. }

on obtiendra le résultat suivant :

60 = y
61 = z
62 = 10
63 = 11
64 = 12
65 = 13
66 = 14
67 = 15
68 = 16
69 = 17
70 = 18
71 = 19
72 = 1A
73 = 1B
74 = 1C
75 = 1D
76 = 1E
77 = 1F
78 = 1G
79 = 1H
80 = 1I

BaseX

Avec exemples les précédents, vous l'aurez compris, il est possible d'avoir une formule pour n'importe quel base. En somme, voici un programme permettant d'effectuer une conversion d'une valeur décimal à base relative entre 1 et 61 (mais 13 très pour celui-ci) en Turbo C :

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4.  
  5. char ReturnString[255];
  6.  
  7. char * DecimalToBaseX(int value,char baseNumber) {
  8.     char TBase[62] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
  9.     if(0 == value) {
  10.         return "0";
  11.     } else {
  12.         strcpy(ReturnString,"");
  13.         while(value > 0) {
  14.             char Temp[255];
  15.             sprintf(&Temp,"%c",TBase[value % baseNumber]);
  16.             strcat(&Temp,&ReturnString);
  17.             strcpy(&ReturnString,&Temp);
  18.             value /= baseNumber;
  19.         }
  20.         return ReturnString;
  21.     }
  22. }
  23.  
  24. int main()
  25. {
  26.     char I;
  27.     for(I = 0; I <= 20 ; I++) {
  28.         printf("%i = %s\n",I,DecimalToBaseX(I,13));
  29.     }
  30.     return 0;
  31. }

on obtiendra le résultat suivant :

0 = 0
1 = 1
2 = 2
3 = 3
4 = 4
5 = 5
6 = 6
7 = 7
8 = 8
9 = 9
10 = A
11 = B
12 = C
13 = 10
14 = 11
15 = 12
16 = 13
17 = 14
18 = 15
19 = 16
20 = 17

Dernière mise à jour : Dimanche, le 26 juillet 2015