utd bob competition over

solutions/battle-of-the-brains-2026/DealEmOut.java

@@ -0,0 +1,35 @@
+// General imports
+
+import java.util.Scanner;
+
+public class DealEmOut {
+  public static void main(String[] args) {
+    Scanner sc = new Scanner(System.in);
+
+    // Write code here
+
+    int a = sc.nextInt();
+    int b = sc.nextInt();
+    int c = sc.nextInt();
+
+    int cards = 0;
+    int value = a + b + c;
+
+    if (a == 0)
+      cards++;
+    if (b == 0)
+      cards++;
+    if (c == 0)
+      cards++;
+
+    int known = 3 - cards;
+
+    double adder = (416.0 - value) / (52.0 - known);
+
+    double returner = value + adder * cards;
+
+    System.out.printf("%.2f", returner);
+
+    sc.close();
+  }
+}

solutions/battle-of-the-brains-2026/DontTestMe.java

@@ -0,0 +1,52 @@
+// General imports
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.Arrays;
+import java.util.StringTokenizer;
+
+public class DontTestMe  {
+  public static void main(String[] args)  throws IOException{
+
+    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+
+    StringTokenizer st = new StringTokenizer(br.readLine());
+    int N = Integer.parseInt(st.nextToken());
+    int H = Integer.parseInt(st.nextToken());
+    Test[] ar = new Test[N];
+    for (int i =0; i < N; i++){
+      st = new StringTokenizer(br.readLine());
+      ar[i] = new Test(Integer.parseInt(st.nextToken()),Integer.parseInt(st.nextToken()),Double.parseDouble(st.nextToken()));
+    }
+
+    Arrays.sort(ar, (a1,a2) -> a1.compareTo(a2));
+
+
+    
+
+
+
+  }
+
+}
+
+class Test{
+  int hours,points;
+  double percent;
+  double weight;
+
+  public Test (int h, int p, double per){
+    hours = h;
+    points = p;
+    percent = per;
+    weight = 1/(double) hours * points * percent;
+  }
+
+  public int compareTo(Object o){
+    Test t = (Test) o;
+    if (this.weight > t.weight) return 1;
+    else if (this.weight < t.weight) return -1;
+    return 0;
+  }
+}

solutions/battle-of-the-brains-2026/Island.java

@@ -0,0 +1,80 @@
+// General imports
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.StringTokenizer;
+
+public class Island {
+  static int N, M;
+  static int[][] grid;
+  static boolean[][] visited;
+  static Map<Integer, Integer> islands = new HashMap<>();
+  public static void main(String[] args) throws IOException {
+    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+    StringTokenizer st = new StringTokenizer(br.readLine());
+    N = Integer.parseInt(st.nextToken());
+    M = Integer.parseInt(st.nextToken());
+    grid = new int[N][M];
+    visited = new boolean[N][M];
+    for (int i = 0; i < N; i++) {
+      st = new StringTokenizer(br.readLine());
+      for (int j = 0; j < M; j++) {
+        int cell = Integer.parseInt(st.nextToken());
+        grid[i][j] = cell;
+      }
+    }
+    br.close();
+    for (int i = 0; i < N; i++) {
+      for (int j = 0; j < M; j++) {
+        if (visited[i][j]) continue;
+        if (grid[i][j] > 0) {
+          islands.put(grid[i][j], islands.getOrDefault(grid[i][j], 0) + 1);
+          search(grid[i][j], i, j);
+        } else {
+          visited[i][j] = true;
+        }
+      }
+    }
+    if (islands.size() == 0) {
+      System.out.println(0);
+      return;
+    }
+    for (Map.Entry<Integer, Integer> e : islands.entrySet()) {
+      int terrainNumber = e.getKey();
+      int islandNum = e.getValue();
+      System.out.printf("%d %d%n", terrainNumber, islandNum);
+    }
+  }
+
+  static void search(int val, int i, int j) {
+    if (visited[i][j]) return;
+    visited[i][j] = true;
+    for (int dir = 0; dir < 4; dir++) {
+      switch(dir) {
+        case 0:
+          if (j + 1 < M && grid[i][j + 1] == val) {
+            search(val, i, j + 1);
+          }
+          break;
+        case 1:
+          if (i + 1 < N && grid[i + 1][j] == val) {
+            search(val, i + 1, j);
+          }
+          break;
+        case 2:
+          if (j - 1 >= 0 && grid[i][j - 1] == val) {
+            search(val, i, j - 1);
+          }
+          break;
+        case 3:
+          if (i - 1 >= 0 && grid[i - 1][j] == val) {
+            search(val, i - 1, j);
+          }
+          break;
+      }
+    }
+  }
+}

