Add etl

Author: keiravillekode

config.json

@@ -362,6 +362,14 @@
         "prerequisites": [],
         "difficulty": 2
       },
+      {
+        "slug": "etl",
+        "name": "ETL",
+        "uuid": "1e65a945-b044-4392-b8d9-59bcefa7a314",
+        "practices": [],
+        "prerequisites": [],
+        "difficulty": 2
+      },
       {
         "slug": "grains",
         "name": "Grains",

exercises/practice/etl/.docs/instructions.md

@@ -0,0 +1,27 @@
+# Instructions
+
+Your task is to change the data format of letters and their point values in the game.
+
+Currently, letters are stored in groups based on their score, in a one-to-many mapping.
+
+- 1 point: "A", "E", "I", "O", "U", "L", "N", "R", "S", "T",
+- 2 points: "D", "G",
+- 3 points: "B", "C", "M", "P",
+- 4 points: "F", "H", "V", "W", "Y",
+- 5 points: "K",
+- 8 points: "J", "X",
+- 10 points: "Q", "Z",
+
+This needs to be changed to store each individual letter with its score in a one-to-one mapping.
+
+- "a" is worth 1 point.
+- "b" is worth 3 points.
+- "c" is worth 3 points.
+- "d" is worth 2 points.
+- etc.
+
+As part of this change, the team has also decided to change the letters to be lower-case rather than upper-case.
+
+~~~~exercism/note
+If you want to look at how the data was previously structured and how it needs to change, take a look at the examples in the test suite.
+~~~~

exercises/practice/etl/.docs/introduction.md

@@ -0,0 +1,16 @@
+# Introduction
+
+You work for a company that makes an online multiplayer game called Lexiconia.
+
+To play the game, each player is given 13 letters, which they must rearrange to create words.
+Different letters have different point values, since it's easier to create words with some letters than others.
+
+The game was originally launched in English, but it is very popular, and now the company wants to expand to other languages as well.
+
+Different languages need to support different point values for letters.
+The point values are determined by how often letters are used, compared to other letters in that language.
+
+For example, the letter 'C' is quite common in English, and is only worth 3 points.
+But in Norwegian it's a very rare letter, and is worth 10 points.
+
+To make it easier to add new languages, your team needs to change the way letters and their point values are stored in the game.

exercises/practice/etl/.meta/config.json

@@ -0,0 +1,19 @@
+{
+  "authors": [
+    "keiravillekode"
+  ],
+  "files": {
+    "solution": [
+      "etl.zig"
+    ],
+    "test": [
+      "test_etl.zig"
+    ],
+    "example": [
+      ".meta/example.zig"
+    ]
+  },
+  "blurb": "Change the data format for scoring a game to more easily add other languages.",
+  "source": "Based on an exercise by the JumpstartLab team for students at The Turing School of Software and Design.",
+  "source_url": "https://turing.edu"
+}

exercises/practice/etl/.meta/example.zig

@@ -0,0 +1,15 @@
+const std = @import("std");
+const ascii = std.ascii;
+const mem = std.mem;
+
+pub fn transform(allocator: mem.Allocator, legacy: std.AutoHashMap(i5, []const u8)) mem.Allocator.Error!std.AutoHashMap(u8, i5) {
+    var result = std.AutoHashMap(u8, i5).init(allocator);
+    var iter = legacy.iterator();
+    while (iter.next()) |entry| {
+        const points: i5 = entry.key_ptr.*;
+        for (entry.value_ptr.*) |letter| {
+            try result.put(ascii.toLower(letter), points);
+        }
+    }
+    return result;
+}

exercises/practice/etl/.meta/tests.toml

@@ -0,0 +1,22 @@
+# 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.
+
+[78a7a9f9-4490-4a47-8ee9-5a38bb47d28f]
+description = "single letter"
+
+[60dbd000-451d-44c7-bdbb-97c73ac1f497]
+description = "single score with multiple letters"
+
+[f5c5de0c-301f-4fdd-a0e5-df97d4214f54]
+description = "multiple scores with multiple letters"
+
+[5db8ea89-ecb4-4dcd-902f-2b418cc87b9d]
+description = "multiple scores with differing numbers of letters"

exercises/practice/etl/etl.zig

@@ -0,0 +1,8 @@
+const std = @import("std");
+const mem = std.mem;
+
+pub fn transform(allocator: mem.Allocator, legacy: std.AutoHashMap(i5, []const u8)) mem.Allocator.Error!std.AutoHashMap(u8, i5) {
+    _ = allocator;
+    _ = legacy;
+    @compileError("please implement the transform function");
+}

exercises/practice/etl/test_etl.zig

@@ -0,0 +1,88 @@
+const std = @import("std");
+const testing = std.testing;
+
+const etl = @import("etl.zig");
+const transform = etl.transform;
+
+test "single letter" {
+    var legacy = std.AutoHashMap(i5, []const u8).init(testing.allocator);
+    try legacy.put(1, "A");
+    var actual = try transform(testing.allocator, legacy);
+    legacy.deinit();
+
+    try testing.expectEqual(1, actual.count());
+    try testing.expectEqual(1, actual.get('a'));
+    actual.deinit();
+}
+
+test "single score with multiple letters" {
+    var legacy = std.AutoHashMap(i5, []const u8).init(testing.allocator);
+    try legacy.put(1, "AEIOU");
+    var actual = try transform(testing.allocator, legacy);
+    legacy.deinit();
+
+    try testing.expectEqual(5, actual.count());
+    try testing.expectEqual(1, actual.get('a'));
+    try testing.expectEqual(1, actual.get('e'));
+    try testing.expectEqual(1, actual.get('i'));
+    try testing.expectEqual(1, actual.get('o'));
+    try testing.expectEqual(1, actual.get('u'));
+    actual.deinit();
+}
+
+test "multiple scores with multiple letters" {
+    var legacy = std.AutoHashMap(i5, []const u8).init(testing.allocator);
+    try legacy.put(1, "AE");
+    try legacy.put(2, "DG");
+    var actual = try transform(testing.allocator, legacy);
+    legacy.deinit();
+
+    try testing.expectEqual(4, actual.count());
+    try testing.expectEqual(1, actual.get('a'));
+    try testing.expectEqual(2, actual.get('d'));
+    try testing.expectEqual(1, actual.get('e'));
+    try testing.expectEqual(2, actual.get('g'));
+    actual.deinit();
+}
+
+test "multiple scores with differing numbers of letters" {
+    var legacy = std.AutoHashMap(i5, []const u8).init(testing.allocator);
+    try legacy.put(1, "AEIOULNRST");
+    try legacy.put(10, "QZ");
+    try legacy.put(2, "DG");
+    try legacy.put(3, "BCMP");
+    try legacy.put(4, "FHVWY");
+    try legacy.put(5, "K");
+    try legacy.put(8, "JX");
+    var actual = try transform(testing.allocator, legacy);
+    legacy.deinit();
+
+    try testing.expectEqual(26, actual.count());
+    try testing.expectEqual(1, actual.get('a'));
+    try testing.expectEqual(3, actual.get('b'));
+    try testing.expectEqual(3, actual.get('c'));
+    try testing.expectEqual(2, actual.get('d'));
+    try testing.expectEqual(1, actual.get('e'));
+    try testing.expectEqual(4, actual.get('f'));
+    try testing.expectEqual(2, actual.get('g'));
+    try testing.expectEqual(4, actual.get('h'));
+    try testing.expectEqual(1, actual.get('i'));
+    try testing.expectEqual(8, actual.get('j'));
+    try testing.expectEqual(5, actual.get('k'));
+    try testing.expectEqual(1, actual.get('l'));
+    try testing.expectEqual(3, actual.get('m'));
+    try testing.expectEqual(1, actual.get('n'));
+    try testing.expectEqual(1, actual.get('o'));
+    try testing.expectEqual(3, actual.get('p'));
+    try testing.expectEqual(10, actual.get('q'));
+    try testing.expectEqual(1, actual.get('r'));
+    try testing.expectEqual(1, actual.get('s'));
+    try testing.expectEqual(1, actual.get('t'));
+    try testing.expectEqual(1, actual.get('u'));
+    try testing.expectEqual(4, actual.get('v'));
+    try testing.expectEqual(4, actual.get('w'));
+    try testing.expectEqual(8, actual.get('x'));
+    try testing.expectEqual(4, actual.get('y'));
+    try testing.expectEqual(10, actual.get('z'));
+    actual.deinit();
+}