Sync intergalactic transmission with problem specs

Author: kahgoh

exercises/practice/intergalactic-transmission/.docs/instructions.md

@@ -1,37 +1,54 @@
 # Instructions
 
-Your job is to help implement the message sequencer to add the parity bit to the messages and the decoder to receive messages.
+Your job is to help implement
 
-The entire message, itself, is sequence of a number of bytes.
-The transmitters and receivers can only transmit and receive one byte at a time, so parity bit needs to be added every eighth bit. 
-The algorithm for adding the bits is as follows:
-1. Divide the message bits into groups of 7, starting from the left (the message is transmitted from left to right).
-2. If the last group has less than 7 bits, append some 0s to pad the group to 7 bits.
-3. For each group, determine if there are an odd or even number of 1s.
-4. If the group has even number of 1s or none at all, append a 0 to the group. Otherwise, append 1 if there is odd number.
+- the transmitter, which calculates the transmission sequence, and
+- the receiver, which decodes it.
 
-For example, consider the message 0xC0_01_C0_DE.
-Writing this out in binary and locating every 7th bit:
+A parity bit is simple way of detecting transmission errors.
+The transmitters and receivers can only transmit and receive _exactly_ eight bits at a time (including the parity bit).
+The parity bit is set so that there is an _even_ number 1s in each transmission and is always the first bit from the right.
+So if the receiver receives `11000001`, `01110101` or `01000000` (i.e. a transmission with an odd number of 1 bits), it knows there is an error.
+
+However, messages are rarely this short, and need to be transmitted in a sequence when they are longer.
+
+For example, consider the message `11000000 00000001 11000000 11011110` (or `C0 01 C0 DE` in hex).
+
+Since each transmission contains exactly eight bits, it can only contain seven bits of data and the parity bit.
+A parity bit must then be inserted after every seven bits of data:
 
 ```text
-C    0    0    1    C    0    D    E
-1100_0000 0000_0001 1100_0000 1101_1110
-       ↑        ↑        ↑       ↑        (7th bits)
+11000000 00000001 11000000 11011110
+      ↑       ↑       ↑       ↑          (7th bits)
 ```
 
-The last group has only 4 bits (0b1110), so three 0 bits are appended to make it 7 bits:
+The transmission sequence for this message looks like this:
 
 ```text
-| 1100_000 | 0000_000 | 0111_000 | 0001_101 | 1110_000 |
+1100000_ 0000000_ 0111000_ 0001101_ 1110
+       ↑        ↑        ↑        ↑      (parity bits)
 ```
 
-The first group contains two 1s (an even number of 1s), so 0 is appended to the group.
-The second group has none, so append 0.
-The rest have three, so they append 1.
+The data in the first transmission in the sequence (`1100000`) has two 1 bits (an even number), so the parity bit is 0.
+The first transmission becomes `11000000` (or `C0` in hex).
+
+The data in the next transmission (`0000000`) has zero 1 bits (an even number again), so the parity bit is 0 again.
+The second transmission thus becomes `00000000` (or `00` in hex).
+
+The data for the next two transmissions (`0111000` and `0001101`) have three 1 bits.
+Their parity bits are set to 1 so that they have an even number of 1 bits in the transmission.
+They are transmitted as `01110001` and `00011011` (or `71` and `1B` in hex).
+
+The last transmission (`1110`) has only four bits of data.
+Since exactly eight bits are transmitted at a time and the parity bit is the right most bit, three 0 bits and then the parity bit are added to make up eight bits.
+It now looks like this (where `_` is the parity bit):
 
 ```text
-| 1100_0000 | 0000_0000 | 0111_0001 | 0001_1011 | 1110_0001 |
-| C    0    | 0    0    | 7    1    | 1    B    | E    1    |  (in hex)
+1110 000_
+     ↑↑↑   (added 0 bits)
 ```
 
-Thus, the transmission sequence is 0xC0_00_71_1B_E1.
+There is an odd number of 1 bits again, so the parity bit is 1.
+The last transmission in the sequence becomes `11100001` (or `E1` in hex).
+
+The entire transmission sequence for this message is `11000000 00000000 01110001 00011011 11100001` (or `C0 00 71 1B E1` in hex).

