I. Giới thiệu chung

Trong Toán học, hệ cơ số (hay hệ đếm) là một hệ thống các kí hiệu toán học và quy tắc sử dụng tập kí hiệu đó để biểu diễn số đếm. Các kí hiệu toán học có thể là chữ số hoặc các kí tự chữ cái. Cần phân biệt giữa Hệ cơ số và Cơ số (số lượng kí hiệu sử dụng trong một hệ cơ số).

Có rất nhiều hệ cơ số khác nhau, mỗi hệ cơ số có những quy tắc biểu diễn số khác nhau. Những dãy kí hiệu giống nhau có thể sẽ ứng với những số khác nhau trong các hệ đếm khác nhau. Ví dụ trong hệ thập phân, $11$ thể hiện số “mười một”, tuy nhiên trong hệ nhị phân, nó lại thể hiện số “ba”,… Số đếm mà dãy kí hiệu thể hiện được gọi là giá trị của nó.

Có hai loại hệ cơ số là hệ cơ số phụ thuộc vào vị trí và hệ cơ số không phụ thuộc vào vị trí. Chẳng hạn, hệ đếm La Mã là một hệ cơ số không phụ thuộc vào vị trí. Hệ đếm này gồm các kí hiệu chữ cái: $I,V,X,L,C,D,M;$ mỗi kí hiệu có giá trị cụ thể:

$$I=1,V=5,X=10,L=50,C=100,D=500,M=1000.$$

Trong hệ đếm này, giá trị của các kí hiệu không phụ thuộc vào vị trí của nó. Ví dụ, trong hai biểu diễn $IX(9)$ và $XI(11)$ thì $X$ đều có giá trị là $10$.

Các hệ đếm thường dùng là các hệ đếm phụ thuộc vị trí. Mọi số nguyên $base$ bất kỳ có giá trị lớn hơn $1$ đều có thể được chọn làm cơ số cho một hệ đếm. Trong các hệ đếm loại này, số lượng kí hiệu sử dụng sẽ chính bằng cơ số của hệ đếm đó, và giá trị tương ứng của các kí hiệu là: $0,1,2,...,base-1$. Để thể hiện một biểu diễn $X$ là biểu diễn của số ở hệ cơ số $base$, ta kí hiệu là XbaseX_{base}Xbase​.

</div>

II. Biểu diễn số trong các hệ đếm

1. Giá trị của một số trong hệ cơ số bất kỳ

Trong một hệ cơ số $b$, giả sử số $N$ có biểu diễn:

dndn−1dn−2…d0,d−1d−2…d−md_nd_{n-1}d_{n-2}…d_0,d_{-1}d_{-2}…d_{-m}
dn​dn−1​dn−2​...d0​,d−1​d−2​...d−m​

trong đó có $n+1$ chữ số bên trái dấu phẩy, $m$ chữ số bên phải dấu phẩy thể hiện cho phần nguyên và phần phân của $N$, và 0≤di<b0 le d_i < b0≤di​<b. Khi đó giá trị của số N được tính theo công thức:

N=dnbn+dn−1bn−1+…+ d0b0+d−1b−1+d−2b−2+…+ d−mb−mN=d_nb^n+d_{n-1}b^{n-1}+…+text{ }d_0b^0+d_{-1}b^{-1}+d_{-2}b^{-2}+…+text{ }d_{-m}b^{-m}
N=dn​bn+dn−1​bn−1+...+ d0​b0+d−1​b−1+d−2​b−2+...+ d−m​b−m

Giá trị của một số trong hệ cơ số $b$ cũng chính là biểu diễn tương ứng của nó ở hệ cơ số $10$.

Cài đặt chương trình tính giá trị một số thực $N$ trong hệ cơ số $b$:

voidenter(){getline(cin, N);// Nhập N ở dạng xâu.
    cin >> B;}// Tính giá trị của biểu diễn N trong hệ cơ số B.doubleget_value(string N,int B){int pos = N.find('.');// Tìm vị trí dấu '.' của N.// Lấy phần nguyên và phần phân của N.
    string left_path = N.substr(0, pos), right_path = N.substr(pos +1, N.size()- pos);// Tính giá trị từng phần, lưu ý ép kiểu số thực.double value =0, power =1;for(int i = left_path.size()-1; i >=0;--i){
        value +=(double)(left_path[i]-'0')* power;
        power = power *(double)B;}

    power =1.0/(double)B;for(int i =0; i < right_path.size();++i){
        value +=(double)(right_path[i]-'0')* power;
        power /=(double)B;}return value;}

