fix runners

Author: thuva4

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) {

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();

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;
-     }
+   }
 }

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
   }

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
   }
 }

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
+        }
       }
     }
 

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

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

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
 

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