byte → short → int → long → float → double
         ↓
       char → int

// Implicit conversion examples
byte b = 10;
short s = b;        // byte to short
int i = s;          // short to int  
long l = i;         // int to long
float f = l;        // long to float
double d = f;       // float to double

// Character conversion
char c = 'A';       // ASCII value 65
int ascii = c;      // char to int (65)

// Mixed operations
int x = 5;
double y = 2.5;
double result = x + y;  // x promoted to double

// Basic casting syntax
(target_type) value

// Examples
double d = 9.78;
int i = (int) d;        // 9 (fractional part lost)

long l = 100L;
int x = (int) l;        // 100 (fits in int)

float f = 65.4f;
char c = (char) f;      // 'A' (ASCII 65)

// Complex expressions
double result = 10.5 * 3.2;
int finalValue = (int) (result + 0.5);  // Rounding

// Potential data loss scenarios
int large = 300;
byte small = (byte) large;    // -44 (overflow!)

double precise = 123.456789;
float less = (float) precise; // 123.45679 (precision loss)

long bigNumber = 3000000000L;
int overflow = (int) bigNumber; // -1294967296 (overflow!)

// Character conversions
int ascii = 65;
char letter = (char) ascii;   // 'A'

char symbol = 'A';
int code = (int) symbol;      // 65

// 1. Check ranges before casting
long bigValue = 1500L;
if (bigValue <= Integer.MAX_VALUE) {
    int safeValue = (int) bigValue;
}

// 2. Use appropriate wrapper methods
String numberStr = "123";
int number = Integer.parseInt(numberStr);

// 3. Handle precision loss consciously
double price = 99.99;
int rupees = (int) Math.round(price);  // Round first

// 4. Use constants for readability
public static final double CONVERSION_RATE = 83.5;
double dollars = 100.0;
int rupees = (int) (dollars * CONVERSION_RATE);

// 1. Ignoring overflow
int result = 2000000000 + 2000000000;  // Overflow!

// 2. Unnecessary casting
double d = 5.0;
int i = (int) 5;  // Should be: int i = 5;

// 3. Loss of precision without consideration
double precise = 123.456789;
int rough = (int) precise;  // 123, but no rounding

// 4. Mixing types carelessly
byte a = 10;
byte b = 20;
byte sum = a + b;  // Compilation error!

// Method 1: Declaration then creation
int[] ages;                    // Declaration
ages = new int[5];            // Creation

// Method 2: Combined declaration and creation
int[] scores = new int[10];

// Method 3: Declaration with initialization
int[] numbers = {10, 20, 30, 40, 50};

// Method 4: Alternative syntax
int marks[] = new int[]{85, 90, 78, 92, 88};

// Different data types
String[] names = {"Alice", "Bob", "Charlie"};
double[] prices = {99.99, 149.50, 75.25};
boolean[] flags = {true, false, true, false};

int[] numbers = {10, 20, 30, 40, 50};

// Array length
int size = numbers.length;  // 5 (property, not method)

// Accessing elements
int first = numbers[0];     // 10 (first element)
int last = numbers[4];      // 50 (last element)

// Modifying elements
numbers[2] = 35;           // Change 30 to 35

// Array bounds
// int invalid = numbers[5];  // Runtime error!
// numbers[-1] = 10;          // Runtime error!

// 1. Initialize array with values
int[] marks = new int[5];
for (int i = 0; i < marks.length; i++) {
    marks[i] = (i + 1) * 10;  // 10, 20, 30, 40, 50
}

// 2. Display array elements
System.out.println("Student Marks:");
for (int i = 0; i < marks.length; i++) {
    System.out.println("Student " + (i+1) + ": " + marks[i]);
}

// 3. Enhanced for loop (for-each)
for (int mark : marks) {
    System.out.println("Mark: " + mark);
}

// 4. Find sum and average
int sum = 0;
for (int mark : marks) {
    sum += mark;
}
double average = (double) sum / marks.length;

