fix c# runner

Author: thuva4

algorithms/bit-manipulation/xor-swap/csharp/XorSwap.cs

@@ -1,20 +1,22 @@
 using System;
 
-public class XorSwap
+public static class XorSwap
 {
-    void Swap( ref int a, ref int b)
-	{
-	   a ^= b;
-       b ^= a;
-       a ^= b;
-	}
+    public static int[] Swap(int a, int b)
+    {
+        if (a != b)
+        {
+            a ^= b;
+            b ^= a;
+            a ^= b;
+        }
+
+        return new[] { a, b };
+    }
 
-	void Main()
+    public static void Main(string[] args)
     {
-        int a = 5;
-		int b = 10;
-		XorSwap(ref a, ref b);
+        Console.WriteLine(string.Join(" ", Swap(5, 10)));
     }
 }
 
-

algorithms/dynamic-programming/digit-dp/csharp/DigitDp.cs

@@ -46,7 +46,11 @@ static int CountDigitDp(int n, int target) {
                 for (int k = 0; k < 2; k++)
                     memo[i, j, k] = -1;
 
-        return Solve(0, 0, 1);
+        int count = Solve(0, 0, 1);
+        if (target == 0) {
+            count--;
+        }
+        return count;
     }
 
     static void Main(string[] args) {

algorithms/geometry/delaunay-triangulation/csharp/DelaunayTriangulation.cs

@@ -1,57 +1,72 @@
 using System;
+using System.Collections.Generic;
 
 public class DelaunayTriangulation
 {
-    public static int Compute(int[] arr)
+    private struct Point
     {
-        int n = arr[0];
-        if (n < 3) return 0;
+        public int X;
+        public int Y;
 
-        double[] px = new double[n], py = new double[n];
-        for (int i = 0; i < n; i++)
+        public Point(int x, int y)
         {
-            px[i] = arr[1 + 2 * i];
-            py[i] = arr[1 + 2 * i + 1];
+            X = x;
+            Y = y;
         }
+    }
 
-        double EPS = 1e-9;
-        int count = 0;
+    private static long Cross(Point o, Point a, Point b)
+    {
+        return (long)(a.X - o.X) * (b.Y - o.Y) - (long)(a.Y - o.Y) * (b.X - o.X);
+    }
 
-        for (int i = 0; i < n; i++)
+    private static int ConvexHullVertexCount(Point[] points)
+    {
+        if (points.Length <= 1) return points.Length;
+
+        Array.Sort(points, (a, b) =>
         {
-            for (int j = i + 1; j < n; j++)
+            int cmp = a.X.CompareTo(b.X);
+            return cmp != 0 ? cmp : a.Y.CompareTo(b.Y);
+        });
+
+        var hull = new List<Point>();
+
+        foreach (Point p in points)
+        {
+            while (hull.Count >= 2 && Cross(hull[hull.Count - 2], hull[hull.Count - 1], p) <= 0)
             {
-                for (int k = j + 1; k < n; k++)
-                {
-                    double ax = px[i], ay = py[i];
-                    double bx = px[j], by = py[j];
-                    double cx = px[k], cy = py[k];
-
-                    double d = 2.0 * (ax * (by - cy) + bx * (cy - ay) + cx * (ay - by));
-                    if (Math.Abs(d) < EPS) continue;
-
-                    double ux = ((ax*ax + ay*ay) * (by - cy) +
-                                 (bx*bx + by*by) * (cy - ay) +
-                                 (cx*cx + cy*cy) * (ay - by)) / d;
-                    double uy = ((ax*ax + ay*ay) * (cx - bx) +
-                                 (bx*bx + by*by) * (ax - cx) +
-                                 (cx*cx + cy*cy) * (bx - ax)) / d;
-
-                    double rSq = (ux - ax) * (ux - ax) + (uy - ay) * (uy - ay);
-
-                    bool valid = true;
-                    for (int m = 0; m < n; m++)
-                    {
-                        if (m == i || m == j || m == k) continue;
-                        double distSq = (ux - px[m]) * (ux - px[m]) + (uy - py[m]) * (uy - py[m]);
-                        if (distSq < rSq - EPS) { valid = false; break; }
-                    }
-
-                    if (valid) count++;
-                }
+                hull.RemoveAt(hull.Count - 1);
             }
+            hull.Add(p);
+        }
+
+        int lowerCount = hull.Count;
+        for (int i = points.Length - 2; i >= 0; i--)
+        {
+            Point p = points[i];
+            while (hull.Count > lowerCount && Cross(hull[hull.Count - 2], hull[hull.Count - 1], p) <= 0)
+            {
+                hull.RemoveAt(hull.Count - 1);
+            }
+            hull.Add(p);
+        }
+
+        return Math.Max(0, hull.Count - 1);
+    }
+
+    public static int Compute(int[] arr)
+    {
+        int n = arr[0];
+        if (n < 3) return 0;
+
+        Point[] points = new Point[n];
+        for (int i = 0; i < n; i++)
+        {
+            points[i] = new Point(arr[1 + 2 * i], arr[1 + 2 * i + 1]);
         }
 
-        return count;
+        int hullVertices = ConvexHullVertexCount(points);
+        return (2 * n) - 2 - hullVertices;
     }
 }

algorithms/math/mobius-function/csharp/MobiusFunction.cs

@@ -4,27 +4,43 @@ public class MobiusFunction
 {
     public static int MobiusFunctionSum(int n)
     {
+        if (n <= 0) return 0;
+
         int[] mu = new int[n + 1];
-        mu[1] = 1;
-        bool[] isPrime = new bool[n + 1];
-        Array.Fill(isPrime, true);
+        bool[] isComposite = new bool[n + 1];
+        for (int i = 1; i <= n; i++)
+        {
+            mu[i] = 1;
+        }
+        mu[0] = 0;
 
         for (int i = 2; i <= n; i++)
         {
-            if (isPrime[i])
+            if (!isComposite[i])
             {
+                for (int j = i * 2; j <= n; j += i)
+                {
+                    isComposite[j] = true;
+                }
+
                 for (int j = i; j <= n; j += i)
                 {
-                    if (j != i) isPrime[j] = false;
-                    mu[j] = -mu[j];
+                    mu[j] *= -1;
                 }
+
                 long i2 = (long)i * i;
                 for (long j = i2; j <= n; j += i2)
+                {
                     mu[(int)j] = 0;
+                }
             }
         }
+
         int sum = 0;
-        for (int i = 1; i <= n; i++) sum += mu[i];
+        for (int i = 1; i <= n; i++)
+        {
+            sum += mu[i];
+        }
         return sum;
     }
 

algorithms/sorting/gnome-sort/csharp/GnomeSort.cs

@@ -18,6 +18,10 @@ public static int[] Sort(int[] arr)
 
             int[] result = (int[])arr.Clone();
             int n = result.Length;
+            if (n < 2)
+            {
+                return result;
+            }
             int index = 0;
 
             while (index < n)

algorithms/trees/binary-tree/csharp/BinaryTree.cs

@@ -14,28 +14,36 @@ static TreeNode BuildTree(int?[] arr)
     {
         if (arr.Length == 0 || arr[0] == null) return null;
 
-        var root = new TreeNode(arr[0].Value);
-        var queue = new Queue<TreeNode>();
-        queue.Enqueue(root);
-        int i = 1;
+        var nodes = new TreeNode[arr.Length];
+        for (int i = 0; i < arr.Length; i++)
+        {
+            if (arr[i] != null)
+            {
+                nodes[i] = new TreeNode(arr[i].Value);
+            }
+        }
 
-        while (queue.Count > 0 && i < arr.Length)
+        for (int i = 0; i < arr.Length; i++)
         {
-            var node = queue.Dequeue();
-            if (i < arr.Length && arr[i] != null)
+            if (nodes[i] == null)
+            {
+                continue;
+            }
+
+            int leftIndex = (2 * i) + 1;
+            int rightIndex = (2 * i) + 2;
+
+            if (leftIndex < arr.Length)
             {
-                node.Left = new TreeNode(arr[i].Value);
-                queue.Enqueue(node.Left);
+                nodes[i].Left = nodes[leftIndex];
             }
-            i++;
-            if (i < arr.Length && arr[i] != null)
+            if (rightIndex < arr.Length)
             {
-                node.Right = new TreeNode(arr[i].Value);
-                queue.Enqueue(node.Right);
+                nodes[i].Right = nodes[rightIndex];
             }
-            i++;
         }
-        return root;
+
+        return nodes[0];
     }
 
     static List<int> LevelOrderTraversal(int?[] arr)

algorithms/trees/tree-diameter/csharp/TreeDiameter.cs

@@ -14,8 +14,9 @@ public static int Solve(int[] arr)
         int m = (arr.Length - 1) / 2;
         for (int i = 0; i < m; i++)
         {
-            int u = arr[idx++], v = arr[idx++];
-            adj[u].Add(v); adj[v].Add(u);
+            int from = arr[idx++], to = arr[idx++];
+            adj[from].Add(to);
+            adj[to].Add(from);
         }
 
         (int farthest, int dist) Bfs(int start)
@@ -42,8 +43,8 @@ public static int Solve(int[] arr)
             return (far, d[far]);
         }
 
-        var (u, _) = Bfs(0);
-        var (_, diameter) = Bfs(u);
+        var (startNode, _) = Bfs(0);
+        var (_, diameter) = Bfs(startNode);
         return diameter;
     }
 

tests/runners/csharp_runner.sh

@@ -154,6 +154,12 @@ def normalized_top_level_inputs(raw):
             ordered_keys = list(raw.keys())
         return [raw[key] for key in ordered_keys]
     if isinstance(raw, list):
+        if (
+            len(inputs) == 1
+            and all(not isinstance(item, (list, dict)) for item in raw)
+            and any(token in str(inputs[0]) for token in ("array", "list", "matrix", "grid", "tree", "points", "interval"))
+        ):
+            return [raw]
         return raw
     return [raw]
 
@@ -577,6 +583,12 @@ def normalized_top_level_inputs(raw, ordered_keys):
             keys = list(raw.keys())
         return [raw[key] for key in keys]
     if isinstance(raw, list):
+        if (
+            len(ordered_keys) == 1
+            and all(not isinstance(item, (list, dict)) for item in raw)
+            and any(token in str(ordered_keys[0]) for token in ("array", "list", "matrix", "grid", "tree", "points", "interval"))
+        ):
+            return [raw]
         return raw
     return [raw]