solutions/battle-of-the-brains-2026/MaximumAura.java

@@ -0,0 +1,61 @@
+// General imports
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.PrintWriter;
+import java.util.PriorityQueue;
+import java.util.StringTokenizer;
+
+public class MaximumAura {
+  public static void main(String[] args) throws IOException {
+
+    long t = System.nanoTime();
+
+    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+    PrintWriter out = new PrintWriter(System.out);
+
+    // Write code here
+
+    int a = Integer.parseInt(br.readLine());
+    int[] input = new int[a];
+    int[] left = new int[a];
+    int[] right = new int[a];
+    left[0] = 1;
+    right[a - 1] = 1;
+    StringTokenizer st = new StringTokenizer(br.readLine());
+    for (int i = 0; i < a; i++) {
+      input[i] = Integer.parseInt(st.nextToken());
+    }
+
+    for (int i = 1; i < input.length; i++) {
+      int max = 0;
+      for (int j = 0; j < i; j++) {
+        if (input[j] < input[i]) {
+          max = Math.max(max, left[j]);
+        }
+      }
+      left[i] = max + 1;
+    }
+
+    for (int i = a - 2; i >= 0; i--) {
+      right[i] = 1;
+      int max = 0;
+      for (int j = a - 1; j > i; j--) {
+        if (input[j] < input[i]) {
+          max = Math.max(max, right[j]);
+        }
+      }
+      right[i] += max;
+    }
+    PriorityQueue<Integer> p = new PriorityQueue<>();
+    for (int i = 0; i < input.length; i++) {
+      out.print((left[i] + right[i] - 1) + " ");
+    }
+
+
+    br.close();
+    out.flush();
+
+  }
+}

solutions/battle-of-the-brains-2026/Solution.java

@@ -1,8 +1,6 @@
 // General imports
 
-import java.io.*;
-import java.math.*;
-import java.util.*;
+import java.util.Scanner;
 
 public class Solution {
   public static void main(String[] args) {
@@ -16,3 +14,4 @@ public class Solution {
     sc.close();
   }
 }
+

solutions/battle-of-the-brains-2026/WeightedDifference.java

@@ -0,0 +1,49 @@
+// General imports
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.StringTokenizer;
+
+public class WeightedDifference  {
+  public static void main(String[] args)  throws IOException{
+
+    double  t = System.currentTimeMillis();
+
+    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+
+
+    // Write code here
+
+    int a = Integer.parseInt(br.readLine());
+    StringTokenizer st = new StringTokenizer(br.readLine());
+    int[] ar = new int[a];
+    for (int i = 0; i < a; i++) {
+      ar[i] = Integer.parseInt(st.nextToken());
+    }
+
+    long max = Long.MIN_VALUE;
+    int left = 0;
+    int right = ar.length - 1;
+    int gap = right - left;
+    int prevGap = 0;
+    while (gap > 0) {
+      int diff = ar[right] - ar[left] - (right - left);
+      max = diff > max ? diff : max;
+      if (gap == prevGap && right < ar.length - 1) {
+        left++;
+        right++;
+      } else {
+        gap--;
+        prevGap = gap;
+        left = 0;
+        right = gap;
+      }
+    }
+
+    System.out.println(max);
+    System.out.println(System.currentTimeMillis()-t);
+
+  }
+
+}