chore: auto-sync new Rosetta Code examples

Author: github-actions[bot]

examples/rosetta/100_prisoners.zc

@@ -0,0 +1,74 @@
+import "std/random.zc"
+import "locale.h"
+
+let rng: Random;
+
+fn shuffle(a: int*, len: usize) {
+    for let i: usize = len - 1; i >= 1; --i {
+        let j = rng.next_int_range(0, (int)i);
+        if j != i {
+            let t = a[i];
+            a[i] = a[j];
+            a[j] = t;
+        }
+    }
+}
+
+fn do_trials(trials: int, np: int, strategy: string) {
+    let pardoned = 0;
+    for t in 0..trials {
+        let drawers: [int; 100];
+        for i in 0..100 { drawers[i] = i; }
+        shuffle((int*)drawers, 100);
+        let next_trial = false;
+        for p in 0..np {
+            let next_prisoner = false;
+            if strcmp(strategy, "optimal") == 0 {
+                let prev = p;
+                for d in 0..50 {
+                    let curr = drawers[prev];
+                    if curr == p {
+                        next_prisoner = true;
+                        break;
+                    }
+                    prev = curr;
+                }
+            } else {
+                let opened: [bool; 100];
+                for d in 0..50 {
+                    let n: int;
+                    loop {
+                        n = rng.next_int_range(0, 99);
+                        if !opened[n] {
+                            opened[n] = true;
+                            break;
+                        }
+                    }
+                    if drawers[n] == p {
+                        next_prisoner = true;
+                        break;
+                    }
+                }
+            }
+            if !next_prisoner {
+                next_trial = true;
+                break;
+            }
+        }
+        if !next_trial { pardoned++; }
+    }
+    let rf = (f64)pardoned / (f64)trials * 100.0;
+    println "  strategy = {strategy:-7s}  pardoned = {pardoned:'6d}  relative frequency = {rf:5.2f}%\n";
+}
+
+fn main() {
+    rng = Random::new();
+    setlocale(LC_NUMERIC, "");
+    let trials = 100_000;
+    let nps = [10, 100];
+    let strategies = ["random", "optimal"];
+    for np in nps {
+        println "Results from {trials:'d} trials with {np} prisoners:\n";
+        for i in 0..strategies.len { do_trials(trials, np, strategies[i]); }
+    }
+}

examples/rosetta/Accumulator_factory.zc

@@ -0,0 +1,20 @@
+fn accumulator<T>(acc: T) -> fn(T) -> T {
+    return fn(f: T) -> T {
+        acc += f;
+        return acc;
+    }
+}
+
+fn main() {
+    // Example with f64s.
+    let x = accumulator(1.0);
+    x(5.0);
+    accumulator(3.0);
+    println "{x(2.3):g}";
+
+    // Example with ints.
+    let y = accumulator(1);
+    y(5);
+    accumulator(3);
+    println "{y(2)}";
+}

examples/rosetta/Arithmetic_Complex.zc

@@ -0,0 +1,35 @@
+import "std/complex.zc"
+import "std/string.zc"
+
+fn negate(c: Complex) -> Complex {
+    return Complex{real: -c.real, imag: -c.imag};
+}
+
+fn inverse(c: Complex) -> Complex {
+    return Complex::new(1, 0) / c;
+}
+
+fn conjugate(c: Complex) -> Complex {
+    return Complex{real: c.real, imag: -c.imag};
+}
+
+fn cstr(c: Complex) -> String {
+    let rsign = c.real < 0 ? "-" : " ";
+    let isign = c.imag < 0 ? "-" : "+";
+    let s = "{rsign}{fabs(c.real):g} {isign} {fabs(c.imag):g}i";
+    return String::from(s);
+}
+
+fn main() {
+    let x = Complex::new(1.0, 3.0);
+    let y = Complex::new(5.0, 2.0);
+    println "x     =  {cstr(x)}";
+    println "y     =  {cstr(y)}";
+    println "x + y =  {cstr(x + y)}";
+    println "x - y =  {cstr(x - y)}";
+    println "x * y =  {cstr(x * y)}";
+    println "x / y =  {cstr(x / y)}";
+    println "-x    =  {cstr(negate(x))}";
+    println "1 / x =  {cstr(inverse(x))}";
+    println "x*    =  {cstr(conjugate(x))}";
+}