// Find maximum element
int[] numbers = {45, 23, 67, 12, 89, 34};
int max = numbers[0];
for (int i = 1; i < numbers.length; i++) {
    if (numbers[i] > max) {
        max = numbers[i];
    }
}

// Linear search
public static int linearSearch(int[] arr, int target) {
    for (int i = 0; i < arr.length; i++) {
        if (arr[i] == target) {
            return i;  // Return index
        }
    }
    return -1;  // Not found
}

// Count occurrences
public static int countOccurrences(int[] arr, int value) {
    int count = 0;
    for (int element : arr) {
        if (element == value) {
            count++;
        }
    }
    return count;
}

// Method 1: Declaration then creation
int[][] matrix;
matrix = new int[3][4];  // 3 rows, 4 columns

// Method 2: Combined
int[][] scores = new int[5][3];

// Method 3: With initialization
int[][] marks = {
    {85, 90, 78},
    {92, 88, 95},
    {76, 82, 89}
};

// Method 4: Row by row
int[][] table = new int[2][];
table[0] = new int[]{1, 2, 3};
table[1] = new int[]{4, 5, 6, 7};  // Jagged array

int[][] marks = {
    {85, 90, 78},
    {92, 88, 95}, 
    {76, 82, 89}
};

// Access specific element
int firstStudentMath = marks[0][0];  // 85
int lastStudentScience = marks[2][2]; // 89

// Modify elements
marks[1][2] = 97;  // Change second student's third subject

// Array dimensions
int rows = marks.length;        // 3
int cols = marks[0].length;     // 3

// Display all elements
for (int i = 0; i < marks.length; i++) {
    for (int j = 0; j < marks[i].length; j++) {
        System.out.print(marks[i][j] + " ");
    }
    System.out.println();  // New line after each row
}

// Enhanced for loop
for (int[] row : marks) {
    for (int mark : row) {
        System.out.print(mark + " ");
    }
    System.out.println();
}

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

// Example usage
int[][] matrix1 = {{1, 2}, {3, 4}};
int[][] matrix2 = {{5, 6}, {7, 8}};
int[][] sum = addMatrices(matrix1, matrix2);
// Result: {{6, 8}, {10, 12}}

public static int[][] transpose(int[][] matrix) {
    int rows = matrix.length;
    int cols = matrix[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] = matrix[i][j];
        }
    }
    return result;
}

import java.util.Scanner;

public class MatrixAddition {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int[][] matrix1 = new int[3][3];
        int[][] matrix2 = new int[3][3];
        int[][] result = new int[3][3];
        
        // Input first matrix
        System.out.println("Enter first 3x3 matrix:");
        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 3; j++) {
                matrix1[i][j] = sc.nextInt();
            }
        }
        
        // Input second matrix
        System.out.println("Enter second 3x3 matrix:");
        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 3; j++) {
                matrix2[i][j] = sc.nextInt();
            }
        }
        
        // Add matrices
        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 3; j++) {
                result[i][j] = matrix1[i][j] + matrix2[i][j];
            }
        }
        
        // Display result
        System.out.println("Sum of matrices:");
        displayMatrix(result);
    }
    
    public static void displayMatrix(int[][] matrix) {
        for (int[] row : matrix) {
            for (int element : row) {
                System.out.print(element + " ");
            }
            System.out.println();
        }
    }
}

// Mixed expression evaluation
public class TypePromotionDemo {
    public static void main(String[] args) {
        demonstratePromotionRules();
        demonstrateMethodOverloadingWithTypes();
        demonstratePrecisionLoss();
        demonstrateWrapperConversion();
    }
    