2. Các hệ cơ số thông dụng trong Tin học

Trong Tin học, ngoài hệ cơ số $10$, người ta còn sử dụng hai loại hệ đếm sau:

• Hệ cơ số $2$ (Hệ nhị phân): Chỉ sử dụng hai kí hiệu $0$ và $1$. Lấy ví dụ, 10112=1×20+1×21+0×22+1×23=11101011_2=1times 2^0 + 1times 2^1 + 0times 2^2 + 1times 2^3=11_{10}10112​=1×20+1×21+0×22+1×23=1110​.
• Hệ cơ số $16$ (Hệ thập lục phân hay hệ Hexa): Sử dụng các chữ số từ $0$ tới $9$ và $6$ chữ cái $A,B,C,D,E,F;$ trong đó $A,B,C,D,E,F$ có giá trị lần lượt là $10,11,12,13,14,15$. Lấy ví dụ, 16A=10×160+6×161+1×162=3621016A = 10times 16^0+6times 16^1+1times 16^2=362_{10}16A=10×160+6×161+1×162=36210​.

3. Biểu diễn số nguyên và số thực

3.1. Biểu diễn số nguyên

Trong Tin học, các số nguyên có thể được biểu diễn dưới dạng có dấu hoặc không dấu. Để biểu diễn số nguyên, ta có thể chọn kích thước số nguyên là $1$ byte, $2$ byte, $4$ byte$,…,2^N$ byte, mỗi cách chọn sẽ tương ứng với một khoảng giá trị có thể biểu diễn.

Đối với số nguyên không âm, kích thước 2N2^N2N byte sẽ lưu trữ được các số trong phạm vi từ $0$ tới (28×2N−1),(2^{8 times 2^N} – 1),(28×2N−1), bởi $1$ byte gồm $8$ bit và toàn bộ các bit đều được sử dụng để biểu diễn giá trị số.

Đối với số nguyên có dấu, bit bên phải nhất của số nguyên sẽ được dùng để thể hiện dấu của số đó, quy ước $1$ là dấu âm, $0$ là dấu dương, các bit còn lại sẽ dùng để biểu diễn giá trị số. Theo đó, số nguyên kích thước 2N2^N2N sẽ biểu diễn được các giá trị trong phạm vi (−28×2N−1+1)(-2^{8 times 2^N – 1} + 1)(−28×2N−1+1) đến (28×2N−1−1)(2^{8 times 2^N – 1} – 1)(28×2N−1−1). Vấn đề này sẽ liên quan tới việc lựa chọn kiểu dữ liệu và kiểm soát bộ nhớ chương trình khi lập trình.

<center>

</center>

3.2. Biểu diễn số thực

Khác với cách viết trong Toán học, khi mà ta dùng dấu $(,)$ để ngăn cách giữa phần nguyên và phần phân; trong Tin học ta thay dấu $(,)$ bằng dấu $(.)$, và các nhóm ba chữ số cạnh nhau sẽ viết liền. Ví dụ, trong toán ta viết $123 456,$$789;$ thì trong Tin học sẽ viết là $123456.789$.

Một cách biểu diễn mà máy tính sử dụng để lưu trữ số thực là dạng dấu chấm động, khi mọi số thực sẽ được biểu diễn ở dạng ±M×10±Kpm M times 10^{pm K}±M×10±K. Trong đó, $0,1\le M<1,$$M$ được gọi là phần định trị, và $K$ là một số nguyên không âm được gọi là phần bậc. Ví dụ, số $123456,789$ sẽ được biểu diễn dưới dạng 0.123456789×1060.123456789 times 10^60.123456789×106.

4. Phân tách các chữ số của một số nguyên

Giả sử số nguyên $N$ có $n$ chữ số được biểu diễn ở hệ thập phân dưới dạng:

N=dndn−1dn−2…d1N=d_nd_{n-1}d_{n-2}…d_1
N=dn​dn−1​dn−2​...d1​

