`13b5_(16) = 1*16^3 + 3*16^2 + 11*16^1 + 5*16^0 = 5045` .

`1103_(16) = 1*16^3 + 1*16^2 + 0*16^1 + 3*16^0 = 4355_(10) != 1103_(10)` .

Deel `1103_(10)` door `16` .
Je krijgt `68_(10)` met rest `15_(10) = f_(16)` .

Deel `68_(10)` door `16` .
Je krijgt `4_(10)` met rest `4_(10) = 4_(16)` .

`4_(10)` is verder niet door `16` te delen.

Uitkomst: `1103_(10) = 44f_(16)` .

Je vervangt elk hexadecimaal symbool door de `4` -bits binaire code uit de tabel die erbij hoort.

Dus: `13b5_(16) = 0001.0011.1011.0101_2` .

Bij a is dat al aangetoond dat `13b5_(16) = 5045_(10)` .

Laat nog zien, dat `0001001110110101_2 = 5045_(10)` .

`1011011001_2 = 0010.1101.1001_2 = 2d9_(16)` .

`1011011001_2 = 729_(10)`

`2d9_(16) = 729_(10)`

66.99.CC wordt `102.153.204` .

`204_(10) = 12*16^1 + 2*16^0 = cc_(16)` en `51_(10) = 3*16^1 + 3*16^0 = 33_(16)` .

`204.51.51` wordt CC.33.33.

Het RGB-systeem loopt van `00.00.00` tot `ff.ff.ff` (hexadecimaal).

En dus van `0.0.0` tot `255.255.255` (hexadecimaal).

Er zijn daarom `256*256*256 = 16777216` verschillende kleurcodes.

`aa04f_(16) = 10*16^4 + 10*16^3 + 0*16^2 + 4*16 + 15 = 696399_(10)`

`65034_(10) // 16 = 4064_(10)` met rest `10_(10) = a_(16)` .
`4064_(10) // 16 = 254_(10)` met rest `0_(10) = 0_(16)` .
`254_(10) // 16 = 15_(10)` met rest `14_(10) = e_(16)` .
`15_(10) = f_(16)` .
Dus: `65034_(10) = fe0a_(16)` .

`ffff_(16) = 15*16^3 + 15*16^2 + 15*16 + 15 = 65535_(10)`

`1100100100_2 = 0011.0010.0100 = 324_(16)`

`3d0f_(16) = 0011.1101.0000.1111 = 11110100001111_2`

In het voorbeeld zie je dat het grootste getal `ffff_(16)` is.

`2^(32) = 4.294.967.296` .

`1000100110101101111000010000111_2 =` ` 0100.0100.1101.0110.1111.0000.1000.0111 = 44d6f087_(16)`

`1a0b_(16) = 1*16^3 + 10*16^2 + 11 = 6667_(10)` .

`1200f_(16) = 1*16^4 + 2*16^3 + 15 = 73743_(10)` .

`cafe_(16) = 12*16^3 + 10*16^2 + 15*16 + 14 = 51966_(10)` .

`4096_(16) = 100_(10)`

`14096 // 16 = 881` rest `0_(10) = 0_(16)` .
`881 // 16 = 55` rest `1_(10) = 1_(16)` .
`55 // 16 = 3` rest `7_(10) = 7_(16)` .
`3_(10) = 3_(16)` .
Dus `14906_(10) = 3710_(16)` .

`104906_(16) = 196a0_(16)` .

`10111110111110010011010_2 = 0101.1111.0111.1100.1001.1010 = 5f7c9a_(16)`

`79cf0_(16) = 0111.1001.1100.1111.0000 = 1111001110011110000_2`

`003c_(16) = 3*16 + 12 = 60` .

`03b1_(16) = 3*16^2 + 11*16 + 1 = 945` .

`8658_(10) = 21d2_(16)` en dus Unicode U+21D2.
Even in Google deze code invoeren en je ziet dat het een dubbele pijl naar rechts is.

Het decimale stelsel is onhandig omdat omrekenen naar binair (wat nu nog voor onze computers nodig is) nogal bewerkelijk is.

Het binaire stelsel is onhandig omdat dit voor mensen vrijwel onleesbaar is.

Het hexadecimale stelsel is handig omdat dit voor mensen nog leesbaar is en gemakkelijk te vertalen is naar een binaire vorm.

Met IPv4 `2^(32) = 4.294.967.296` , slechts ongeveer `4,3` miljard.

Met IPv6 `2^(128) ~~ 3,4 * 10^(38)` adressen, best wel meer...

Er zijn `8` groepen hexadecimale getallen van `4` tekens. Elk hexadecimaal teken bestaat uit `4` bits. Dus in totaal zijn er `8*4*4=128` bits.

2001:0db8:85a3:0000:1319:8a2e:0370:7344 kun je schrijven als:
0010.0000.0000.0001:0000.1101.1011.0100:1000.0101.1010.0011:0000.0000.0000.0000:
0001.0011.0001.1001:1000.1010.0010.1110:0000.0011.0111.0000:0111.0011.0100.0100

`a0bf13_(16) = 10534675_(10)` .

`16000_(10) = 3f80_(16)`

`1101111100110110010011010_2 = 1be6c9a_(16)`

`a0bf13_(16) = 10100000101111110011_2`