exercises/practice/intergalactic-transmission/.docs/introduction.md

@@ -1,10 +1,23 @@
 # Introduction
 
-Trillions upon trillions of messages are exchanged between Earth and the neighboring galaxies every millisecond. 
-But transmission over such long distances faces many obstacles.
-Pesky solar flares, worm holes, temporal distortions, stray forces, heck even the flap of a space butterfly wing can cause a random bit to flip during transmission.
-The difference between an "o" and a "k", a "[" and "{" or a cowboy emoji and a clown emoji can have huge ramifications, from missed orders to Galactic Stockmarket crashes.
-It is thus important for the receiver to know if a message has been corrupted so that the receiver can ask for the message to be sent again.
-
-One day, an important message comes through.
-People have just heard about the legend about a way of transmitting in such a way that the receiver can tell when bit flipped ... the parity bit ...
+Trillions upon trillions of messages zip between Earth and neighboring galaxies every millisecond.
+But transmitting over such long distances is tricky.
+Pesky solar flares, temporal distortions, stray forces, and even the flap of a space butterfly's wing can cause a random bit to change during transmission.
+
+Now imagine the consequences:
+
+- Crashing the Intergalactic Share Market when "buy low" turns to "sell now".
+- Losing contact with the Kepler Whirl system when "save new worm hole" becomes "cave new worm hole".
+- Or plunging the universe into existential horror by replacing a cowboy emoji 🤠 with a clown emoji 🤡.
+
+Detecting corrupted messages isn't just important — it's critical.
+The receiver _must_ know when something has gone wrong before disaster strikes.
+
+But how?
+Scientists and engineers from across the universe have been battling this problem for eons.
+Entire cosmic AI superclusters churn through the data.
+And then, one day, a legend resurfaces — an ancient, powerful method, whispered in debugging forums, muttered by engineers who've seen too much...
+
+The Parity Bit!
+
+A method so simple, so powerful, that it might just save interstellar communication.

exercises/practice/intergalactic-transmission/.meta/Generator.tpl

@@ -0,0 +1,19 @@
+public class {{ testClass }}
+{
+    {{- for test in tests }}
+    [Fact{{ if !for.first }}(Skip = "Remove this Skip property to run this test"){{ end }}]
+    public void {{ test.testMethod }}()
+    {
+        {{- message = string.replace test.input.message "\"" "" }}
+        {{- if test.property == "transmitSequence" }}
+        Assert.Equal({{ string.replace test.expected "\"" "" }}, IntergalacticTransmission.GetTransmitSequence({{ message }}));
+        {{- else if test.property == "decodeMessage" }}
+        {{- if test.expected.error }}
+        Assert.Throws<ArgumentException>(() => IntergalacticTransmission.DecodeSequence({{ message }}));        
+        {{- else }}
+        Assert.Equal({{ string.replace test.expected "\"" "" }}, IntergalacticTransmission.DecodeSequence({{ message }}));
+        {{ end -}}
+        {{ end -}}
+    }
+    {{ end -}}
+}

exercises/practice/intergalactic-transmission/.meta/config.json

@@ -11,7 +11,12 @@
     ],
     "example": [
       ".meta/Example.cs"
+    ],
+    "invalidator": [
+      "IntergalacticTransmission.csproj"
     ]
   },
-  "blurb": "Help detect errors in transmissions to neighboring galaxies"
+  "blurb": "Add parity bits to a message for transmission",
+  "source": "Kah Goh",
+  "source_url": "https://github.com/exercism/problem-specifications/pull/2543"
 }

exercises/practice/intergalactic-transmission/.meta/tests.toml