    private static void demonstratePromotionRules() {
        System.out.println("=== Expression Promotion Rules ===");
        
        // Rule 1: byte and short promoted to int in expressions
        byte b1 = 10, b2 = 20;
        // byte result = b1 + b2;  // Compilation error!
        int result = b1 + b2;      // Correct
        System.out.println("byte + byte = " + result + " (int)");
        
        // Rule 2: Mixed type promotion
        int i = 100;
        long l = 200L;
        float f = 3.14f;
        double d = 2.718;
        
        // Result types in mixed expressions
        long longResult = i + l;        // int + long = long
        float floatResult = i + f;      // int + float = float
        double doubleResult = l + d;    // long + double = double
        
        System.out.println("int + long = " + longResult + " (long)");
        System.out.println("int + float = " + floatResult + " (float)");
        System.out.println("long + double = " + doubleResult + " (double)");
        
        // Rule 3: char promotion
        char c1 = 'A', c2 = 'B';
        int charSum = c1 + c2;  // chars promoted to int
        System.out.println("'A' + 'B' = " + charSum + " (ASCII sum)");
    }
    
    private static void demonstrateMethodOverloadingWithTypes() {
        System.out.println("\n=== Method Overloading with Type Conversion ===");
        
        TypeConverter converter = new TypeConverter();
        
        // Automatic type promotion in method calls
        converter.process(10);        // Calls int version
        converter.process(10L);       // Calls long version
        converter.process(10.5f);     // Calls float version
        converter.process(10.5);      // Calls double version
        converter.process('A');       // Calls int version (char promoted)
    }
    
    static class TypeConverter {
        public void process(int value) {
            System.out.println("Processing int: " + value);
        }
        
        public void process(long value) {
            System.out.println("Processing long: " + value);
        }
        
        public void process(float value) {
            System.out.println("Processing float: " + value);
        }
        
        public void process(double value) {
            System.out.println("Processing double: " + value);
        }
    }
    
    private static void demonstratePrecisionLoss() {
        System.out.println("\n=== Precision Loss Analysis ===");
        
        // Float precision limits
        float largeFloat = 16777216f;  // 2^24
        float nextFloat = largeFloat + 1f;
        
        System.out.println("Large float: " + largeFloat);
        System.out.println("Large float + 1: " + nextFloat);
        System.out.println("Are they equal? " + (largeFloat == nextFloat));
        
        // Double to float precision loss
        double preciseValue = 1.23456789012345;
        float lessprecise = (float) preciseValue;
        
        System.out.println("Original double: " + preciseValue);
        System.out.println("Cast to float: " + lessprecise);
        System.out.println("Precision lost: " + (preciseValue - lessprecise));
        
        // Long to int overflow examples
        long[] testValues = {
            Integer.MAX_VALUE - 1,
            Integer.MAX_VALUE,
            Integer.MAX_VALUE + 1L,
            Integer.MIN_VALUE - 1L
        };
        
        System.out.println("\nLong to int conversion:");
        for (long value : testValues) {
            int converted = (int) value;
            System.out.println(value + " -> " + converted + 
                             (value != converted ? " (OVERFLOW!)" : ""));
        }
    }
    
    private static void demonstrateWrapperConversion() {
        System.out.println("\n=== Wrapper Type Conversion ===");
        
        // Autoboxing and unboxing
        Integer wrapper = 42;           // Autoboxing: int -> Integer
        int primitive = wrapper;        // Unboxing: Integer -> int
        
        System.out.println("Autoboxed: " + wrapper);
        System.out.println("Unboxed: " + primitive);
        
        // Wrapper to different primitive types
        Integer intWrapper = 65;
        Character charValue = (char) intWrapper.intValue();
        Double doubleValue = intWrapper.doubleValue();
        
        System.out.println("Integer 65 as char: " + charValue);
        System.out.println("Integer 65 as double: " + doubleValue);
        
        // String to number conversion
        String[] numberStrings = {"123", "45.67", "true", "invalid"};
        
        for (String str : numberStrings) {
            try {
                int intValue = Integer.parseInt(str);
                System.out.println("'" + str + "' -> int: " + intValue);
            } catch (NumberFormatException e) {
                System.out.println("'" + str + "' -> int: INVALID");
            }
            
            try {
                double doubleVal = Double.parseDouble(str);
                System.out.println("'" + str + "' -> double: " + doubleVal);
            } catch (NumberFormatException e) {
                System.out.println("'" + str + "' -> double: INVALID");
            }
        }
    }
}

