Java Notes on Dan Stefan Oprean

Introduction

Mon, 01 Jan 0001 00:00:00 +0000

Hello World

public class Main {
    public static void main(String[] args) {
        System.out.println("Hello, world!");
    }
}

Compile and run:

javac Main.java
java Main

This is the standard Java entry point: the main method runs first, and System.out.println prints to the console.

Variables

String name = "Dan";
int count = 1;
boolean active = true;

These are a few common Java types. Java keeps types explicit, so the declaration tells you exactly what each value holds.

Add

Mon, 01 Jan 0001 00:00:00 +0000

Java Add

public class Solution {
    public static int add(int param1, int param2) {
        return param1 + param2;
    }
}

This just adds the two input numbers with the language’s normal arithmetic and returns the sum.

Add Border

Mon, 01 Jan 0001 00:00:00 +0000

Java Add Border

public class Solution {
    public static String[] addBorder(String[] picture) {
        int width = picture[0].length() + 2;
        String border = "*".repeat(width);

        String[] result = new String[picture.length + 2];
        result[0] = border;
        for (int i = 0; i < picture.length; i++) {
            result[i + 1] = "*" + picture[i] + "*";
        }
        result[result.length - 1] = border;

        return result;
    }
}

This builds a new grid with a * border around every side. It adds a full top and bottom row, then wraps each existing row from left and right.

Adjacent Elements Product

Mon, 01 Jan 0001 00:00:00 +0000

Java Adjacent Elements Product

public class Solution {
    public static int adjacentElementsProduct(int[] inputArray) {
        int max = Integer.MIN_VALUE;

        for (int i = 0; i < inputArray.length - 1; i++) {
            max = Math.max(max, inputArray[i] * inputArray[i + 1]);
        }

        return max;
    }
}

This walks through neighboring values, multiplies each pair, and keeps the biggest product it finds.

Almost Magic Square

Mon, 01 Jan 0001 00:00:00 +0000

Java Almost Magic Square

public class Solution {
    public static int[] almostMagicSquare(int[] a) {
        int[][] grid = new int[3][3];
        for (int i = 0; i < 9; i++) {
            grid[i / 3][i % 3] = a[i];
        }

        int[] rowSum = new int[3];
        int[] colSum = new int[3];
        int maxSum = 0;

        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 3; j++) {
                rowSum[i] += grid[i][j];
                colSum[i] += grid[j][i];
            }
        }

        for (int k = 0; k < 3; k++) {
            maxSum = Math.max(maxSum, rowSum[k]);
            maxSum = Math.max(maxSum, colSum[k]);
        }

        for (int i = 0, j = 0; i < 3 && j < 3; ) {
            int diff = Math.min(maxSum - rowSum[i], maxSum - colSum[j]);
            grid[i][j] += diff;
            rowSum[i] += diff;
            colSum[j] += diff;

            if (rowSum[i] == maxSum) {
                i++;
            }
            if (colSum[j] == maxSum) {
                j++;
            }
        }

        int[] result = new int[9];
        for (int i = 0; i < 9; i++) {
            result[i] = grid[i / 3][i % 3];
        }

        return result;
    }
}

This adjusts the matrix toward a matching target sum so the rows and columns line up more like a magic square.

Are Equally Strong

Mon, 01 Jan 0001 00:00:00 +0000

Java Are Equally Strong

public class Solution {
    public static boolean areEquallyStrong(int yourLeft, int yourRight, int friendsLeft, int friendsRight) {
        return Math.max(yourLeft, yourRight) == Math.max(friendsLeft, friendsRight)
                && Math.min(yourLeft, yourRight) == Math.min(friendsLeft, friendsRight);
    }
}

This compares each person’s strongest and weakest arm. If both pairs match, the result is true.

Array Change

Mon, 01 Jan 0001 00:00:00 +0000

Java Array Change

public class Solution {
    public static long arrayChange(int[] a) {
        long min = 0;
        long[] arr = new long[a.length];
        for (int i = 0; i < a.length; i++) {
            arr[i] = a[i];
        }

        for (int k = 0; k < arr.length - 1; k++) {
            if (arr[k] >= arr[k + 1]) {
                long dif = arr[k] - arr[k + 1] + 1;
                arr[k + 1] += dif;
                min += dif;
            }
        }

        return min;
    }
}

This moves left to right and bumps values only when needed so the array becomes strictly increasing.

Array Maximal Adjacement Difference

Mon, 01 Jan 0001 00:00:00 +0000

Java Array Maximal Adjacement Difference

