attempt to only add new strings to list.

... En crasht meteen op een index OOB

.gitignore

@@ -0,0 +1,2 @@
+zig-out
+zig-cache

src/main.zig

@@ -1,11 +1,12 @@
 const std = @import("std");
+const mem = std.mem;
 
 
-const M:u8 = 0;
-const I:u8 = 1;
-const U:u8 = 2;
-
-
+const Symbol = enum {
+    M,
+    U,
+    I
+};
 
 pub fn main() !void {
     // Prints to stderr (it's a shortcut based on `std.io.getStdErr()`)
@@ -20,12 +21,145 @@ pub fn main() !void {
 
 
 
+    var bag = std.ArrayList([]Symbol).init(std.heap.page_allocator);
+    defer bag.deinit(); // try commenting this out and see if zig detects the memory leak!
+
+    var initial: [2]Symbol = .{Symbol.M, Symbol.I};
+    try bag.append(&initial);
+
+    var count: u64 = 0;
+    while(bag.items.len > count){
+        std.debug.print("curr/total {d}/{d}, \n", .{count, bag.items.len});
+
+        count = bag.items.len;
+        for(bag.items)|string|{
+            std.debug.print("Testing: {any}\n", .{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!
+            }
+        }
+    }
+
+
 
     try stdout.print("Run `zig build test` to run the tests.\n", .{});
 
     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-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-1] = Symbol.U;
+
+    return arr;
+    
+}
+
+pub fn rule2Test(input: []Symbol) bool {
+    return input[0] == Symbol.M;
+}
+pub fn rule2(input: []Symbol) ![]Symbol{
+    //M_ => M__
+
+    // var arr = try std.heap.page_allocator.alloc(Symbol, input.len * 2);
+    
+    // arr = input[0..];
+    // arr[input.len] = input[1..];
+
+    // mem.copy([]Symbol, arr)
+
+    return mem.concat(std.heap.page_allocator, Symbol, &[_][]Symbol{input[0..], input[1..]});
+}
+
+pub fn rule3Test(input: []Symbol) bool {
+    const pattern: [3]Symbol = .{Symbol.I, Symbol.I, Symbol.I};
+
+    for(input)|symbol, i|{
+        if(symbol == Symbol.I){
+            var streak = input[i..i+2];
+            if(mem.eql(Symbol, streak, &pattern) ){
+                return true;
+            } 
+        }
+    }
+    return false;
+}
+pub fn rule3(input: []Symbol) ![]Symbol{
+    // III => U
+    const pattern: [3]Symbol = .{Symbol.I, Symbol.I, Symbol.I};
+    var single = try std.heap.page_allocator.alloc(Symbol, 1);
+    single[0] = Symbol.U;
+
+    //var i:u64 = 0;
+    for(input)|symbol, i|{
+        if(symbol == Symbol.I){
+            var streak = input[i..i+2];
+            if(mem.eql(Symbol, streak, &pattern)){
+                //return input[0..i] ++ u ++ input[i+2..];
+
+                return mem.concat(std.heap.page_allocator, Symbol, &[_][]Symbol{input[0..i], single,input[i..]});
+
+            }
+        }
+    }
+
+    return error.NOTFOUND;
+}
+
+pub fn rule4Test(input: []Symbol) bool {
+    const pattern: [2]Symbol = .{Symbol.U, Symbol.U};
+
+    for(input)|symbol, i|{
+        if(symbol == Symbol.U){
+            var streak = input[i..i+1];
+            return (mem.eql(Symbol, streak, &pattern));
+        }
+    }
+    return false;
+}
+pub fn rule4(input: []Symbol) ![]Symbol{
+    // UU => -
+    const pattern: [2]Symbol = .{Symbol.U, Symbol.U};
+
+    for(input)|symbol, i|{
+        if(symbol == Symbol.U){
+            var streak = input[i..i+2];
+            if(mem.eql(Symbol, streak, &pattern)){
+                //return input[0..i] ++ input[i+1..];
+                return mem.concat(std.heap.page_allocator, Symbol, &[_][]Symbol{input[0..i], input[i+2..]});
+
+            }
+        }
+    }
+
+    return error.NOTFOUND;
+}
+
+pub fn finish(input: []Symbol) bool{
+    const pattern: [2]Symbol = .{Symbol.M, Symbol.U};
+
+    return mem.eql(Symbol, input, &pattern);
+}
+
+
 test "simple test" {
     var list = std.ArrayList(i32).init(std.testing.allocator);
     defer list.deinit(); // try commenting this out and see if zig detects the memory leak!