YAPC::EU 2018 Glasgow Update!

Task/Chinese-remainder-theorem/Perl/chinese-remainder-theorem-3.pl

@@ -1,2 +1,2 @@
-use ntheory qw/chinese/;
+use ntheory qw/chinese lcm/;
 say chinese( [2328,16256], [410,5418] ), " mod ", lcm(16256,5418);

Task/Chinese-remainder-theorem/Rust/chinese-remainder-theorem.rust

@@ -40,5 +40,4 @@ fn main() {
 	let s = a.len();
     println!("{}",chinese_remainder(&mut n,&mut a,s));
 
-
 }

Task/Chinese-remainder-theorem/Scala/chinese-remainder-theorem.scala

@@ -0,0 +1,41 @@
+import scala.util.{Success, Try}
+
+object ChineseRemainderTheorem extends App {
+
+  def chineseRemainder(n: List[Int], a: List[Int]): Option[Int] = {
+    require(n.size == a.size)
+    val prod = n.product
+
+    def iter(n: List[Int], a: List[Int], sm: Int): Int = {
+      def mulInv(a: Int, b: Int): Int = {
+        def loop(a: Int, b: Int, x0: Int, x1: Int): Int = {
+          if (a > 1) loop(b, a % b, x1 - (a / b) * x0, x0) else x1
+        }
+
+        if (b == 1) 1
+        else {
+          val x1 = loop(a, b, 0, 1)
+          if (x1 < 0) x1 + b else x1
+        }
+      }
+
+      if (n.nonEmpty) {
+        val p = prod / n.head
+
+        iter(n.tail, a.tail, sm + a.head * mulInv(p, n.head) * p)
+      } else sm
+    }
+
+    Try {
+      iter(n, a, 0) % prod
+    } match {
+      case Success(v) => Some(v)
+      case _          => None
+    }
+  }
+
+  println(chineseRemainder(List(3, 5, 7), List(2, 3, 2)))
+  println(chineseRemainder(List(11, 12, 13), List(10, 4, 12)))
+  println(chineseRemainder(List(11, 22, 19), List(10, 4, 9)))
+
+}

Task/Chinese-remainder-theorem/Sidef/chinese-remainder-theorem.sidef

@@ -1,19 +1,10 @@
-func mul_inv(a, b) {
-    b == 1 && return 1
-    var (b0, x0, x1) = (0, 0, 1)
-    while (a > 1) {
-        (a, b, x0, x1) = (b, a % b, x1 - x0*int(a / b), x0)
-    }
-    x1 < 0 ? x1+b0 : x1
-}
-
 func chinese_remainder(*n) {
-    var N = n«*»
+    var N = n.prod
     func (*a) {
-        n.range.map { |i|
-            var p = int(N / n[i])
-            a[i] * mul_inv(p, n[i]) * p
-        }.sum
+        n.range.sum { |i|
+            var p = (N / n[i])
+            a[i] * p.invmod(n[i]) * p
+        } % N
     }
 }