public class Solution {
    public static int arrayMaximalAdjacentDifference(int[] a) {
        int dif = 0;
        for (int i = 1; i < a.length - 1; i++) {
            dif = Math.max(dif, Math.max(Math.abs(a[i] - a[i - 1]), Math.abs(a[i] - a[i + 1])));
        }

        return dif;
    }
}

This checks the gap between each pair of neighbors and returns the largest difference.

Binary Gap

Mon, 01 Jan 0001 00:00:00 +0000

Java Binary Gap

public class Solution {
    public static int binaryGap(int n) {
        String bin = Integer.toBinaryString(n).replaceAll("^0+|0+$", "");
        String[] zeroes = bin.split("1", -1);

        int gap = 0;
        for (String zero : zeroes) {
            gap = Math.max(gap, zero.length());
        }

        return gap;
    }
}

This turns the number into binary, ignores zeroes outside the edges, and finds the longest run of zeroes between 1s.

Bracket

Mon, 01 Jan 0001 00:00:00 +0000

Java Bracket

import java.util.ArrayDeque;
import java.util.Deque;

public class Solution {
    public static int bracket(String s) {
        Deque<Character> stack = new ArrayDeque<>();

        for (char v : s.toCharArray()) {
            switch (v) {
                case ')':
                    if (stack.isEmpty() || stack.pop() != '(') {
                        return 0;
                    }
                    break;
                case ']':
                    if (stack.isEmpty() || stack.pop() != '[') {
                        return 0;
                    }
                    break;
                case '}':
                    if (stack.isEmpty() || stack.pop() != '{') {
                        return 0;
                    }
                    break;
                default:
                    stack.push(v);
                    break;
            }
        }

        return stack.isEmpty() ? 1 : 0;
    }
}

This uses a simple stack approach: open brackets go in, matching closing brackets pop them out.

Century From Year

Mon, 01 Jan 0001 00:00:00 +0000

Java Century From Year

public class Solution {
    public static int centuryFromYear(int year) {
        return (int) Math.ceil(year / 100.0);
    }
}

This converts a year into its century. Years 1-100 are century 1, 101-200 are century 2, and so on.

Check Palindrome

Mon, 01 Jan 0001 00:00:00 +0000

Java Check Palindrome

public class Solution {
    public static boolean checkPalindrome(String inputString) {
        return new StringBuilder(inputString).reverse().toString().equals(inputString);
    }
}

This compares the string with its reverse. If they match, it is a palindrome.

Chocolates By Numbers

Mon, 01 Jan 0001 00:00:00 +0000

Java Chocolates By Numbers

public class Solution {
    public static int chocolatesByNumbers(int n, int m) {
        long gcd = gcd(n, m);
        long result = ((long) n * m / gcd) / m;

        return (int) result;
    }

    private static long gcd(long n, long m) {
        if (n % m == 0) {
            return m;
        }

        return gcd(m, n % m);
    }
}

This uses the greatest common divisor to figure out how many chocolates get eaten before the pattern repeats.

Common Prime Divisors

Mon, 01 Jan 0001 00:00:00 +0000

Java Common Prime Divisors

public class Solution {
    public static int commonPrimeDivisors(int[] a, int[] b) {
        int counter = 0;

        for (int i = 0; i < a.length; i++) {
            int x = a[i];
            int y = b[i];
            int d = gcd(x, y);

            x = removeCommonPrimeDivisors(x, d);
            if (x != 1) {
                continue;
            }

            y = removeCommonPrimeDivisors(y, d);
            if (y == 1) {
                counter++;
            }
        }

        return counter;
    }

    private static int gcd(int n, int m) {
        if (n % m == 0) {
            return m;
        }

        return gcd(m, n % m);
    }

    private static int removeCommonPrimeDivisors(int n, int m) {
        while (n != 1) {
            int d = gcd(n, m);
            if (d == 1) {
                break;
            }
            n /= d;
        }

        return n;
    }
}

This checks whether two numbers are built from the same prime factors by repeatedly dividing out their shared parts.

Count Div

Mon, 01 Jan 0001 00:00:00 +0000

Java Count Div

public class Solution {
    public static int countDiv(int a, int b, int k) {
        int firstDiv = a % k == 0 ? a : a + (k - a % k);
        int lastDiv = b - b % k;

        return (lastDiv - firstDiv) / k + 1;
    }
}

This counts how many numbers in a range are divisible by K without looping through every value.

Count Factors

Mon, 01 Jan 0001 00:00:00 +0000

Java Count Factors

public class Solution {
    public static int countFactors(int n) {
        int count = 0;
        long i = 1;

        while (i * i < n) {
            if (n % i == 0) {
                count += 2;
            }
            i++;
        }
        if (i * i == n) {
            ++count;
        }

        return count;
    }
}