@@ -0,0 +1,82 @@
+# This is an auto-generated file.
+#
+# Regenerating this file via `configlet sync` will:
+# - Recreate every `description` key/value pair
+# - Recreate every `reimplements` key/value pair, where they exist in problem-specifications
+# - Remove any `include = true` key/value pair (an omitted `include` key implies inclusion)
+# - Preserve any other key/value pair
+#
+# As user-added comments (using the # character) will be removed when this file
+# is regenerated, comments can be added via a `comment` key.
+
+[f99d4046-b429-4582-9324-f0bcac7ab51c]
+description = "calculate transmit sequences -> empty message"
+
+[ee27ea2d-8999-4f23-9275-8f6879545f86]
+description = "calculate transmit sequences -> 0x00 is transmitted as 0x0000"
+
+[97f27f98-8020-402d-be85-f21ba54a6df0]
+description = "calculate transmit sequences -> 0x02 is transmitted as 0x0300"
+
+[24712fb9-0336-4e2f-835e-d2350f29c420]
+description = "calculate transmit sequences -> 0x06 is transmitted as 0x0600"
+
+[7630b5a9-dba1-4178-b2a0-4a376f7414e0]
+description = "calculate transmit sequences -> 0x05 is transmitted as 0x0581"
+
+[ab4fe80b-ef8e-4a99-b4fb-001937af415d]
+description = "calculate transmit sequences -> 0x29 is transmitted as 0x2881"
+
+[4e200d84-593b-4449-b7c0-4de1b6a0955e]
+description = "calculate transmit sequences -> 0xc001c0de is transmitted as 0xc000711be1"
+
+[fbc537e9-6b21-4f4a-8c2b-9cf9b702a9b7]
+description = "calculate transmit sequences -> six byte message"
+
+[d5b75adf-b5fc-4f77-b4ab-77653e30f07c]
+description = "calculate transmit sequences -> seven byte message"
+
+[6d8b297b-da1d-435e-bcd7-55fbb1400e73]
+description = "calculate transmit sequences -> eight byte message"
+
+[54a0642a-d5aa-490c-be89-8e171a0cab6f]
+description = "calculate transmit sequences -> twenty byte message"
+
+[879af739-0094-4736-9127-bd441b1ddbbf]
+description = "decode received messages -> zero message"
+
+[7a89eeef-96c5-4329-a246-ec181a8e959a]
+description = "decode received messages -> 0x0300 is decoded to 0x02"
+
+[3e515af7-8b62-417f-960c-3454bca7f806]
+description = "decode received messages -> 0x0581 is decoded to 0x05"
+
+[a1b4a3f7-9f05-4b7a-b86e-d7c6fc3f16a9]
+description = "decode received messages -> 0x2881 is decoded to 0x29"
+
+[2e99d617-4c91-4ad5-9217-e4b2447d6e4a]
+description = "decode received messages -> first byte has wrong parity"
+
+[507e212d-3dae-42e8-88b4-2223838ff8d2]
+description = "decode received messages -> second byte has wrong parity"
+
+[b985692e-6338-46c7-8cea-bc38996d4dfd]
+description = "decode received messages -> 0xcf4b00 is decoded to 0xce94"
+
+[467549dc-a558-443b-80c5-ff3d4eb305d4]
+description = "decode received messages -> six byte message"
+
+[1f3be5fb-093a-4661-9951-c1c4781c71ea]
+description = "decode received messages -> seven byte message"
+
+[6065b8b3-9dcd-45c9-918c-b427cfdb28c1]
+description = "decode received messages -> last byte has wrong parity"
+
+[98af97b7-9cca-4c4c-9de3-f70e227a4cb1]
+description = "decode received messages -> eight byte message"
+
+[aa7d4785-2bb9-43a4-a38a-203325c464fb]
+description = "decode received messages -> twenty byte message"
+
+[4c86e034-b066-42ac-8497-48f9bc1723c1]
+description = "decode received messages -> wrong parity on 16th byte"

exercises/practice/intergalactic-transmission/IntergalacticTransmission.csproj

@@ -15,4 +15,4 @@
     <PackageReference Include="xunit.runner.visualstudio" Version="3.0.1" />
     <PackageReference Include="Exercism.Tests.xunit.v3" Version="0.1.0-beta1" />
   </ItemGroup>
-</Project>
+</Project>