Foundational questions are often lost not because the ideas are advanced, but because one small representation error travels into the next step. A wrong bit can spoil a base conversion, Boolean result, address calculation or architecture trace. Translate 45.375 into 101101.011, reason about F(A,B,C) = Sigma m(1,2,3,5,7), size a 32 KiB byte-addressable memory, and follow a value through a simple CPU to connect number representation, Boolean logic, memory and architecture. The concepts stay stable, but always confirm the current Basic or Senior scope through the applicable official RSSB notice.
Map the RSSB digital logic and computer fundamentals block before solving
Concept | What you must be able to produce |
|---|---|
Number systems | Correct binary, octal and hexadecimal representation |
Boolean reasoning | Truth table, simplified function and gate circuit |
Memory units | Capacity, word count, addresses and address lines |
Basic architecture | A CPU, register, ALU, bus and memory trace |
The RSSB Basic Computer Instructor course covers Digital Logic Systems plus Computer Organization and Architecture. The RSSB Senior Computer Instructor course covers Fundamentals of Computer plus Boolean expression and minimisation. The applicable official RSSB notice is the authority for the current Basic or Senior syllabus. Reuse this order: identify representation, write powers or truth rows, operate, reverse-check, then attach the hardware or memory meaning.
Convert 45.375 across decimal, binary, octal and hexadecimal
Separate the integer and fractional parts first. For the integer:
45 = 32 + 8 + 4 + 1 = 2^5 + 2^3 + 2^2 + 2^0
The coefficients from 2^5 to 2^0 are 1, 0, 1, 1, 0, 1, so (45)10 = (101101)2.
For the fraction, multiply repeatedly by 2 and record each integer part in order:
0.375 x 2 = 0.75, record0.0.75 x 2 = 1.5, record1.0.5 x 2 = 1.0, record1.
Therefore, (45.375)10 = (101101.011)2.
Now group bits outward from the radix point. Octal uses groups of three: 101 101 . 011, so the result is (55.3)8. Hexadecimal uses groups of four, padded only at the outer ends: 0010 1101 . 0110, so the result is (2D.6)16.
Reverse-check the hexadecimal form:
2 x 16 + 13 + 6/16 = 32 + 13 + 0.375 = 45.375
For more practice with this check, use Number Systems and Base Conversions Explained.
Simplify one Boolean function and realise it with gates
Take F(A,B,C) = Sigma m(1,2,3,5,7). Here the minterm number is decimal ABC, with A as the most significant bit. Write all eight rows:
A | B | C | Minterm | F |
|---|---|---|---|---|
0 | 0 | 0 | 0 | 0 |
0 | 0 | 1 | 1 | 1 |
0 | 1 | 0 | 2 | 1 |
0 | 1 | 1 | 3 | 1 |
1 | 0 | 0 | 4 | 0 |
1 | 0 | 1 | 5 | 1 |
1 | 1 | 0 | 6 | 0 |
1 | 1 | 1 | 7 | 1 |
Put these values in K-map rows A = 0, 1 and Gray-code columns BC = 00, 01, 11, 10. The four-cell group m1, m3, m5, m7 gives C. The pair m2, m3 gives A'B because A = 0 and B = 1 stay fixed. The minimum SOP is:
F = C + A'B
For A=1, B=0, C=1, F = 1 + 0 = 1. For A=1, B=1, C=0, F = 0 + 0 = 0. Both match the table. Implement it with three gates: NOT makes A', AND makes A'B, and OR combines that term with C. Continue with the Boolean Algebra and K-map Minimization Guide.
Turn 32 KiB of memory into bytes, words and address lines
State the organisation before calculating: this memory is 32 KiB, byte-addressable, and attached to a 16-bit data path.
32 KiB = 32 x 1024 bytes = 32768 bytes = 2^15 bytes
Because each address selects one byte, there are 2^15 addressable locations and therefore 15 address lines. The byte-address range is 0x0000 through 0x7FFF, giving exactly 32768 distinct addresses.
The total storage in bits is:
32768 x 8 = 262144 bits
A 16-bit word occupies 2 bytes, so the same memory holds:
32768 / 2 = 16384 non-overlapping 16-bit words.
The assumptions matter because a word-addressable memory would produce a different location count. Also keep binary and decimal prefixes separate: 32 KiB means 32768 bytes, while decimal 32 kB means 32000 bytes. Never switch between them halfway through a solution.
Trace one value through CPU registers, the ALU and memory
Use a simple teaching machine with 16-bit registers and data path, byte-addressable memory, PC = 0x0100, R2 = 0x0003, and the 16-bit word 0x0006 stored across addresses 0x002C-0x002D. Its schematic program is LOAD R1,[0x002C], ADD R1,R2, then STORE [0x0030],R1. Labels 0x0100, 0x0102 and 0x0104 mark trace steps, not a real instruction encoding.
For the first fetch, PC -> MAR, instruction memory sends the instruction -> MDR -> IR, and the control unit decodes it. The next schematic PC label is 0x0102. During load, 0x002C -> MAR, then memory sends 0x0006 -> MDR -> R1.
For add, the ALU receives 0x0006 and 0x0003:
0x0006 + 0x0003 = 0x0009
Thus R1 = 0x0009, carry flag C = 0, and zero flag Z = 0. For store, R1 -> MDR, 0x0030 -> MAR, and 0x0009 goes to the two bytes starting at 0x0030.
The control unit sequences transfers. The ALU computes, registers hold working values, the address bus selects a location, the data bus carries the word, and memory retains instructions or data.
Practise five question forms across digital logic and computer fundamentals
Build practice around five prompt forms:
Direct conversion, such as
(45.375)10to binary.Reverse conversion, such as
(2D.6)16to decimal.Boolean truth-table, equivalence or gate-output work.
Memory capacity and address-line calculation.
CPU-component identification or a register-transfer trace.
Rotate among all five forms instead of drilling only one representation. Start untimed, mark the exact step where an error begins, and repeat that step with new values. On the next attempt, mix conversion, Boolean, memory and architecture prompts so you must recognise the method before applying it.
Before building an RSSB-specific practice set, check the current Basic or Senior syllabus and pattern instructions on the official RSSB site. Use the applicable RSSB bulletin whenever a question depends on the current exam structure.
Fix the traps that make easy-looking questions expensive
If octal or hexadecimal grouping starts at the left edge, stop and regroup outward from the radix point. Pad only at the outer ends. If 101101.011 looks like a decimal string, expand it with powers of two before assigning its value.
K-map cells cannot be grouped diagonally. Rewrite the Gray-code order, use only horizontal or vertical adjacency, and remember that edge cells can be adjacent by wrap-around.
For memory questions, write the addressable unit before using powers of two. Here 2^15 byte locations require 15 address lines, not 16. Keep bit, byte, kB and KiB beside every intermediate value. In an architecture trace, the address bus carries 0x002C, while the data path carries 0x0006. Do not swap their jobs.
Finish every solution with a ten-second check: reverse the conversion, test one truth row, verify the largest address, or trace the value back to its source register.
The short version and the right RSSB next step
Use this recall card:
Powers for conversion.
Gray order for K-maps.
Capacity divided by addressable unit for locations.
log2(locations)for address lines.PC-MAR-MDR-IR, registers and ALU for a trace.
The four anchors are 45.375 = 101101.011 = 55.3 = 2D.6, F = C + A'B, 32 KiB = 2^15 bytes, and 0x0006 + 0x0003 = 0x0009.
Spend 25 minutes: redo both conversion directions for 7, redraw the K-map for 7, reproduce the memory arithmetic for 5, and narrate the CPU trace for 6. Check exact agreement, not speed. Use the RSSB Computer Instructor Exam Prep category, then choose Basic or Senior only after matching your target post with the current official syllabus.