This checks divisors in pairs up to the square root, which keeps the work much smaller than testing every number.

Count Non Divisible

Mon, 01 Jan 0001 00:00:00 +0000

Java Count Non Divisible

import java.util.Arrays;

public class Solution {
    public static int[] countNonDivisible(int[] a) {
        int size = a.length;
        int[] nondivisor = new int[size];
        int maxValue = Arrays.stream(a).max().orElse(0);
        int[] occurrences = new int[maxValue + 1];

        for (int v : a) {
            occurrences[v]++;
        }

        for (int k = 0; k < size; k++) {
            int v = a[k];
            int count = 0;
            long i = 1;
            while (i * i <= v) {
                if (v % i == 0) {
                    count += occurrences[(int) i];
                    if (v / i != i) {
                        count += occurrences[(int) (v / i)];
                    }
                }
                i++;
            }
            nondivisor[k] = size - count;
        }

        return nondivisor;
    }
}

This counts how often each value appears, then subtracts the divisor matches so you get the non-divisible count for each item.

Count Semi Primes

Mon, 01 Jan 0001 00:00:00 +0000

Java Count Semi Primes

import java.util.Arrays;

public class Solution {
    public static int[] countSemiPrimes(int n, int[] p, int[] q) {
        boolean[] primes = new boolean[n + 1];
        Arrays.fill(primes, true);
        int[] semiPrimes = new int[n + 1];
        int[] semiPrimeCounts = new int[p.length];

        for (int i = 2; (long) i * i <= n; i++) {
            if (primes[i]) {
                for (int k = i * i; k <= n; k += i) {
                    primes[k] = false;
                }
            }
        }

        for (int k = 2; (long) k * k <= n; k++) {
            if (primes[k]) {
                for (int i = 2; i * k <= n; i++) {
                    if (primes[i]) {
                        semiPrimes[k * i] = 1;
                    }
                }
            }
        }

        for (int i = 1; i <= n; i++) {
            semiPrimes[i] += semiPrimes[i - 1];
        }

        for (int k = 0; k < p.length; k++) {
            semiPrimeCounts[k] = semiPrimes[q[k]] - semiPrimes[p[k] - 1];
        }

        return semiPrimeCounts;
    }
}

This precomputes semiprimes and prefix sums so each range query becomes a quick subtraction.

Cyclic Rotation

Mon, 01 Jan 0001 00:00:00 +0000

Java Cyclic Rotation

public class Solution {
    public static int[] cyclicRotation(int[] a, int k) {
        if (a.length > 0) {
            for (int i = 0; i < k; i++) {
                int last = a[a.length - 1];
                System.arraycopy(a, 0, a, 1, a.length - 1);
                a[0] = last;
            }
        }

        return a;
    }
}

This rotates the array to the right by K steps and keeps the wrap-around values in the correct order.

Distinct

Mon, 01 Jan 0001 00:00:00 +0000

Java Distinct

import java.util.Arrays;

public class Solution {
    public static int distinct(int[] a) {
        return (int) Arrays.stream(a).distinct().count();
    }
}

This counts unique values by tracking what has already been seen.

Dominator

Mon, 01 Jan 0001 00:00:00 +0000

Java Dominator

public class Solution {
    public static int dominator(int[] a) {
        int size = 0;
        int value = 0;
        int index = 0;

        for (int k = 0; k < a.length; k++) {
            int v = a[k];
            if (size == 0) {
                size++;
                value = v;
                index = k;
            } else if (value != v) {
                size--;
            } else {
                size++;
            }
        }
        int candidate = size > 0 ? value : -1;

        int count = 0;
        for (int v : a) {
            if (v == candidate) {
                count++;
            }
        }
        if (count <= a.length / 2.0) {
            index = -1;
        }

        return index;
    }
}

This finds a value that appears in more than half of the array, then returns one valid index for it.

Equi Leader

Mon, 01 Jan 0001 00:00:00 +0000

Java Equi Leader

