fix runners

thuva4 · thuva4 · commit c5a67bd968b6 · 2026-03-23T20:27:57.000Z
diff --git a/algorithms/data-structures/fibonacci-heap/scala/FibonacciHeap.scala b/algorithms/data-structures/fibonacci-heap/scala/FibonacciHeap.scala
@@ -3,7 +3,7 @@ import scala.collection.mutable.ArrayBuffer
 
 object FibonacciHeap {
   def fibonacciHeap(operations: Array[Int]): Array[Int] = {
-    val heap = mutable.PriorityQueue.empty[Int](Ordering[Int].reverse)
+    val heap = mutable.PriorityQueue.empty[Int](using Ordering.Int.reverse)
     val results = ArrayBuffer[Int]()
     for (op <- operations) {
       if (op == 0) {
diff --git a/algorithms/dynamic-programming/convex-hull-trick/csharp/ConvexHullTrick.cs b/algorithms/dynamic-programming/convex-hull-trick/csharp/ConvexHullTrick.cs
@@ -41,6 +41,15 @@ public static long[] Solve(long[][] lines, long[] queries)
         return results;
     }
 
+    public static long[] Solve(int[][] lines, int[] queries)
+    {
+        long[][] longLines = lines
+            .Select(line => line.Select(value => (long)value).ToArray())
+            .ToArray();
+        long[] longQueries = queries.Select(value => (long)value).ToArray();
+        return Solve(longLines, longQueries);
+    }
+
     public static void Main(string[] args)
     {
         var tokens = Console.ReadLine().Trim().Split();
diff --git a/algorithms/dynamic-programming/fibonacci/csharp/Fibonacci.cs b/algorithms/dynamic-programming/fibonacci/csharp/Fibonacci.cs
@@ -3,13 +3,19 @@ public class Fibonacci
 {
    public int cal(int number)
    {
-     int a = 1, b = 0, temp;
-     while (number >= 0){
-        temp = a;
-        a = a + b;
+     if (number <= 0)
+     {
+        return 0;
+     }
+
+     int a = 0, b = 1;
+     for (int i = 1; i < number; i++)
+     {
+        int temp = a + b;
+        a = b;
         b = temp;
-        number--;
      }
+
      return b;
-     }
+   }
 }
diff --git a/algorithms/geometry/convex-hull-jarvis/scala/ConvexHullJarvis.scala b/algorithms/geometry/convex-hull-jarvis/scala/ConvexHullJarvis.scala
@@ -21,7 +21,9 @@ object ConvexHullJarvis {
 
     var hullCount = 0
     var current = start
-    do {
+    var firstPass = true
+    while (firstPass || current != start) {
+      firstPass = false
       hullCount += 1
       var candidate = 0
       for (i <- 1 until n) {
@@ -37,7 +39,7 @@ object ConvexHullJarvis {
         }
       }
       current = candidate
-    } while (current != start)
+    }
 
     hullCount
   }
diff --git a/algorithms/geometry/delaunay-triangulation/scala/DelaunayTriangulation.scala b/algorithms/geometry/delaunay-triangulation/scala/DelaunayTriangulation.scala
@@ -4,39 +4,36 @@ object DelaunayTriangulation {
     val n = arr(0)
     if (n < 3) return 0
 
-    val px = Array.tabulate(n)(i => arr(1 + 2 * i).toDouble)
-    val py = Array.tabulate(n)(i => arr(1 + 2 * i + 1).toDouble)
-
-    val eps = 1e-9
-    var count = 0
-
-    for (i <- 0 until n; j <- (i + 1) until n; k <- (j + 1) until n) {
-      val (ax, ay) = (px(i), py(i))
-      val (bx, by) = (px(j), py(j))
-      val (cx, cy) = (px(k), py(k))
-
-      val d = 2.0 * (ax * (by - cy) + bx * (cy - ay) + cx * (ay - by))
-      if (math.abs(d) >= eps) {
-        val ux = ((ax*ax + ay*ay) * (by - cy) +
-                  (bx*bx + by*by) * (cy - ay) +
-                  (cx*cx + cy*cy) * (ay - by)) / d
-        val uy = ((ax*ax + ay*ay) * (cx - bx) +
-                  (bx*bx + by*by) * (ax - cx) +
-                  (cx*cx + cy*cy) * (bx - ax)) / d
-
-        val rSq = (ux - ax) * (ux - ax) + (uy - ay) * (uy - ay)
-
-        val valid = (0 until n).forall { m =>
-          m == i || m == j || m == k || {
-            val distSq = (ux - px(m)) * (ux - px(m)) + (uy - py(m)) * (uy - py(m))
-            distSq >= rSq - eps
-          }
-        }
-
-        if (valid) count += 1
+    val points = Array.tabulate(n) { i =>
+      (arr(1 + 2 * i), arr(1 + 2 * i + 1))
+    }
+
+    def cross(o: (Int, Int), a: (Int, Int), b: (Int, Int)): Long =
+      (a._1 - o._1).toLong * (b._2 - o._2) - (a._2 - o._2).toLong * (b._1 - o._1)
+
+    val base = points(0)
+    val allCollinear = points.drop(2).forall(point => cross(base, points(1), point) == 0L)
+    if (allCollinear) return 0
+
+    val sorted = points.sortBy(point => (point._1, point._2))
+
+    val lower = scala.collection.mutable.ArrayBuffer[(Int, Int)]()
+    for (point <- sorted) {
+      while (lower.length >= 2 && cross(lower(lower.length - 2), lower(lower.length - 1), point) <= 0L) {
+        lower.remove(lower.length - 1)
+      }
+      lower += point
+    }
+
+    val upper = scala.collection.mutable.ArrayBuffer[(Int, Int)]()
+    for (point <- sorted.reverse) {
+      while (upper.length >= 2 && cross(upper(upper.length - 2), upper(upper.length - 1), point) <= 0L) {
+        upper.remove(upper.length - 1)
       }
+      upper += point
     }
 
-    count
+    val hullVertices = lower.length + upper.length - 2
+    2 * n - 2 - hullVertices
   }
 }
diff --git a/algorithms/graph/2-sat/scala/TwoSat.scala b/algorithms/graph/2-sat/scala/TwoSat.scala
@@ -55,11 +55,13 @@ object TwoSat {
       if (low(u) == dfn(u)) {
         sccCnt += 1
         var v = -1
-        do {
+        var draining = true
+        while (draining) {
           v = stack.pop()
           inStack(v) = false
           sccId(v) = sccCnt
-        } while (u != v)
+          draining = u != v
+        }
       }
     }
 
diff --git a/algorithms/graph/dijkstras/scala/Dijkstra.scala b/algorithms/graph/dijkstras/scala/Dijkstra.scala
@@ -1,7 +1,7 @@
 package algorithms.graph.dijkstras
 
-import scala.collection.mutable
-import scala.math.Ordering
+import _root_.scala.collection.mutable
+import _root_.scala.math.Ordering
 
 object Dijkstra {
   private val INF = 1000000000
diff --git a/algorithms/graph/dinic/scala/Dinic.scala b/algorithms/graph/dinic/scala/Dinic.scala
@@ -1,9 +1,7 @@
 package algorithms.graph.dinic
 
-import java.util.LinkedList
-import java.util.Queue
-import scala.collection.mutable.ArrayBuffer
-import scala.math.min
+import _root_.scala.collection.mutable.ArrayBuffer
+import _root_.scala.math.min
 
 object Dinic {
   case class Edge(to: Int, rev: Int, cap: Long, var flow: Long)
@@ -34,9 +32,9 @@ object Dinic {
     val ptr = new Array[Int](n)
 
     def bfs(): Boolean = {
-      java.util.Arrays.fill(level, -1)
+      _root_.java.util.Arrays.fill(level, -1)
       level(s) = 0
-      val q: Queue[Int] = new LinkedList()
+      val q: _root_.java.util.Queue[Int] = new _root_.java.util.LinkedList[Int]()
       q.add(s)
 
       while (!q.isEmpty) {
@@ -81,12 +79,14 @@ object Dinic {
 
     var flow: Long = 0
     while (bfs()) {
-      java.util.Arrays.fill(ptr, 0)
+      _root_.java.util.Arrays.fill(ptr, 0)
       var pushed: Long = 0
-      do {
+      var keepPushing = true
+      while (keepPushing) {
         pushed = dfs(s, Long.MaxValue)
         flow += pushed
-      } while (pushed != 0)
+        keepPushing = pushed != 0
+      }
     }
 
     flow.toInt
diff --git a/algorithms/graph/prims-fibonacci-heap/scala/PrimsFibonacciHeap.scala b/algorithms/graph/prims-fibonacci-heap/scala/PrimsFibonacciHeap.scala
@@ -12,7 +12,7 @@ object PrimsFibonacciHeap {
     val inMst = Array.fill(n)(false)
     val key = Array.fill(n)(INF)
     key(0) = 0
-    val pq = scala.collection.mutable.PriorityQueue[(Int, Int)]()(Ordering.by[(Int, Int), Int](_._1).reverse)
+    val pq = scala.collection.mutable.PriorityQueue.empty[(Int, Int)](using Ordering.by[(Int, Int), Int](_._1).reverse)
     pq.enqueue((0, 0))
     var total = 0
 
diff --git a/algorithms/graph/prims/scala/Prim.scala b/algorithms/graph/prims/scala/Prim.scala
@@ -11,7 +11,7 @@ object Prim {
     key(0) = 0
 
     // Priority queue: (weight, vertex)
-    val pq = mutable.PriorityQueue[(Int, Int)]()(Ordering.by[(Int, Int), Int](-_._1))
+    val pq = mutable.PriorityQueue.empty[(Int, Int)](using Ordering.by[(Int, Int), Int](-_._1))
     pq.enqueue((0, 0))
 
     var totalWeight = 0
diff --git a/algorithms/greedy/huffman-coding/scala/HuffmanCoding.scala b/algorithms/greedy/huffman-coding/scala/HuffmanCoding.scala
@@ -5,7 +5,7 @@ object HuffmanCoding {
   def huffmanCoding(frequencies: Array[Int]): Int = {
     if (frequencies.length <= 1) return 0
 
-    val minHeap = mutable.PriorityQueue[Int]()(Ordering[Int].reverse)
+    val minHeap = mutable.PriorityQueue.empty[Int](using Ordering.Int.reverse)
     frequencies.foreach(minHeap.enqueue(_))
 
     var totalCost = 0
diff --git a/algorithms/math/discrete-logarithm/csharp/DiscreteLogarithm.cs b/algorithms/math/discrete-logarithm/csharp/DiscreteLogarithm.cs
@@ -18,26 +18,18 @@ static long ModPow(long b, long exp, long mod)
     public static int Solve(long baseVal, long target, long modulus)
     {
         if (modulus == 1) return 0;
-        int m = (int)Math.Ceiling(Math.Sqrt(modulus));
         target %= modulus;
-
-        var table = new Dictionary<long, int>();
-        long power = 1;
-        for (int j = 0; j < m; j++)
+        long value = 1 % modulus;
+        for (int exponent = 0; exponent < modulus; exponent++)
         {
-            if (power == target) return j;
-            table[power] = j;
-            power = power * baseVal % modulus;
-        }
-
-        long baseInvM = ModPow(baseVal, modulus - 1 - (m % (modulus - 1)), modulus);
-        long gamma = target;
-        for (int i = 0; i < m; i++)
-        {
-            if (table.ContainsKey(gamma)) return i * m + table[gamma];
-            gamma = gamma * baseInvM % modulus;
+            if (value == target)
+            {
+                return exponent;
+            }
+            value = value * (baseVal % modulus) % modulus;
         }
         return -1;
+
     }
 
     public static void Main(string[] args)
diff --git a/algorithms/math/doomsday/csharp/Doomsday.cs b/algorithms/math/doomsday/csharp/Doomsday.cs
@@ -2,43 +2,20 @@
 
 namespace DD{
     public class DoomsDay{
-        public static int DayOfWeek(int y, int m, int d){
+        public static string DayOfWeek(int y, int m, int d){
             int[] t = {0, 3, 2, 5, 0, 3, 5, 1, 4, 6, 2, 4};
             y -= (m<3) ? 1 : 0;
-            return (y + y/4 - y/100 + y/400 + t[m-1] + d) % 7;
+            string[] names = {"Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"};
+            int day = (y + y/4 - y/100 + y/400 + t[m-1] + d) % 7;
+            return names[day];
         }
 
         public static void PrintDay(int y, int m, int d){
-            switch(DayOfWeek(y,m,d)){
-                case 0:
-                    Console.WriteLine("Sunday");
-                    break;
-                case 1:
-                    Console.WriteLine("Monday");
-                    break;
-                case 2:
-                    Console.WriteLine("Tuesday");
-                    break;
-                case 3:
-                    Console.WriteLine("Wednesday");
-                    break;
-                case 4:
-                    Console.WriteLine("Thursday");
-                    break;
-                case 5:
-                    Console.WriteLine("Friday");
-                    break;
-                case 6:
-                    Console.WriteLine("Saturday");
-                    break;                
-                default:
-                    Console.WriteLine("Doomsday");
-                    break;
-            }
+            Console.WriteLine(DayOfWeek(y, m, d));
         }
 
         public static void Main(){
             PrintDay(1970, 1, 1);
         }
     }
-}
+}
diff --git a/algorithms/math/mobius-function/scala/MobiusFunction.scala b/algorithms/math/mobius-function/scala/MobiusFunction.scala
@@ -1,14 +1,22 @@
 object MobiusFunction {
   def mobiusFunction(n: Int): Int = {
-    val mu = Array.fill(n + 1)(0)
+    val mu = Array.fill(n + 1)(1)
     mu(1) = 1
     val isPrime = Array.fill(n + 1)(true)
+    if (n >= 0) {
+      isPrime(0) = false
+    }
+    if (n >= 1) {
+      isPrime(1) = false
+    }
 
     for (i <- 2 to n) {
       if (isPrime(i)) {
         var j = i
         while (j <= n) {
-          if (j != i) isPrime(j) = false
+          if (j != i) {
+            isPrime(j) = false
+          }
           mu(j) = -mu(j)
           j += i
         }
diff --git a/algorithms/math/sieve-of-eratosthenes/csharp/SieveofEratosthenes.cs b/algorithms/math/sieve-of-eratosthenes/csharp/SieveofEratosthenes.cs
@@ -13,6 +13,12 @@ public class SieveofEratosthenes
         
         public List<int> GetPrimes(int n)
         {
+            _primes.Clear();
+            if (n < 2)
+            {
+                return _primes;
+            }
+
             _primes.Add(2);
 
             for (var i = 3; i <= n; i++)
diff --git a/algorithms/math/swap-two-variables/scala/Swap.scala b/algorithms/math/swap-two-variables/scala/Swap.scala
@@ -9,9 +9,8 @@ object Swap {
     var swapped = swap(x,y)
     x = swapped._1
     y = swapped._2
-    println(x, y)
+    println(s"$x $y")
   }
 
 }
 
-
diff --git a/algorithms/sorting/bitonic-sort/scala/BitonicSort.scala b/algorithms/sorting/bitonic-sort/scala/BitonicSort.scala
@@ -28,10 +28,10 @@ object BitonicSort {
   }
 
   private def compareAndSwap(arr: Array[Int], i: Int, j: Int, ascending: Boolean): Unit = {
-    if ((ascending && arr[i] > arr[j]) || (!ascending && arr[i] < arr[j])) {
-      val temp = arr[i]
-      arr[i] = arr[j]
-      arr[j] = temp
+    if ((ascending && arr(i) > arr(j)) || (!ascending && arr(i) < arr(j))) {
+      val temp = arr(i)
+      arr(i) = arr(j)
+      arr(j) = temp
     }
   }
 
diff --git a/algorithms/sorting/bogo-sort/scala/BogoSort.scala b/algorithms/sorting/bogo-sort/scala/BogoSort.scala
diff --git a/algorithms/sorting/gnome-sort/scala/GnomeSort.scala b/algorithms/sorting/gnome-sort/scala/GnomeSort.scala
diff --git a/algorithms/sorting/partial-sort/scala/PartialSort.scala b/algorithms/sorting/partial-sort/scala/PartialSort.scala
diff --git a/algorithms/trees/binary-tree/scala/BinaryTree.scala b/algorithms/trees/binary-tree/scala/BinaryTree.scala
diff --git a/algorithms/trees/splay-tree/scala/SplayTree.scala b/algorithms/trees/splay-tree/scala/SplayTree.scala
diff --git a/tests/runners/csharp_runner.sh b/tests/runners/csharp_runner.sh
diff --git a/tests/runners/scala_runner.sh b/tests/runners/scala_runner.sh

Original file line number	Diff line number	Diff line change
`@@ -21,7 +21,9 @@ object ConvexHullJarvis {`
`21`	`21`
`22`	`22`	`var hullCount = 0`
`23`	`23`	`var current = start`
`24`		`- do {`
	`24`	`+ var firstPass = true`
	`25`	`+ while (firstPass \|\| current != start) {`
	`26`	`+ firstPass = false`
`25`	`27`	`hullCount += 1`
`26`	`28`	`var candidate = 0`
`27`	`29`	`for (i <- 1 until n) {`
`@@ -37,7 +39,7 @@ object ConvexHullJarvis {`
`37`	`39`	`}`
`38`	`40`	`}`
`39`	`41`	`current = candidate`
`40`		`- } while (current != start)`
	`42`	`+ }`
`41`	`43`
`42`	`44`	`hullCount`
`43`	`45`	`}`