attempt to only add new strings to list.

src/main.zig

@@ -2,7 +2,7 @@ const std = @import("std");
 const mem = std.mem;
 
 
-const Symbol = enum(u2) {
+const Symbol = enum {
     M,
     U,
     I
@@ -21,20 +21,25 @@ pub fn main() !void {
 
 
 
-    var list = std.ArrayList([]Symbol).init(std.heap.page_allocator);
+    var bag = std.ArrayList([]Symbol).init(std.heap.page_allocator);
-    defer list.deinit(); // try commenting this out and see if zig detects the memory leak!
+    defer bag.deinit(); // try commenting this out and see if zig detects the memory leak!
 
     var initial: [2]Symbol = .{Symbol.M, Symbol.I};
-    try list.append(&initial);
+    try bag.append(&initial);
 
     var count: u64 = 0;
-    while(list.items.len > count){
+    while(bag.items.len > count){
-        count = list.items.len;
+        std.debug.print("curr/total {d}/{d}, \n", .{count, bag.items.len});
-        for(list.items)|string|{
+
-            if(rule1Test(string)){ try list.append(try rule1(string)); }
+        count = bag.items.len;
-            if(rule2Test(string)){ try list.append(try rule2(string)); }
+        for(bag.items)|string|{
-            if(rule3Test(string)){ try list.append(try rule3(string)); }
+            std.debug.print("Testing: {any}\n", .{string});
-            if(rule4Test(string)){ try list.append(try rule4(string)); }
+
+            //if(rule1Test(string)){ try bag.append(try rule1(string)); }
+            if(rule1Test(string)){ try addToBag(bag,string);}
+            if(rule2Test(string)){ try bag.append(try rule2(string)); }
+            if(rule3Test(string)){ try bag.append(try rule3(string)); }
+            if(rule4Test(string)){ try bag.append(try rule4(string)); }
             
             if(finish(string)){
                 break; //Finished!
@@ -49,13 +54,20 @@ pub fn main() !void {
     try bw.flush(); // don't forget to flush!
 }
 
+pub fn addToBag(list: std.ArrayList([]Symbol), new: []Symbol) !void{
+    if(mem.containsAtLeast([]Symbol, list.items, 1, new)){
+        try list.append(new);
+    }
+}
+
 pub fn rule1Test(input: []Symbol ) bool{
-    return (input[input.len] == Symbol.I);
+    return (input[input.len-1] == Symbol.I);
+
 }
 pub fn rule1(input: []Symbol) ![]Symbol{
     var arr = try std.heap.page_allocator.alloc(Symbol, input.len + 1);
     arr = input[0..];
-    arr[arr.len] = Symbol.U;
+    arr[arr.len-1] = Symbol.U;
 
     return arr;
     
@@ -137,7 +149,7 @@ pub fn rule4(input: []Symbol) ![]Symbol{
             }
         }
     }
-    
+
     return error.NOTFOUND;
 }