public class Solution {
    public static int equiLeader(int[] a) {
        int leaderSize = 0;
        int value = 0;

        for (int v : a) {
            if (leaderSize == 0) {
                leaderSize++;
                value = v;
            } else if (value != v) {
                leaderSize--;
            } else {
                leaderSize++;
            }
        }
        int candidate = leaderSize > 0 ? value : -1;

        int leaderCount = 0;
        for (int v : a) {
            if (v == candidate) {
                leaderCount++;
            }
        }
        int leader = -1;
        if (leaderCount > a.length / 2.0) {
            leader = candidate;
        }

        int count = a.length;
        int lLeaderCount = 0;
        int equiLeaders = 0;

        for (int k = 0; k < count; k++) {
            int v = a[k];
            int leftHalf = (k + 1) / 2;
            int rightHalf = (count - k - 1) / 2;
            if (v == leader) {
                lLeaderCount++;
            }

            int rLeaderCount = leaderCount - lLeaderCount;
            if (lLeaderCount > leftHalf && rLeaderCount > rightHalf) {
                equiLeaders++;
            }
        }

        return equiLeaders;
    }
}

This keeps leader counts on both sides of the split and counts positions where the same leader survives in each half.

Fib Frog

Mon, 01 Jan 0001 00:00:00 +0000

Java Fib Frog

import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Deque;
import java.util.List;

public class Solution {
    public static int fibFrog(int[] a) {
        int size = a.length;

        List<Integer> fib = new ArrayList<>(List.of(0, 1));
        for (int i = 1; fib.get(i) <= size; ) {
            i++;
            fib.add(fib.get(i - 1) + fib.get(i - 2));
        }

        Deque<int[]> paths = new ArrayDeque<>();
        paths.add(new int[]{-1, 0}); // {idx, jmp}

        boolean[] steps = new boolean[size];

        while (!paths.isEmpty()) {
            int[] path = paths.poll();
            int curIdx = path[0];
            int jmp = path[1];

            for (int i = fib.size() - 1; i >= 2; i--) {
                int idx = curIdx + fib.get(i);
                if (idx == size) {
                    return jmp + 1;
                }
                if (idx > size || steps[idx] || a[idx] == 0) {
                    continue;
                }
                if (a[idx] == 1) {
                    steps[idx] = true;
                    paths.add(new int[]{idx, jmp + 1});
                }
            }
        }

        return -1;
    }
}

This precomputes Fibonacci jumps, then uses a breadth-first search to find the shortest valid path across the river.

Fish

Mon, 01 Jan 0001 00:00:00 +0000

Java Fish

import java.util.ArrayDeque;
import java.util.Deque;

public class Solution {
    public static int fish(int[] a, int[] b) {
        int size = a.length;
        int dead = 0;
        Deque<Integer> fish = new ArrayDeque<>();

        for (int i = 0; i < size; i++) {
            if (b[i] == 1) {
                fish.push(a[i]);
            } else if (!fish.isEmpty()) {
                while (!fish.isEmpty()) {
                    dead++;
                    if (a[i] > fish.peek()) {
                        fish.pop();
                    } else {
                        break;
                    }
                }
            }
        }

        return size - dead;
    }
}

This uses a stack for downstream fish and resolves fights only when opposite directions meet.

Flags

Mon, 01 Jan 0001 00:00:00 +0000

Java Flags

public class Solution {
    public static int flags(int[] a) {
        int size = a.length;
        boolean[] peaks = new boolean[size];

        for (int i = 1; i < size; i++) {
            int next = (i + 1 < size) ? a[i + 1] : 0;
            peaks[i] = a[i - 1] < a[i] && a[i] > next;
        }

        int[] next = new int[size];
        next[size - 1] = -1;
        for (int i = size - 2; i >= 0; i--) {
            next[i] = peaks[i] ? i : next[i + 1];
        }

        int i = 1;
        int result = 0;
        while (i * (i - 1) <= size) {
            int pos = 0;
            int num = 0;
            while (pos < size && num < i) {
                pos = next[pos];
                if (pos == -1) {
                    break;
                }
                ++num;
                pos += i;
            }
            i++;
            result = Math.max(result, num);
        }

        return result;
    }
}

This finds all peaks first, then checks how many flags can be placed while keeping the required distance.

Frog Jmp

Mon, 01 Jan 0001 00:00:00 +0000

Java Frog Jmp

public class Solution {
    public static long frogJmp(int x, int y, int d) {
        return (long) Math.ceil(((double) y - x) / d);
    }
}

This computes the jump count with math instead of simulation, which is the cleanest way to solve it.

Frog River One

Mon, 01 Jan 0001 00:00:00 +0000

Java Frog River One

public class Solution {
    public static int frogRiverOne(int x, int[] a) {
        boolean[] existing = new boolean[x + 1];
        int count = 0;

        for (int k = 0; k < a.length; k++) {
            int i = a[k];
            if (i <= x && !existing[i]) {
                existing[i] = true;
                count++;
                if (count == x) {
                    return k;
                }
            }
        }

        return -1;
    }
}

