Arrays

import java.util.ArrayList;
import java.util.Arrays;

public class ArrayDemo {
    public static void main(String[] args) {
        // Static array — fixed size
        int[] arr = {10, 20, 30, 40, 50};

        // Access by index — O(1)
        System.out.println("arr[0] = " + arr[0]);  // 10
        System.out.println("arr[4] = " + arr[4]);  // 50

        // Traversal
        System.out.print("Elements: ");
        for (int i = 0; i < arr.length; i++) System.out.print(arr[i] + " ");
        System.out.println();

        // Enhanced for loop
        for (int x : arr) System.out.print(x + " ");
        System.out.println();

        // Dynamic array — ArrayList
        ArrayList<Integer> list = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5));
        list.add(6);       // add to end — O(1) amortized
        list.remove(0);    // remove at index — O(n)
        System.out.println("Size: " + list.size());

        // 2D array
        int[][] matrix = {{1,2,3},{4,5,6},{7,8,9}};
        System.out.println("matrix[1][2] = " + matrix[1][2]);  // 6
    }
}

# Python list — dynamic array (no fixed-size arrays by default)
arr = [10, 20, 30, 40, 50]

# Access by index — O(1)
print("arr[0] =", arr[0])   # 10
print("arr[-1] =", arr[-1]) # 50 (negative index from end)

# Traversal
print("Elements:", arr)
for x in arr:
    print(x, end=" ")
print()

# Dynamic operations
arr.append(60)      # add to end — O(1)
arr.insert(2, 25)   # insert at index 2 — O(n)
arr.pop()           # remove last — O(1)
arr.pop(0)          # remove at index — O(n)
print("After ops:", arr)

# List slicing
print("First 3:", arr[:3])
print("Last 2:", arr[-2:])
print("Reversed:", arr[::-1])

# 2D array (list of lists)
matrix = [[1,2,3],[4,5,6],[7,8,9]]
print("matrix[1][2] =", matrix[1][2])  # 6

# NumPy for true arrays (optional)
# import numpy as np
# arr = np.array([1, 2, 3, 4, 5])

// JavaScript Array — dynamic, can hold mixed types
const arr = [10, 20, 30, 40, 50];

// Access by index — O(1)
console.log("arr[0] =", arr[0]);   // 10
console.log("arr[4] =", arr[4]);   // 50

// Traversal
arr.forEach(x => process.stdout.write(x + " "));
console.log();

// Dynamic operations
arr.push(60);       // add to end — O(1)
arr.pop();          // remove last — O(1)
arr.unshift(5);     // add to front — O(n)
arr.shift();        // remove from front — O(n)
arr.splice(2, 0, 25); // insert at index 2 — O(n)

// Useful array methods
const doubled = arr.map(x => x * 2);
const evens   = arr.filter(x => x % 2 === 0);
const sum     = arr.reduce((acc, x) => acc + x, 0);
console.log("Sum:", sum);

// 2D array
const matrix = [[1,2,3],[4,5,6],[7,8,9]];
console.log("matrix[1][2] =", matrix[1][2]);  // 6

import java.util.Arrays;

public class ArrayAlgorithms {
    static int findMax(int[] arr) {
        int max = arr[0];
        for (int x : arr) if (x > max) max = x;
        return max;
    }

    static void reverse(int[] arr) {
        int lo = 0, hi = arr.length - 1;
        while (lo < hi) {
            int temp = arr[lo]; arr[lo] = arr[hi]; arr[hi] = temp;
            lo++; hi--;
        }
    }

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

arr = [3, 1, 4, 1, 5, 9, 2, 6]

# Find max — O(n)
print("Max:", max(arr))          # 9
print("Max:", max(arr, key=abs)) # using key function

# Reverse — O(n)
arr.reverse()                    # in-place
print("Reversed:", arr)

# Or using slicing (creates new list)
reversed_arr = arr[::-1]

# Rotate left by k — O(n)
def rotate_left(arr, k):
    k %= len(arr)
    return arr[k:] + arr[:k]

arr = [1, 2, 3, 4, 5]
print("Rotated left by 2:", rotate_left(arr, 2))  # [3, 4, 5, 1, 2]

# Two-pointer: find pair with given sum
def two_sum(arr, target):
    seen = {}
    for i, x in enumerate(arr):
        if target - x in seen:
            return [seen[target - x], i]
        seen[x] = i
    return []

print(two_sum([2, 7, 11, 15], 9))  # [0, 1]

const arr = [3, 1, 4, 1, 5, 9, 2, 6];

// Find max — O(n)
const max = Math.max(...arr);
console.log("Max:", max);  // 9

// Reverse — O(n)
const reversed = [...arr].reverse();  // non-destructive
console.log("Reversed:", reversed);

// Rotate left by k
function rotateLeft(arr, k) {
    k = k % arr.length;
    return [...arr.slice(k), ...arr.slice(0, k)];
}
console.log("Rotated:", rotateLeft([1,2,3,4,5], 2));  // [3,4,5,1,2]

// Two Sum — O(n)
function twoSum(arr, target) {
    const seen = new Map();
    for (let i = 0; i < arr.length; i++) {
        const complement = target - arr[i];
        if (seen.has(complement)) return [seen.get(complement), i];
        seen.set(arr[i], i);
    }
    return [];
}
console.log(twoSum([2, 7, 11, 15], 9));  // [0, 1]