Arrays in Java
Complete Deep Dive

public class ArrayCreation {
    public static void main(String[] args) {

        // ── WAY 1: new keyword se allocate, phir values assign ──
        // Default values automatically set hoti hain (int = 0)
        // Use karo: jab size pehle se pata ho lekin values baad mein milenge
        int[] arr1 = new int[5];
        arr1[0] = 10;  arr1[1] = 20;  arr1[2] = 30;
        arr1[3] = 40;  arr1[4] = 50;

        // ── WAY 2: Initializer syntax — direct values ──
        // Size automatically calculate hoti hai (yahan 5)
        // Use karo: jab values pehle se pata hain
        int[] arr2 = {10, 20, 30, 40, 50};

        // ── WAY 3: new keyword + values ──
        // Method return karne ke liye ya anonymous array ke liye
        // Use karo: kisi method ko directly array pass karna ho
        int[] arr3 = new int[]{100, 200, 300};

        // .length — PROPERTY hai, method nahi (isliye parentheses nahi)
        System.out.println("arr1 length: " + arr1.length);  // 5
        System.out.println("arr2 length: " + arr2.length);  // 5
        System.out.println("arr3 length: " + arr3.length);  // 3

        // First aur Last element access karna
        System.out.println("First: " + arr2[0]);                 // index 0
        System.out.println("Last:  " + arr2[arr2.length - 1]);   // index 4

        // Anonymous array — seedha method mein pass karo
        printSum(new int[]{5, 10, 15, 20});
    }

    static void printSum(int[] arr) {
        int sum = 0;
        for (int n : arr) sum += n;
        System.out.println("Sum of anonymous array: " + sum);
    }
}

public class CallByReference {

    // Ye method original array ko MODIFY karta hai
    static void doubleAll(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            arr[i] *= 2;  // same memory location pe write kar raha hai
        }
    }

    // Ye method naya array return karta hai (safe way)
    static int[] createSquares(int n) {
        int[] result = new int[n];  // naya array heap pe create hoga
        for (int i = 0; i < n; i++) {
            result[i] = (i + 1) * (i + 1);
        }
        return result;  // reference return hoga, copy nahi
    }

    public static void main(String[] args) {
        int[] nums = {1, 2, 3, 4, 5};

        System.out.print("Before doubleAll: ");
        for (int n : nums) System.out.print(n + " ");

        doubleAll(nums);  // nums ka reference pass hua, copy nahi

        System.out.print("\nAfter doubleAll:  ");
        for (int n : nums) System.out.print(n + " ");
        System.out.println("\n← Original array change ho gaya!");

        int[] sq = createSquares(5);
        System.out.print("\nSquares: ");
        for (int s : sq) System.out.print(s + " ");
    }
}

import java.util.Arrays;

public class ShallowVsDeep {
    public static void main(String[] args) {
        int[] original = {1, 2, 3, 4, 5};

        // ── SHALLOW COPY (= operator) ──
        // Dono variables SAME memory location point karte hain!
        int[] shallow = original;       // sirf reference copy hua
        shallow[0] = 999;               // yahan change karo...
        System.out.println("Shallow ne change kiya, original[0] = "
            + original[0]);             // ...original mein bhi aaya!

        original[0] = 1;  // reset

        // ── DEEP COPY Way 1: Manual loop ──
        // Most explicit, sabko clear pata chalta hai kya ho raha hai
        int[] deep1 = new int[original.length];
        for (int i = 0; i < original.length; i++) deep1[i] = original[i];

        // ── DEEP COPY Way 2: Arrays.copyOf() ── RECOMMENDED ──
        // Clean, concise, 2nd param = new length (thoda bada bhi kar sakte ho)
        int[] deep2 = Arrays.copyOf(original, original.length);

        // ── DEEP COPY Way 3: System.arraycopy() ──
        // Fastest for large arrays (native implementation)
        // Params: src, srcPos, dest, destPos, length
        int[] deep3 = new int[original.length];
        System.arraycopy(original, 0, deep3, 0, original.length);

        // ── DEEP COPY Way 4: clone() ──
        // Simple, but only works for 1D arrays (2D ke liye kaam nahi karta)
        int[] deep4 = original.clone();

        // Verify: deep copy se original change nahi hota
        deep2[0] = -100;
        System.out.println("deep2[0] = " + deep2[0]);
        System.out.println("original[0] after deep2 change = " + original[0]); // unchanged!

        System.out.println("Arrays.equals(original, deep3): "
            + Arrays.equals(original, deep3));  // true — same contents
        System.out.println("original == deep3: "
            + (original == deep3));             // false — different objects
    }
}