This tracks the earliest time each needed position appears and stops as soon as the frog can cross.

Genomic Range Query

Mon, 01 Jan 0001 00:00:00 +0000

Java Genomic Range Query

public class Solution {
    public static int[] genomicRangeQuery(String s, int[] p, int[] q) {
        int[] r = new int[p.length];

        for (int k = 0; k < p.length; k++) {
            int pi = p[k];
            int qi = q[k] - pi + 1;
            String subStr = s.substring(pi, pi + qi);

            if (subStr.contains("A")) {
                r[k] = 1;
            } else if (subStr.contains("C")) {
                r[k] = 2;
            } else if (subStr.contains("G")) {
                r[k] = 3;
            } else {
                r[k] = 4;
            }
        }

        return r;
    }
}

This builds prefix counts for each DNA letter so every query can return the minimum impact factor quickly.

Is Ipv 4 Adress

Mon, 01 Jan 0001 00:00:00 +0000

Java Is Ipv 4 Adress

public class Solution {
    public static boolean isIPv4Address(String inputString) {
        String[] a = inputString.split("\\.", -1);

        for (String v : a) {
            if (v.isEmpty() || v.length() > 3 || !v.matches("\\d+")) {
                return false;
            }
            int num = Integer.parseInt(v);
            if (num > 255 || !String.valueOf(num).equals(v)) {
                return false;
            }
        }

        return a.length == 4;
    }
}

This splits the string by dots and validates each part as a normal IPv4 octet.

Ladder

Mon, 01 Jan 0001 00:00:00 +0000

Java Ladder

import java.util.Arrays;

public class Solution {
    public static int[] ladder(int[] a, int[] b) {
        int size = a.length;
        int[] r = new int[size];
        int maxB = Arrays.stream(b).max().orElse(0);
        int mod = (1 << maxB) - 1;

        int maxA = Arrays.stream(a).max().orElse(0);
        int[] fib = new int[maxA + 2];
        fib[0] = 0;
        fib[1] = 1;
        for (int i = 2; i < maxA + 2; i++) {
            fib[i] = (fib[i - 1] + fib[i - 2]) & mod;
        }

        for (int i = 0; i < size; i++) {
            r[i] = fib[a[i] + 1] & ((1 << b[i]) - 1);
        }

        return r;
    }
}

This precomputes climb counts once and applies the modulo per query, which avoids recalculating the same paths over and over.

Largest String

Mon, 01 Jan 0001 00:00:00 +0000

Java Largest String

public class Solution {
    public static String largestString(String s) {
        char[] chars = s.toCharArray();
        int len = chars.length;
        StringBuilder cur = new StringBuilder();

        for (int i = len - 1; i >= 0; i--) {
            cur.insert(0, chars[i]);

            if (cur.length() == 3) {
                if (cur.toString().equals("abb")) {
                    chars[i] = 'b';
                    chars[i + 1] = 'a';
                    chars[i + 2] = 'a';
                    if (i + 4 < len && chars[i + 4] == 'b') {
                        i += 4 + 1;
                    } else if (i + 3 < len && chars[i + 3] == 'b') {
                        i += 3 + 1;
                    } else if (chars[i + 2] == 'b') {
                        i += 2 + 1;
                    }
                }
                if (chars[i + 1] == 'b') {
                    i += 1 + 1;
                } else {
                    ++i;
                }
                cur.setLength(0);
            }
        }

        return new String(chars);
    }
}

This builds the biggest valid string it can under the challenge rules by always choosing the best next character it is allowed to use.

Max Counters

Mon, 01 Jan 0001 00:00:00 +0000

Java Max Counters

public class Solution {
    public static int[] maxCounters(int n, int[] a) {
        int[] counters = new int[n];
        int maxCounter = 0;
        int lastUpdate = 0;
        int condition = n + 1;

        for (int v : a) {
            if (v <= n) {
                int index = v - 1;
                if (counters[index] < lastUpdate) {
                    counters[index] = lastUpdate;
                }
                counters[index]++;
                maxCounter = Math.max(counters[index], maxCounter);
            }
            if (v == condition) {
                lastUpdate = maxCounter;
            }
        }

        for (int k = 0; k < counters.length; k++) {
            if (counters[k] < lastUpdate) {
                counters[k] = lastUpdate;
            }
        }

        return counters;
    }
}

This delays the expensive “set all counters to max” work until it is really needed, which keeps the solution fast.

Max Double Slice Sum

Mon, 01 Jan 0001 00:00:00 +0000

Java Max Double Slice Sum