public class ArraySearching {
    public static void main(String[] args) {
        int[] numbers = {64, 34, 25, 12, 22, 11, 90, 5};
        
        demonstrateLinearSearch(numbers);
        demonstrateBinarySearch(numbers);
        demonstrateAdvancedSearching(numbers);
    }
    
    // Linear Search - O(n) time complexity
    public static int linearSearch(int[] arr, int target) {
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == target) {
                return i;
            }
        }
        return -1; // Not found
    }
    
    // Binary Search - O(log n) - requires sorted array
    public static int binarySearch(int[] arr, int target) {
        int left = 0, right = arr.length - 1;
        
        while (left <= right) {
            int mid = left + (right - left) / 2;
            
            if (arr[mid] == target) {
                return mid;
            } else if (arr[mid] < target) {
                left = mid + 1;
            } else {
                right = mid - 1;
            }
        }
        return -1; // Not found
    }
    
    private static void demonstrateLinearSearch(int[] arr) {
        System.out.println("=== Linear Search ===");
        System.out.println("Array: " + Arrays.toString(arr));
        
        int target = 25;
        long startTime = System.nanoTime();
        int index = linearSearch(arr, target);
        long endTime = System.nanoTime();
        
        System.out.println("Searching for " + target + ": " + 
                          (index != -1 ? "Found at index " + index : "Not found"));
        System.out.println("Time: " + (endTime - startTime) + " ns");
    }
    
    private static void demonstrateBinarySearch(int[] arr) {
        System.out.println("\n=== Binary Search ===");
        
        // First, sort the array for binary search
        int[] sortedArr = arr.clone();
        Arrays.sort(sortedArr);
        System.out.println("Sorted array: " + Arrays.toString(sortedArr));
        
        int target = 25;
        long startTime = System.nanoTime();
        int index = binarySearch(sortedArr, target);
        long endTime = System.nanoTime();
        
        System.out.println("Searching for " + target + ": " + 
                          (index != -1 ? "Found at index " + index : "Not found"));
        System.out.println("Time: " + (endTime - startTime) + " ns");
        
        // Compare with built-in binary search
        int builtInIndex = Arrays.binarySearch(sortedArr, target);
        System.out.println("Built-in binary search result: " + builtInIndex);
    }
    
    private static void demonstrateAdvancedSearching(int[] arr) {
        System.out.println("\n=== Advanced Searching ===");
        
        // Find all occurrences of a value
        int target = 25;
        List<Integer> indices = findAllOccurrences(arr, target);
        System.out.println("All occurrences of " + target + ": " + indices);
        
        // Find second largest element
        int secondLargest = findSecondLargest(arr);
        System.out.println("Second largest element: " + secondLargest);
        
        // Find missing number in sequence (1 to n)
        int[] sequence = {1, 2, 4, 5, 6};
        int missing = findMissingNumber(sequence, 6);
        System.out.println("Missing number in {1,2,4,5,6}: " + missing);
    }
    
    public static List<Integer> findAllOccurrences(int[] arr, int target) {
        List<Integer> indices = new ArrayList<>();
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == target) {
                indices.add(i);
            }
        }
        return indices;
    }
    
    public static int findSecondLargest(int[] arr) {
        if (arr.length < 2) return -1;
        
        int largest = Integer.MIN_VALUE;
        int secondLargest = Integer.MIN_VALUE;
        
        for (int num : arr) {
            if (num > largest) {
                secondLargest = largest;
                largest = num;
            } else if (num > secondLargest && num != largest) {
                secondLargest = num;
            }
        }
        return secondLargest;
    }
    
    public static int findMissingNumber(int[] arr, int n) {
        int expectedSum = n * (n + 1) / 2;
        int actualSum = 0;
        for (int num : arr) {
            actualSum += num;
        }
        return expectedSum - actualSum;
    }
}