`2^8 = 256` .

`256` getallen is bij lange na niet genoeg.

`150_(10) = 10010110_2` en `text(-)150 = 01101010_2` .

`10010110_2 + 01101010_2 = (1)00000000_2` .

`186_(10) - 150_(10) = 10111010_2 + 01101010_2 = (1)00100100_2` .

`150_(10) - 186_(10) = 10010110_2 + 01000110_2 = (0)11011100_2` .

`00001010 + 11111001 = (1)00000011` (decimaal: `10 - 7 = 3` ).

`00000111 + 11110110 = (0)11111101` (decimaal: `7 - 10 = text(-)3` ).

`11011001 + 11101011 = (1)11000100` (decimaal: `217 - 21 = 196` ).

`00010101 + 00100111 = (0)00111100` (decimaal: `217 - 21 = text(-)196` ).

Je haalt eerst `100` keer `1101` van `1000001` af:
`01000001 - 00110100 = 01000001 + 11001100 = (1)00001101` .

Vervolgens haal je `1` keer `1101` van `00001101` af: `00001101 - 00001101 = 00000000` .

Dus kun je `100 + 1 = 101` keer `1101` van `1000001` afhalen.
Ofwel: `1000001 // 1101 = 101` .

Controle: `65_(10) // 13_(10) = 5_(10)` .

Ofwel zo laten, het antwoord wordt dan als breuk weergegeven, ofwel een binaire komma invoeren. Zie Toepassen .

`0000000101010000 - 0000000001111101 =`
`0000000101010000 + 1111111110000011 = 0000000011010101`

`0000000001111101 - 0000000101010000 =`
`0000000001111101 + 1111111010110000 = (0)1111111100101101`
en dat is het complement van `0000000011010101` .

`46_(10) + 19_(10) = 0000000001000011`
Dus: `0000000000100011 + 1111111110111101 = 1111111111100000` .

`10011111`

`(0)10101001`

`(1)01010111`

Dit past niet in een `8` -bits systeem.

Doen, vergelijk je resultaten met het voorbeeld.

`10111010 // 00001101 = 00001110` rest `00000100` .
Controle: `186_(10) // 13_(10) = 14_(10)` rest `4` .

`a - b = 11001101 - 00101001 = 11001101 + 11010111 = (1)10100100` .
En `205_(10) - 41_(10) = 164_(10) = 10100100_2` .

`b - a = 00101001 - 11001101 = 00101001 + 00110011 = (0)01011100` met complement `10100100` .
En `41_(10) - 205_(10) = text(-)164_(10)` .

`a//b = 100 + 1 = 101` .
En `205_(10) // 41_(10) = 5_(10) = 101_2` .

`1111111111111111 = 2^(15) + 2^(14) + ... + 2^2 + 2^1 + 2^0 = 65535_(10)` .

`0000000000000001`

`1111111111111111 + 0000000000000001 = (1)0000000000000000` .

`6_(10) + 7_(10) = 110 + 111 = 1101 (= 13_(10))`

`(156_(10))/(1101_2) = (10011100)/(1101) = 1100 (=12_(10))`

`15_(10) * (11/3)_(10) = 15_(10) * (11_(10))/(3_(10)) = (15_(10))/(3_(10))*11_(10)`

`(15_(10))/(3_(10)) = (1111)/(11) = 101`

`101_2 * 11_(10) = 101 * 1011 = 110111 (= 55_(10))`

`00011010 // 00000101 = 101` met rest `1` .
Controle: `26_(10) // 5_(10) = 5_(10)` met rest `1_(10)` .

`11011010 // 00000111 = 11111` met rest `1` .
Controle: `218_(10) // 7_(10) = 31_(10)` met rest `1_(10)` .

Bijvoorbeeld als `11,110100` en `00,101000` .

Of als `0011,1101` en `0000,1010` .

`0011,1101 - 0000,1010 = 0011,1101 + 1111,0110 = (1)0011,0011`

Controle: `11,1101_2 - 0,101_2 = 3,8125_(10) - 0,625_(10) = 3,1875_(10) = 0011,0011_2` .

`10,1101 // 0,101 = 00101101 // 00001010 = 100,1`

Controle: `10,1101_2 // 0,101_2 = 2,8125_(10) // 0,625_(10) = 4,5_(10) = 100,1_2` .

Doe dit op dezelfde manier als in het Toepassen, of voer de deling `6_(10)//10_(10) = 110_2 // 1010_2` uit.

`0,6_(10)` is niet in machten van `2` te verdelen.

`0,75_(10) = 0,5_(10) + 0,25_(10) = 2^(text(-)1) + 2^(text(-)2) = 0,11_2` .

Nee: `0,1_(10) = 0,00011001100110011..._2` .

`a - b = 00110101 - 00011101 = (1)00011000`

`a = 110101_2 = 53_(10)` en `b = 11101_2 = 29` .
`a-b = 53_(10) - 29_(10) = 24_(10) = 00011000_2` .

`c // b = 11`

`c = 1010111_2 = 87_(10)` en `b = 11101_2 = 29` .
`c//b = 87_(10) // 29_(10) = 3_(10) = 11_2` .

`10011001 - 01000011 = 10011001 + 10111101 = (1)01010110` .
Ga na dat `01010110_2 = 153_(10) - 67_(10) = 86_(10)` .

`10011001 // 01000011 = 10` met rest `10011` .
Ga na dat `10_2 = 153_(10) // 67_(10) = 2_(10)` met rest `19_(10)` .