init
This commit is contained in:
jonathan santis
171
src/day2.zig
Normal file
171
src/day2.zig
Normal file
@@ -0,0 +1,171 @@
|
||||
const std = @import("std");
|
||||
const print = std.debug.print;
|
||||
var data : [1024][20]i32 = undefined;
|
||||
var data_len : [1024]u32 = undefined;
|
||||
var res:u32=0;
|
||||
var res2:u32=0;
|
||||
const dir = enum {zero,up,down};
|
||||
var data_size : u32 = 0;
|
||||
var direction = dir.zero;
|
||||
var safe : bool = true;
|
||||
var safe_rep : u32 = 0;
|
||||
var safe_no_dump : u32 = 0;
|
||||
//const e_data = data[0..data_size];
|
||||
var temp : i32 = 0;
|
||||
var legit : bool = false;
|
||||
var instance_unsafe : u32 = 0;
|
||||
|
||||
pub fn main() !void {
|
||||
_ = try readFile();
|
||||
const e_data = data[0..data_size];
|
||||
const e_data_len = data_len[0..data_size];
|
||||
|
||||
for(e_data,e_data_len) | row,len |
|
||||
{
|
||||
print("[main]len:{}\n",.{len});
|
||||
const row2 = row[0..len];
|
||||
if(checkLevel(row2) > 0)
|
||||
{
|
||||
safe_no_dump += 1;
|
||||
for(1..len) | i |
|
||||
{
|
||||
print("\x1B[0m",.{});
|
||||
const row1 = try rmNum(&row,len,i);
|
||||
print("rmRow: {d}\n",.{row1});
|
||||
print("remove level {}\n",.{i-1});
|
||||
if(checkLevel(row1)>0)
|
||||
{
|
||||
print("still unsafe ",.{});
|
||||
}
|
||||
else
|
||||
{
|
||||
print("now safe ",.{});
|
||||
safe_rep += 1;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
safe_rep += 1;
|
||||
}
|
||||
}
|
||||
print("Data_size: {}\n",.{data_size});
|
||||
std.debug.print("safe reports: {}\nsafe rep without dump:{}\n",.{safe_rep,safe_no_dump});
|
||||
}
|
||||
fn rmNum(slice : [] const i32,len : u32,pos : usize) ![]i32
|
||||
{
|
||||
var str = try std.heap.page_allocator.alloc(i32,len);
|
||||
|
||||
print("len rm: {}, slicelen: {}\n",.{len,slice.len});
|
||||
|
||||
for(slice,0..) | num, i |
|
||||
{
|
||||
if(i > len-1)
|
||||
{
|
||||
break;
|
||||
}
|
||||
|
||||
if(num == 0) break;
|
||||
if(i < pos)
|
||||
{
|
||||
str[i] = num;
|
||||
}
|
||||
else
|
||||
{
|
||||
str[i-1] = num;
|
||||
}
|
||||
}
|
||||
const sl2 = str[0..len-1];
|
||||
return sl2;
|
||||
}
|
||||
|
||||
fn checkLevel(slice : [] const i32) u8
|
||||
{
|
||||
direction = dir.zero;
|
||||
legit = false;
|
||||
print("slice: {d}, len {}\n",.{slice,slice.len});
|
||||
|
||||
for(slice,0..) | num,ii |
|
||||
{
|
||||
if(ii < slice.len-1 )
|
||||
{
|
||||
if(num == slice[ii+1])
|
||||
{
|
||||
std.debug.print("\x1B[31mequal1\n",.{});
|
||||
return 1;
|
||||
}
|
||||
if(direction == dir.zero and num > slice[ii+1])
|
||||
{
|
||||
direction = dir.down;
|
||||
}
|
||||
if(direction == dir.zero and num < slice[ii+1])
|
||||
{
|
||||
direction = dir.up;
|
||||
}
|
||||
if(direction == dir.down and num < slice[ii+1])
|
||||
{
|
||||
std.debug.print("\x1B[31mexit2\n",.{});
|
||||
return 2;
|
||||
}
|
||||
if(direction == dir.up and num > slice[ii+1])
|
||||
{
|
||||
std.debug.print("\x1B[31mexit3\n direction : {}\n num :{} > {}, index: {}\n",.{direction,num,slice[ii+1],ii});
|
||||
return 3;
|
||||
}
|
||||
//temp = @intCast(num);
|
||||
if(@abs(num - slice[ii+1]) < 1 or @abs(num - slice[ii+1]) > 3)
|
||||
{
|
||||
std.debug.print("\x1B[31mexit4 num: {} slice[ii+1]: {}, full slice {d}, index: {}\n,",.{num,slice[ii+1],slice,ii});
|
||||
return 4;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
print("\x1B[0m",.{});
|
||||
return 0;
|
||||
}
|
||||
|
||||
fn readFile() !void
|
||||
{
|
||||
const file = try std.fs.cwd().openFile("day2-1.txt",.{});
|
||||
defer file.close();
|
||||
|
||||
var buf_reader = std.io.bufferedReader(file.reader());
|
||||
var in_stream = buf_reader.reader();
|
||||
|
||||
var buf: [1024*5]u8 = undefined;
|
||||
var index : u32 = 0;
|
||||
var row : u32 = 0;
|
||||
|
||||
while(try in_stream.readUntilDelimiterOrEof(&buf,'\n')) | line |
|
||||
{
|
||||
var it = std.mem.split(u8,line," ");
|
||||
|
||||
while (it.next()) |word|
|
||||
{
|
||||
if(std.mem.eql(u8,word,"\n")==false)
|
||||
{
|
||||
if(std.mem.eql(u8,word," ")==false)
|
||||
{
|
||||
data[row][index] = try std.fmt.parseInt(i32,word,10);
|
||||
index += 1;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
|
||||
data_len[row] = index;
|
||||
row += 1;
|
||||
index = 0;
|
||||
}
|
||||
}
|
||||
data_len[row] = index;
|
||||
index = 0;
|
||||
row += 1;
|
||||
|
||||
}
|
||||
data_size = row;
|
||||
}
|
||||
|
||||
204
src/day3-2.zig
Normal file
204
src/day3-2.zig
Normal file
@@ -0,0 +1,204 @@
|
||||
const std = @import("std");
|
||||
const print = std.debug.print;
|
||||
var buffer : [22048]u8 = undefined;
|
||||
|
||||
pub fn main() !void
|
||||
{
|
||||
var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
|
||||
defer arena.deinit();
|
||||
const allocator = arena.allocator();
|
||||
|
||||
const read_bytes = try readFile("day3.txt");
|
||||
const pattern = "mul(";
|
||||
|
||||
|
||||
|
||||
var slice :[]u8= undefined;
|
||||
var slice2 :[]u8= undefined;
|
||||
slice2 = buffer[0..read_bytes];
|
||||
|
||||
var mulresult : u64 = 0;
|
||||
var count : u64 = 0;
|
||||
|
||||
var endpos : usize = 0;
|
||||
//var buf : [10]u8 = undefined;
|
||||
|
||||
|
||||
while(slice2.len != 0) : (count += 1)
|
||||
{
|
||||
print("slice2: {}\n",.{slice2.len});
|
||||
while(true)
|
||||
{
|
||||
var do = std.mem.indexOf(u8,slice2,"do()");
|
||||
if(count == 0)
|
||||
{
|
||||
do = 0;
|
||||
}
|
||||
|
||||
const dont = std.mem.indexOf(u8,slice2,"don't()");
|
||||
|
||||
if(do == null and dont == null)
|
||||
{
|
||||
print("last line\n",.{});
|
||||
std.posix.exit(1);
|
||||
break;
|
||||
}
|
||||
if(do) | do2 |
|
||||
{
|
||||
if(dont) | dont2 |
|
||||
{
|
||||
if(dont2 > do2)
|
||||
{
|
||||
print("endpos{s} ,endpos{d}\n",.{buffer[endpos..endpos+5],endpos});
|
||||
slice2 = slice2[do2..dont2];
|
||||
endpos = endpos + dont2 + 7; //absolute pos in buffer
|
||||
break;
|
||||
}
|
||||
else
|
||||
{
|
||||
endpos = endpos + dont2 + 7;
|
||||
slice2 = buffer[endpos..];
|
||||
print("endpos{s} ,endpos{d}\n",.{buffer[endpos..endpos+5],endpos});
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
//slice2 = slice2[do2..];
|
||||
print("last line\n",.{});
|
||||
std.posix.exit(1);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
slice = slice2;
|
||||
while(slice.len != 0)
|
||||
{
|
||||
//_ = try std.io.getStdIn().reader().readUntilDelimiterOrEof(buf[0..],'\n');
|
||||
const first = std.mem.indexOf(u8,slice,pattern);
|
||||
|
||||
var index2 : usize = 0;
|
||||
|
||||
|
||||
if(first) | index |
|
||||
{
|
||||
var num :u64 = 0;
|
||||
const len = try getNum(allocator,slice,index + pattern.len,&num);
|
||||
if(len > 0)
|
||||
{
|
||||
if(slice[index + pattern.len + len] == ',')
|
||||
{
|
||||
var num2 : u64 = 0;
|
||||
const len2 = try getNum(allocator,slice,index + pattern.len + len + 1,&num2);
|
||||
if(len2 > 0)
|
||||
{
|
||||
//print("num2: {}\n",.{num2});
|
||||
index2 = index + pattern.len + len + len2 + 1;
|
||||
if(slice[index2] == ')')
|
||||
{
|
||||
mulresult = mulresult + (num * num2);
|
||||
if(num > 999 or num2 > 999)
|
||||
{
|
||||
print("error invalid data to loong number",.{});
|
||||
std.posix.exit(1);
|
||||
}
|
||||
print("{s}({d},{d})\nmulresult: {d}\n",.{pattern,num,num2,mulresult});
|
||||
}
|
||||
else
|
||||
{
|
||||
index2 = index + 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
index2 = index + 1;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
print("len: {}\n slice: {s}\n endpos{s}\n",.{len,slice,buffer[endpos-5..endpos]});
|
||||
}
|
||||
if(slice.len > index2)
|
||||
{
|
||||
slice = slice[index2..];
|
||||
//print("slice len: {} \nindex2:{}\n",.{slice.len,index2});
|
||||
}
|
||||
else
|
||||
{
|
||||
break;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
|
||||
break;
|
||||
}
|
||||
//print("do: {?}, dont(): {?}\nslice.len:{}\n,index2:\n",.{do,dont,slice.len});
|
||||
|
||||
}
|
||||
|
||||
slice2 = buffer[endpos..];
|
||||
}
|
||||
print("add up muls: {d}\nreadBytes from File: {d}",.{mulresult,read_bytes});
|
||||
}
|
||||
|
||||
fn getNum(allocator : std.mem.Allocator,buf : []u8,first : usize,parsed : *u64) !usize
|
||||
{
|
||||
var result : []u8 = try allocator.alloc(u8,0);
|
||||
var i: u64 = first;
|
||||
if(i >= buf.len - 1)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
while(isNumber(buf[i]) == true) : ( i += 1)
|
||||
{
|
||||
//_ = try std.fmt.bufPrint(&result,"{s}{}",.{temp,buf[i]});
|
||||
result = try std.fmt.allocPrint(allocator,"{s}{c}",.{result,buf[i]});
|
||||
if(i >= buf.len-1)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
print("\n{s}\nlen: {}",.{result,result.len});
|
||||
if(result.len > 0)
|
||||
{
|
||||
parsed.* = try std.fmt.parseUnsigned(u64,result,10);
|
||||
}
|
||||
else
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
defer allocator.free(result);
|
||||
return result.len;
|
||||
}
|
||||
|
||||
fn isNumber(number : u8) bool
|
||||
{
|
||||
const numbers = [10]u8{'0','1','2','3','4','5','6','7','8','9'};
|
||||
for(numbers) | nbr |
|
||||
{
|
||||
if(number == nbr)
|
||||
{
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
fn readFile(filename : [] const u8) !usize
|
||||
{
|
||||
const file = try std.fs.cwd().openFile(filename,.{});
|
||||
defer file.close();
|
||||
|
||||
const bytes_read = try file.readAll(&buffer);
|
||||
return bytes_read;
|
||||
|
||||
}
|
||||
|
||||
test "search substring"
|
||||
{
|
||||
const pos = std.mem.indexOf(u8,"abcde","ded");
|
||||
print("Pos: {?}",.{pos});
|
||||
}
|
||||
142
src/day3.zig
Normal file
142
src/day3.zig
Normal file
@@ -0,0 +1,142 @@
|
||||
const std = @import("std");
|
||||
const print = std.debug.print;
|
||||
var buffer : [22048]u8 = undefined;
|
||||
|
||||
pub fn main() !void
|
||||
{
|
||||
var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
|
||||
defer arena.deinit();
|
||||
const allocator = arena.allocator();
|
||||
|
||||
const read_bytes = try readFile("day3.txt");
|
||||
const pattern = "mul(";
|
||||
|
||||
|
||||
|
||||
var slice :[]u8= undefined;
|
||||
slice = buffer[0..read_bytes];
|
||||
|
||||
var mulresult : u64 = 0;
|
||||
|
||||
//var buf : [10]u8 = undefined;
|
||||
|
||||
while(slice.len != 0)
|
||||
{
|
||||
//index2 = 0;
|
||||
//_ = try std.io.getStdIn().reader().readUntilDelimiterOrEof(buf[0..],'\n');
|
||||
const first = std.mem.indexOf(u8,slice,pattern);
|
||||
var index2 : usize = 0;
|
||||
|
||||
if(first) | index |
|
||||
{
|
||||
var num :u64 = 0;
|
||||
const len = try getNum(allocator,slice,index + pattern.len,&num);
|
||||
if(len > 0)
|
||||
{
|
||||
if(slice[index + pattern.len + len] == ',')
|
||||
{
|
||||
var num2 : u64 = 0;
|
||||
const len2 = try getNum(allocator,slice,index + pattern.len + len + 1,&num2);
|
||||
if(len2 > 0)
|
||||
{
|
||||
//print("num2: {}\n",.{num2});
|
||||
index2 = index + pattern.len + len + len2 + 1;
|
||||
if(slice[index2] == ')')
|
||||
{
|
||||
mulresult = mulresult + (num * num2);
|
||||
if(num > 999 or num2 > 999)
|
||||
{
|
||||
print("error invalid data to loong number",.{});
|
||||
std.posix.exit(1);
|
||||
}
|
||||
print("{s}({d},{d})\nmulresult: {d}\n",.{pattern,num,num2,mulresult});
|
||||
}
|
||||
else
|
||||
{
|
||||
index2 = index + 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
index2 = index + 1;
|
||||
print("should be , but is: {c}\nindex2 = {}\n",.{slice[index + pattern.len + len],index2});
|
||||
}
|
||||
}
|
||||
if(slice.len > index2)
|
||||
{
|
||||
slice = slice[index2..];
|
||||
//print("slice len: {} \nindex2:{}\n",.{slice.len,index2});
|
||||
}
|
||||
else
|
||||
{
|
||||
break;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
break;
|
||||
}
|
||||
}
|
||||
print("add up muls: {d}\nreadBytes from File: {d}",.{mulresult,read_bytes});
|
||||
}
|
||||
|
||||
fn getNum(allocator : std.mem.Allocator,buf : []u8,first : usize,parsed : *u64) !usize
|
||||
{
|
||||
var result : []u8 = try allocator.alloc(u8,0);
|
||||
var i: u64 = first;
|
||||
if(i >= buf.len - 1)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
while(isNumber(buf[i]) == true) : ( i += 1)
|
||||
{
|
||||
//_ = try std.fmt.bufPrint(&result,"{s}{}",.{temp,buf[i]});
|
||||
result = try std.fmt.allocPrint(allocator,"{s}{c}",.{result,buf[i]});
|
||||
if(i >= buf.len-1)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
print("\n-{s}\nlen: {}",.{result,result.len});
|
||||
if(result.len > 0)
|
||||
{
|
||||
parsed.* = try std.fmt.parseUnsigned(u64,result,10);
|
||||
}
|
||||
else
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
defer allocator.free(result);
|
||||
return result.len;
|
||||
}
|
||||
|
||||
fn isNumber(number : u8) bool
|
||||
{
|
||||
const numbers = [10]u8{'0','1','2','3','4','5','6','7','8','9'};
|
||||
for(numbers) | nbr |
|
||||
{
|
||||
if(number == nbr)
|
||||
{
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
fn readFile(filename : [] const u8) !usize
|
||||
{
|
||||
const file = try std.fs.cwd().openFile(filename,.{});
|
||||
defer file.close();
|
||||
|
||||
const bytes_read = try file.readAll(&buffer);
|
||||
return bytes_read;
|
||||
|
||||
}
|
||||
|
||||
test "search substring"
|
||||
{
|
||||
const pos = std.mem.indexOf(u8,"abcde","ded");
|
||||
print("Pos: {?}",.{pos});
|
||||
}
|
||||
232
src/day4.zig
Normal file
232
src/day4.zig
Normal file
@@ -0,0 +1,232 @@
|
||||
const std = @import("std");
|
||||
const print = std.debug.print;
|
||||
var buffer : [30000]u8 = undefined;
|
||||
var debugBuffer : [30000]u64 = undefined;
|
||||
|
||||
const Dir = enum {leftUp, Up, rightUp, left, right, downLeft, down, downRight};
|
||||
|
||||
const GenericError = error{
|
||||
NoNewlineFound,
|
||||
HitBoundary,
|
||||
};
|
||||
var debugFile : std.fs.File = undefined;
|
||||
|
||||
pub fn main() ! void
|
||||
{
|
||||
|
||||
debugFile = try std.fs.cwd().createFile("debug.log",.{});
|
||||
defer debugFile.close();
|
||||
|
||||
var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
|
||||
defer arena.deinit();
|
||||
const allocator = arena.allocator();
|
||||
|
||||
var absPos : usize = 0;
|
||||
// var currentPos : usize = 0;
|
||||
var found : u64 = 0;
|
||||
var ret : u64 = 0;
|
||||
|
||||
const read_bytes = try readFile("day4.txt");
|
||||
const lineLen = try getLineLen();
|
||||
|
||||
for(buffer[0..read_bytes],0..) | _,currentPos |
|
||||
{
|
||||
absPos = currentPos;
|
||||
print("absolute Pos: {}\n",.{absPos});
|
||||
// if(@mod(currentPos+1,lineLen) != 0 or currentPos == 0)
|
||||
// {
|
||||
print("mod: {}\n",.{@mod(currentPos,lineLen)});
|
||||
//ret = try checkString(allocator,"XMAS",&absPos,lineLen);
|
||||
ret = try checkForMas(allocator,&absPos,lineLen);
|
||||
debugBuffer[currentPos] = ret;
|
||||
found = found + ret;
|
||||
print("Found: {}\n",.{ret});
|
||||
//}
|
||||
|
||||
}
|
||||
print("AllFound: {}\n",.{found});
|
||||
|
||||
for(debugBuffer[0..read_bytes],0..) | buf,i |
|
||||
{
|
||||
if(buf == 0)
|
||||
{
|
||||
if(@mod(i,lineLen-1) != 0)
|
||||
{
|
||||
print(".",.{});
|
||||
}
|
||||
|
||||
}
|
||||
else
|
||||
{
|
||||
print("{d}",.{buf});
|
||||
}
|
||||
if(@mod(i+1,lineLen) == 0)
|
||||
{
|
||||
print("\n",.{});
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
fn checkString(allocator : std.mem.Allocator, pattern : [] const u8,pos : *usize,lineLen : u64) !u64
|
||||
{
|
||||
var result : u64 = 0;
|
||||
const tempPos = pos.*;
|
||||
inline for (@typeInfo(Dir).Enum.fields) | enu |
|
||||
{
|
||||
pos.* = tempPos;
|
||||
//print("typeof:{s} {}\n",.{enu.name,i});
|
||||
const slice = move(allocator,@enumFromInt(enu.value),pattern.len-1,pos,lineLen) catch "";
|
||||
print("pattern: {s} slice {s} {s}\n",.{pattern,slice,enu.name});
|
||||
if(std.mem.eql(u8,pattern,slice) == true)
|
||||
{
|
||||
result +=1;
|
||||
}
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
fn checkForMas(allocator : std.mem.Allocator,pos : *usize,lineLen : u64) !u64
|
||||
{
|
||||
var result : u64 = 0;
|
||||
const tempPos = pos.*;
|
||||
|
||||
pos.* = tempPos;
|
||||
if(buffer[pos.*] == 'A')
|
||||
{
|
||||
const slice = move(allocator,Dir.leftUp,1,pos,lineLen) catch "..";
|
||||
pos.* = tempPos;
|
||||
const slice2 = move(allocator,Dir.downRight,1,pos,lineLen) catch "..";
|
||||
pos.* = tempPos;
|
||||
|
||||
const slice3 = move(allocator,Dir.rightUp,1,pos,lineLen) catch "..";
|
||||
pos.* = tempPos;
|
||||
const slice4 = move(allocator,Dir.downLeft,1,pos,lineLen) catch "..";
|
||||
pos.* = tempPos;
|
||||
|
||||
print("slice: {s}\n",.{slice});
|
||||
print("slice2: {s}\n",.{slice2});
|
||||
print("slice3: {s}\n",.{slice3});
|
||||
print("slice4: {s}\n",.{slice4});
|
||||
|
||||
if(((slice3[1] == 'M' and slice4[1] == 'S') or (slice3[1] == 'S' and slice4[1] == 'M')) and ((slice[1] == 'M' and slice2[1] == 'S') or (slice[1] == 'S' and slice2[1] == 'M')))
|
||||
{
|
||||
result += 1;
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
fn move(allocator : std.mem.Allocator, dir : Dir, count: usize,absPos : *usize,lineLen : u64) ![]u8
|
||||
{
|
||||
var result : []u8 = try allocator.alloc(u8,1);
|
||||
|
||||
result[0] = buffer[absPos.*];
|
||||
//defer allocator.free(result);
|
||||
|
||||
for(0..count) | _ |
|
||||
{
|
||||
const homePos = absPos.*;
|
||||
//debugBuffer[absPos.*] = '.';
|
||||
if(absPos.* != '\n')
|
||||
{
|
||||
switch(dir) {
|
||||
Dir.leftUp => {
|
||||
if(absPos.* > lineLen)
|
||||
{
|
||||
absPos.* = absPos.* - lineLen - 1;
|
||||
}
|
||||
else
|
||||
{
|
||||
return error.HitBoundary;
|
||||
}
|
||||
},
|
||||
Dir.Up => {
|
||||
if(absPos.* > lineLen)
|
||||
{
|
||||
absPos.* = absPos.* - lineLen;
|
||||
print("dir.up {c}\n",.{buffer[absPos.*]});
|
||||
}
|
||||
else
|
||||
{
|
||||
return error.HitBoundary;
|
||||
}
|
||||
},
|
||||
Dir.rightUp => {
|
||||
if(absPos.* > lineLen)
|
||||
{
|
||||
absPos.* = absPos.* - lineLen + 1 ;
|
||||
}
|
||||
else
|
||||
{
|
||||
return error.HitBoundary;
|
||||
}
|
||||
},
|
||||
Dir.left => {
|
||||
//if(@mod(absPos.*,lineLen)!=0)
|
||||
if(absPos.* > 0)
|
||||
{
|
||||
absPos.* = absPos.* - 1;
|
||||
}
|
||||
else
|
||||
{
|
||||
return error.HitBoundary;
|
||||
}
|
||||
},
|
||||
Dir.right => {
|
||||
absPos.* = absPos.* + 1;
|
||||
},
|
||||
Dir.downLeft => {
|
||||
absPos.* = absPos.* + lineLen - 1;
|
||||
},
|
||||
Dir.down => {
|
||||
absPos.* = absPos.* + lineLen;
|
||||
},
|
||||
Dir.downRight => {
|
||||
absPos.* = absPos.* + lineLen + 1;
|
||||
},
|
||||
}
|
||||
}
|
||||
if(buffer[absPos.*] != '\n')
|
||||
{
|
||||
result = try std.fmt.allocPrint(allocator,"{s}{c}",.{result,buffer[absPos.*]});
|
||||
}
|
||||
else
|
||||
{
|
||||
absPos.* = homePos;
|
||||
result = try std.fmt.allocPrint(allocator,"...",.{});
|
||||
}
|
||||
|
||||
}
|
||||
//print("absPos: {} lineLen: {}\n",.{absPos.*,lineLen});
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
fn getLineLen() GenericError!usize
|
||||
{
|
||||
if(std.mem.indexOf(u8,&buffer,"\n")) | index |
|
||||
{
|
||||
print("found newline at {?}\n",.{index});
|
||||
//add for the newline itself
|
||||
return index+1;
|
||||
}
|
||||
else
|
||||
{
|
||||
return error.NoNewlineFound;
|
||||
}
|
||||
}
|
||||
|
||||
fn readFile(filename : [] const u8) !usize
|
||||
{
|
||||
const file = try std.fs.cwd().openFile(filename,.{});
|
||||
defer file.close();
|
||||
|
||||
const bytes_read = try file.readAll(&buffer);
|
||||
return bytes_read;
|
||||
|
||||
}
|
||||
|
||||
179
src/day5.zig
Normal file
179
src/day5.zig
Normal file
@@ -0,0 +1,179 @@
|
||||
const std = @import("std");
|
||||
const print = std.debug.print;
|
||||
|
||||
pub fn main() !void
|
||||
{
|
||||
const allocator = std.heap.page_allocator;
|
||||
var rules = std.ArrayList([]u8).init(allocator);
|
||||
var data = std.ArrayList([]u8).init(allocator);
|
||||
var sum : usize = 0;
|
||||
|
||||
print("typeof arraylist: {}",.{@TypeOf(rules)});
|
||||
try readFile(allocator,"day5.txt",&rules,&data);
|
||||
|
||||
print("rules:\n",.{});
|
||||
for(rules.items) | rule |
|
||||
{
|
||||
print("{s}\n",.{rule});
|
||||
}
|
||||
print("data:\n",.{});
|
||||
for(data.items) | dat |
|
||||
{
|
||||
print("{s}\n",.{dat});
|
||||
}
|
||||
|
||||
|
||||
|
||||
for(data.items) | dat |
|
||||
{
|
||||
const values = try parseIntsToSlice(allocator,dat);
|
||||
print("ints: {d}\n",.{values});
|
||||
if(try checkOrder(allocator,dat,&rules)) | failed_rule |
|
||||
{
|
||||
print("dataset failed at rule {d}\n",.{failed_rule});
|
||||
}
|
||||
else
|
||||
{
|
||||
print("dataset {d} clean\n",.{values});
|
||||
const middle = getMiddleFromSlice(values);
|
||||
print("middle value {d}\n",.{values[middle]});
|
||||
sum = sum + values[middle];
|
||||
}
|
||||
}
|
||||
|
||||
print("Final result: {d}",.{sum});
|
||||
|
||||
}
|
||||
|
||||
fn readFile(allocator : std.mem.Allocator, filename : [] const u8, rules : *std.ArrayList([]u8), data : *std.ArrayList([]u8)) !void
|
||||
{
|
||||
const file = try std.fs.cwd().openFile(filename,.{});
|
||||
var buf_reader = std.io.bufferedReader(file.reader());
|
||||
var reader = buf_reader.reader();
|
||||
|
||||
var buf: [1024]u8 = undefined;
|
||||
|
||||
while(try reader.readUntilDelimiterOrEof(&buf,'\n') )| line |
|
||||
{
|
||||
|
||||
if(std.mem.indexOf(u8,line,"|")) | _ |
|
||||
{
|
||||
print("this is a rule: ",.{});
|
||||
try rules.append(try std.fmt.allocPrint(allocator,"{s}",.{line}));
|
||||
}
|
||||
else if(std.mem.indexOf(u8,line,",")) | _ |
|
||||
{
|
||||
try data.append( try std.fmt.allocPrint(allocator,"{s}",.{line}));
|
||||
print("this is a data set: ",.{});
|
||||
}
|
||||
|
||||
print("{s}\n",.{line});
|
||||
}
|
||||
}
|
||||
|
||||
fn parseIntsToSlice(allocator : std.mem.Allocator, data : []u8) ![]u64
|
||||
{
|
||||
var values : []u64 = try allocator.alloc(u64,0);
|
||||
var start_pos : usize = 0;
|
||||
|
||||
//first must be different as dataset does not beginn with a ,
|
||||
|
||||
if(std.mem.indexOfAnyPos(u8,data,0,",")) | index |
|
||||
{
|
||||
values = try allocator.realloc(values,values.len + 1);
|
||||
const cur_index = values.len - 1;
|
||||
|
||||
//parses the string from beginning to , to an integer
|
||||
values[cur_index] = try std.fmt.parseInt(u64,data[0..index],10);
|
||||
}
|
||||
|
||||
while(std.mem.indexOfAnyPos(u8,data,start_pos,",")) | index |
|
||||
{
|
||||
if(start_pos >= data.len - 1) break;
|
||||
|
||||
if(std.mem.indexOfAnyPos(u8,data,index+1,",")) | sub_index |
|
||||
{
|
||||
values = try allocator.realloc(values,values.len + 1);
|
||||
const cur_index = values.len - 1;
|
||||
|
||||
//parses the string from , to , to an integer
|
||||
values[cur_index] = try std.fmt.parseInt(u64,data[index+1..sub_index],10);
|
||||
start_pos = sub_index;
|
||||
}
|
||||
else
|
||||
{
|
||||
values = try allocator.realloc(values,values.len + 1);
|
||||
const cur_index = values.len - 1;
|
||||
values[cur_index] = try std.fmt.parseInt(u64,data[index+1..data.len],10);
|
||||
break;
|
||||
}
|
||||
}
|
||||
//print("address of heap allocated memory: {}\nvalues itself: {d}\n",.{&values,values});
|
||||
return values;
|
||||
}
|
||||
fn parseRule(allocator : std.mem.Allocator,rule : []u8) ![2]u64
|
||||
{
|
||||
_ = allocator;
|
||||
|
||||
if(std.mem.indexOf(u8,rule,"|")) | index |
|
||||
{
|
||||
const int1 = try std.fmt.parseInt(u64,rule[0..index],10);
|
||||
const int2 = try std.fmt.parseInt(u64,rule[index+1..],10);
|
||||
return .{int1,int2};
|
||||
}
|
||||
return.{0,0};
|
||||
}
|
||||
|
||||
//returns the rule number which first caused a rule mismatch
|
||||
fn checkOrder(allocator : std.mem.Allocator,data : []u8,rules : *std.ArrayList([]u8)) !? usize
|
||||
{
|
||||
const nbrs = try parseIntsToSlice(allocator,data);
|
||||
//const nbrs2 = try parseIntsToSlice(allocator,data);
|
||||
var pass_test : bool = false;
|
||||
var fail_index : usize = 0;
|
||||
|
||||
for(nbrs,0..) | nbr, index_nbr |
|
||||
{
|
||||
for (rules.items,0..) | rule, index_rule |
|
||||
{
|
||||
|
||||
const rule_i = try parseRule(allocator,rule);
|
||||
if(nbr == rule_i[0])
|
||||
{
|
||||
print("check rule: {s}",.{rule});
|
||||
for(nbrs,0..) | nbr2, index_nbr2 |
|
||||
{
|
||||
if(nbr2 == rule_i[1])
|
||||
{
|
||||
if(index_nbr2 > index_nbr)
|
||||
{
|
||||
print("... OK\n",.{});
|
||||
pass_test = true;
|
||||
break;
|
||||
}
|
||||
else
|
||||
{
|
||||
print("... failed at rule {d}\n",.{index_rule});
|
||||
pass_test = false;
|
||||
fail_index = index_rule;
|
||||
return fail_index;
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
print("... skip rule\n",.{});
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
fn getMiddleFromSlice(data : []u64) usize
|
||||
{
|
||||
const middle = (data.len - 1) / 2;
|
||||
print("middle: {}\n",.{middle});
|
||||
|
||||
return middle;
|
||||
}
|
||||
121
src/main.zig
Normal file
121
src/main.zig
Normal file
@@ -0,0 +1,121 @@
|
||||
const std = @import("std");
|
||||
var data : [4][1024]u32 = undefined;
|
||||
var res:u32=0;
|
||||
var res2:u32=0;
|
||||
|
||||
pub fn main() !void {
|
||||
_ = try readFile();
|
||||
std.debug.print("{},{}\n",.{data[0][0],data[1][0]});
|
||||
|
||||
for(&data[0],0..) | *elema,indexa |
|
||||
{
|
||||
const slice = data[0][indexa+1..];
|
||||
for(slice) |*elemb|
|
||||
{
|
||||
if(elemb.* < elema.*)
|
||||
{
|
||||
const temp = elema.*;
|
||||
elema.* = elemb.*;
|
||||
elemb.* = temp;
|
||||
}
|
||||
}
|
||||
}
|
||||
for(&data[1],0..) | *elema,indexa |
|
||||
{
|
||||
const slice = data[1][indexa+1..];
|
||||
for(slice) |*elemb|
|
||||
{
|
||||
if(elemb.* < elema.*)
|
||||
{
|
||||
const temp = elema.*;
|
||||
elema.* = elemb.*;
|
||||
elemb.* = temp;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
for(&data[0],&data[1],&data[2],&data[3]) | a, b, *c, *d |
|
||||
{
|
||||
d.* = 0;
|
||||
if(a < b)
|
||||
{
|
||||
c.* = b-a;
|
||||
}
|
||||
else if (a > b)
|
||||
{
|
||||
c.* = a-b;
|
||||
}
|
||||
}
|
||||
for(&data[0]) | a |
|
||||
{
|
||||
|
||||
for(&data[1], &data[3]) | b, *c |
|
||||
{
|
||||
//std.debug.print("a:{} ,b:{}\n",.{a,b});
|
||||
if(a == b and a != 0)
|
||||
{
|
||||
c.* = a;
|
||||
std.debug.print("c:{}, a:{}\n",.{c.*,a});
|
||||
}
|
||||
}
|
||||
}
|
||||
for(&data[3]) | count |
|
||||
{
|
||||
res2 = res2 + count;
|
||||
}
|
||||
|
||||
for(&data[2]) | a |
|
||||
{
|
||||
res = res + a;
|
||||
}
|
||||
std.debug.print("res: {}\n",.{res});
|
||||
std.debug.print("res2: {}\n",.{res2});
|
||||
std.debug.print("ex: {} {} {}",.{data[0][1],data[1][1],data[3][1]});
|
||||
|
||||
|
||||
}
|
||||
|
||||
|
||||
|
||||
fn readFile() !void
|
||||
{
|
||||
const file = try std.fs.cwd().openFile("input.txt",.{});
|
||||
defer file.close();
|
||||
|
||||
var buf_reader = std.io.bufferedReader(file.reader());
|
||||
var in_stream = buf_reader.reader();
|
||||
|
||||
var buf: [1024]u8 = undefined;
|
||||
var index : u32 = 0;
|
||||
var indexa: u32 = 0;
|
||||
var indexb : u32 = 0;
|
||||
|
||||
while(try in_stream.readUntilDelimiterOrEof(&buf,'\n')) | line |
|
||||
{
|
||||
var it = std.mem.split(u8,line," ");
|
||||
|
||||
while (it.next()) |word|
|
||||
{
|
||||
if(std.mem.eql(u8,word,"\n")==false)
|
||||
{
|
||||
if(std.mem.eql(u8,word,"")==false)
|
||||
{
|
||||
//std.debug.print("entry:{s}\n", .{word});
|
||||
if(@mod(index,2)==0)
|
||||
{
|
||||
data[0][indexa] = try std.fmt.parseInt(u32,word,10);
|
||||
indexa +=1;
|
||||
}
|
||||
else
|
||||
{
|
||||
data[1][indexb] = try std.fmt.parseInt(u32,word,10);
|
||||
indexb += 1;
|
||||
}
|
||||
index += 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
10
src/root.zig
Normal file
10
src/root.zig
Normal file
@@ -0,0 +1,10 @@
|
||||
const std = @import("std");
|
||||
const testing = std.testing;
|
||||
|
||||
export fn add(a: i32, b: i32) i32 {
|
||||
return a + b;
|
||||
}
|
||||
|
||||
test "basic add functionality" {
|
||||
try testing.expect(add(3, 7) == 10);
|
||||
}
|
||||
Reference in New Issue
Block a user