public class BoundaryHandling {
    public static void main(String[] args) {
        int[] arr = {10, 20, 30, 40, 50};  // length = 5, valid: 0 to 4

        // ✅ Safe access — boundary check ke baad
        int index = 3;
        if (index >= 0 && index < arr.length) {
            System.out.println("Safe access: arr[" + index + "] = " + arr[index]);
        }

        // ✅ Try-catch se exception handle karna
        try {
            System.out.println(arr[10]);  // invalid index!
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("Exception caught: " + e.getMessage());
        }

        // ✅ Negative index bhi exception deta hai
        try {
            System.out.println(arr[-1]);  // negative index!
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("Negative index caught: " + e.getMessage());
        }

        // ✅ Safe last element access
        System.out.println("Last element: " + arr[arr.length - 1]);  // ALWAYS safe

        // ✅ NullPointerException handle karna
        int[] nullArr = null;
        try {
            System.out.println(nullArr.length);
        } catch (NullPointerException e) {
            System.out.println("NullPointerException: array is null!");
        }
    }
}

public class AllDeclarationStyles {
    public static void main(String[] args) {

        // ── Modern Style (PREFERRED) — brackets type ke saath ──
        int[]     intArr  = new int[4];
        double[]  dblArr  = new double[3];
        boolean[] boolArr = new boolean[2];
        char[]    charArr = new char[5];
        String[]  strArr  = new String[3];
        long[]    longArr = new long[3];

        // ── Old C-style (AVOID) — bracket variable ke saath ──
        int oldStyle[] = new int[3];  // valid but not Java convention

        // ── Ek line mein declare + allocate + initialize ──
        int[]    primes = {2, 3, 5, 7, 11, 13};
        String[] fruits = {"Apple", "Mango", "Banana", "Orange"};
        double[] marks  = {85.5, 92.0, 78.3, 96.7};
        char[]   vowels = {'a', 'e', 'i', 'o', 'u'};

        // ── Declaration alag, use alag ──
        int[] delayed;             // sirf reference, abhi null
        delayed = new int[3];     // baad mein allocate
        delayed[0] = 100;

        // ── Sab lengths print karo ──
        System.out.println("primes.length = " + primes.length);
        System.out.println("fruits.length = " + fruits.length);
        System.out.println("vowels.length = " + vowels.length);
        System.out.println("marks.length  = " + marks.length);

        // ── String array access ──
        System.out.println("First fruit: "  + fruits[0]);
        System.out.println("Last fruit:  "  + fruits[fruits.length - 1]);
        System.out.println("Fruit length: " + fruits[1].length());  // "Mango".length()

        // ── Zero size array ──
        int[] empty = new int[0];
        System.out.println("Empty array length: " + empty.length);  // 0, no exception
    }
}

import java.util.Scanner;

public class DynamicArrayInput {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        System.out.print("Kitne students hain? ");
        int n = sc.nextInt();

        // Runtime pe size decide hota hai — n compile time pe pata nahi tha
        String[] names = new String[n];
        int[]    marks = new int[n];

        for (int i = 0; i < n; i++) {
            System.out.print("Student " + (i+1) + " ka naam: ");
            names[i] = sc.next();
            System.out.print("Marks (0-100): ");
            marks[i] = sc.nextInt();
        }

        // Stats nikalo
        int sum = 0, maxIdx = 0, minIdx = 0, passCount = 0;
        for (int i = 0; i < n; i++) {
            sum += marks[i];
            if (marks[i] > marks[maxIdx]) maxIdx = i;
            if (marks[i] < marks[minIdx]) minIdx = i;
            if (marks[i] >= 35) passCount++;
        }

        System.out.println("\n── RESULT SUMMARY ──");
        System.out.printf("Class Average: %.2f%n", (double) sum / n);
        System.out.println("Topper: " + names[maxIdx] + " (" + marks[maxIdx] + ")");
        System.out.println("Lowest: " + names[minIdx] + " (" + marks[minIdx] + ")");
        System.out.println("Pass: " + passCount + ", Fail: " + (n - passCount));
        sc.close();
    }
}

import java.util.Arrays;

public class CharArrayOps {
    public static void main(String[] args) {
        String word = "programming";

        // String → char[]
        char[] chars = word.toCharArray();
        System.out.println("char array: " + Arrays.toString(chars));

        // char[] → String
        String back = new String(chars);
        System.out.println("Back to String: " + back);

        // Palindrome check karo
        String test = "madam";
        char[] t = test.toCharArray();
        boolean isPalin = true;
        for (int i = 0; i < t.length / 2; i++) {
            if (t[i] != t[t.length - 1 - i]) { isPalin = false; break; }
        }
        System.out.println("\"" + test + "\" is palindrome: " + isPalin);

        // Character frequency count karo
        int[] freq = new int[26];  // a-z ke liye
        for (char c : word.toCharArray()) freq[c - 'a']++;
        System.out.println("\nFrequency in \"" + word + "\":");
        for (int i = 0; i < 26; i++) {
            if (freq[i] > 0)
                System.out.println("  " + (char)('a' + i) + ": " + freq[i]);
        }
    }
}

