Practice Code Examples

static boolean isPrime(int n) {
    if (n < 2) return false;
    for (int i = 2; i <= Math.sqrt(n); i++)
        if (n % i == 0) return false;
    return true;
}
isPrime(17);   // true

static long factorial(int n) {
    return n <= 1 ? 1 : n * factorial(n - 1);
}
factorial(5);   // 120

int a = 0, b = 1;
for (int i = 0; i < 8; i++) {
    System.out.print(a + " ");   // 0 1 1 2 3 5 8 13
    int next = a + b; a = b; b = next;
}

String reversed = new StringBuilder("hello").reverse().toString();
System.out.println(reversed);   // "olleh"

static boolean isPalindrome(String s) {
    String c = s.toLowerCase().replaceAll("[^a-z0-9]", "");
    return c.equals(new StringBuilder(c).reverse().toString());
}
isPalindrome("Race car");   // true

int a = 5, b = 10;
a = a + b;   // 15
b = a - b;   // 5
a = a - b;   // 10

static double toFahrenheit(double c) { return c * 9 / 5 + 32; }
toFahrenheit(100);   // 212.0

static boolean isEven(int n) { return n % 2 == 0; }
isEven(7);   // false

static boolean isLeap(int y) {
    return (y % 4 == 0 && y % 100 != 0) || y % 400 == 0;
}
isLeap(2024);   // true

static int sumUpTo(int n) { return n * (n + 1) / 2; }
sumUpTo(100);   // 5050

static int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
static int lcm(int a, int b) { return a / gcd(a, b) * b; }
gcd(36, 60);   // 12

int n = 5;
for (int i = 1; i <= 10; i++)
    System.out.println(n + " x " + i + " = " + (n * i));

Integer.toBinaryString(42);   // "101010"
Integer.toHexString(42);      // "2a"
Integer.parseInt("2a", 16);   // 42

static double calc(double a, char op, double b) {
    return switch (op) {
        case '+' -> a + b; case '-' -> a - b;
        case '*' -> a * b; case '/' -> a / b;
        default -> throw new IllegalArgumentException("bad op");
    };
}
calc(6, '*', 7);   // 42.0

for (int i = 1; i <= 15; i++) {
    if (i % 15 == 0) System.out.println("FizzBuzz");
    else if (i % 3 == 0) System.out.println("Fizz");
    else if (i % 5 == 0) System.out.println("Buzz");
    else System.out.println(i);
}

static long countVowels(String s) {
    return s.toLowerCase().chars()
        .filter(c -> "aeiou".indexOf(c) >= 0).count();
}
countVowels("Java");   // 2

int max = Math.max(a, Math.max(b, c));

static int digitSum(int n) {
    int sum = 0;
    while (n > 0) { sum += n % 10; n /= 10; }
    return sum;
}
digitSum(1234);   // 10

String s = "the quick brown fox";
int words = s.trim().split("\\s+").length;   // 4

static long power(int base, int exp) {
    long r = 1;
    for (int i = 0; i < exp; i++) r *= base;
    return r;
}
power(2, 10);   // 1024

static int binarySearch(int[] a, int target) {
    int lo = 0, hi = a.length - 1;
    while (lo <= hi) {
        int mid = (lo + hi) >>> 1;
        if (a[mid] == target) return mid;
        if (a[mid] < target) lo = mid + 1; else hi = mid - 1;
    }
    return -1;
}

static void bubbleSort(int[] a) {
    for (int i = 0; i < a.length; i++)
        for (int j = 0; j < a.length - i - 1; j++)
            if (a[j] > a[j + 1]) {
                int t = a[j]; a[j] = a[j + 1]; a[j + 1] = t;
            }
}

Map<String, Integer> freq = new HashMap<>();
for (String w : "the cat and the dog".split(" "))
    freq.merge(w, 1, Integer::sum);
// {the=2, cat=1, and=1, dog=1}

int[] a = {4, 9, 2, 7};
int sum = Arrays.stream(a).sum();       // 22
int max = Arrays.stream(a).max().getAsInt();   // 9

static int[] rotate(int[] a, int k) {
    int n = a.length; k %= n;
    int[] r = new int[n];
    for (int i = 0; i < n; i++) r[(i + k) % n] = a[i];
    return r;
}

List<Integer> unique = new ArrayList<>(
    new LinkedHashSet<>(List.of(1, 2, 2, 3, 3)));   // [1, 2, 3]

