Add crypto-square

Author: keiravillekode

config.json

@@ -343,6 +343,14 @@
         "prerequisites": [],
         "difficulty": 6
       },
+      {
+        "slug": "crypto-square",
+        "name": "Crypto Square",
+        "uuid": "af35d898-215e-4dc6-a4f0-d4511a39be0e",
+        "practices": [],
+        "prerequisites": [],
+        "difficulty": 6
+      },
       {
         "slug": "knapsack",
         "name": "Knapsack",

exercises/practice/crypto-square/.docs/instructions.md

@@ -0,0 +1,71 @@
+# Instructions
+
+Implement the classic method for composing secret messages called a square code.
+
+Given an English text, output the encoded version of that text.
+
+First, the input is normalized: the spaces and punctuation are removed from the English text and the message is down-cased.
+
+Then, the normalized characters are broken into rows.
+These rows can be regarded as forming a rectangle when printed with intervening newlines.
+
+For example, the sentence
+
+```text
+"If man was meant to stay on the ground, god would have given us roots."
+```
+
+is normalized to:
+
+```text
+"ifmanwasmeanttostayonthegroundgodwouldhavegivenusroots"
+```
+
+The plaintext should be organized into a rectangle as square as possible.
+The size of the rectangle should be decided by the length of the message.
+
+If `c` is the number of columns and `r` is the number of rows, then for the rectangle `r` x `c` find the smallest possible integer `c` such that:
+
+- `r * c >= length of message`,
+- and `c >= r`,
+- and `c - r <= 1`.
+
+Our normalized text is 54 characters long, dictating a rectangle with `c = 8` and `r = 7`:
+
+```text
+"ifmanwas"
+"meanttos"
+"tayonthe"
+"groundgo"
+"dwouldha"
+"vegivenu"
+"sroots  "
+```
+
+The coded message is obtained by reading down the columns going left to right.
+
+The message above is coded as:
+
+```text
+"imtgdvsfearwermayoogoanouuiontnnlvtwttddesaohghnsseoau"
+```
+
+Output the encoded text in chunks that fill perfect rectangles `(r X c)`, with `c` chunks of `r` length, separated by spaces.
+For phrases that are `n` characters short of the perfect rectangle, pad each of the last `n` chunks with a single trailing space.
+
+```text
+"imtgdvs fearwer mayoogo anouuio ntnnlvt wttddes aohghn  sseoau "
+```
+
+Notice that were we to stack these, we could visually decode the ciphertext back in to the original message:
+
+```text
+"imtgdvs"
+"fearwer"
+"mayoogo"
+"anouuio"
+"ntnnlvt"
+"wttddes"
+"aohghn "
+"sseoau "
+```

exercises/practice/crypto-square/.meta/config.json

@@ -0,0 +1,19 @@
+{
+  "authors": [
+    "keiravillekode"
+  ],
+  "files": {
+    "solution": [
+      "crypto_square.s"
+    ],
+    "test": [
+      "crypto_square_test.c"
+    ],
+    "example": [
+      ".meta/example.s"
+    ]
+  },
+  "blurb": "Implement the classic method for composing secret messages called a square code.",
+  "source": "J Dalbey's Programming Practice problems",
+  "source_url": "https://users.csc.calpoly.edu/~jdalbey/103/Projects/ProgrammingPractice.html"
+}

exercises/practice/crypto-square/.meta/example.s

@@ -0,0 +1,90 @@
+.text
+.globl ciphertext
+
+/* extern void ciphertext(char *buffer, const char *plaintext); */
+ciphertext:
+        move    a2, zero                /* number of alphanumeric characters */
+        move    t0, a1                  /* source pointer */
+        li      t5, 10
+        li      t6, 26
+        j       .scan
+
+.count:
+        addi    t2, t1, -'0'
+        bltu    t2, t5,  .accept        /* digit? */
+
+        ori     t1, t1, 32
+        addi    t2, t1, -'a'
+        bgeu    t2, t6, .scan           /* non-letter? */
+
+.accept:
+        add     a2, a2, 1
+
+.scan:
+        lbu     t1, 0(t0)               /* read */
+        addi    t0, t0, 1
+        bnez    t1, .count
+
+        sb      zero, 0(a0)
+        beqz    a2, .return             /* no alphanumeric characters? */
+
+        move    a4, zero                /* number of input columns */
+        j       .square
+
+.increment_columns:
+        addi    a4, a4, 1
+
+.square:
+        mul     t2, a4, a4
+        blt     t2, a2, .increment_columns
+
+        addi    a3, a4, -1              /* number of input rows */
+        mul     t2, a3, a4
+        slt     t2, t2, a2              /* 1 iff rows * columns < number of alphanumeric characters */
+        add     a3, a3, t2
+
+        mul     t2, a3, a4
+        add     t2, t2, a4              /* add number of input columns */
+        addi    t2, t2, -1              /* length of output: (rows + 1) * columns - 1 */
+        add     t2, a0, t2
+
+        sb      zero, 0(t2)
+        li      t1, ' '
+
+.space:
+        addi    t2, t2, -1
+        sb      t1, 0(t2)
+        bne     t2, a0, .space
+
+        add     a3, a3, 1               /* number of output columns = number of input rows + 1 */
+
+.next_output_column:
+        move    t3, a4                  /* number of output rows remaining */
+        move    t4, zero
+
+.read:
+        lbu     t1, 0(a1)               /* read */
+        addi    a1, a1, 1
+        addi    t2, t1, -'0'
+        bltu    t2, t5, .write          /* digit? */
+
+        ori     t1, t1, 32
+        addi    t2, t1, -'a'
+        bgeu    t2, t6, .read           /* non-letter? */
+
+.write:
+        add     a5, a0, t4
+        sb      t1, 0(a5)
+
+        addi    a2, a2, -1
+        beqz    a2, .return             /* no alphanumeric characters remain? */
+
+        add     t4, t4, a3
+        addi    t3, t3, -1
+        bnez    t3, .read
+
+        addi    a0, a0, 1               /* next output column */
+        j       .next_output_column
+
+.return:
+        ret

exercises/practice/crypto-square/.meta/tests.toml

@@ -0,0 +1,39 @@
+# 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.
+
+[407c3837-9aa7-4111-ab63-ec54b58e8e9f]
+description = "empty plaintext results in an empty ciphertext"
+
+[aad04a25-b8bb-4304-888b-581bea8e0040]
+description = "normalization results in empty plaintext"
+
+[64131d65-6fd9-4f58-bdd8-4a2370fb481d]
+description = "Lowercase"
+
+[63a4b0ed-1e3c-41ea-a999-f6f26ba447d6]
+description = "Remove spaces"
+
+[1b5348a1-7893-44c1-8197-42d48d18756c]
+description = "Remove punctuation"
+
+[8574a1d3-4a08-4cec-a7c7-de93a164f41a]
+description = "9 character plaintext results in 3 chunks of 3 characters"
+
+[a65d3fa1-9e09-43f9-bcec-7a672aec3eae]
+description = "8 character plaintext results in 3 chunks, the last one with a trailing space"
+
+[fbcb0c6d-4c39-4a31-83f6-c473baa6af80]
+description = "54 character plaintext results in 7 chunks, the last two with trailing spaces"
+include = false
+
+[33fd914e-fa44-445b-8f38-ff8fbc9fe6e6]
+description = "54 character plaintext results in 8 chunks, the last two with trailing spaces"
+reimplements = "fbcb0c6d-4c39-4a31-83f6-c473baa6af80"

exercises/practice/crypto-square/Makefile

@@ -0,0 +1,36 @@
+AS = /usr/bin/riscv64-linux-gnu-as
+CC = /usr/bin/riscv64-linux-gnu-gcc
+
+CFLAGS = -g -Wall -Wextra -pedantic -Werror
+LDFLAGS =
+
+ALL_LDFLAGS = -pie -Wl,--fatal-warnings
+
+ALL_CFLAGS = -std=c99 -fPIE $(CFLAGS)
+ALL_LDFLAGS += $(LDFLAGS)
+
+C_OBJS = $(patsubst %.c,%.o,$(wildcard *.c))
+AS_OBJS = $(patsubst %.s,%.o,$(wildcard *.s))
+ALL_OBJS = $(filter-out example.o,$(C_OBJS) $(AS_OBJS) vendor/unity.o)
+
+CC_CMD = $(CC) $(ALL_CFLAGS) -c -o $@ $<
+
+all: tests
+	qemu-riscv64 -L /usr/riscv64-linux-gnu ./$<
+
+tests: $(ALL_OBJS)
+	@$(CC) $(ALL_CFLAGS) $(ALL_LDFLAGS) -o $@ $(ALL_OBJS)
+
+%.o: %.s
+	@$(AS) -o $@ $<
+
+%.o: %.c
+	@$(CC_CMD)
+
+vendor/unity.o: vendor/unity.c vendor/unity.h vendor/unity_internals.h
+	@$(CC_CMD)
+
+clean:
+	@rm -f *.o vendor/*.o tests
+
+.PHONY: all clean

exercises/practice/crypto-square/crypto_square.s

@@ -0,0 +1,5 @@
+.text
+.globl ciphertext
+
+ciphertext:
+        ret

exercises/practice/crypto-square/crypto_square_test.c

@@ -0,0 +1,87 @@
+#include "vendor/unity.h"
+
+#define BUFFER_SIZE 80
+
+extern void ciphertext(char *buffer, const char *plaintext);
+
+void setUp(void) {
+}
+
+void tearDown(void) {
+}
+
+void test_empty_plaintext_results_in_an_empty_ciphertext(void) {
+    char buffer[BUFFER_SIZE];
+
+    ciphertext(buffer, "");
+    TEST_ASSERT_EQUAL_STRING("", buffer);
+}
+
+void test_normalization_results_in_empty_plaintext(void) {
+    TEST_IGNORE();
+    char buffer[BUFFER_SIZE];
+
+    ciphertext(buffer, "... --- ...");
+    TEST_ASSERT_EQUAL_STRING("", buffer);
+}
+
+void test_lowercase(void) {
+    TEST_IGNORE();
+    char buffer[BUFFER_SIZE];
+
+    ciphertext(buffer, "A");
+    TEST_ASSERT_EQUAL_STRING("a", buffer);
+}
+
+void test_remove_spaces(void) {
+    TEST_IGNORE();
+    char buffer[BUFFER_SIZE];
+
+    ciphertext(buffer, "  b ");
+    TEST_ASSERT_EQUAL_STRING("b", buffer);
+}
+
+void test_remove_punctuation(void) {
+    TEST_IGNORE();
+    char buffer[BUFFER_SIZE];
+
+    ciphertext(buffer, "@1,%!");
+    TEST_ASSERT_EQUAL_STRING("1", buffer);
+}
+
+void test_9_character_plaintext_results_in_3_chunks_of_3_characters(void) {
+    TEST_IGNORE();
+    char buffer[BUFFER_SIZE];
+
+    ciphertext(buffer, "This is fun!");
+    TEST_ASSERT_EQUAL_STRING("tsf hiu isn", buffer);
+}
+
+void test_8_character_plaintext_results_in_3_chunks_the_last_one_with_a_trailing_space(void) {
+    TEST_IGNORE();
+    char buffer[BUFFER_SIZE];
+
+    ciphertext(buffer, "Chill out.");
+    TEST_ASSERT_EQUAL_STRING("clu hlt io ", buffer);
+}
+
+void test_54_character_plaintext_results_in_8_chunks_the_last_two_with_trailing_spaces(void) {
+    TEST_IGNORE();
+    char buffer[BUFFER_SIZE];
+
+    ciphertext(buffer, "If man was meant to stay on the ground, god would have given us roots.");
+    TEST_ASSERT_EQUAL_STRING("imtgdvs fearwer mayoogo anouuio ntnnlvt wttddes aohghn  sseoau ", buffer);
+}
+
+int main(void) {
+    UNITY_BEGIN();
+    RUN_TEST(test_empty_plaintext_results_in_an_empty_ciphertext);
+    RUN_TEST(test_normalization_results_in_empty_plaintext);
+    RUN_TEST(test_lowercase);
+    RUN_TEST(test_remove_spaces);
+    RUN_TEST(test_remove_punctuation);
+    RUN_TEST(test_9_character_plaintext_results_in_3_chunks_of_3_characters);
+    RUN_TEST(test_8_character_plaintext_results_in_3_chunks_the_last_one_with_a_trailing_space);
+    RUN_TEST(test_54_character_plaintext_results_in_8_chunks_the_last_two_with_trailing_spaces);
+    return UNITY_END();
+}