docs: auto-sync Rosetta Code examples from zenc repo

Author: github-actions[bot]

rosetta/Blum_integer.md

@@ -0,0 +1,111 @@
++++
+title = "Blum integer"
++++
+
+# Blum integer
+
+{{trans|Wren}}
+
+```zc
+import "locale.h"
+
+let inc = [4, 2, 4, 2, 4, 6, 2, 6];
+
+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;
+}
+
+// Assumes n is odd.
+fn first_prime_factor(n: int) -> int {
+    if n == 1 { return 1; }
+    if n % 3 == 0 { return 3; }
+    if n % 5 == 0 { return 5; }
+    let k = 7;
+    let i = 0;
+    while k * k <= n {
+        if n % k == 0 {
+            return k;
+        } else {
+            k += inc[i];
+            i = (i + 1) % 8;
+        }
+    }
+    return n;
+}
+
+fn main() {
+    setlocale(LC_NUMERIC, "");
+    let blum: [int; 50];
+    let bc = 0;
+    let counts: [int; 10];
+    let digits = [1, 3, 7, 9];
+    let i = 1;
+    loop {
+        let p = first_prime_factor(i);
+        if p % 4 == 3 {
+            let q = i / p;
+            if q != p && q % 4 == 3 && is_prime(q) {
+                if bc < 50 { blum[bc] = i; }
+                counts[i % 10]++;
+                bc++;
+                if bc == 50 {
+                    println "First 50 Blum integers:";
+                    for j in 0..50 {
+                        print "{blum[j]:3d} ";
+                        if !((j + 1) % 10) { println ""; }
+                    }
+                    println "";
+                } else if bc == 26_828 || bc % 100_000 == 0 {
+                    println "The {bc:'7d}th Blum integer is: {i:'9d}";
+                    if bc == 400_000 {
+                        println "\n% distribution of the first 400,000 Blum integers:";
+                        for j in digits {
+                            println "  {counts[j] / 4000.0:6.3f}% end in {j}";
+                        }
+                        break;
+                    }
+                }
+            }
+        }
+        i = (i % 5 == 3) ? i + 4 : i + 2;
+    }
+}
+```
+
+**Output:**
+
+```
+First 50 Blum integers:
+ 21  33  57  69  77  93 129 133 141 161 
+177 201 209 213 217 237 249 253 301 309 
+321 329 341 381 393 413 417 437 453 469 
+473 489 497 501 517 537 553 573 581 589 
+597 633 649 669 681 713 717 721 737 749 
+
+The  26,828th Blum integer is:   524,273
+The 100,000th Blum integer is: 2,075,217
+The 200,000th Blum integer is: 4,275,533
+The 300,000th Blum integer is: 6,521,629
+The 400,000th Blum integer is: 8,802,377
+
+% distribution of the first 400,000 Blum integers:
+  25.001% end in 1
+  25.017% end in 3
+  24.997% end in 7
+  24.985% end in 9
+```
+
+---
+**Attribution:** This is a community solution for the Rosetta Code task [**Blum integer**](https://rosettacode.org/wiki/Blum_integer) in Zen C.
+
+*This article uses material from the Rosetta Code article **Blum integer**, 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/Blum_integer?action=history).*

rosetta/Brazilian_numbers.md

@@ -0,0 +1,100 @@
++++
+title = "Brazilian numbers"
++++
+
+# Brazilian numbers
+
+{{trans|Wren}}
+
+```zc
+import "locale.h"
+
+fn same_digits(n: int, b: int) -> bool {
+    let f = n % b;
+    n /= b;
+    while n > 0 {
+        if n % b != f { return false; }
+        n /= b;
+    }
+    return true;
+}
+
+fn is_brazilian(n: int) -> bool {
+    if n < 7 { return false; }
+    if !(n % 2) && n >= 8 { return true; }
+    for b in 2..(n - 1) {
+        if same_digits(n, b) { return true; }
+    }
+    return false;
+}
+
+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() {
+    setlocale(LC_NUMERIC, "");
+    let kinds = [" ", " odd ", " prime "];
+    for i, kind in kinds {
+        println "First 20{kind}Brazilian numbers:";
+        let c = 0;
+        let n = 7;
+        loop {
+            if is_brazilian(n) {
+                print "{n} ";
+                if ++c == 20 {
+                    let nl = i < 2 ? "\n" : "";
+                    println "{nl}";
+                    break;
+                }
+            }
+            if kind == " " {
+                n++;
+            } else if kind == " odd " {
+                n += 2;
+            } else {
+                loop {
+                    n += 2;
+                    if is_prime(n) { break; }
+                }
+            }
+        }
+    }
+    let c = 0;
+    let n = 7;
+    while c < 100_000 {
+        if is_brazilian(n) { c++; }
+        n++;
+    }
+    println "The 100,000th Brazilian number: {n - 1:'d}";
+}
+```
+
+**Output:**
+
+```
+First 20 Brazilian numbers:
+7 8 10 12 13 14 15 16 18 20 21 22 24 26 27 28 30 31 32 33 
+
+First 20 odd Brazilian numbers:
+7 13 15 21 27 31 33 35 39 43 45 51 55 57 63 65 69 73 75 77 
+
+First 20 prime Brazilian numbers:
+7 13 31 43 73 127 157 211 241 307 421 463 601 757 1093 1123 1483 1723 2551 2801 
+The 100,000th Brazilian number: 110,468
+```
+
+---
+**Attribution:** This is a community solution for the Rosetta Code task [**Brazilian numbers**](https://rosettacode.org/wiki/Brazilian_numbers) in Zen C.
+
+*This article uses material from the Rosetta Code article **Brazilian numbers**, 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/Brazilian_numbers?action=history).*