Phân tích cấu tạo số của $N,$ ta có:
N=dn×10n−1+dn−1×10n−2+…+d1×100N=d_n times 10^{n – 1} + d_{n-1}times10^{n-2}+…+d_1times 10^0N=dn​×10n−1+dn−1​×10n−2+...+d1​×100⇒log(dn×10n−1)≤log(N)=log(dn×10n−1+dn−1×10n−2+…+d1×100)≤log(10n)Rightarrow log(d_ntimes 10^{n-1}) le log(N)=log(d_n times 10^{n – 1} + d_{n-1}times10^{n-2}+…+d_1times 10^0) le log(10^n)⇒log(dn​×10n−1)≤log(N)=log(dn​×10n−1+dn−1​×10n−2+...+d1​×100)≤log(10n)$\iff (n-1)\le log(N)\le n$.
$\iff log(N)\le n\le log(N)+1$.

Giữa hai số $log(N)$ và $log(N)+1$ chỉ có duy nhất một số là $[log(N)]+1$. Vậy $n=[log(N)]+1$. Ta có thể cài đặt chương trình tính số chữ số của số nguyên $N$ như sau:

intcnt_digits(int N){int digits =0;while(N !=0){++digits;
        N /=10;}return digits;}

Hoặc sử dụng trực tiếp hàm $\text{log}10$ của thư viện <cmath> trong C++:

intcnt_digits(int N){return(int)log10(N)+1;}

Dựa vào biểu diễn trên của số nguyên $N,$ ta nhận thấy, chữ số hàng đơn vị của N chính bằng $N\%10,$ chữ số hàng chục bằng $N\%100,...,$ chữ số ở hàng thứ $K$ tính từ phải qua trái chính bằng N % 10KN % 10^KN % 10K. Đối với bất kỳ hệ cơ số nào ta cũng có thể coi như đang ở hệ cơ số $10$ để tìm các chữ số từ phải qua trái theo cách này.

Cài đặt:

intfind_k_digits(int N,int K){int power =(int)pow(10, K);return N % power;}

III. Chuyển đổi giữa các hệ cơ số

1. Chuyển đổi từ hệ cơ số $10$ sang các hệ cơ số khác

Xét số thực $N$ ở hệ cơ số $10$. Để tìm biểu diễn của $N$ trong hệ cơ số $b$, ta sẽ lần lượt chuyển đổi phần nguyên và phần phân, sau đó ghép chúng lại với nhau.

1.1. Chuyển đổi phần nguyên

Xét phần nguyên của $N$ là $K$. Giả sử trong hệ đếm b, $K$ có giá trị là:

K=dnbn+dn−1bn−1+…+ d1b+d0K=d_nb^n + d_{n-1}b^{n-1} + … + text{ }d_1b + d_0
K=dn​bn+dn−1​bn−1+...+ d1​b+d0​

Do 0≤d0<b0 le d_0 < b0≤d0​<b nên khi chia $K$ cho $b$ thì phần dư của phép chia là d0d_0d0​, còn thương là:

K1=dnbn+dn−1bn−1+…+ d1K_1=d_nb^n + d_{n-1}b^{n-1} +…+ text{ }d_1
K1​=dn​bn+dn−1​bn−1+...+ d1​

Tương tự, d1d_1d1​ chính là phần dư của phép chia K1K_1K1​ cho $b,$ và sẽ thu được K2K_2K2​ là thương của phép chia đó. Lặp lại quá trình chia như trên tới khi thu được thương bằng $0$, khi đó biểu diễn của $K$ ở hệ cơ số $b$ là dn…d0d_n…d_0dn​...d0​. Nói cách khác, ta lấy $K$ chia cho $b$, thu nhận thương và số dư ở mỗi lần chia cho tới khi thương bằng $0$, khi đó viết các số dư theo thứ tự ngược từ dưới lên trên thì sẽ thu được biểu diễn của $K$ ở hệ cơ số $b$.

Ví dụ, với K=410K=4_{10}K=410​ và $b=2$, quá trình chuyển đổi sẽ diễn ra như sau:

• Chia $4$ cho $2$, thu được K1=2,d0=0K_1=2, d_0 = 0K1​=2,d0​=0.
• Chia $2$ cho $2$, thu được K2=1,d1=0K_2=1, d_1=0K2​=1,d1​=0.
• Chia $1$ cho $2$, thu được K3=0,d2=1K_3=0, d_2=1K3​=0,d2​=1.
• Tới đây quá trình dừng lại, thu được kết quả 410=10024_{10}=100_2410​=1002​.

Cài đặt:

// Chuyển phần nguyên K sang hệ đếm b, lưu vào string.
string change_integer_path(int K,int b){
    string res;while(K !=0){
        res =(char)(K % b +48)+ res;
        K /= b;}return res;}

1.2. Chuyển đổi phần phân

Xét phần phân của số thực $N$ là K′K’K′. Giả sử trong hệ đếm $b$, K′K’K′ có giá trị là:

K′=d−1b−1+d−2b−2+…+ d−mb−m (1)K’=d_{-1}b^{-1}+d_{-2}b^{-2}+…+text{ }d_{-m}b^{-m}text{ }(1)
K′=d−1​b−1+d−2​b−2+...+ d−m​b−m (1)

Nhân cả $2$ vế của $(1)$ với $b$, ta có:

K1′=d−1+d−2b−1+…+ d−mb−(m−1)K’_1=d_{-1}+d_{-2}b^{-1}+…+text{ }d_{-m}b^{-(m-1)}
K1′​=d−1​+d−2​b−1+...+ d−m​b−(m−1)

Ta thấy, d−1d_{-1}d−1​ chính là phần nguyên của kết quả phép nhân K′K’K′ với $b$, còn phần phân của kết quả là:

K2′=d−2b−1+…+ d−mb−(m−1) (2)K’_2=d_{-2}b^{-1}+…+text{ }d_{-m}b^{-(m-1)}text{ }(2)
K2′​=d−2​b−1+...+ d−m​b−(m−1) (2)

Tiếp tục lặp lại phép nhân như trên với (2), ta sẽ thu được d−2d_{-2}d−2​ là phần nguyên. Làm liên tục theo cách này, cuối cùng thu được dãy d−1d−2d−3…,d_{-1}d_{-2}d_{-3}…,d−1​d−2​d−3​..., trong đó 0≤di<b0 le d_i < b0≤di​<b. Nói cách khác, lấy phần phân K′K’K′ nhân liên tục với $b$, ở mỗi bước thu nhận chữ số ở phần nguyên của kết quả và lặp lại quá trình nhân với phần phân của kết quả cho tới khi thu được số lượng chữ số như ý muốn.

Ví dụ, với K′=0.12310,b=2K’=0.123_{10}, b=2K′=0.12310​,b=2 và cần lấy tới $5$ chữ số phần phân ở kết quả, ta làm như sau:

• 0.123×2=0.246→d−1=00.123 times 2 = 0.246 rightarrow d_{-1}=00.123×2=0.246→d−1​=0.
• 0.246×2=0.492→d−2=00.246 times 2 = 0.492 rightarrow d_{-2}=00.246×2=0.492→d−2​=0.
• 0.492×2=0.984→d−3=00.492 times 2 = 0.984 rightarrow d_{-3}=00.492×2=0.984→d−3​=0.
• 0.984×2=1.968→d−4=10.984 times 2 = 1.968 rightarrow d_{-4}=10.984×2=1.968→d−4​=1.
• 0.968×2=1.936→d−5=10.968 times 2 = 1.936 rightarrow d_{-5}=10.968×2=1.936→d−5​=1.
  $\cdots$

Tới đây thu được kết quả 0.12310=0.00011…20.123_{10}=0.00011…_20.12310​=0.00011...2​

Cài đặt:

// Chuyển phần phân K sang hệ đếm B, lấy cnt_digits chữ số phần phân.
string change_double_path(double K,int B,int cnt_digits){
    string ans;while(ans.size()< cnt_digits){double next_K = K *(double)B;int digit =(int)next_K;

        ans = ans +(char)(digit +48);
        K = next_K -(int)next_K;}return ans;}

2. Chuyển đổi hệ cơ số $X$ sang hệ cơ số $Y$

Để chuyển một số từ hệ cơ số $X$ sang hệ cơ số $Y,$ ta làm theo các bước sau:

• Bước $1$: Tính giá trị của $X$, nói cách khác là chuyển $X$ sang hệ cơ số $10$.
• Bước $2$: Chuyển kết quả vừa tìm được sang hệ cơ só $Y$ theo phương pháp chuyển một số ở hệ $10$ sang hệ $Y$ ở phần $1$.

Cài đặt:

// Chuyển số thực N từ hệ đếm X sang hệ đếm Y, lấy D chữ số sau dấu phẩy.
string change_X_to_Y(double N,int X,int Y,int D){
    string NN =to_string(N);double value_X =get_value(NN, X);int integer_path =(int)value_X;double double_path = value_X - integer_path;

    string res =change_integer_path(integer_path, Y)+'.'+change_double_path(double_path, Y, D);return res;}

3. Chuyển đổi giữa hệ cơ số $2$ (hệ nhị phân) và hệ cơ số $16$ (hệ Hexa)

Do $16$ là lũy thừa của $2$(16=24)(16=2^4)(16=24), nên việc chuyển đổi giữa hệ nhị phân và hệ hexa có thể được thực hiện dễ dàng theo quy tắc sau:

• Bước $1$: Tính từ vị trí phân cách phần nguyên và phần phân, ta gộp các chữ số thành từng nhóm $4$ chữ số về hai phía trái phải, nếu thiếu chữ số sẽ thay bằng các chữ số $0$.
• Bước $2$:Tính giá trị của từng nhóm chữ số, sau đó thay kết quả bằng một kí hiệu tương ứng ở hệ Hexa. Ví dụ $2$ tương ứng với $2$, $10$ tương ứng với $A$,…
• Bước $3$: Đặt các kí hiệu sau khi đã chuyển đổi vào đúng thứ tự của từng nhóm, ta thu được kết quả chuyển đổi.

Cài đặt:

char hexa[16]={'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};

string binary_to_hexa(double N){
    string NN =to_string(N);int pos = NN.find('.');
    string left_path = NN.substr(0, pos), right_path = NN.substr(pos +1, NN.size()- pos);// Bổ sung đủ chữ số 0 để tạo thành các nhóm 4.while(left_path.size()%4!=0)
        left_path ='0'+ left_path;while(right_path.size()%4!=0)
        right_path = right_path +'0';

    string ans_left, ans_right;for(int i =0; i < left_path.size()-3; i +=4){// Gộp cụm 4 kí tự liên tiếp.
        string group = left_path.substr(i,4);// Tính giá trị cụm 4 kí tự.int power =1, value =0;for(int j =3; j >=0;--j){
            value +=(group[j]-'0')* power;
            power *=2;}// Lấy kí tự hexa mang giá trị tương ứng.
        ans_left = ans_left + hexa[value];}for(int i =0; i < right_path.size()-3;++i){
        string group = left_path.substr(i,4);int power =1, value =0;for(int j =3; j >=0;--j){
            value +=(group[j]-'0')* power;
            power *=2;}

        ans_right = ans_right + hexa[value];}return(ans_left +'.'+ ans_right);}

Ở chiều hướng ngược lại, khi chuyển từ hệ nhị phân sang hệ hexa, chúng ta chỉ cần đổi từng kí tự hexa sang cụm bốn kí tự nhị phân có giá trị tương ứng, công việc này có thể thực hiện dễ dàng như sau:

voidhexa_to_binary(double N){
    string NN =to_string(N);for(int i =0; i < NN.size();++i)switch(NN[i]){case'0':
                cout <<"0000";break;case'1':
                cout <<"0001";break;case'2':
                cout <<"0010";break;case'3':
                cout <<"0011";break;case'4':
                cout <<"0100";break;case'5':
                cout <<"0101";break;case'6':
                cout <<"0110";break;case'7':
                cout <<"0111";break;case'8':
                cout <<"1000";break;case'9':
                cout <<"1001";break;case'A':
                cout <<"1010";break;case'B':
                cout <<"1011";break;case'C':
                cout <<"1100";break;case'D':
                cout <<"1101";break;case'E':
                cout <<"1110";break;case'F':
                cout <<"1111";break;default:// Trường hợp dấu '.' ngăn cách phần nguyên và phần phân.continue;break;}}

IV. Tài liệu tham khảo

• https://en.wikipedia.org/wiki/Numeral_system
• Sách giáo khoa Tin học 10 – Thầy Hồ Sĩ Đàm