public class DefaultValues {
    public static void main(String[] args) {

        int[]     intArr  = new int[3];
        double[]  dblArr  = new double[3];
        boolean[] boolArr = new boolean[3];
        char[]    charArr = new char[3];
        String[]  strArr  = new String[3];
        long[]    longArr = new long[3];

        System.out.println("Type      Default");
        System.out.println("──────────────────");
        System.out.println("int:      " + intArr[0]);
        System.out.println("double:   " + dblArr[0]);
        System.out.println("boolean:  " + boolArr[0]);
        System.out.println("char:     '" + charArr[0] + "' (null char = '" + (int)charArr[0] + "')");
        System.out.println("String:   " + strArr[0]);
        System.out.println("long:     " + longArr[0]);

        // ── Null Safety Patterns ──
        System.out.println("\n── Null Safety Patterns ──");

        // Pattern 1: null check before using
        for (int i = 0; i < strArr.length; i++) {
            if (strArr[i] != null) {
                System.out.println(strArr[i].toUpperCase());
            } else {
                System.out.println("[index " + i + " is null]");
            }
        }

        // Pattern 2: Initialize with default value before use
        String[] names = new String[3];
        for (int i = 0; i < names.length; i++) names[i] = "Unknown";
        System.out.println("Pre-initialized: " + names[0]); // "Unknown", not null

        // ── Is int[] array auto-initialized? ──
        // Ye confirm karo: frequency count correctly kaam karega
        int[] freq = new int[10];  // sab 0 hain
        freq[3]++;  freq[7]++;  freq[3]++;
        System.out.println("\nFreq[3] = " + freq[3] + ", Freq[7] = " + freq[7]);
    }
}

public class AllLoopTypes {
    public static void main(String[] args) {
        int[] arr = {10, 20, 30, 40, 50};

        // ── 1. for loop (index-based) ──
        // Best: modification, specific range, index chahiye
        System.out.print("for loop:      ");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
        System.out.println("  | i goes 0 to " + (arr.length-1));

        // ── 2. for-each ──
        // Best: read-only traversal, cleanest syntax
        System.out.print("for-each:      ");
        for (int val : arr) {
            System.out.print(val + " ");
        }
        System.out.println("  | No index available");

        // ── 3. while loop ──
        // Best: condition runtime pe decide ho
        System.out.print("while loop:    ");
        int i = 0;
        while (i < arr.length) {
            System.out.print(arr[i] + " ");
            i++;
        }
        System.out.println("  | i manually manage karo");

        // ── 4. do-while ──
        // At least ek baar chalega, even if condition false ho
        System.out.print("do-while:      ");
        int j = 0;
        do {
            System.out.print(arr[j] + " ");
            j++;
        } while (j < arr.length);
        System.out.println("  | Body pehle, condition baad");

        // ── 5. Reverse traversal ──
        System.out.print("Reverse:       ");
        for (int k = arr.length - 1; k >= 0; k--) {
            System.out.print(arr[k] + " ");
        }
        System.out.println();

        // ── 6. Step-by-2 ──
        System.out.print("Step by 2:     ");
        for (int k = 0; k < arr.length; k += 2) {
            System.out.print(arr[k] + " ");
        }
        System.out.println("  | Only even indices");
    }
}

public class ArrayStatistics {
    public static void main(String[] args) {
        int[] nums = {5, 12, 3, 8, 17, 24, 9, 6, 15, 2, 11, 19};

        // Single pass mein sab calculate karo — O(n)
        int    sum = 0, max = nums[0], min = nums[0];
        int    evenSum = 0, oddSum = 0, evenCnt = 0, oddCnt = 0;
        int    posCount = 0, negCount = 0;
        long   product = 1;

        for (int n : nums) {
            sum     += n;
            product *= n;
            if (n > max) max = n;
            if (n < min) min = n;
            if (n % 2 == 0) { evenSum += n; evenCnt++; }
            else             { oddSum  += n; oddCnt++;  }
            if (n > 0) posCount++; else if (n < 0) negCount++;
        }

        int n = nums.length;
        System.out.println("Array size:     " + n);
        System.out.println("Sum:            " + sum);
        System.out.printf( "Average:        %.2f%n", (double) sum / n);
        System.out.println("Max:            " + max);
        System.out.println("Min:            " + min);
        System.out.println("Range (max-min):" + (max - min));
        System.out.println("Even count/sum: " + evenCnt + " / " + evenSum);
        System.out.println("Odd  count/sum: " + oddCnt  + " / " + oddSum);
        System.out.println("Positive count: " + posCount);
    }
}

import java.util.Arrays;

public class ArrayRotation {

    static void leftRotateOne(int[] arr) {
        int first = arr[0];                          // pehla element save karo
        for (int i = 0; i < arr.length - 1; i++)
            arr[i] = arr[i + 1];                     // sab left shift karo
        arr[arr.length - 1] = first;                 // last pe rakh do
    }

    static void rightRotateOne(int[] arr) {
        int last = arr[arr.length - 1];              // aakhri element save
        for (int i = arr.length - 1; i > 0; i--)
            arr[i] = arr[i - 1];                     // sab right shift
        arr[0] = last;                               // pehle pe rakh do
    }