examples/rosetta/Arithmetic_Rational.zc

@@ -0,0 +1,213 @@
+/* rat.zc */
+
+import "std/string.zc"
+
+fn gcd(x: i64, y: i64) -> i64 {
+    while y {
+        let t = y;
+        y = x % y;
+        x = t;
+    }
+    return labs(x);
+}
+
+@derive(Copy)
+struct Rat {
+    num: i64;
+    den: i64;
+}
+
+impl Rat {
+    // Creates a new Rat struct in canonical form
+    // i.e. n and d have no common factors and d > 0. 
+    // The Rat struct should not be created directly
+    // unless you're certain it's already in such a form.
+    fn new(n: i64, d: i64 = 1) -> Self {
+        assert(d != 0, "Denominator must be non-zero.");
+        if n == 0 {
+            d = 1;
+        } else if d < 0 {
+            n = -n;
+            d = -d;
+        }
+        if labs(n) != 1 && d > 1 {
+            let g = gcd(n, d);
+            if g > 1 {
+                n /= g;
+                d /= g;
+            }
+        }
+        return Rat{num: n, den: d};
+    }
+
+    fn neg(self) -> Rat {
+        return Rat{num: -self.num, den: self.den};
+    }
+
+    fn add(self, other: Rat) -> Rat {
+        return Rat::new(
+            self.num * other.den + self.den * other.num,
+            self.den * other.den
+        );
+    }
+
+    fn sub(self, other: Rat) -> Rat {
+        return *self + (-other);
+    }
+
+    fn mul(self, other: Rat) -> Rat {
+        return Rat::new(
+            self.num * other.num,
+            self.den * other.den
+        );
+    }
+
+    fn div(self, other: Rat) -> Rat {
+        return Rat::new(
+            self.num * other.den,
+            self.den * other.num
+        );
+    }
+
+    fn trunc(self) -> Rat {
+        return Rat{num: self.num / self.den, den: 1};
+    }
+
+    fn ceil(self) -> Rat {
+        if self.den == 1 return self.clone();
+        return self.num >= 0 ? self.trunc().inc() : self.trunc();
+    }
+
+    fn floor(self) -> Rat {
+        if self.den == 1 return self.clone();
+        return self.num >= 0 ? self.trunc() : self.trunc().dec();
+    }
+
+    fn round(self) -> Rat {
+        if self.num >= 0 { return (*self + Rat{num: 1, den: 2}).trunc(); }
+        return (*self - Rat{num: 1, den: 2}).trunc();
+    }
+
+    fn frac(self) -> Rat {
+        return *self - self.trunc();
+    }
+
+    fn idiv(self, other: Rat) -> Rat {
+        return (*self / other).trunc();
+    }
+
+    fn rem(self, other: Rat) -> Rat {
+        return *self - self.idiv(other) * other;
+    }
+
+    fn pow(self, exp: int) -> Rat {
+        let r = Rat{num: self.num ** abs(exp), den: self.den ** abs(exp)};
+        return exp >= 0 ? r : r.inv();
+    }
+
+    fn inv(self) -> Rat {
+        return Rat::new(self.den, self.num);
+    }
+
+    fn abs(self) -> Rat {
+        return Rat{num: labs(self.num), den: self.den};
+    }
+
+    fn inc(self) -> Rat {
+        return Rat{num: self.num + self.den, den: self.den};
+    }
+
+    fn dec(self) -> Rat {
+        return Rat{num: self.num - self.den, den: self.den};
+    }
+
+    fn sign(self) -> int {
+        return self.num > 0 ? 1 : self.num < 0 ? -1 : 0;
+    }
+
+    fn eq(self, other: Rat) -> bool {
+        return self.num == other.num && self.den == other.den;
+    }
+
+    fn neq(self, other: Rat) -> bool {
+        return !self.eq(other);
+    }
+
+    fn lt(self, other: Rat) -> bool {
+        return (*self - other).num < 0;
+    }
+
+    fn gt(self, other: Rat) -> bool {
+        return (*self - other).num > 0;
+    }
+
+    fn le(self, other: Rat) -> bool {
+        return (*self - other).num <= 0;
+    }
+
+    fn ge(self, other: Rat) -> bool {
+        return (*self - other).num >= 0;
+    }
+
+    fn to_f64(self) -> f64 {
+        return (f64)self.num / (f64)self.den;
+    }
+
+    fn to_i64(self) -> i64 {
+        return self.trunc().num;
+    }
+
+    fn to_string(self) -> String {
+        let s = .den > 1 ? "{self.num:ld} / {self.den:ld}" : "{self.num:ld}";
+        return String::from(s);
+    }
+
+    fn max(r1: Rat, r2: Rat) -> Rat {
+        return r1 < r2 ? r2 : r1;
+    }
+
+    fn min(r1: Rat, r2: Rat) -> Rat {
+        return r1 < r2 ? r1 : r2;
+    }
+}
+
+impl Clone for Rat {
+    fn clone(self) -> Rat {
+        return Rat{num: self.num, den: self.den};
+    }
+}
+
+import "std/vec.zc"
+import "rat.zc"
+
+fn divisors(n: int) -> Vec<int> {
+    let divs = Vec<int>::new();
+    if n < 1 { return divs; }
+    let divs2 = Vec<int>::new();
+    let i = 1;
+    let k = (n % 2 == 0) ? 1 : 2;
+    while i * i <= n {
+        if n % i == 0 {
+            divs << i;
+            let j = n / i;
+            if j != i { divs2 << j; }
+        }
+        i += k;
+    }
+    if divs2.length() {
+        divs2.reverse();
+        for l in 0..divs2.length() { divs << divs2[l]; }
+    }
+    return divs;
+}
+
+fn main() {
+    println "The following numbers (less than 2^19) are perfect:";
+    let one: const Rat = Rat::new(1);
+    for i in 2..(1 << 19) {
+        let sum = Rat::new(1, i);
+        let pd = divisors(i);
+        for j in 1..(pd.length() - 1) { sum += Rat::new(1, pd[j]); }
+        if sum == one { println "  {i}"; }
+    }
+}

