Compare commits

...

31 commits

Author SHA1 Message Date
30d90e0019
Merge branch 'main' of https://codeberg.org/ziglings/exercises 2024-04-17 21:13:37 -04:00
Chris Boesch
9432c2b0fd Merge pull request 'Fixed woodpecker warnings' (#79) from pr78 into main
Reviewed-on: https://codeberg.org/ziglings/exercises/pulls/79
2024-04-10 21:02:13 +00:00
Chris Boesch
f4f8eb7ff1
Fixed woodpecker warnings 2024-04-10 22:56:33 +02:00
Chris Boesch
72e3d6ebdc Update .woodpecker/eowyn.yml 2024-04-10 18:38:59 +00:00
Chris Boesch
3c9c55df8e Merge pull request 'Additional timer in thread start added' (#77) from I75 into main
Reviewed-on: https://codeberg.org/ziglings/exercises/pulls/77
2024-04-10 17:21:18 +00:00
Chris Boesch
376a839672 Merge branch 'main' into I75 2024-04-10 17:16:14 +00:00
Chris Boesch
ba2a9622c4
Additional timer in thread start added 2024-04-10 19:13:46 +02:00
Chris Boesch
2122c477a0 Merge pull request 'Greater gradation of timers built into the threads' (#76) from I75 into main
Reviewed-on: https://codeberg.org/ziglings/exercises/pulls/76
2024-04-10 14:18:01 +00:00
Chris Boesch
7732cd7716
Greater gradation of timers built into the threads 2024-04-10 16:06:23 +02:00
Chris Boesch
564916db81 Update README.md 2024-04-03 07:51:19 +00:00
Chris Boesch
84864d808f Merge pull request 'Zig version changed' (#73) from pr72 into main
Reviewed-on: https://codeberg.org/ziglings/exercises/pulls/73
2024-04-03 07:47:46 +00:00
Chris Boesch
7875a0f9aa
Zig version changed 2024-04-03 00:37:33 +02:00
Chris Boesch
c0ff1b70c1 Merge pull request 'WIP - fix breaking zig change to @fieldParentPtr' (#72) from kamidev/exercises:fix_zig_breaking_pr_19470 into main
Reviewed-on: https://codeberg.org/ziglings/exercises/pulls/72
2024-04-02 22:19:17 +00:00
kamidev
f06c1f27d1
Fix breaking zig change to @fieldParentPtr parameters
See https://github.com/ziglang/zig/pull/19470
2024-03-31 17:02:29 +02:00
Chris Boesch
ba4709b20f Merge pull request 'fix typo' (#70) from i69 into main
Reviewed-on: https://codeberg.org/ziglings/exercises/pulls/70
2024-03-28 20:53:46 +00:00
Chris Boesch
e06cdc0b70 Merge branch 'main' into i69 2024-03-28 20:42:35 +00:00
Chris Boesch
86ac326885
fix typo 2024-03-28 21:33:16 +01:00
Chris Boesch
20919722ff Merge pull request 'added exercise/106_files.zig' (#66) from dizzyi_solo/exercises:main into main
Reviewed-on: https://codeberg.org/ziglings/exercises/pulls/66
2024-03-27 18:54:51 +00:00
Chris Boesch
db21ab9855 Merge branch 'main' into main 2024-03-27 18:50:52 +00:00
Alan CHUNG
05589f8ba1 added format parameter {d} 2024-03-27 16:53:19 +08:00
Alan CHUNG
223fc79e44 106 & 107 2024-03-27 16:40:24 +08:00
Alan CHUNG
69bc9a0723 Pass CI test locally 2024-03-26 14:33:25 +08:00
Alan CHUNG
5f74c7f911 specify directory on patch file 106 2024-03-26 14:05:16 +08:00
Alan CHUNG
2c44f3e4ff specify directory on patch file 106 2024-03-26 14:03:54 +08:00
Alan CHUNG
92ea6718b2 remove header of patch files of 106 2024-03-26 14:01:12 +08:00
Alan CHUNG
9bf7a84e56 106_files.patches actual 2024-03-26 13:53:29 +08:00
Alan CHUNG
9ce889b438 106_files.zig actual test 2024-03-26 13:51:59 +08:00
Alan CHUNG
74a6e60e17 add patch files for 106_files.zig 2024-03-25 16:39:45 +08:00
Alan CHUNG
23b11a7509 106_files.zig format 2024-03-25 16:36:15 +08:00
Alan CHUNG
66d08f1e1f modified build.zig 2024-03-25 16:24:42 +08:00
Dizzyi
ec6f6c5870 added exercise/106_files.zig 2024-03-25 01:11:33 +08:00
11 changed files with 229 additions and 13 deletions

2
.gitignore vendored
View file

@ -3,3 +3,5 @@
/answers/ /answers/
/patches/healed/ /patches/healed/
*.md *.md
/output/

View file

@ -15,7 +15,7 @@ const print = std.debug.print;
// 1) Getting Started // 1) Getting Started
// 2) Version Changes // 2) Version Changes
comptime { comptime {
const required_zig = "0.12.0-dev.3397"; const required_zig = "0.12.0-dev.3518";
const current_zig = builtin.zig_version; const current_zig = builtin.zig_version;
const min_zig = std.SemanticVersion.parse(required_zig) catch unreachable; const min_zig = std.SemanticVersion.parse(required_zig) catch unreachable;
if (current_zig.order(min_zig) == .lt) { if (current_zig.order(min_zig) == .lt) {
@ -247,7 +247,7 @@ const ZiglingStep = struct {
fn make(step: *Step, prog_node: *std.Progress.Node) !void { fn make(step: *Step, prog_node: *std.Progress.Node) !void {
// NOTE: Using exit code 2 will prevent the Zig compiler to print the message: // NOTE: Using exit code 2 will prevent the Zig compiler to print the message:
// "error: the following build command failed with exit code 1:..." // "error: the following build command failed with exit code 1:..."
const self = @fieldParentPtr(ZiglingStep, "step", step); const self: *ZiglingStep = @alignCast(@fieldParentPtr("step", step));
if (self.exercise.skip) { if (self.exercise.skip) {
print("Skipping {s}\n\n", .{self.exercise.main_file}); print("Skipping {s}\n\n", .{self.exercise.main_file});
@ -495,8 +495,7 @@ const PrintStep = struct {
} }
fn make(step: *Step, _: *std.Progress.Node) !void { fn make(step: *Step, _: *std.Progress.Node) !void {
const self = @fieldParentPtr(PrintStep, "step", step); const self: *PrintStep = @alignCast(@fieldParentPtr("step", step));
print("{s}", .{self.message}); print("{s}", .{self.message});
} }
}; };
@ -1121,6 +1120,17 @@ const exercises = [_]Exercise{
.main_file = "105_threading2.zig", .main_file = "105_threading2.zig",
.output = "PI ≈ 3.14159265", .output = "PI ≈ 3.14159265",
}, },
.{
.main_file = "106_files.zig",
.output = "Successfully wrote 18 bytes.",
},
.{
.main_file = "107_files2.zig",
.output =
\\AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
\\Successfully Read 18 byte: It's zigling time!
,
},
.{ .{
.main_file = "999_the_end.zig", .main_file = "999_the_end.zig",
.output = .output =

View file

@ -106,7 +106,7 @@ pub fn main() !void {
// After the threads have been started, // After the threads have been started,
// they run in parallel and we can still do some work in between. // they run in parallel and we can still do some work in between.
std.time.sleep((1) * std.time.ns_per_s); std.time.sleep(1500 * std.time.ns_per_ms);
std.debug.print("Some weird stuff, after starting the threads.\n", .{}); std.debug.print("Some weird stuff, after starting the threads.\n", .{});
} }
// After we have left the closed area, we wait until // After we have left the closed area, we wait until
@ -117,8 +117,13 @@ pub fn main() !void {
// This function is started with every thread that we set up. // This function is started with every thread that we set up.
// In our example, we pass the number of the thread as a parameter. // In our example, we pass the number of the thread as a parameter.
fn thread_function(num: usize) !void { fn thread_function(num: usize) !void {
std.time.sleep(200 * num * std.time.ns_per_ms);
std.debug.print("thread {d}: {s}\n", .{ num, "started." }); std.debug.print("thread {d}: {s}\n", .{ num, "started." });
std.time.sleep((5 - num % 3) * std.time.ns_per_s);
// This timer simulates the work of the thread.
const work_time = 3 * ((5 - num % 3) - 2);
std.time.sleep(work_time * std.time.ns_per_s);
std.debug.print("thread {d}: {s}\n", .{ num, "finished." }); std.debug.print("thread {d}: {s}\n", .{ num, "finished." });
} }
// This is the easiest way to run threads in parallel. // This is the easiest way to run threads in parallel.

View file

@ -46,7 +46,7 @@
// 1,000,000,000 partial values. And for each additional digit we have to // 1,000,000,000 partial values. And for each additional digit we have to
// add a zero. // add a zero.
// Even fast computers - and I mean really fast computers - get a bit warmer // Even fast computers - and I mean really fast computers - get a bit warmer
// on the CPU when it comes to really many diggits. But the 8 digits are // on the CPU when it comes to really many digits. But the 8 digits are
// enough for us for now, because we want to understand the principle and // enough for us for now, because we want to understand the principle and
// nothing more, right? // nothing more, right?
// //

92
exercises/106_files.zig Normal file
View file

@ -0,0 +1,92 @@
//
// Until now, we've only been printing our output in the console,
// which is good enough for fighting alien and hermit bookkeeping.
//
// However, many other task require some interaction with the file system,
// which is the underlying structure for organizing files on your computer.
//
// The File System provide a hierarchical structure for storing files
// by organizing files into directories, which hold files and other directories,
// thus creating a tree structure for navigating.
//
// Fortunately, zig standard library provide a simple api for interacting
// with the file system, see the detail documentation here
//
// https://ziglang.org/documentation/master/std/#std.fs
//
// In this exercise, we'll try to
// - create a new directory
// - open a file in the directory
// - write to the file.
//
// import std as always
const std = @import("std");
pub fn main() !void {
// first we get the current working directory
const cwd: std.fs.Dir = std.fs.cwd();
// then we'll try to make a new directory /output/
// to put our output files.
cwd.makeDir("output") catch |e| switch (e) {
// there are chance you might want to run this
// program more than once and the path might already
// been created, so we'll have to handle this error
// by doing nothing
//
// we want to catch error.PathAlreadyExists and do nothing
??? => {},
// if is any other unexpected error we just propagate it through
else => return e,
};
// then we'll try to open our freshly created directory
// wait a minute
// opening a directory might fail!
// what should we do here?
var output_dir: std.fs.Dir = cwd.openDir("output", .{});
defer output_dir.close();
// we try to open the file `zigling.txt`,
// and propagate the error up if there are any errors
const file: std.fs.File = try output_dir.createFile("zigling.txt", .{});
// it is a good habit to close a file after you are done with
// so that other program can read it and prevent data corruption
// but here we are not yet done writing to the file
// if only there are a keyword in zig that
// allow you "defer" code execute to the end of scope...
file.close();
// !you are not allow to switch this two lines to before file closing line!
const byte_written = try file.write("It's zigling time!");
std.debug.print("Successfully wrote {d} bytes.\n", .{byte_written});
}
// to check if you actually write to the file, you can either,
// 1. open the file on your text editor, or
// 2. print the content of the file in the console with command
// >> cat ./output/zigling.txt
//
//
// More on Creating files
//
// notice in:
// ... try output_dir.createFile("zigling.txt", .{});
// ^^^
// we passed this anonymous struct to the function call
//
// this is the struct `CreateFlag` with default fields
// {
// read: bool = false,
// truncate: bool = true,
// exclusive: bool = false,
// lock: Lock = .none,
// lock_nonblocking: bool = false,
// mode: Mode = default_mode
// }
//
// Question:
// - what should you do if you want to also read the file after opening it?
// - go to documentation of the struct `std.fs.Dir` here
// https://ziglang.org/documentation/master/std/#std.fs.Dir
// - can you find a function for opening a file? how about deleting a file?
// - what kind of option can you uses with those function?

52
exercises/107_files2.zig Normal file
View file

@ -0,0 +1,52 @@
//
// Prerequisite :
// - exercise/106_files.zig, or
// - create a file {project_root}/output/zigling.txt
// with content `It's zigling time!`(18 byte total)
//
// Now there no point in writing to a file if we don't read from it am I right?
// let's wrote a program to read the content of the file that we just created.
//
// I am assuming you've created the appropriate files for this to work.
//
// Alright, bud, lean in close here's the game plan.
// - First, we open the {project_root}/output/ directory
// - Secondly, we open file `zigling.txt` in that directory
// - then, we initalize an array of character with all letter 'A', and print it
// - Afte that, we read the content of the file to the array
// - Finally, we print out the read content
const std = @import("std");
pub fn main() !void {
// Get the current working directory
const cwd = std.fs.cwd();
// try to open ./output assuming you did your 106_files exercise
var output_dir = try cwd.openDir("output", .{});
defer output_dir.close();
// try to open the file
const file = try output_dir.openFile("zigling.txt", .{});
defer file.close();
// initalize an array of u8 with all letter 'A'.
// we need to pick a size of the array, 64 seems like a good number.
// fix the initalization below
var content = ['A']*64;
// this should print out : `AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA`
std.debug.print("{s}\n", .{content});
// okay, seem like threat of violence is not the answer in this case
// can you go here to find a way to read the content ?
// https://ziglang.org/documentation/master/std/#std.fs.File
// hint: you might find two answer that are both vaild in this case
const byte_read = zig_read_the_file_or_i_will_fight_you(&content);
// Woah, too screamy, I know you're excited for zigling time but tone it down a bit
// Can you print only what we read from the file ?
std.debug.print("Successfully Read {d} byte: {s}\n", .{
byte_read,
content, // change this line only
});
}

Binary file not shown.

Before

Width:  |  Height:  |  Size: 94 KiB

View file

@ -1,5 +1,5 @@
--- exercises/104_threading.zig 2024-03-05 09:09:04.013974229 +0100 --- exercises/104_threading.zig 2024-04-10 19:12:29.878856370 +0200
+++ answers/104_threading.zig 2024-03-05 09:12:03.987162883 +0100 +++ answers/104_threading.zig 2024-04-10 19:11:22.304265713 +0200
@@ -97,12 +97,12 @@ @@ -97,12 +97,12 @@
defer handle.join(); defer handle.join();

View file

@ -0,0 +1,29 @@
--- exercises/106_files.zig 2024-03-27 16:52:05.660910200 +0800
+++ answers/106_files.zig 2024-03-27 16:52:09.649422200 +0800
@@ -35,7 +35,7 @@
// by doing nothing
//
// we want to catch error.PathAlreadyExists and do nothing
- ??? => {},
+ error.PathAlreadyExists => {},
// if is any other unexpected error we just propagate it through
else => return e,
};
@@ -44,7 +44,7 @@
// wait a minute
// opening a directory might fail!
// what should we do here?
- var output_dir: std.fs.Dir = cwd.openDir("output", .{});
+ var output_dir: std.fs.Dir = try cwd.openDir("output", .{});
defer output_dir.close();
// we try to open the file `zigling.txt`,
@@ -55,7 +55,7 @@
// but here we are not yet done writing to the file
// if only there are a keyword in zig that
// allow you "defer" code execute to the end of scope...
- file.close();
+ defer file.close();
// !you are not allow to switch this two lines to before file closing line!
const byte_written = try file.write("It's zigling time!");

View file

@ -0,0 +1,26 @@
--- exercises/107_files2.zig 2024-03-27 16:51:56.199719600 +0800
+++ answers/107_files2.zig 2024-03-27 16:52:01.650935300 +0800
@@ -33,7 +33,7 @@
// initalize an array of u8 with all letter 'A'.
// we need to pick a size of the array, 64 seems like a good number.
// fix the initalization below
- var content = ['A']*64;
+ var content = [_]u8{'A'} ** 64;
// this should print out : `AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA`
std.debug.print("{s}\n", .{content});
@@ -41,12 +41,12 @@
// can you go here to find a way to read the content ?
// https://ziglang.org/documentation/master/std/#std.fs.File
// hint: you might find two answer that are both vaild in this case
- const byte_read = zig_read_the_file_or_i_will_fight_you(&content);
+ const byte_read = try file.read(&content);
// Woah, too screamy, I know you're excited for zigling time but tone it down a bit
// Can you print only what we read from the file ?
std.debug.print("Successfully Read {d} byte: {s}\n", .{
byte_read,
- content, // change this line only
+ content[0..byte_read], // change this line only
});
}

View file

@ -152,7 +152,7 @@ const CheckNamedStep = struct {
fn make(step: *Step, _: *std.Progress.Node) !void { fn make(step: *Step, _: *std.Progress.Node) !void {
const b = step.owner; const b = step.owner;
const self = @fieldParentPtr(CheckNamedStep, "step", step); const self: *CheckNamedStep = @alignCast(@fieldParentPtr("step", step));
const ex = self.exercise; const ex = self.exercise;
const stderr_file = try fs.cwd().openFile( const stderr_file = try fs.cwd().openFile(
@ -204,7 +204,7 @@ const CheckStep = struct {
fn make(step: *Step, _: *std.Progress.Node) !void { fn make(step: *Step, _: *std.Progress.Node) !void {
const b = step.owner; const b = step.owner;
const self = @fieldParentPtr(CheckStep, "step", step); const self: *CheckStep = @alignCast(@fieldParentPtr("step", step));
const exercises = self.exercises; const exercises = self.exercises;
const stderr_file = try fs.cwd().openFile( const stderr_file = try fs.cwd().openFile(
@ -327,7 +327,7 @@ const FailStep = struct {
fn make(step: *Step, _: *std.Progress.Node) !void { fn make(step: *Step, _: *std.Progress.Node) !void {
const b = step.owner; const b = step.owner;
const self = @fieldParentPtr(FailStep, "step", step); const self: *FailStep = @alignCast(@fieldParentPtr("step", step));
try step.result_error_msgs.append(b.allocator, self.error_msg); try step.result_error_msgs.append(b.allocator, self.error_msg);
return error.MakeFailed; return error.MakeFailed;
@ -370,7 +370,7 @@ const HealStep = struct {
fn make(step: *Step, _: *std.Progress.Node) !void { fn make(step: *Step, _: *std.Progress.Node) !void {
const b = step.owner; const b = step.owner;
const self = @fieldParentPtr(HealStep, "step", step); const self: *HealStep = @alignCast(@fieldParentPtr("step", step));
return heal(b.allocator, self.exercises, self.work_path); return heal(b.allocator, self.exercises, self.work_path);
} }