    static void leftRotateByK(int[] arr, int k) {
        k = k % arr.length;  // handle k > length (e.g. rotate by 7 on len 5 = rotate by 2)
        if (k < 0) k += arr.length;  // negative k handle
        for (int i = 0; i < k; i++) leftRotateOne(arr);
    }

    // Efficient rotation using reversal — O(n), O(1) space
    static void reverse(int[] arr, int start, int end) {
        while (start < end) {
            int t = arr[start]; arr[start] = arr[end]; arr[end] = t;
            start++; end--;
        }
    }

    static void leftRotateEfficient(int[] arr, int k) {
        k %= arr.length;
        reverse(arr, 0, k - 1);           // first k reverse
        reverse(arr, k, arr.length - 1);  // rest reverse
        reverse(arr, 0, arr.length - 1);  // whole array reverse
    }

    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5};
        System.out.println("Original:         " + Arrays.toString(arr));

        leftRotateOne(arr);
        System.out.println("Left rotate 1:    " + Arrays.toString(arr));

        arr = new int[]{1, 2, 3, 4, 5};
        rightRotateOne(arr);
        System.out.println("Right rotate 1:   " + Arrays.toString(arr));

        arr = new int[]{1, 2, 3, 4, 5};
        leftRotateByK(arr, 2);
        System.out.println("Left rotate by 2: " + Arrays.toString(arr));

        arr = new int[]{1, 2, 3, 4, 5};
        leftRotateEfficient(arr, 2);
        System.out.println("Efficient rotate 2:" + Arrays.toString(arr));

        arr = new int[]{1, 2, 3, 4, 5};
        leftRotateByK(arr, 7); // 7 % 5 = 2
        System.out.println("Rotate by 7(≡2):  " + Arrays.toString(arr));
    }
}

public class SlidingWindow {
    public static void main(String[] args) {
        int[] arr = {2, 1, 5, 1, 3, 2, 8, 1, 4, 3};
        int k = 3;  // window size

        // ── Brute Force O(n×k) — For comparison ──
        int maxBrute = Integer.MIN_VALUE;
        for (int i = 0; i <= arr.length - k; i++) {
            int winSum = 0;
            for (int j = i; j < i + k; j++) winSum += arr[j];
            if (winSum > maxBrute) maxBrute = winSum;
        }
        System.out.println("Brute Force Max Sum (k=" + k + "): " + maxBrute);

        // ── Sliding Window O(n) — Efficient ──
        // Pehla window calculate karo
        int windowSum = 0;
        for (int i = 0; i < k; i++) windowSum += arr[i];
        int maxSum = windowSum, maxStart = 0;

        // Window slide karo — add new element, remove old
        for (int i = k; i < arr.length; i++) {
            windowSum += arr[i] - arr[i - k];  // add right, remove left
            if (windowSum > maxSum) {
                maxSum = windowSum;
                maxStart = i - k + 1;
            }
        }
        System.out.println("Sliding Window Max Sum: " + maxSum);
        System.out.print("Window: ");
        for (int i = maxStart; i < maxStart + k; i++)
            System.out.print(arr[i] + " ");
    }
}

public class MatrixOperations {

    static void printMatrix(int[][] m, String title) {
        System.out.println("\n── " + title + " ──");
        for (int[] row : m) {
            for (int v : row) System.out.printf("%5d", v);
            System.out.println();
        }
    }

    public static void main(String[] args) {
        int[][] mat = {
            {1, 2, 3, 4},
            {5, 6, 7, 8},
            {9, 10, 11, 12}
        };
        printMatrix(mat, "Original Matrix (3×4)");

        // Row sums
        System.out.println("\nRow Sums:");
        for (int i = 0; i < mat.length; i++) {
            int rowSum = 0;
            for (int j = 0; j < mat[i].length; j++) rowSum += mat[i][j];
            System.out.println("  Row " + i + ": " + rowSum);
        }

        // Column sums
        System.out.println("Column Sums:");
        for (int j = 0; j < mat[0].length; j++) {
            int colSum = 0;
            for (int i = 0; i < mat.length; i++) colSum += mat[i][j];
            System.out.println("  Col " + j + ": " + colSum);
        }

        // Square matrix diagonal sums
        int[][] sq = {{1,2,3},{4,5,6},{7,8,9}};
        int mainDiag = 0, antiDiag = 0, n = sq.length;
        for (int i = 0; i < n; i++) {
            mainDiag += sq[i][i];              // top-left to bottom-right
            antiDiag += sq[i][n - 1 - i];     // top-right to bottom-left
        }
        System.out.println("\nSquare matrix 3×3:");
        System.out.println("  Main Diagonal Sum: " + mainDiag);
        System.out.println("  Anti Diagonal Sum: " + antiDiag);

        // Total sum
        int total = 0;
        for (int[] row : mat) for (int v : row) total += v;
        System.out.println("\nTotal sum of all elements: " + total);
    }
}

