Fix count to actually _be_ a count

Also, start from 1 in the positive direction, instead of 5, since that
is more how the thing works (sorry, mathematician brain).

Additionally, adds some extra information in the comments:
information about how long the code would take if one actually sets
count to 2,5 * 10^12, and adding a plus in front of the 4/1 to show that
that is in fact the first element of the "plus" side.

Finally, add an (floating point) error to the debug print.

exercises/108_threading2.zig

@@ -28,9 +28,9 @@
 // We will not go into the formula and its derivation in detail, but
 // will deal with the series straight away:
 //
-//        4     4     4     4     4
+//          4     4     4     4     4
-//  PI = --- - --- + --- - --- + --- ...
+//  PI = + --- - --- + --- - --- + --- ...
-//        1     3     5     7     9
+//          1     3     5     7     9
 //
 // As you can clearly see, the series starts with the whole number 4 and
 // approaches the circle number by subtracting and adding smaller and
@@ -71,27 +71,28 @@
 const std = @import("std");
 
 pub fn main() !void {
-    const count = 1_000_000_000;
+    const count = 500_000_000;
+
     var pi_plus: f64 = 0;
     var pi_minus: f64 = 0;
 
     {
         // First thread to calculate the plus numbers.
-        const handle1 = try std.Thread.spawn(.{}, thread_pi, .{ &pi_plus, 5, count });
+        const handle1 = try std.Thread.spawn(.{}, thread_pi, .{ &pi_plus, 1, count });
         defer handle1.join();
 
         // Second thread to calculate the minus numbers.
         ???
-        
     }
+
     // Here we add up the results.
-    std.debug.print("PI ≈ {d:.8}\n", .{4 + pi_plus - pi_minus});
+    std.debug.print("PI ≈ {d:.8} (error = {e:.1})\n", .{ pi_plus - pi_minus, std.math.pi - (pi_plus - pi_minus) });
 }
 
-fn thread_pi(pi: *f64, begin: u64, end: u64) !void {
+fn thread_pi(pi: *f64, begin: u64, count: u64) !void {
-    var n: u64 = begin;
+    for (0..count) |i| {
-    while (n < end) : (n += 4) {
+        const term = 4 / @as(f64, @floatFromInt(begin + 4 * i));
-        pi.* += 4 / @as(f64, @floatFromInt(n));
+        pi.* += term;
     }
 }
 // If you wish, you can increase the number of loop passes, which
@@ -106,5 +107,6 @@ fn thread_pi(pi: *f64, begin: u64, end: u64) !void {
 // And you should remove the formatting restriction in "print",
 // otherwise you will not be able to see the additional digits.
 //
-// If count = 10_000_000_000_000 you should see the following:
+// If count = 2_500_000_000_000, you should see the following:
 // 3.141592653589
+// (after waiting on the order of 1000 seconds, or 17 minutes)

patches/patches/108_threading2.patch

@@ -1,13 +1,12 @@
---- exercises/108_threading2.zig	2026-04-14 06:44:18.848246237 +0200
+--- exercises/108_threading2.zig	2026-06-29 23:25:53
-+++ answers/108_threading2.zig	2026-04-14 08:15:30.894485037 +0200
++++ answers/108_threading2.zig	2026-06-29 23:25:25
-@@ -81,8 +81,8 @@
+@@ -82,7 +82,8 @@
          defer handle1.join();
  
          // Second thread to calculate the minus numbers.
 -        ???
--        
 +        const handle2 = try std.Thread.spawn(.{}, thread_pi, .{ &pi_minus, 3, count });
 +        defer handle2.join();
      }
+ 
      // Here we add up the results.
-     std.debug.print("PI ≈ {d:.8}\n", .{4 + pi_plus - pi_minus});

rivendell/elrond.zig

@@ -1150,7 +1150,7 @@ const exercises = [_]Exercise{
     },
     .{
         .main_file = "108_threading2.zig",
-        .output = "PI ≈ 3.14159265",
+        .output = "PI ≈ 3.14159265 (error = 1.0e-9)",
     },
     .{
         .main_file = "109_files.zig",