public class Solution {
    public static int maxDoubleSliceSum(int[] a) {
        int size = a.length;
        if (size < 3) {
            return 0;
        }

        int[] p1 = new int[size];
        int[] p2 = new int[size];
        p1[1] = 0;
        p2[size - 2] = 0;

        for (int i = 2; i < size - 1; i++) {
            p1[i] = Math.max(0, p1[i - 1] + a[i - 1]);
            p2[size - i - 1] = Math.max(0, p2[size - i] + a[size - i]);
        }

        int sum = p1[1] + p2[1];
        for (int i = 1; i < size - 1; i++) {
            sum = Math.max(sum, p1[i] + p2[i]);
        }

        return sum;
    }
}

This keeps the best sum ending on the left and starting on the right, then combines them around each middle position.

Max Product Of Three

Mon, 01 Jan 0001 00:00:00 +0000

Java Max Product Of Three

import java.util.Arrays;

public class Solution {
    public static long maxProductOfThree(int[] a) {
        int[] sorted = a.clone();
        Arrays.sort(sorted);
        int c = sorted.length;

        long p1 = (long) sorted[c - 1] * sorted[c - 2] * sorted[c - 3];
        long p2 = (long) sorted[0] * sorted[1] * sorted[c - 1];

        return Math.max(p1, p2);
    }
}

This checks the useful extremes, because the best product can come from either the three largest numbers or two negatives plus one large positive.

Max Profit

Mon, 01 Jan 0001 00:00:00 +0000

Java Max Profit

public class Solution {
    public static int maxProfit(int[] a) {
        int price = a[0];
        int profit = 0;

        for (int v : a) {
            price = Math.min(price, v);
            profit = Math.max(profit, v - price);
        }

        return profit;
    }
}

This tracks the lowest buy price seen so far and updates the best profit as it scans the prices once.

Max Slice Sum

Mon, 01 Jan 0001 00:00:00 +0000

Java Max Slice Sum

public class Solution {
    public static int maxSliceSum(int[] a) {
        long tmp = Long.MIN_VALUE;
        long max = Long.MIN_VALUE;

        for (int v : a) {
            tmp = Math.max(tmp + v, v);
            max = Math.max(max, tmp);
        }

        return (int) max;
    }
}

This is a Kadane-style scan: keep the best running sum and the best overall sum while moving once through the array.

Min Avg Two Slice

Mon, 01 Jan 0001 00:00:00 +0000

Java Min Avg Two Slice

public class Solution {
    public static int minAvgTwoSlice(int[] a) {
        int idx = 0;
        double min = (a[0] + a[1]) / 2.0;

        for (int i = 0; i < a.length - 1; i++) {
            double cur = (a[i] + a[i + 1]) / 2.0;
            if (i + 2 < a.length) {
                double three = (a[i] + a[i + 1] + a[i + 2]) / 3.0;
                cur = Math.min(cur, three);
            }
            if (cur < min) {
                min = cur;
                idx = i;
            }
        }

        return idx;
    }
}

This leans on the key trick for this problem: the minimum average slice is always length 2 or 3.

Min Perimeter Rectangle

Mon, 01 Jan 0001 00:00:00 +0000

Java Min Perimeter Rectangle

public class Solution {
    public static int minPerimeterRectangle(int n) {
        long i = 1;
        long min = Long.MAX_VALUE;

        while (i * i < n) {
            if (n % i == 0) {
                min = Math.min(min, 2 * (i + n / i));
            }
            i++;
        }

        return (int) min;
    }
}

This searches factor pairs up to the square root and picks the pair with the smallest perimeter.

Missing Integer

Mon, 01 Jan 0001 00:00:00 +0000

Java Missing Integer

import java.util.Arrays;

public class Solution {
    public static int missingInteger(int[] a) {
        int min = 1;
        int[] sorted = Arrays.stream(a).distinct().sorted().toArray();

        for (int v : sorted) {
            if (v > 0) {
                if (min != v) {
                    break;
                }
                min++;
            }
        }

        return min;
    }
}

This records the positive numbers that exist, then returns the smallest positive value that is still missing.

Nesting

Mon, 01 Jan 0001 00:00:00 +0000

Java Nesting

import java.util.ArrayDeque;
import java.util.Deque;

public class Solution {
    public static int nesting(String s) {
        if (s.isEmpty()) {
            return 1;
        }

        Deque<Character> stack = new ArrayDeque<>();
        for (char v : s.toCharArray()) {
            if (v == ')') {
                if (stack.isEmpty() || stack.pop() != '(') {
                    return 0;
                }
            } else {
                stack.push(v);
            }
        }

        return stack.isEmpty() ? 1 : 0;
    }
}