public class MatrixMath {

    static int[][] transpose(int[][] mat) {
        int rows = mat.length, cols = mat[0].length;
        int[][] result = new int[cols][rows];
        for (int i = 0; i < rows; i++)
            for (int j = 0; j < cols; j++)
                result[j][i] = mat[i][j];
        return result;
    }

    static int[][] multiply(int[][] A, int[][] B) {
        // A: (r × k), B: (k × c) => Result: (r × c)
        if (A[0].length != B.length) throw new IllegalArgumentException("Invalid dimensions");
        int r = A.length, c = B[0].length, k = B.length;
        int[][] result = new int[r][c];
        for (int i = 0; i < r; i++)
            for (int j = 0; j < c; j++)
                for (int m = 0; m < k; m++)
                    result[i][j] += A[i][m] * B[m][j];
        return result;
    }

    static void print(int[][] mat, String name) {
        System.out.println(name + " (" + mat.length + "×" + mat[0].length + "):");
        for (int[] row : mat) {
            for (int v : row) System.out.printf("%5d", v);
            System.out.println();
        }
    }

    public static void main(String[] args) {
        int[][] A = {{1, 2, 3}, {4, 5, 6}};  // 2×3
        print(A, "A");
        print(transpose(A), "Transpose of A");

        int[][] X = {{1, 2}, {3, 4}};
        int[][] Y = {{5, 6}, {7, 8}};
        print(X, "\nX");
        print(Y, "Y");
        print(multiply(X, Y), "X × Y");
    }
}

public class JaggedAndPascal {
    public static void main(String[] args) {

        // ── Simple Jagged Array ──
        int[][] jagged = new int[4][];  // 4 rows, column size unknown
        jagged[0] = new int[]{10};                  // row 0: 1 element
        jagged[1] = new int[]{20, 21};              // row 1: 2 elements
        jagged[2] = new int[]{30, 31, 32};          // row 2: 3 elements
        jagged[3] = new int[]{40, 41, 42, 43};      // row 3: 4 elements

        System.out.println("Jagged Array:");
        for (int i = 0; i < jagged.length; i++) {
            System.out.printf("  Row %d (len=%d): ", i, jagged[i].length);
            for (int v : jagged[i]) System.out.printf("%4d", v);
            System.out.println();
        }

        // ── Pascal's Triangle ──
        // Row i mein i+1 elements hote hain
        // pascal[i][j] = pascal[i-1][j-1] + pascal[i-1][j]
        // Edges (first aur last) hamesha 1 hote hain
        int rows = 8;
        int[][] pascal = new int[rows][];

        for (int i = 0; i < rows; i++) {
            pascal[i] = new int[i + 1];     // row i mein i+1 elements
            pascal[i][0] = 1;                // first element = 1
            pascal[i][i] = 1;                // last element = 1
            for (int j = 1; j < i; j++) {   // middle elements
                pascal[i][j] = pascal[i-1][j-1] + pascal[i-1][j];
            }
        }

        System.out.println("\nPascal's Triangle:");
        for (int i = 0; i < rows; i++) {
            for (int sp = 0; sp < rows - i; sp++) System.out.print("   ");
            for (int j = 0; j <= i; j++) System.out.printf("%6d", pascal[i][j]);
            System.out.println();
        }
    }
}

import java.util.Arrays;
import java.util.Comparator;

public class ArraysClassDemo {
    public static void main(String[] args) {

        // ── toString() — MUST USE for printing ──
        int[] nums = {5, 3, 8, 1, 9, 2, 7};
        System.out.println("Raw print:    " + nums);               // [I@7c30a502 ← garbage!
        System.out.println("toString:     " + Arrays.toString(nums)); // readable

        // ── sort() — Dual-Pivot Quicksort internally ──
        Arrays.sort(nums);
        System.out.println("After sort:   " + Arrays.toString(nums));

        // ── Partial sort (index 1 to 4) ──
        int[] partial = {9, 5, 3, 7, 1, 8};
        Arrays.sort(partial, 1, 4);  // sirf index 1,2,3 sort hoga
        System.out.println("Partial sort: " + Arrays.toString(partial));

        // ── fill() ──
        int[] filled = new int[6];
        Arrays.fill(filled, 42);
        System.out.println("Filled 42:    " + Arrays.toString(filled));
        Arrays.fill(filled, 2, 5, -1);  // index 2,3,4 = -1
        System.out.println("Partial fill: " + Arrays.toString(filled));

        // ── copyOf() — size badha sakte ya ghata sakte ho ──
        int[] orig = {10, 20, 30};
        int[] bigger = Arrays.copyOf(orig, 6);       // 0s se fill hoga
        int[] smaller = Arrays.copyOf(orig, 2);      // truncate hoga
        int[] range = Arrays.copyOfRange(orig, 1, 3);// index 1 to 2 (3 exclusive)
        System.out.println("Bigger:  "  + Arrays.toString(bigger));
        System.out.println("Smaller: "  + Arrays.toString(smaller));
        System.out.println("Range:   "  + Arrays.toString(range));

        // ── equals() — reference vs content ──
        int[] a = {1, 2, 3}, b = {1, 2, 3}, c = {1, 2, 4};
        System.out.println("a == b:          " + (a == b));            // false (ref compare)
        System.out.println("Arrays.equals:   " + Arrays.equals(a, b)); // true (content)
        System.out.println("Arrays.equals c: " + Arrays.equals(a, c)); // false

        // ── deepToString for 2D ──
        int[][] mat = {{1, 2, 3}, {4, 5, 6}};
        System.out.println("deepToString: " + Arrays.deepToString(mat));

        // ── Descending sort (Integer[] needed, not int[]) ──
        Integer[] desc = {5, 3, 8, 1, 9};
        Arrays.sort(desc, Comparator.reverseOrder());
        System.out.println("Descending:   " + Arrays.toString(desc));
    }
}

