Compare commits

...

28 commits

Author SHA1 Message Date
b22b03d9f6
Merge branch 'main' of https://codeberg.org/ziglings/exercises 2024-05-18 21:41:51 -04:00
d4ed21490e
059-061 completed 2024-05-18 21:28:59 -04:00
Chris Boesch
776316e60b Merge pull request 'Update exercises/105_threading2.zig' (#95) from rpm0372/exercises:TypoIn105 into main
Reviewed-on: https://codeberg.org/ziglings/exercises/pulls/95
2024-05-12 11:50:56 +00:00
rpm0372
efe2d19c69 Update exercises/105_threading2.zig
The last word, '"diggits" was misspelled.
2024-05-11 22:38:15 +00:00
Chris Boesch
49c54fb075 Merge pull request 'Nobody wants the long version of finding out if a variable is set.' (#94) from minor_improvements into main
Reviewed-on: https://codeberg.org/ziglings/exercises/pulls/94
2024-05-10 21:40:54 +00:00
Chris Boesch
67f87a76c2
Nobody wants the long version of finding out if a variable is set.
So switched to the short version with 'orelse'. ;)
2024-05-10 23:21:04 +02:00
Chris Boesch
dfdaf03d99 Merge pull request 'Add devcontainer config' (#90) from aquilarafa/exercises:add-devcontainer into main
Reviewed-on: https://codeberg.org/ziglings/exercises/pulls/90
2024-05-06 15:17:52 +00:00
Rafael Áquila
5da194ba9c Add devcontainer.json 2024-05-06 07:47:27 -03:00
Chris Boesch
8345e839b0 Merge pull request 'Fix some typos' (#89) from typos into main
Reviewed-on: https://codeberg.org/ziglings/exercises/pulls/89
2024-05-06 07:25:18 +00:00
Chris Boesch
6c23f2682e Merge branch 'main' into typos 2024-05-06 07:20:37 +00:00
Chris Boesch
19bd8745e4
Fix some typos 2024-05-06 09:13:56 +02:00
Chris Boesch
1ac46d7a42 Merge pull request 'Fix patches for 106 and 107' (#88) from wp433 into main
Reviewed-on: https://codeberg.org/ziglings/exercises/pulls/88
2024-05-04 23:27:01 +00:00
Chris Boesch
165cc199ca
Fix patches for 106 and 107 2024-05-05 01:16:23 +02:00
Chris Boesch
e182d1f19d Merge pull request 'fix: typos in exercises 094 and 098' (#87) from d-hain/ziglings-exercises:typo-fix-094-098 into main
Reviewed-on: https://codeberg.org/ziglings/exercises/pulls/87
2024-05-04 22:46:16 +00:00
Chris Boesch
09e2f37a50 Merge branch 'main' into typo-fix-094-098 2024-05-04 22:45:32 +00:00
Chris Boesch
27db3112f9 Merge pull request 'fix: typo: % instead of @ for a builtin function' (#85) from d-hain/ziglings-exercises:094_c_math-typo-fix into main
Reviewed-on: https://codeberg.org/ziglings/exercises/pulls/85
2024-05-04 22:34:11 +00:00
David Hain
8cb2a5aa3c fix: some grammatical errors 2024-05-04 22:53:04 +02:00
David Hain
c936c5e123 fix: many grammatical errors 2024-05-04 22:35:07 +02:00
David Hain
5c2354a1bf fix: typo: removed extra s 2024-05-04 21:12:54 +02:00
David Hain
4dbd056100 fix: typo: % instead of @ for a builtin function 2024-05-04 18:51:00 +02:00
Chris Boesch
9ce4a7d6f0 Merge pull request 'Update .woodpecker/eowyn.yaml' (#83) from wp-patch-2 into main
Reviewed-on: https://codeberg.org/ziglings/exercises/pulls/83
2024-04-24 14:58:05 +00:00
Chris Boesch
b484be9ac1 Update .woodpecker/eowyn.yaml
Add pull command
2024-04-24 14:40:01 +00:00
Chris Boesch
a2a0a6e891 Merge pull request 'Update .woodpecker/eowyn.yaml' (#82) from chrboesch-wp-patch-1 into main
Reviewed-on: https://codeberg.org/ziglings/exercises/pulls/82
2024-04-24 14:31:07 +00:00
Chris Boesch
e7eaa080b6 Update .woodpecker/eowyn.yaml
Add tag "latest"
2024-04-24 14:20:57 +00:00
Chris Boesch
ce0a6cc91c Merge pull request 'Switch to new zig dev release 0.13' (#81) from r013 into main
Reviewed-on: https://codeberg.org/ziglings/exercises/pulls/81
2024-04-20 20:37:30 +00:00
Chris Boesch
c94eb33e44
Switch to new zig dev release 0.13 2024-04-20 22:35:14 +02:00
Chris Boesch
8f36619bd7 Merge pull request 'fixing little typo on exercise 107_files2.zig' (#80) from susubub/exercises:little-typo_107 into main
Reviewed-on: https://codeberg.org/ziglings/exercises/pulls/80
2024-04-18 17:55:02 +00:00
susubub
aa74dde367 fixing little typo on exercise 107_files2.zig 2024-04-17 20:04:43 -03:00
17 changed files with 67 additions and 67 deletions

View file

@ -1128,7 +1128,7 @@ const exercises = [_]Exercise{
.main_file = "107_files2.zig",
.output =
\\AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
\\Successfully Read 18 byte: It's zigling time!
\\Successfully Read 18 bytes: It's zigling time!
,
},
.{

View file

@ -51,6 +51,7 @@ fn visitElephants(first_elephant: *Elephant) void {
// We should stop once we encounter a tail that
// does NOT point to another element. What can
// we put here to make that happen?
if (e.tail == null) break;
e = e.tail.?;

View file

@ -20,9 +20,9 @@ const print = @import("std").debug.print;
pub fn main() void {
const zig = [_]u8{
0o131, // octal
0b1101000, // binary
0x66, // hex
0o132, // octal
0b1101001, // binary
0x67, // hex
};
print("{s} is cool.\n", .{zig});

View file

@ -43,7 +43,7 @@ pub fn main() void {
//
// We'll convert this weight from pound to kilograms at a
// conversion of 0.453592kg to the pound.
const shuttle_weight: f16 = 0.453592 * 4480e6;
const shuttle_weight: f32 = 0.453592 * 4480e+3;
// By default, float values are formatted in scientific
// notation. Try experimenting with '{d}' and '{d:.3}' to see

View file

@ -67,7 +67,7 @@ const print = @import("std").debug.print;
pub fn main() void {
var letter: u8 = 'A';
const my_letter: ??? = &letter;
const my_letter: ?*[1]u8 = &letter;
// ^^^^^^^
// Your type here.
// Must coerce from &letter (which is a *u8).

View file

@ -13,7 +13,7 @@
// How could we do that? A good method is to use the modulo function.
// But if we write "765.2 % 360", it only works with float values
// that are known at compile time.
// In Zig, we would use %mod(a, b) instead.
// In Zig, we would use @mod(a, b) instead.
//
// Let us now assume that we cannot do this in Zig, but only with
// a C function from the standard library. In the library "math",

View file

@ -30,9 +30,9 @@
// std.debug.print("slice_ptr={*}\n", .{slice_ptr});
// }
// Instead of a simple integer or a constant sized slice, this
// program requires a slice to be allocated that is the same size as
// an input array.
// Instead of a simple integer or a slice with a constant size,
// this program requires allocating a slice that is the same size
// as an input array.
// Given a series of numbers, take the running average. In other
// words, each item N should contain the average of the last N

View file

@ -1,5 +1,5 @@
//
// Bit manipulations is a very powerful tool just also from Zig.
// Bit manipulation is a very powerful tool, also from Zig.
// Since the dawn of the computer age, numerous algorithms have been
// developed that solve tasks solely by moving, setting, or logically
// combining bits.
@ -8,10 +8,10 @@
// functions where possible. And it is often possible with calculations
// based on integers.
//
// Often it is not easy to understand at first glance what exactly these
// At first glance, it is often not easy to understand what exactly these
// algorithms do when only "numbers" in memory areas change outwardly.
// But it must never be forgotten that the numbers only represent the
// interpretation of the bit sequences.
// However, it should never be forgotten that the numbers only represent
// the interpretation of the bit sequences.
//
// Quasi the reversed case we have otherwise, namely that we represent
// numbers in bit sequences.
@ -21,7 +21,7 @@
// Zig provides all the necessary functions to change the bits inside
// a variable. It is distinguished whether the bit change leads to an
// overflow or not. The details are in the Zig documentation in section
// 10.1 "Table of Operators".
// "Table of Operators".
//
// Here are some examples of how the bits of variables can be changed:
//

View file

@ -1,5 +1,5 @@
//
// Another useful practice for bit manipulation is setting bits as flags.
// Another useful application for bit manipulation is setting bits as flags.
// This is especially useful when processing lists of something and storing
// the states of the entries, e.g. a list of numbers and for each prime
// number a flag is set.
@ -19,9 +19,9 @@
// For example, you could take an array of bool and set the value to 'true'
// for each letter in the order of the alphabet (a=0; b=1; etc.) found in
// the sentence. However, this is neither memory efficient nor particularly
// fast. Instead we take a simpler way, very similar in principle, we define
// a variable with at least 26 bits (e.g. u32) and also set the bit for each
// letter found at the corresponding position.
// fast. Instead we choose a simpler approach that is very similar in principle:
// We define a variable with at least 26 bits (e.g. u32) and set the bit for
// each letter that is found in the corresponding position.
//
// Zig provides functions for this in the standard library, but we prefer to
// solve it without these extras, after all we want to learn something.
@ -39,7 +39,7 @@ fn isPangram(str: []const u8) bool {
// first we check if the string has at least 26 characters
if (str.len < 26) return false;
// we uses a 32 bit variable of which we need 26 bits
// we use a 32 bit variable of which we need 26 bits
var bits: u32 = 0;
// loop about all characters in the string

View file

@ -19,10 +19,10 @@
// https://github.com/ziglang/zig/blob/master/lib/std/fmt.zig#L29
//
// Zig already has a very nice selection of formatting options.
// These can be used in different ways, but typically to convert
// numerical values into various text representations. The
// results can be used for direct output to a terminal or stored
// for later use or written to a file. The latter is useful when
// These can be used in different ways, but generally to convert
// numerical values into various text representations. The results
// can be used for direct output to a terminal or stored for
// later use or written to a file. The latter is useful when
// large amounts of data are to be processed by other programs.
//
// In Ziglings, we are concerned with the output to the console.

View file

@ -4,8 +4,8 @@
// one possibility, namely asynchronous processes, in Exercises 84-91.
//
// However, the computing power of the processor is only distributed to
// the started tasks, which always reaches its limits when pure computing
// power is called up.
// the started and running tasks, which always reaches its limits when
// pure computing power is called up.
//
// For example, in blockchains based on proof of work, the miners have
// to find a nonce for a certain character string so that the first m bits

View file

@ -1,6 +1,6 @@
//
// Now that we are familiar with the principles of multi threading, we
// boldly venture into a practical example from mathematics.
// Now that we are familiar with the principles of multi-threading,
// let's boldly venture into a practical example from mathematics.
// We will determine the circle number PI with sufficient accuracy.
//
// There are different methods for this, and some of them are several
@ -104,4 +104,4 @@ fn thread_pi(pi: *f64, begin: u64, end: u64) !void {
// to such an extent that seconds become minutes during execution.
//
// And you should remove the formatting restriction in "print",
// otherwise you will not be able to see the additional diggits.
// otherwise you will not be able to see the additional digits.

View file

@ -50,20 +50,20 @@ pub fn main() !void {
// 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
// it is a good habit to close a file after you are done with it
// so that other programs 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...
// if only there were a keyword in zig that
// allows 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!
// !you are not allowed to switch these two lines above the 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
// 2. print the content of the file in the console with the following command
// >> cat ./output/zigling.txt
//
//
@ -89,4 +89,4 @@ pub fn main() !void {
// - 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?
// - what kind of options can you use with those functions?

View file

@ -5,15 +5,15 @@
// 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.
// let's write 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.
// I am assuming that 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
// - then, we initalize an array of characters with all letter 'A', and print it
// - After that, we read the content of the file to the array
// - Finally, we print out the read content
const std = @import("std");
@ -31,22 +31,22 @@ pub fn main() !void {
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.
// we need to pick the 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
// okay, seems like a 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);
// hint: you might find two answers that are both vaild in this case
const bytes_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,
std.debug.print("Successfully Read {d} bytes: {s}\n", .{
bytes_read,
content, // change this line only
});
}

View file

@ -1,5 +1,5 @@
--- exercises/046_optionals2.zig 2023-10-03 22:15:22.122241138 +0200
+++ answers/046_optionals2.zig 2023-10-05 20:04:07.049433424 +0200
--- exercises/046_optionals2.zig 2024-05-10 23:11:25.796632478 +0200
+++ answers/046_optionals2.zig 2024-05-10 23:10:16.115335668 +0200
@@ -21,7 +21,7 @@
const Elephant = struct {
@ -9,12 +9,11 @@
visited: bool = false,
};
@@ -51,7 +51,7 @@
@@ -51,6 +51,6 @@
// We should stop once we encounter a tail that
// does NOT point to another element. What can
// we put here to make that happen?
- if (e.tail == null) ???;
+ if (e.tail == null) break;
e = e.tail.?;
- e = e.tail ???
+ e = e.tail orelse break;
}
}

View file

@ -1,5 +1,5 @@
--- exercises/106_files.zig 2024-03-27 16:52:05.660910200 +0800
+++ answers/106_files.zig 2024-03-27 16:52:09.649422200 +0800
--- exercises/106_files.zig 2024-05-05 00:48:25.808548611 +0200
+++ answers/106_files.zig 2024-05-05 01:00:40.742969819 +0200
@@ -35,7 +35,7 @@
// by doing nothing
//
@ -20,10 +20,10 @@
// 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...
// if only there were a keyword in zig that
// allows 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!
// !you are not allowed to switch these two lines above the file closing line!
const byte_written = try file.write("It's zigling time!");

View file

@ -1,8 +1,8 @@
--- exercises/107_files2.zig 2024-03-27 16:51:56.199719600 +0800
+++ answers/107_files2.zig 2024-03-27 16:52:01.650935300 +0800
--- exercises/107_files2.zig 2024-05-05 00:48:25.808548611 +0200
+++ answers/107_files2.zig 2024-05-05 01:14:03.866062288 +0200
@@ -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.
// we need to pick the size of the array, 64 seems like a good number.
// fix the initalization below
- var content = ['A']*64;
+ var content = [_]u8{'A'} ** 64;
@ -12,15 +12,15 @@
@@ -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);
// hint: you might find two answers that are both vaild in this case
- const bytes_read = zig_read_the_file_or_i_will_fight_you(&content);
+ const bytes_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,
std.debug.print("Successfully Read {d} bytes: {s}\n", .{
bytes_read,
- content, // change this line only
+ content[0..byte_read], // change this line only
+ content[0..bytes_read], // change this line only
});
}