This treats the string like a balance counter: open parentheses add one, closing ones remove one.

Number Of Disc Intersections

Mon, 01 Jan 0001 00:00:00 +0000

Java Number Of Disc Intersections

public class Solution {
    public static int numberOfDiscIntersections(int[] a) {
        int c = a.length;
        long sum = 0;
        long active = 0;
        int[] start = new int[c];
        int[] end = new int[c];

        for (int k = 0; k < c; k++) {
            long v = a[k];
            int key = (k < v) ? 0 : (int) (k - v);
            start[key]++;

            long endKey = (k + v >= c) ? c - 1 : k + v;
            end[(int) endKey]++;
        }

        for (int k = 0; k < c; k++) {
            sum += active * start[k] + (long) start[k] * (start[k] - 1) / 2;
            active += start[k] - end[k];
            if (sum > 10000000) {
                return -1;
            }
        }

        return (int) sum;
    }
}

This sorts disc start and end points and counts active overlaps without comparing every pair directly.

Odd Occurrences In Array

Mon, 01 Jan 0001 00:00:00 +0000

Java Odd Occurrences In Array

import java.util.LinkedHashMap;
import java.util.Map;

public class Solution {
    public static Integer oddOccurrencesInArray(int[] a) {
        Map<Integer, Integer> count = new LinkedHashMap<>();

        for (int value : a) {
            if (!count.containsKey(value)) {
                count.put(value, 1);
            } else {
                count.remove(value);
            }
        }

        for (Integer key : count.keySet()) {
            return key;
        }

        return null;
    }
}

This uses XOR to cancel out pairs, leaving only the value that appears an odd number of times.

Palindrome Rearranging

Mon, 01 Jan 0001 00:00:00 +0000

Java Palindrome Rearranging

import java.util.HashMap;
import java.util.Map;

public class Solution {
    public static boolean palindromeRearranging(String inputString) {
        Map<Character, Integer> counts = new HashMap<>();
        for (char c : inputString.toCharArray()) {
            counts.merge(c, 1, Integer::sum);
        }

        int oddCount = 0;
        for (int v : counts.values()) {
            if (v % 2 != 0) {
                oddCount++;
            }
        }

        return oddCount <= 1;
    }
}

This counts character frequency and checks whether the string has the right number of odd counts to form a palindrome.

Passing Cars

Mon, 01 Jan 0001 00:00:00 +0000

Java Passing Cars

public class Solution {
    public static int passingCars(int[] a) {
        long passingCars = 0;
        int multiply = 0;

        for (int i : a) {
            if (i == 0) {
                multiply++;
            } else if (multiply > 0) {
                passingCars += multiply;
                if (passingCars > 1000000000) {
                    return -1;
                }
            }
        }

        return (int) passingCars;
    }
}

This counts eastbound cars as it scans, then adds them whenever a westbound car appears.

Peaks

Mon, 01 Jan 0001 00:00:00 +0000

Java Peaks

public class Solution {
    public static int peaks(int[] a) {
        int n = a.length;
        if (n <= 2) {
            return 0;
        }

        int[] sum = new int[n];
        int last = -1;
        int dist = 0;
        for (int i = 1; i + 1 < n; ++i) {
            sum[i] = sum[i - 1];
            if (a[i] > a[i - 1] && a[i] > a[i + 1]) {
                dist = Math.max(dist, i - last);
                last = i;
                ++sum[i];
            }
        }

        sum[n - 1] = sum[n - 2];
        if (sum[n - 1] == 0) {
            return 0;
        }
        dist = Math.max(dist, n - last);

        int j = 0;
        for (int i = (dist >> 1) + 1; i < dist; ++i) {
            if (n % i == 0) {
                last = 0;
                for (j = i; j <= n; j += i) {
                    if (sum[j - 1] <= last) {
                        break;
                    }
                    last = sum[j - 1];
                }
                if (j > n) {
                    return n / i;
                }
            }
        }

        for (last = dist; n % last != 0; ) {
            ++last;
        }

        return n / last;
    }
}

This finds the peak positions, then tests how many equal blocks can each contain at least one peak.

Perm Check

Mon, 01 Jan 0001 00:00:00 +0000

Java Perm Check

import java.util.Arrays;

public class Solution {
    public static int permCheck(int[] a) {
        int[] sorted = a.clone();
        Arrays.sort(sorted);

        for (int k = 0; k < sorted.length - 1; k++) {
            if (sorted[k] != k + 1) {
                return 0;
            }
        }

        return 1;
    }
}

This validates that every value from 1 to N appears exactly once.

