base logic created

src/main.zig

@@ -1,9 +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(u2) {
+    M,
+    U,
+    I
+};
 
 
 
@@ -20,12 +23,107 @@ pub fn main() !void {
 
 
 
+    var list = std.ArrayList([]Symbol).init(std.heap.page_allocator);
+    defer list.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);
+
+    var count: u64 = 0;
+    while(list.items.len > count){
+        count = list.items.len;
+        for(list.items)|string|{
+            if(rule1Test(string)){ try list.append(rule1(string)); }
+            if(rule2Test(string)){ try list.append(rule2(string)); }
+            if(rule3Test(string)){ try list.append(rule3(string)); }
+            if(rule4Test(string)){ try list.append(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 rule1Test(input: []Symbol ) bool{
+    return (input[input.len] == Symbol.I);
+}
+pub fn rule1(input: []Symbol) []Symbol{
+    const lastEl:Symbol = input[input.len];
+
+    if(lastEl == Symbol.I){
+        
+        return input ++ &Symbol.U;
+    }
+}
+
+pub fn rule2Test(input: []Symbol) bool {
+    return input[0] == Symbol.M;
+}
+pub fn rule2(input: []Symbol) []Symbol{
+    //M_ => M__
+    return input ++ input[1..];
+}
+
+pub fn rule3Test(input: []Symbol) bool {
+    for(input)|symbol, i|{
+        if(symbol == Symbol.I){
+            var streak = input[i..i+2];
+            if(mem.eql(u2, streak, [_]Symbol{Symbol.I ** 3}) ){
+                return true;
+            } 
+        }
+    }
+    return false;
+}
+pub fn rule3(input: []Symbol) []Symbol{
+    // III => U
+
+    //var i:u64 = 0;
+    for(input)|symbol, i|{
+        if(symbol == Symbol.I){
+            var streak = input[i..i+2];
+            if(mem.eql(u2, streak, []Symbol{Symbol.I ** 3})){
+                return input[0..i] ++ Symbol.U ++ input[i+2..];
+            }
+        }
+    }
+
+}
+
+pub fn rule4Test(input: []Symbol) bool {
+    for(input)|symbol, i|{
+        if(symbol == Symbol.U){
+            var streak = input[i..i+2];
+            return (mem.eql(u2, streak, []Symbol{Symbol.U ** 3}));
+        }
+    }
+    return false;
+}
+pub fn rule4(input: []Symbol) []Symbol{
+    // UU => -
+
+    for(input)|symbol, i|{
+        if(symbol == Symbol.U){
+            var streak = input[i..i+2];
+            if(mem.eql(u2, streak, []Symbol{Symbol.U ** 3})){
+                return input[0..i] ++ input[i+1..];
+            }
+        }
+    }
+}
+
+pub fn finish(input: []Symbol) bool{
+    return mem.eql(u2, input, []Symbol{Symbol.M, Symbol.U});
+}
+
+
 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!