import java.util.Arrays;

public class StreamOperations {
    public static void main(String[] args) {
        int[] nums = {3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5};

        // ── Aggregate Operations ──
        System.out.println("Sum:          " + Arrays.stream(nums).sum());
        System.out.printf( "Average:      %.2f%n",
            Arrays.stream(nums).average().getAsDouble());
        System.out.println("Max:          " + Arrays.stream(nums).max().getAsInt());
        System.out.println("Min:          " + Arrays.stream(nums).min().getAsInt());
        System.out.println("Count:        " + Arrays.stream(nums).count());

        // ── Filter ──
        System.out.println("Count > 4:    " + Arrays.stream(nums).filter(n -> n > 4).count());
        int[] evens = Arrays.stream(nums).filter(n -> n % 2 == 0).toArray();
        System.out.println("Evens only:   " + Arrays.toString(evens));

        // ── Map ──
        int[] squared = Arrays.stream(nums).map(n -> n * n).toArray();
        System.out.println("Squared:      " + Arrays.toString(squared));

        // ── Sorted + Distinct ──
        int[] sortedUniq = Arrays.stream(nums).sorted().distinct().toArray();
        System.out.println("Sorted Unique:" + Arrays.toString(sortedUniq));

        // ── anyMatch, allMatch, noneMatch ──
        System.out.println("Any negative: " + Arrays.stream(nums).anyMatch(n -> n < 0));
        System.out.println("All positive: " + Arrays.stream(nums).allMatch(n -> n > 0));

        // ── reduce — custom aggregation ──
        int product = Arrays.stream(nums).reduce(1, (a, b) -> a * b);
        System.out.println("Product:      " + product);
    }
}

import java.util.Arrays;

public class BubbleSort {

    static void bubbleSort(int[] arr) {
        int n = arr.length;
        int passes = 0, comparisons = 0, swaps = 0;

        for (int i = 0; i < n - 1; i++) {
            boolean swapped = false;  // optimization: early exit
            passes++;
            for (int j = 0; j < n - i - 1; j++) {
                comparisons++;
                if (arr[j] > arr[j + 1]) {
                    // Swap
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                    swapped = true;
                    swaps++;
                }
            }
            if (!swapped) break;  // koi swap nahi = already sorted
        }
        System.out.printf("Passes: %d, Comparisons: %d, Swaps: %d%n",
            passes, comparisons, swaps);
    }

    public static void main(String[] args) {
        int[] arr = {64, 25, 12, 22, 11, 90, 47, 36};
        System.out.println("Before: " + Arrays.toString(arr));
        bubbleSort(arr);
        System.out.println("After:  " + Arrays.toString(arr));

        // Already sorted case — O(n)
        int[] sorted = {1, 2, 3, 4, 5};
        System.out.println("\nAlready sorted:");
        bubbleSort(sorted);
    }
}

import java.util.Arrays;

public class SelInsSort {

    static void selectionSort(int[] arr) {
        int n = arr.length;
        for (int i = 0; i < n - 1; i++) {
            int minIdx = i;  // assume i minimum hai
            for (int j = i + 1; j < n; j++) {
                if (arr[j] < arr[minIdx]) minIdx = j;  // actual minimum dhundo
            }
            // Minimum ko sahi jagah pe rakh do
            int temp = arr[minIdx]; arr[minIdx] = arr[i]; arr[i] = temp;
        }
        // Advantage: minimum swaps (n-1 max) — useful jab write ops costly ho
    }

    static void insertionSort(int[] arr) {
        int n = arr.length;
        for (int i = 1; i < n; i++) {
            int key = arr[i];  // current element "haath mein le lo"
            int j = i - 1;
            // Bade elements ko right shift karo jab tak sahi jagah na mile
            while (j >= 0 && arr[j] > key) {
                arr[j + 1] = arr[j];
                j--;
            }
            arr[j + 1] = key;  // "card" sahi jagah rakho
        }
        // Advantage: Nearly sorted data ke liye best O(n), stable sort
    }