examples/rosetta/Associative_array_Creation.zc

@@ -0,0 +1,32 @@
+import "std/map.zc"
+
+fn print_map(m: Map<string>*) {
+    for entry in *m {
+        print "{{{entry.key}: {entry.val}}}, ";
+    }
+    println "\b\b ";
+}
+
+fn main() {
+    let fruit = Map<string>::new(); // creates an empty map
+    fruit.put("1", "orange");       // associates a key of "1" with "orange"
+    fruit.put("2", "apple");        // associates a key of "2" with "apple"
+    let f = fruit["1"].unwrap();    // retrieves the value with a key of "1"
+    println "{f}";                  // and prints it out
+    fruit.remove("1");              // removes the entry with a key of "1" from the map
+    print_map(&fruit);              // prints the rest of the map
+    println "";
+
+    let capitals = Map<string>::new();   // creates a new map with four entries
+    capitals.put("France","Paris");
+    capitals.put("Germany", "Berlin");
+    capitals.put("Spain", "Madrid");
+    capitals.put("Russia", "Moscow");
+    let c = capitals["France"].unwrap(); // retrieves the "France" entry
+    println "{c}";                       // and prints out its capital
+    capitals.remove("France")            // removes the "France" entry
+    print_map(&capitals);                // prints all remaining entries
+    println "{capitals.length()}"        // prints the number of remaining entries
+    c = capitals["Sweden"].unwrap_or("none");
+    println "{c}"                        // prints the entry for Sweden (none as there isn't one)
+}