Data representation and computer logic

A1.2.1 Binary and hexadecimal

In any base, each place is worth the base times the place to its right. A bit is one binary digit, a nibble is 4 bits, and a byte is 8 bits.

00101011₂ = 32 + 8 + 2 + 1 = 43₁₀. Always write the place values down first.

Every conversion

Hex digits run 0–9, then A = 10 up to F = 15. Programmers use hex because each digit maps to exactly 4 bits, so it is a compact way to read binary in memory dumps, debugging tools and colour codes.

Prefixes

The scale continues with exa and zetta. A lowercase b means bits and an uppercase B means bytes, so 100 MB/s is eight times faster than 100 Mb/s.

def to_binary(n):
    bits = ""
    while n > 0:
        bits = str(n % 2) + bits
        n = n // 2
    return bits.zfill(8)


def to_decimal(bits):
    total = 0
    for b in bits:
        total = total * 2 + int(b)
    return total


def to_hex(n):
    digits = "0123456789ABCDEF"
    out = ""
    while n > 0:
        out = digits[n % 16] + out
        n = n // 16
    return out or "0"


print(to_binary(42))            # 00101010
print(to_decimal("10111011"))   # 187
print(to_hex(254))              # FE

Next: text →

A1.2.2 Characters and strings

Text is stored by giving each character a number. Everyone must agree on the numbers, which is why encoding standards exist.

ASCII

ASCII was standardized in 1963 so that devices from different makers could exchange text. It began with 7 bits (128 characters). Extended ASCII uses 8 bits (256 characters), but countries filled the extra space differently, so documents did not always travel well.

The codes have a neat pattern. The first three bits show the case, and the last five give the position in the alphabet:

Unicode

The Unicode Consortium formed in 1991 to give every character in every language one unique number. Version 15.0 from 2022 has 149,186 characters, including Thai, Chinese and emoji. In Python, ord("A") returns 65 and ord("ก") returns 3585.

How UTF-8 marks its bytes

The leading 1s say how many bytes belong to the character, and 10 marks a continuation byte. Remove the markers, join the x bits, and you have the code point. This keeps ASCII text at its original size. Its drawback is that variable-length characters take more processing than a fixed width.

def encode(text):
    return "".join(format(ord(c), "08b") for c in text)


def decode(bits):
    return "".join(chr(int(bits[i:i + 8], 2)) for i in range(0, len(bits), 8))


secret = encode("Meet at noon")
print(secret)
print(decode(secret))   # Meet at noon

def shift(message, key):
    out = ""
    for ch in message:
        if ch.isalpha():
            base = ord("A") if ch.isupper() else ord("a")
            out += chr((ord(ch) - base + key) % 26 + base)
        else:
            out += ch
    return out


def decrypt(message, key):
    return shift(message, -key)


def brute_force(message):
    for key in range(1, 26):
        print(key, decrypt(message, key))


code = shift("Hello", 3)
print(code)              # Khoor
print(decrypt(code, 3))  # Hello
brute_force(code)        # the real word appears at key 3

Next: images, audio and video →

Images

A bitmap is a grid of pixels, each stored as a binary value. Two settings control its quality and its size:

image size in bits = width × height × colour depth

Real files are larger because they hold metadata such as dimensions and colour depth. Sharpness also depends on pixels per inch: the same image looks clearer on a phone than on a cinema screen.

Most screens use 24-bit colour: one byte each for red, green and blue, which gives about 16.8 million colours. Each channel runs 0–255, so a colour can be written in hex. RGB (216, 190, 199) is #D8BEC7.

from PIL import Image        # pip install pillow

image = Image.open("photo.jpg").convert("RGB")
width, height = image.size
result = Image.new("RGB", (width, height))

for y in range(height):
    for x in range(width):
        r, g, b = image.getpixel((x, y))
        grey = int(0.3 * r + 0.59 * g + 0.11 * b)
        result.putpixel((x, y), (grey, grey, grey))

result.save("grey.jpg")

Audio

Sound is a continuous analogue wave. An analogue-to-digital converter samples its amplitude at regular intervals and stores each sample in binary.

bits per second = sample rate × bit depth × channels

Video

A container format such as MP4, MKV or AVI holds frames, audio tracks, metadata and subtitles. Frames are still images shown at 24–60 per second, like a flipbook.

raw bits = width × height × colour depth × frames per second × seconds

Raw frames are far too large, so they are compressed. They are often converted from RGB to YUV, which keeps brightness separate from colour. Eyes are more sensitive to brightness, so colour detail can be reduced.

Next: integers and reals →

Storing integers

Gray code for 0–7

Storing real numbers

Fixed point

The binary point stays in one agreed position. After the point, the places are worth ½, ¼, ⅛ and 1/16. With four bits on each side, 6.75 is 0110.1100. As a signed value this format runs from −8 to 7.9375 in steps of 0.0625. It is simple and fast, but its range is small.

Floating point (IEEE 754)

