docs: auto-sync Rosetta Code examples from zenc repo

Author: github-actions[bot]

rosetta/Additive_primes.md

@@ -0,0 +1,63 @@
++++
+title = "Additive primes"
++++
+
+# Additive primes
+
+```zc
+fn digit_sum(n: int) -> int {
+    let sum = 0;
+    while n > 0 {
+        sum += n % 10;
+        n /= 10;
+    }
+    return sum;
+}
+
+fn is_prime(n: int) -> bool {
+    if n < 2      { return false; }
+    if n % 2 == 0 { return n == 2; }
+    if n % 3 == 0 { return n == 3; }
+    let d = 5;
+    while d * d <= n {
+        if n % d == 0 { return false; }
+        d += 2;
+        if n % d == 0 { return false; }
+        d += 4;
+    }
+    return true;
+}
+
+fn main() {
+    println "Additive primes less than 500:";
+    let i = 2;
+    let count = 0;
+    while i < 500 {
+        if is_prime(i) && is_prime(digit_sum(i)) {
+            print "{i:3d}  ";
+            if !(++count % 10) { println ""; }
+        }
+        i = (i > 2) ? i + 2 : 3;
+    }
+    println "\n\n{count} such primes found.";
+}
+```
+
+**Output:**
+
+```
+Additive primes less than 500:
+  2    3    5    7   11   23   29   41   43   47  
+ 61   67   83   89  101  113  131  137  139  151  
+157  173  179  191  193  197  199  223  227  229  
+241  263  269  281  283  311  313  317  331  337  
+353  359  373  379  397  401  409  421  443  449  
+461  463  467  487  
+
+54 such primes found.
+```
+
+---
+**Attribution:** This is a community solution for the Rosetta Code task [**Additive primes**](https://rosettacode.org/wiki/Additive_primes) in Zen C.
+
+*This article uses material from the Rosetta Code article **Additive primes**, which is released under the [GNU Free Documentation License 1.3](https://www.gnu.org/licenses/fdl-1.3.html). A list of the original authors can be found in the [page history](https://rosettacode.org/wiki/Additive_primes?action=history).*

rosetta/Angle_difference_between_two_bearings.md

@@ -34,8 +34,8 @@ fn main() {
     ];
 
     println "Differences (to 4dp) between these bearings:";
-    for pair in pairs {
-        let (p0, p1) = pair;
+    for i in 0..pairs.len {
+        let (p0, p1) = pairs[i];
         let diff = subtract(p0, p1);
         println "{p0:12.4f}° and {p1:12.4f}° -> {diff:9.4f}°";
     }

rosetta/Approximate_equality.md

@@ -0,0 +1,49 @@
++++
+title = "Approximate equality"
++++
+
+# Approximate equality
+
+```zc
+import "std/math.zc"
+
+fn main() {
+    let tol = 1.0e-16;
+    let sqrt2 = Math::sqrt(2.0);
+    let pairs: (f64, f64)[8] = [
+        (100000000000000.01, 100000000000000.011),
+        (100.01, 100.011),
+        (10000000000000.001 / 10000.0, 1000000000.0000001000),
+        (0.001, 0.0010000001),
+        (0.000000000000000000000101, 0.0),
+        (sqrt2 * sqrt2, 2.0),
+        (-sqrt2 * sqrt2, -2.0),
+        (3.14159265358979323846, 3.14159265358979324)
+    ];
+    println "Approximate equality of test cases for a tolerance of {tol:g}:";
+    for i in 0..pairs.len {
+        let (p0, p1) = pairs[i];
+        let res: bool = Math::abs(p0 - p1) < tol;
+        println "  {i + 1} -> {res}";
+    }
+}
+```
+
+**Output:**
+
+```
+Approximate equality of test cases for a tolerance of 1e-16:
+  1 -> true
+  2 -> false
+  3 -> false
+  4 -> false
+  5 -> true
+  6 -> false
+  7 -> false
+  8 -> true
+```
+
+---
+**Attribution:** This is a community solution for the Rosetta Code task [**Approximate equality**](https://rosettacode.org/wiki/Approximate_equality) in Zen C.
+
+*This article uses material from the Rosetta Code article **Approximate equality**, which is released under the [GNU Free Documentation License 1.3](https://www.gnu.org/licenses/fdl-1.3.html). A list of the original authors can be found in the [page history](https://rosettacode.org/wiki/Approximate_equality?action=history).*

rosetta/Attractive_numbers.md

@@ -49,7 +49,7 @@ fn count_factors(n: int) -> int {
         }
     }
     if n > 1 { factors << n; }
-    return factors.length();
+    return (int)factors.length();
 }
 
 fn is_attractive(n: int) -> bool {

rosetta/Averages_Root_mean_square.md

@@ -7,7 +7,7 @@ title = "Averages/Root mean square"
 ```zc
 import "std/math.zc"
 
-fn rms(a: f64[], len: const int) -> f64 {
+fn rms(a: f64*, len: const int) -> f64 {
     let sum = 0.0;
     for i in 0..len { sum += a[i] * a[i]; }
     return Math::sqrt(sum / len);

rosetta/Catalan_numbers.md

@@ -28,9 +28,9 @@ fn main() {
     setlocale(LC_NUMERIC, "en_US.UTF-8");
     println " n  Catalan number";
     println "------------------";
-    for i in 0..=15 { printf("%2d  %'9llu\n", i, catalan((u64)i)); }
+    for i in 0..=15 { printf("%2d  %'9lu\n", i, catalan((u64)i)); }
     println "\nand again using a recursive function:\n";
-    for i in 0..=15 { printf("%2d  %'9llu\n", i, catalan_rec((u64)i)); }
+    for i in 0..=15 { printf("%2d  %'9lu\n", i, catalan_rec((u64)i)); }
 }
 ```
 

rosetta/Count_the_occurrence_of_each_digit_in_e.md

@@ -8,16 +8,16 @@ title = "Count the occurrence of each digit in e"
 
 ```zc
 fn count_digits_in_e(n: int) {
-    autofree let v: int* = malloc(n * sizeof(int));
-    for i in 0..n { v[i] = 1; }
+    autofree let l: int* = malloc(n * sizeof(int));
+    for i in 0..n { l[i] = 1; }
     let dc: [int; 10];
     dc[2] = 1;  // to count the non-fractional digit
     for col in 1..(2 * n) {
         let a = n + 1;
         let c = 0;
         for i in 0..n {
-            c += v[i] * 10;
-            v[i] = c % a;
+            c += l[i] * 10;
+            l[i] = c % a;
             c /= a--;
         }
         dc[c]++;

rosetta/Determine_if_a_string_is_collapsible.md

@@ -10,15 +10,16 @@ title = "Determine if a string is collapsible"
 import "std/string.zc"
 
 fn collapse(s: string) {
-    let c = String::new(s).runes();
+    let ss = String::new(s);
+    let c = ss.runes();
     let le = (int)c.length();
     println "original : length = {le:2d}, string = «««{s}»»»";
     if le >= 2 {
         for let i = le - 2; i >= 0; --i {
             if c[i] == c[i + 1] { c.remove(i); }
         }
         let cl = (int)c.length();
-        let cs = String::from_runes_vec(c).c_str();
+        let cs = String::from_runes_vec(c);
         println "collapsed: length = {cl:2d}, string = «««{cs}»»»\n";
     } else {
         println "collapsed: length = {le:2d}, string = «««{s}»»»\n";

rosetta/Determine_if_a_string_is_squeezable.md

@@ -10,17 +10,18 @@ title = "Determine if a string is squeezable"
 import "std/string.zc"
 
 fn squeeze(s: string, r: rune) {
-    let c = String::new(s).runes();
+    let ss = String::new(s)
+    let c = ss.runes();
     let le = (int)c.length();
-    let ch = String::from_rune(r).c_str();
+    let ch = String::from_rune(r);
     println "Specified character = '{ch}'";
     println "original : length = {le:2d}, string = «««{s}»»»";
     if le >= 2 {
         for let i = le - 2; i >= 0; --i {
             if c[i] == r && c[i] == c[i + 1] { c.remove(i); }
         }
         let cl = (int)c.length();
-        let cs = String::from_runes_vec(c).c_str();
+        let cs = String::from_runes_vec(c);
         println "squeezed : length = {cl:2d}, string = «««{cs}»»»\n";
     } else {
         println "squeezed: length = {le:2d}, string = «««{s}»»»\n";
@@ -43,7 +44,8 @@ fn main() {
     let spec = [ " ", "-", "7", ".", " -r", "e", "s", "a", "😍" ];
 
     for i in 0..strings.len {
-        for ch in String::new(spec[i]) { squeeze(strings[i], ch); }
+        let s = String::new(spec[i]);
+        for ch in s { squeeze(strings[i], ch); } 
     }
 }
 ```

rosetta/Digital_root_Multiplicative_digital_root.md

@@ -58,6 +58,7 @@ fn main() {
         for v in list[i] { print "{v}, "; }
         println "\b\b]";
     }
+    for i in 0..BASE { list[i].free(); }
 }
 ```