Perm Missing Element

Mon, 01 Jan 0001 00:00:00 +0000

Java Perm Missing Element

import java.util.Arrays;

public class Solution {
    public static int permMissingElement(int[] a) {
        int[] sorted = a.clone();
        Arrays.sort(sorted);

        for (int k = 0; k < sorted.length; k++) {
            if (sorted[k] != k + 1) {
                return k + 1;
            }
        }

        return sorted.length + 1;
    }
}

This uses the expected sum of 1..N+1 and subtracts the actual sum to find the missing value.

Plagiarism Check

Mon, 01 Jan 0001 00:00:00 +0000

Java Plagiarism Check

import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Solution {
    public static boolean plagiarismCheck(String[] code1, String[] code2) {
        String c1 = String.join(" ", code1);
        String c2 = String.join(" ", code2);
        if (c1.equals(c2)) {
            return false;
        }

        List<String> d1 = new ArrayList<>();
        List<String> d2 = new ArrayList<>();
        Matcher m1 = Pattern.compile("\\w+").matcher(c1);
        while (m1.find()) {
            d1.add(m1.group());
        }
        Matcher m2 = Pattern.compile("\\w+").matcher(c2);
        while (m2.find()) {
            d2.add(m2.group());
        }

        Map<String, String> rCand = new LinkedHashMap<>();
        for (int k = 0; k < d1.size(); k++) {
            String v = d1.get(k);
            if (!v.equals(d2.get(k)) && !v.matches("\\d+")) {
                rCand.put(v, d2.get(k));
            }
        }

        for (Map.Entry<String, String> e : rCand.entrySet()) {
            String orig = e.getKey();
            c1 = c1.replaceAll("(\\W)" + orig + "(\\W*)", "$1PLACEHOLDER" + orig + "$2");
            c1 = c1.replaceAll("(\\W)" + orig, "$1PLACEHOLDER" + orig);
        }

        for (Map.Entry<String, String> e : rCand.entrySet()) {
            String orig = e.getKey();
            String repl = e.getValue();
            c1 = c1.replaceAll("(\\W)PLACEHOLDER" + orig + "(\\W)", "$1" + repl + "$2");
            c1 = c1.replaceAll("(\\W)PLACEHOLDER" + orig, "$1" + repl);
        }

        return c1.equals(c2);
    }
}

This flattens both snippets, tries consistent identifier replacements, and checks whether the rewritten code matches.

Shape Area

Mon, 01 Jan 0001 00:00:00 +0000

Java Shape Area

public class Solution {
    public static long shapeArea(int n) {
        return n > 1 ? shapeArea(n - 1) + 4L * (n - 1) : 1;
    }
}

This returns the area of the growing n-interesting polygon using the direct formula instead of building the shape.

Stone Blocks

Mon, 01 Jan 0001 00:00:00 +0000

Java Stone Blocks

public class Solution {
    public static int stoneBlocks(int[] h) {
        int[] height = new int[h.length];
        int index = 0;
        int blocks = 0;

        for (int i : h) {
            while (index > 0 && height[index - 1] > i) {
                index--;
            }
            if (index > 0 && height[index - 1] == i) {
                continue;
            }

            height[index] = i;
            blocks++;
            index++;
        }

        return blocks;
    }
}

This uses a stack of active heights and only counts a new block when the wall needs a new height segment.

Tape Equilibrium

Mon, 01 Jan 0001 00:00:00 +0000

Java Tape Equilibrium

public class Solution {
    public static int tapeEquilibrium(int[] a) {
        long firstPart = 0;
        long secondPart = 0;
        for (int v : a) {
            secondPart += v;
        }

        long min = Long.MAX_VALUE;
        for (int i = 0; i < a.length - 1; i++) {
            firstPart += i;
            secondPart -= i;
            long difference = Math.abs(firstPart - secondPart);
            min = Math.min(min, difference);
        }

        return (int) min;
    }
}

This keeps left and right running sums and updates the smallest difference at each split point.

Triangle

Mon, 01 Jan 0001 00:00:00 +0000

Java Triangle

import java.util.Arrays;

public class Solution {
    public static int triangle(int[] a) {
        int[] sorted = a.clone();
        Arrays.sort(sorted);
        int c = sorted.length;
        if (c < 3) {
            return 0;
        }

        for (int i = 0; i < c - 2; i++) {
            if (sorted[i] > 0 && sorted[i] > (long) sorted[i + 2] - sorted[i + 1]) {
                return 1;
            }
        }

        return 0;
    }
}

This sorts the values and checks nearby triples, because a valid triangle only needs one local match after sorting.