    public static void main(String[] args) {
        int[] arr1 = {64, 25, 12, 22, 11};
        int[] arr2 = arr1.clone();

        System.out.println("Original:       " + Arrays.toString(arr1));
        selectionSort(arr1);
        System.out.println("Selection Sort: " + Arrays.toString(arr1));

        insertionSort(arr2);
        System.out.println("Insertion Sort: " + Arrays.toString(arr2));

        // Insertion sort — nearly sorted data advantage
        int[] nearly = {1, 2, 4, 3, 5};  // sirf 3,4 swap out of order
        insertionSort(nearly);
        System.out.println("Nearly sorted:  " + Arrays.toString(nearly));
    }
}

import java.util.Arrays;

public class MergeSort {

    static void merge(int[] arr, int left, int mid, int right) {
        // Do sorted halves ko merge karo
        int[] L = Arrays.copyOfRange(arr, left, mid + 1);
        int[] R = Arrays.copyOfRange(arr, mid + 1, right + 1);

        int i = 0, j = 0, k = left;
        while (i < L.length && j < R.length) {
            if (L[i] <= R[j]) arr[k++] = L[i++];  // <= makes it stable
            else               arr[k++] = R[j++];
        }
        while (i < L.length) arr[k++] = L[i++];  // remaining
        while (j < R.length) arr[k++] = R[j++];
    }

    static void mergeSort(int[] arr, int left, int right) {
        if (left >= right) return;  // base case: 1 element = sorted
        int mid = left + (right - left) / 2;   // overflow-safe midpoint
        mergeSort(arr, left, mid);             // left half sort karo
        mergeSort(arr, mid + 1, right);        // right half sort karo
        merge(arr, left, mid, right);          // dono merge karo
    }

    public static void main(String[] args) {
        int[] arr = {38, 27, 43, 3, 9, 82, 10, 57};
        System.out.println("Before: " + Arrays.toString(arr));
        mergeSort(arr, 0, arr.length - 1);
        System.out.println("After:  " + Arrays.toString(arr));

        // Large array test
        int[] large = {5,1,8,3,9,2,7,4,6,0};
        mergeSort(large, 0, large.length - 1);
        System.out.println("Large:  " + Arrays.toString(large));
    }
}

import java.util.Arrays;

public class QuickSort {

    static int partition(int[] arr, int low, int high) {
        int pivot = arr[high];  // last element pivot hai
        int i = low - 1;        // smaller elements ka boundary

        for (int j = low; j < high; j++) {
            if (arr[j] <= pivot) {
                i++;
                int temp = arr[i]; arr[i] = arr[j]; arr[j] = temp;
            }
        }
        // Pivot ko sahi jagah pe rakho
        int temp = arr[i+1]; arr[i+1] = arr[high]; arr[high] = temp;
        return i + 1;  // pivot ka final index
    }

    static void quickSort(int[] arr, int low, int high) {
        if (low < high) {
            int pivotIdx = partition(arr, low, high);
            quickSort(arr, low, pivotIdx - 1);   // left part
            quickSort(arr, pivotIdx + 1, high);  // right part
        }
    }

    public static void main(String[] args) {
        int[] arr = {10, 7, 8, 9, 1, 5, 3};
        System.out.println("Before: " + Arrays.toString(arr));
        quickSort(arr, 0, arr.length - 1);
        System.out.println("After:  " + Arrays.toString(arr));
    }
}

import java.util.Arrays;

public class BinarySearch {

    // Iterative — PREFERRED (no stack overhead)
    static int binarySearchIter(int[] arr, int target) {
        int low = 0, high = arr.length - 1;
        while (low <= high) {
            int mid = low + (high - low) / 2;  // (low+high)/2 → overflow risk!
            if      (arr[mid] == target) return mid;     // found!
            else if (arr[mid] <  target) low  = mid + 1;  // right half
            else                         high = mid - 1;  // left half
        }
        return -1;  // not found
    }

    // Recursive version
    static int binarySearchRec(int[] arr, int low, int high, int target) {
        if (low > high) return -1;  // base case: not found
        int mid = low + (high - low) / 2;
        if      (arr[mid] == target) return mid;
        else if (arr[mid] < target)  return binarySearchRec(arr, mid + 1, high, target);
        else                          return binarySearchRec(arr, low, mid - 1, target);
    }

    public static void main(String[] args) {
        int[] arr = {2, 5, 8, 12, 16, 23, 38, 56, 72, 91};
        System.out.println("Array: " + Arrays.toString(arr));

        System.out.println("Search 23 (iterative): index "
            + binarySearchIter(arr, 23));
        System.out.println("Search 91 (recursive): index "
            + binarySearchRec(arr, 0, arr.length-1, 91));
        System.out.println("Search 99 (not found): index "
            + binarySearchIter(arr, 99));

        // Arrays.binarySearch() — negative return = insertion point
        System.out.println("\nArrays.binarySearch(38): " + Arrays.binarySearch(arr, 38));

        int result = Arrays.binarySearch(arr, 20);
        System.out.println("Arrays.binarySearch(20): " + result);
        System.out.println("  → Not found. Insert at index: " + (-result - 1));
        // Negative result = -(insertion_point) - 1
        // -result - 1 = insertion point where 20 should go
    }
}