rosetta/Collections.md

@@ -0,0 +1,32 @@
++++
+title = "Collections"
++++
+
+# Collections
+
+As well as C style arrays, Zen C's standard library also supports vectors, maps, sets, stacks and queues. The following example uses a vector which is a generic growable array:
+
+```zc
+import "std/vec.zc";
+
+fn main() {
+    let vec = Vec<int>::new();
+    vec << 1;
+    vec << 2;
+    vec << 3;
+    for v in vec { println "{v}"; }
+}
+```
+
+**Output:**
+
+```
+1
+2
+3
+```
+
+---
+**Attribution:** This is a community solution for the Rosetta Code task [**Collections**](https://rosettacode.org/wiki/Collections) in Zen C.
+
+*This article uses material from the Rosetta Code article **Collections**, 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/Collections?action=history).*

rosetta/Common_list_elements.md

@@ -0,0 +1,45 @@
++++
+title = "Common list elements"
++++
+
+# Common list elements
+
+```zc
+import "std/vec.zc"
+
+fn intersection(a: Vec<int>*, b: Vec<int>*) -> Vec<int> {
+    let res = Vec<int>::new();
+    for e in *a {
+        if b.contains(e) { res << e; }
+    }
+    return res;
+}
+
+fn main() {
+    let a1 = [2, 5, 1, 3, 8, 9, 4, 6];
+    let a2 = [3, 5, 6, 2, 9, 8, 4];
+    let a3 = [1, 3, 7, 6, 9];
+    let v1 = Vec<int>::new();
+    let v2 = Vec<int>::new();
+    let v3 = Vec<int>::new();
+    for e in a1 { v1 << e; }
+    for e in a2 { v2 << e; }
+    for e in a3 { v3 << e; }
+    let inter1 = intersection(&v1, &v2);
+    let inter2 = intersection(&inter1, &v3);
+    print "[";
+    for v in inter2 { print "{v}, "; }
+    println "\b\b]";
+}
+```
+
+**Output:**
+
+```
+[3, 9, 6]
+```
+
+---
+**Attribution:** This is a community solution for the Rosetta Code task [**Common list elements**](https://rosettacode.org/wiki/Common_list_elements) in Zen C.
+
+*This article uses material from the Rosetta Code article **Common list elements**, 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/Common_list_elements?action=history).*

rosetta/Currency.md

@@ -0,0 +1,56 @@
++++
+title = "Currency"
++++
+
+# Currency
+
+{{libheader|GMP}}
+
+```zc
+//> link: -lgmp
+
+import "gmp.h"
+
+fn main() {
+    let hamburgers: mpf_t;
+    let milkshakes: mpf_t;
+    let price1: mpf_t;
+    let price2: mpf_t;
+    let tax_pc: mpf_t;
+    let total_pre_tax: mpf_t;
+    let total_tax: mpf_t;
+    let total_after_tax: mpf_t;
+    let temp: mpf_t;
+
+    mpf_init_set_ui(hamburgers, (c_ulong)4000000000000000);
+    mpf_init_set_ui(milkshakes, (c_ulong)2);
+    mpf_init_set_str(price1, "5.5", 10);
+    mpf_init_set_str(price2, "2.86", 10);
+    mpf_init_set_str(tax_pc, "0.0765", 10);
+    mpf_inits(total_pre_tax, total_tax, total_after_tax, temp, NULL);
+
+    mpf_mul(total_pre_tax, hamburgers, price1);
+    mpf_mul(temp, milkshakes, price2);
+    mpf_add(total_pre_tax, total_pre_tax, temp);
+    mpf_mul(total_tax, total_pre_tax, tax_pc);
+    mpf_add(total_after_tax, total_pre_tax, total_tax);
+    gmp_printf("Total price before tax : $ %20.2Ff\n", total_pre_tax);
+	gmp_printf("Total tax              : $ %20.2Ff\n", total_tax);
+    gmp_printf("Total price after tax  : $ %20.2Ff\n", total_after_tax);
+    mpf_clears(hamburgers, milkshakes, price1, price2, tax_pc,
+               total_pre_tax, total_tax, total_after_tax, temp, NULL);
+}
+```
+
+**Output:**
+
+```
+Total price before tax : $ 22000000000000005.72
+Total tax              : $  1683000000000000.44
+Total price after tax  : $ 23683000000000006.16
+```
+
+---
+**Attribution:** This is a community solution for the Rosetta Code task [**Currency**](https://rosettacode.org/wiki/Currency) in Zen C.
+
+*This article uses material from the Rosetta Code article **Currency**, 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/Currency?action=history).*