Determining the group number in Grandson tests
2021-03-17
Witold Paluszyński
1. Introduction
The Grandson test system assumes writing a simple test in the lecture hall in
several groups. Each student determines his/her group number based on
their university student number (index or album number), and the test bitmask,
which is a binary number provided by the instructor for each test.
The method of calculating the group number is very specific, but it has
been designed so that the group number can be determined in a very simple
way, reducing as much as possible the chance of calculation errors, even
with a completely manual procedure.
This method of calculating group numbers was invented by my late colleague
and very good friend Marek Wnuk, a well-known and highly respected
scientist and lecturer at the Faculty of Electronics of Wroclaw University
of Science and Technology. In his honor, I have named this type of test
the Grandson Test.
(Marek's last name, Wnuk, is a Polish word which means: Grandson.)
The student number is a six-digit decimal number. For the calculations, the
binary version of this number will be needed.
The test mask is always a binary number. It may contain one or more ones.
We always get the resulting group number as a binary number, but we need to
interpret it as just a number, i.e. convert it to the decimal version.
2. The Android app
The simplest way of computing the group number is to use the Android app
available here:
3. Manually computing the group number
The calculation of the group number can be explained by the following examples.
Suppose the student number is 222222. The binary version of this number is
110110010000001110. For the calculation of the group number, it is sufficient
to use the tail end of that number. In practice we will never need more than
the last eight bits of the binary student number:
The rule for determining the group number: match the test
bitmask to the tail of the student number, then select from the student number
the bits indicated by the ones in the test bitmask. The combination of
these bits is the binary group number.
Example 1: test bitmask is 11
| test bitmask | 1 | 1 |
|---|
| student number | ... | 0 | 0 | 0 | 0 | 1 | 1 | 1 | 0 |
|---|
| selected bits | 1 | 0 |
|---|
the group number is binary 10, decimal 2
Example 2: test bitmask is 1010
| test bitmask | 1 | 0 | 1 | 0 |
|---|
| student number | ... | 0 | 0 | 0 | 0 | 1 | 1 | 1 | 0 |
|---|
| selected bits | 1 | | 1 | |
|---|
the group number is binary 11, decimal 3
Example 3: test bitmask is 10001
| test bitmask | 1 | 0 | 0 | 0 | 1 |
|---|
| student number | ... | 0 | 0 | 0 | 0 | 1 | 1 | 1 | 0 |
|---|
| selected bits | 0 | | 0 |
|---|
the group number is binary 00, decimal 0
Example 4: test bitmask is 10101
| test bitmask | 1 | 0 | 1 | 0 | 1 |
|---|
| student number | ... | 0 | 0 | 0 | 0 | 1 | 1 | 1 | 0 |
|---|
| selected bits | 0 | | 1 | | 0 |
|---|
the group number is binary 010, decimal 2
4. Remembering the student number
Determining the group number based on the student number and test bitmask
requires no arithmetic calculations, only bit matching and selection.
Theoretically, it should be possible - and easy - by drawing on a piece of
paper a table like in the above examples, and simply reading the group number.
However, the problem is remembering the binary student number.
This task can be much simplified by using an intermediate hexadecimal form.
For example, the aforementioned student number 222222 is hexadecimal 3640E.
It is important to remember that in the hex representation, each hex digit
corresponds to exactly four bits of the binary representation. So instead of
remembering the last eight digits (bits) of the binary student number, it is
equivalent to remember the last two hexadecimal digits: 0E. How? You have to
repeat to yourself for several hours per day: I am 0E. I am 0E. I am 0E. ...
And then what can we do with it? Just practice the binary-hexadecimal
conversion patterns:
0(hex)=0000(bin) 4(hex)=0100(bin) 8(hex)=1000(bin) C(hex)=1100(bin)
1(hex)=0001(bin) 5(hex)=0101(bin) 9(hex)=1001(bin) D(hex)=1101(bin)
2(hex)=0010(bin) 6(hex)=0110(bin) A(hex)=1010(bin) E(hex)=1110(bin)
3(hex)=0011(bin) 7(hex)=0111(bin) B(hex)=1011(bin) F(hex)=1111(bin)
and the remembered 0E ending can be rewritten from memory to the required
0000 1110.