6 files changed, 20 insertions, 20 deletions

diff --git a/exercises/096_memory_allocation.zig b/exercises/096_memory_allocation.zig
index 1ece922..58de7b0 100644
--- a/exercises/096_memory_allocation.zig
+++ b/exercises/096_memory_allocation.zig
@@ -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
diff --git a/exercises/097_bit_manipulation.zig b/exercises/097_bit_manipulation.zig
index 424fb4c..03fc72d 100644
--- a/exercises/097_bit_manipulation.zig
+++ b/exercises/097_bit_manipulation.zig
@@ -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:
 //
diff --git a/exercises/098_bit_manipulation2.zig b/exercises/098_bit_manipulation2.zig
index 64cea4b..979b103 100644
--- a/exercises/098_bit_manipulation2.zig
+++ b/exercises/098_bit_manipulation2.zig
@@ -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.
diff --git a/exercises/099_formatting.zig b/exercises/099_formatting.zig
index 07af3ba..1952c5e 100644
--- a/exercises/099_formatting.zig
+++ b/exercises/099_formatting.zig
@@ -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.
diff --git a/exercises/104_threading.zig b/exercises/104_threading.zig
index ac40b3c..9c4e216 100644
--- a/exercises/104_threading.zig
+++ b/exercises/104_threading.zig
@@ -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
diff --git a/exercises/105_threading2.zig b/exercises/105_threading2.zig
index c85f801..94a2c71 100644
--- a/exercises/105_threading2.zig
+++ b/exercises/105_threading2.zig
@@ -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