int second = Arrays.stream(new int[]{5, 9, 9, 3})
    .distinct().boxed()
    .sorted(Comparator.reverseOrder())
    .skip(1).findFirst().get();   // 5

static boolean isAnagram(String a, String b) {
    char[] x = a.toCharArray(), y = b.toCharArray();
    Arrays.sort(x); Arrays.sort(y);
    return Arrays.equals(x, y);
}
isAnagram("listen", "silent");   // true

String title = Arrays.stream("the quick fox".split(" "))
    .map(w -> Character.toUpperCase(w.charAt(0)) + w.substring(1))
    .collect(Collectors.joining(" "));   // "The Quick Fox"

Map<Integer, List<String>> byLen =
    Stream.of("a", "bb", "cc", "d")
        .collect(Collectors.groupingBy(String::length));
// {1=[a, d], 2=[bb, cc]}

static int missing(int[] a, int n) {
    int expected = n * (n + 1) / 2;
    return expected - Arrays.stream(a).sum();
}
missing(new int[]{1, 2, 4, 5}, 5);   // 3

static int[] merge(int[] a, int[] b) {
    int[] r = new int[a.length + b.length];
    int i = 0, j = 0, k = 0;
    while (i < a.length && j < b.length)
        r[k++] = a[i] < b[j] ? a[i++] : b[j++];
    while (i < a.length) r[k++] = a[i++];
    while (j < b.length) r[k++] = b[j++];
    return r;
}

static int reverse(int n) {
    int r = 0;
    while (n != 0) { r = r * 10 + n % 10; n /= 10; }
    return r;
}
reverse(1234);   // 4321

static int[] twoSum(int[] a, int target) {
    Map<Integer, Integer> seen = new HashMap<>();
    for (int i = 0; i < a.length; i++) {
        int need = target - a[i];
        if (seen.containsKey(need)) return new int[]{seen.get(need), i};
        seen.put(a[i], i);
    }
    return new int[0];
}

static Map<Integer, Long> memo = new HashMap<>();
static long fib(int n) {
    if (n <= 1) return n;
    return memo.computeIfAbsent(n, k -> fib(k - 1) + fib(k - 2));
}

static void mergeSort(int[] a, int lo, int hi) {
    if (lo >= hi) return;
    int mid = (lo + hi) >>> 1;
    mergeSort(a, lo, mid);
    mergeSort(a, mid + 1, hi);
    int[] tmp = new int[hi - lo + 1];
    int i = lo, j = mid + 1, k = 0;
    while (i <= mid && j <= hi) tmp[k++] = a[i] <= a[j] ? a[i++] : a[j++];
    while (i <= mid) tmp[k++] = a[i++];
    while (j <= hi) tmp[k++] = a[j++];
    System.arraycopy(tmp, 0, a, lo, tmp.length);
}

static void quickSort(int[] a, int lo, int hi) {
    if (lo >= hi) return;
    int pivot = a[hi], i = lo - 1;
    for (int j = lo; j < hi; j++)
        if (a[j] < pivot) { i++; int t = a[i]; a[i] = a[j]; a[j] = t; }
    int t = a[i + 1]; a[i + 1] = a[hi]; a[hi] = t;
    quickSort(a, lo, i);
    quickSort(a, i + 2, hi);
}

class Stack<T> {
    private List<T> items = new ArrayList<>();
    void push(T x) { items.add(x); }
    T pop() {
        if (items.isEmpty()) throw new RuntimeException("empty");
        return items.remove(items.size() - 1);
    }
    boolean isEmpty() { return items.isEmpty(); }
}

class Account {
    private double balance;
    void deposit(double amt) {
        if (amt <= 0) throw new IllegalArgumentException("bad amount");
        balance += amt;
    }
    void withdraw(double amt) {
        if (amt > balance) throw new IllegalStateException("insufficient funds");
        balance -= amt;
    }
    double getBalance() { return balance; }
}

import java.util.concurrent.atomic.*;

AtomicInteger counter = new AtomicInteger(0);
List<Thread> threads = new ArrayList<>();
for (int i = 0; i < 4; i++) {
    Thread t = new Thread(() -> {
        for (int j = 0; j < 1000; j++) counter.incrementAndGet();
    });
    threads.add(t); t.start();
}
for (Thread t : threads) t.join();
counter.get();   // 4000 — always correct, no lost updates