Series returned fixed-length slices (#520)

The slice length is specified as part of the type.

The stub already used the desired return type, but the
tests and example solution did not.

Author: keiravillekode

exercises/practice/series/.meta/example.zig

@@ -1,24 +1,18 @@
 const std = @import("std");
-const fmt = std.fmt;
 const mem = std.mem;
 
-fn free(allocator: mem.Allocator, array_list: *std.ArrayList([]u8)) void {
-    for (array_list.items) |item| {
-        allocator.free(item);
-    }
-    array_list.deinit(allocator);
-}
-
-pub fn slices(comptime slice_length: usize, allocator: mem.Allocator, series: []const u8) mem.Allocator.Error![][]u8 {
+pub fn slices(comptime slice_length: usize, allocator: mem.Allocator, series: []const u8) mem.Allocator.Error![][slice_length]u8 {
     comptime {
         std.debug.assert(slice_length > 0);
     }
 
-    var array_list = std.ArrayList([]u8).empty;
-    errdefer free(allocator, &array_list);
+    var array_list = std.ArrayList([slice_length]u8).empty;
+    errdefer array_list.deinit(allocator);
     if (slice_length <= series.len) {
         for (slice_length..(series.len + 1)) |i| {
-            try array_list.append(allocator, try fmt.allocPrint(allocator, "{s}", .{series[(i - slice_length)..i]}));
+            var slice: [slice_length]u8 = undefined;
+            @memcpy(slice[0..], series[(i - slice_length)..i]);
+            try array_list.append(allocator, slice);
         }
     }
     return array_list.toOwnedSlice(allocator);

exercises/practice/series/test_series.zig

@@ -3,97 +3,115 @@ const testing = std.testing;
 
 const slices = @import("series.zig").slices;
 
-fn free(arr: [][]u8) void {
-    for (arr) |s| {
-        testing.allocator.free(s);
-    }
-    testing.allocator.free(arr);
-}
-
 test "slices of one from one" {
     const series = "1";
-    const expected = [_][]const u8{"1"};
+    const expected = [_][1]u8{
+        "1"[0..1].*, //
+    };
     const actual = try slices(1, testing.allocator, series);
-    defer free(actual);
+    defer testing.allocator.free(actual);
     try testing.expectEqual(expected.len, actual.len);
     for (expected, 0..) |expected_slice, i| {
-        try testing.expectEqualStrings(expected_slice, actual[i]);
+        try testing.expectEqualStrings(&expected_slice, &actual[i]);
     }
 }
 
 test "slices of one from two" {
     const series = "12";
-    const expected = [_][]const u8{ "1", "2" };
+    const expected = [_][1]u8{
+        "1"[0..1].*, //
+        "2"[0..1].*, //
+    };
     const actual = try slices(1, testing.allocator, series);
-    defer free(actual);
+    defer testing.allocator.free(actual);
     try testing.expectEqual(expected.len, actual.len);
     for (expected, 0..) |expected_slice, i| {
-        try testing.expectEqualStrings(expected_slice, actual[i]);
+        try testing.expectEqualStrings(&expected_slice, &actual[i]);
     }
 }
 
 test "slices of two" {
     const series = "35";
-    const expected = [_][]const u8{"35"};
+    const expected = [_][2]u8{
+        "35"[0..2].*, //
+    };
     const actual = try slices(2, testing.allocator, series);
-    defer free(actual);
+    defer testing.allocator.free(actual);
     try testing.expectEqual(expected.len, actual.len);
     for (expected, 0..) |expected_slice, i| {
-        try testing.expectEqualStrings(expected_slice, actual[i]);
+        try testing.expectEqualStrings(&expected_slice, &actual[i]);
     }
 }
 
 test "slices of two overlap" {
     const series = "9142";
-    const expected = [_][]const u8{ "91", "14", "42" };
+    const expected = [_][2]u8{
+        "91"[0..2].*, //
+        "14"[0..2].*, //
+        "42"[0..2].*, //
+    };
     const actual = try slices(2, testing.allocator, series);
-    defer free(actual);
+    defer testing.allocator.free(actual);
     try testing.expectEqual(expected.len, actual.len);
     for (expected, 0..) |expected_slice, i| {
-        try testing.expectEqualStrings(expected_slice, actual[i]);
+        try testing.expectEqualStrings(&expected_slice, &actual[i]);
     }
 }
 
 test "slices can include duplicates" {
     const series = "777777";
-    const expected = [_][]const u8{ "777", "777", "777", "777" };
+    const expected = [_][3]u8{
+        "777"[0..3].*, //
+        "777"[0..3].*, //
+        "777"[0..3].*, //
+        "777"[0..3].*, //
+    };
     const actual = try slices(3, testing.allocator, series);
-    defer free(actual);
+    defer testing.allocator.free(actual);
     try testing.expectEqual(expected.len, actual.len);
     for (expected, 0..) |expected_slice, i| {
-        try testing.expectEqualStrings(expected_slice, actual[i]);
+        try testing.expectEqualStrings(&expected_slice, &actual[i]);
     }
 }
 
 test "slices of a long series" {
     const series = "918493904243";
-    const expected = [_][]const u8{ "91849", "18493", "84939", "49390", "93904", "39042", "90424", "04243" };
+    const expected = [_][5]u8{
+        "91849"[0..5].*, //
+        "18493"[0..5].*, //
+        "84939"[0..5].*, //
+        "49390"[0..5].*, //
+        "93904"[0..5].*, //
+        "39042"[0..5].*, //
+        "90424"[0..5].*, //
+        "04243"[0..5].*, //
+    };
     const actual = try slices(5, testing.allocator, series);
-    defer free(actual);
+    defer testing.allocator.free(actual);
     try testing.expectEqual(expected.len, actual.len);
     for (expected, 0..) |expected_slice, i| {
-        try testing.expectEqualStrings(expected_slice, actual[i]);
+        try testing.expectEqualStrings(&expected_slice, &actual[i]);
     }
 }
 
 test "slice length is too large" {
     const series = "12345";
-    const expected = [_][]const u8{};
+    const expected = [_][6]u8{};
     const actual = try slices(6, testing.allocator, series);
-    defer free(actual);
+    defer testing.allocator.free(actual);
     try testing.expectEqual(expected.len, actual.len);
     for (expected, 0..) |expected_slice, i| {
-        try testing.expectEqualStrings(expected_slice, actual[i]);
+        try testing.expectEqualStrings(&expected_slice, &actual[i]);
     }
 }
 
 test "slice length is way too large" {
     const series = "12345";
-    const expected = [_][]const u8{};
+    const expected = [_][42]u8{};
     const actual = try slices(42, testing.allocator, series);
-    defer free(actual);
+    defer testing.allocator.free(actual);
     try testing.expectEqual(expected.len, actual.len);
     for (expected, 0..) |expected_slice, i| {
-        try testing.expectEqualStrings(expected_slice, actual[i]);
+        try testing.expectEqualStrings(&expected_slice, &actual[i]);
     }
 }