import java.util.Arrays;

public class TwoPointer {

    static void twoSum(int[] sorted, int target) {
        int left = 0, right = sorted.length - 1;
        System.out.println("Pairs summing to " + target + "  (Two Pointer O(n)):");
        while (left < right) {
            int sum = sorted[left] + sorted[right];
            if      (sum == target) { System.out.println("  "+sorted[left]+" + "+sorted[right]); left++; right--; }
            else if (sum < target)  left++;
            else                    right--;
        }
    }

    static int[] reverseArray(int[] arr) {
        int[] copy = arr.clone();
        int l = 0, r = copy.length - 1;
        while (l < r) {
            int t = copy[l]; copy[l] = copy[r]; copy[r] = t;
            l++; r--;
        }
        return copy;
    }

    static int maxWater(int[] heights) {
        // Container with most water — LeetCode classic
        int left = 0, right = heights.length - 1, maxWater = 0;
        while (left < right) {
            int water = Math.min(heights[left], heights[right]) * (right - left);
            maxWater = Math.max(maxWater, water);
            if (heights[left] < heights[right]) left++;
            else right--;
        }
        return maxWater;
    }

    public static void main(String[] args) {
        twoSum(new int[]{1, 3, 5, 7, 9, 11, 13}, 14);

        System.out.println("\nReverse: "
            + Arrays.toString(reverseArray(new int[]{1,2,3,4,5})));

        System.out.println("Max Water: "
            + maxWater(new int[]{1,8,6,2,5,4,8,3,7}));
    }
}

public class KadanesAlgorithm {
    public static void main(String[] args) {
        int[] arr = {-2, 1, -3, 4, -1, 2, 1, -5, 4};

        // Kadane's — O(n), O(1) space
        // Idea: har point pe decide karo — naya subarray start karo
        //       ya existing mein extend karo
        int maxSoFar    = arr[0];
        int maxEndingHere = arr[0];
        int start = 0, end = 0, tempStart = 0;

        for (int i = 1; i < arr.length; i++) {
            if (arr[i] > maxEndingHere + arr[i]) {
                maxEndingHere = arr[i];   // naya subarray yahan se
                tempStart = i;
            } else {
                maxEndingHere += arr[i];  // extend karo
            }

            if (maxEndingHere > maxSoFar) {
                maxSoFar = maxEndingHere;
                start = tempStart;
                end = i;
            }
        }

        System.out.println("Max Subarray Sum: " + maxSoFar);
        System.out.print("Subarray:         [");
        for (int i = start; i <= end; i++)
            System.out.print(arr[i] + (i == end ? "]" : ", "));
        System.out.println(" → indices [" + start + ", " + end + "]");

        // All negative test
        int[] allNeg = {-5, -3, -8, -2, -9};
        int maxNeg = allNeg[0];
        for (int n : allNeg) if (n > maxNeg) maxNeg = n;
        System.out.println("\nAll negative array max: " + maxNeg + " (single element)");
    }
}

import java.util.*;

public class ArrayListOps {
    public static void main(String[] args) {

        // ── Create ──
        ArrayList<Integer> list = new ArrayList<>();

        // ── Add ──
        list.add(30); list.add(10); list.add(50);
        list.add(20); list.add(40);
        System.out.println("After add:         " + list);

        list.add(2, 99);  // specific index pe insert
        System.out.println("After add(2,99):   " + list);

        // ── Get, Set ──
        System.out.println("get(0):            " + list.get(0));
        list.set(0, 100);
        System.out.println("After set(0,100):  " + list);

        // ── Remove by index vs Remove by value ──
        list.remove(5);              // index 5 remove karo
        list.remove(Integer.valueOf(99));  // value 99 remove karo (Integer wrap)
        System.out.println("After removes:     " + list);

        // ── Search ──
        System.out.println("contains(50):      " + list.contains(50));
        System.out.println("indexOf(50):       " + list.indexOf(50));
        System.out.println("size():            " + list.size());

        // ── Sort ──
        Collections.sort(list);
        System.out.println("Sorted:            " + list);
        list.sort(Comparator.reverseOrder());
        System.out.println("Sorted desc:       " + list);

        // ── Array → ArrayList ──
        String[] arr = {"Java", "Python", "Go", "Rust"};
        List<String> langs = new ArrayList<>(Arrays.asList(arr));
        langs.add("Kotlin");
        System.out.println("\nLangs list: " + langs);

        // ── ArrayList → Array ──
        String[] backToArr = langs.toArray(new String[0]);
        System.out.println("Back to array: " + Arrays.toString(backToArr));

        // ── Iterate ──
        System.out.print("Iterator: ");
        Iterator<String> it = langs.iterator();
        while (it.hasNext()) System.out.print(it.next() + " ");
    }
}