Floating point works like scientific notation in binary. Single precision uses 32 bits:

Floating point covers a huge range, which is why science, engineering and graphics rely on it. It still cannot store every decimal exactly, so rounding errors happen, and it needs more complex hardware.

Next: logic gates →

A1.2.3 Logic gates

In the 1800s George Boole described logic as algebra. Claude Shannon later showed that it could design electrical circuits. Transistors, invented in 1947, made small gates possible, and they are the building blocks of every digital device.

A transistor is a switch: voltage on its control wire lets current flow between two electrodes. Join transistors in series and both must be on, which gives AND. Join them in parallel and either can be on, which gives OR.

The gates

Original diagrams. In exams, write NOT as a bar over the term. A buffer gate simply outputs its input.

NAND is AND then NOT, NOR is OR then NOT, and XNOR is XOR then NOT.

Next: truth tables →

A1.2.4 Truth tables

From a circuit

1. Count the inputs. n inputs give 2ⁿ rows.
2. Fill the inputs: the right column alternates every row, the next every two rows, the next every four.
3. Add a column for each intermediate point in the circuit.
4. Work from left to right through the circuit, then fill in the output.

From a description

Find the inputs, then look for words that signal gates: “and”, “or”, “not”, “unless”.

Order of operations

Brackets come first, then NOT, then AND and NAND, then OR, NOR and XOR.

Next: Karnaugh maps →

Karnaugh maps

A K-map lays out a truth table so that patterns show up. Simplifying an expression means fewer gates, which saves cost, space and power.

Grouping rules

• Group only 1s, in sizes of 1, 2, 4 or 8.
• Groups are rectangles. Diagonals are not allowed.
• Make each group as large as possible, and use as few groups as you can.
• Groups may overlap.
• Groups may wrap around from the left edge to the right edge.

For each group, keep a variable only if it stays the same across the whole group. Join the groups with OR.

Next: logic diagrams →

A1.2.5 Logic diagrams

To draw a circuit from an expression, work from the brackets outward, as you would in maths.

Example: Y = (A · B) + (NOT A · NOT B)

1. Draw inputs A and B on the left.
2. Connect A and B to an AND gate for the first bracket.
3. Connect A to one NOT gate and B to another, then feed both into a second AND gate.
4. Feed both AND outputs into an OR gate. Its output is Y.

Next: review →

Quick quiz

Exam-style questions

These are written for this site in the style of Paper 1. Answer on paper first, then open the mark points.

1. Convert 11010110 to hexadecimal, showing your working. [2]

   Mark points

   • Split into nibbles: 1101 and 0110 [1].
   • 13 and 6, so D6 [1].

2. Calculate the file size in kilobytes of a 640 × 480 bitmap with 1024 colours, ignoring metadata. [2]

   Mark points

   • 1024 colours need 10 bits per pixel [1].
   • 640 × 480 × 10 = 3,072,000 bits = 384,000 bytes = 384 KB [1].

3. Calculate the storage in MB for one minute of 48 kHz, 24-bit stereo audio. [3]

   Mark points

   • 48,000 × 24 × 2 = 2,304,000 bits per second [1].
   • × 60 = 138,240,000 bits [1].
   • ÷ 8 = 17,280,000 bytes = 17.28 MB [1].

4. Explain why UTF-8 is preferred to UTF-32 for web pages. [3]

   Mark points

   • UTF-8 uses a single byte for ASCII characters, while UTF-32 always uses four [1].
   • Pages are smaller, so they use less storage and transfer faster [1].
   • It stays backward compatible with existing ASCII text [1].

5. Distinguish between spatial and temporal video compression. [2]

   Mark points

   • Spatial removes redundancy within a single frame [1].
   • Temporal removes redundancy between frames by storing only the differences [1].

6. Represent −12 in 8-bit two’s complement, showing each step. [3]

   Mark points

   • +12 = 00001100 [1].
   • Invert: 11110011 [1].
   • Add 1: 11110100 [1].

7. Outline one advantage and one disadvantage of floating point over fixed point. [2]

   Mark points

   • Advantage: represents a much larger range of values [1].
   • Disadvantage: arithmetic is more complex and slower, or some values have rounding errors [1].

8. A greenhouse fan runs if the manual switch M is on, or if it is hot H and the door D is closed. Using D = 1 for open, write a Boolean expression and construct the truth table. [4]

   Mark points

   • X = M + (H · NOT D) [1].
   • Eight rows with all input combinations [1].
   • X = 1 on every row where M = 1 [1].
   • With M = 0, X = 1 only at H = 1, D = 0 [1].

9. Use a Karnaugh map to simplify NOT A · B · NOT C + NOT A · B · C + A · B · C. [3]

   Mark points

   • Correct K-map with 1s at AB = 01 for C = 0 and C = 1, and AB = 11 for C = 1 [1].
   • Group of two gives NOT A · B [1].
   • Second group gives B · C, so X = NOT A · B + B · C [1].