11. జావా ఎరేలు — 1D, 2D, Jagged Arrays & అల్గారిథమ్స్ (Arrays Mastery)

import java.util.Arrays;

public class ArrayOperationsAndSearchBenchmark {
    public static void main(String[] args) {
        System.out.println("=================================================");
        System.out.println("⚡ JAVA 1D ARRAY CORE OPERATIONS & ALGORITHMS");
        System.out.println("=================================================
");

        int[] scores = {88, 45, 92, 67, 34, 99, 78, 56, 83};
        System.out.println("1. అసలు ఎరే (Original Array): " + Arrays.toString(scores));

        // 1. Min & Max Calculation
        int min = scores[0];
        int max = scores[0];
        long sum = 0;

        for (int score : scores) {
            if (score < min) min = score;
            if (score > max) max = score;
            sum += score;
        }
        double avg = (double) sum / scores.length;

        System.out.printf("   కనీస విలువ (Min): %d | గరిష్ట విలువ (Max): %d | సగటు (Avg): %.2f%n%n", min, max, avg);

        // 2. In-Place Array Reversal (Two Pointers Technique - O(1) Aux Memory)
        int left = 0;
        int right = scores.length - 1;
        while (left < right) {
            int temp = scores[left];
            scores[left] = scores[right];
            scores[right] = temp;
            left++;
            right--;
        }
        System.out.println("2. ఇన్-ప్లేస్ రివర్స్ చేసిన ఎరే: " + Arrays.toString(scores));

        // 3. Sorting with Dual-Pivot Quicksort
        Arrays.sort(scores);
        System.out.println("3. సార్టింగ్ తర్వాత ఎరే:         " + Arrays.toString(scores));

        // 4. Binary Search vs Linear Search
        int searchTarget = 92;
        int foundIndex = Arrays.binarySearch(scores, searchTarget);
        System.out.printf("4. Binary Search for target %d: ఇండెక్స్ %d వద్ద లభించింది!%n", searchTarget, foundIndex);

        int missingTarget = 70;
        int missingIndex = Arrays.binarySearch(scores, missingTarget);
        System.out.printf("   Missing target %d result:     %d (Insertion point: %d)%n",
                missingTarget, missingIndex, -(missingIndex + 1));

        System.out.println("=================================================");
    }
}

import java.util.Arrays;

public class MatrixAndJaggedArrayEngine {
    public static void main(String[] args) {
        System.out.println("=================================================");
        System.out.println("📊 2D MATRIX TRANSPOSE & JAGGED ARRAYS DEMO");
        System.out.println("=================================================
");

        // PART 1: 2D MATRIX TRANSPOSE (3x2 Matrix to 2x3 Matrix)
        int[][] originalMatrix = {
            {10, 20},
            {30, 40},
            {50, 60}
        };

        int rows = originalMatrix.length;
        int cols = originalMatrix[0].length;
        int[][] transpose = new int[cols][rows];

        for (int r = 0; r < rows; r++) {
            for (int c = 0; c < cols; c++) {
                transpose[c][r] = originalMatrix[r][c];
            }
        }

        System.out.println("1. Original 3x2 Matrix:  " + Arrays.deepToString(originalMatrix));
        System.out.println("   Transposed 2x3 Matrix: " + Arrays.deepToString(transpose));

        // PART 2: DYNAMIC JAGGED ARRAY (Corporate Departments Projects)
        String[] deptNames = {"Core Platform", "Mobile App", "AI Research"};
        String[][] departmentProjects = new String[3][];

        departmentProjects[0] = new String[]{"Auth-v2", "DB-Migration"};
        departmentProjects[1] = new String[]{"Android-Compose", "iOS-SwiftUI", "Flutter-Sync"};
        departmentProjects[2] = new String[]{"LLM-FineTuning"};

        System.out.println("
2. Dynamic Department Jagged Projects:");
        for (int i = 0; i < departmentProjects.length; i++) {
            System.out.printf("   🏢 Dept: %-14s | Count: %d | Projects: %s%n",
                    deptNames[i],
                    departmentProjects[i].length,
                    Arrays.toString(departmentProjects[i]));
        }

        System.out.println("=================================================");
    }
}

import java.util.Arrays;

public class SensorTelemetryMatrixEngine {

    // Analyzes a thermal grid rack of IoT temperature sensors
    public static class RackTelemetryProcessor {
        private final double[][] thermalGrid; // 2D Grid: [RackRows][SensorNodes]
        private final double alertThreshold;

        public RackTelemetryProcessor(double[][] grid, double threshold) {
            this.thermalGrid = grid;
            this.alertThreshold = threshold;
        }

        public void printThermalReport() {
            System.out.println("🌡️ DATA CENTER RACK THERMAL TELEMETRY REPORT:");
            System.out.println("-------------------------------------------------");

            double highestOverall = -1.0;
            int hotRow = -1, hotCol = -1;
            double totalSum = 0;
            int totalSensors = 0;

            for (int r = 0; r < thermalGrid.length; r++) {
                double rowSum = 0;
                double rowMax = thermalGrid[r][0];

                for (int c = 0; c < thermalGrid[r].length; c++) {
                    double temp = thermalGrid[r][c];
                    rowSum += temp;
                    totalSum += temp;
                    totalSensors++;

                    if (temp > rowMax) rowMax = temp;
                    if (temp > highestOverall) {
                        highestOverall = temp;
                        hotRow = r;
                        hotCol = c;
                    }
                }

                double rowAvg = rowSum / thermalGrid[r].length;
                System.out.printf("   Rack-Zone [%d]: Avg: %5.1f°C | Peak: %5.1f°C | Grid: %s%n",
                        r, rowAvg, rowMax, Arrays.toString(thermalGrid[r]));
            }

            double facilityAvg = totalSum / totalSensors;
            System.out.println("-------------------------------------------------");
            System.out.printf("🌐 Facility Overview: Sensors: %d | Avg Temp: %.2f°C%n", totalSensors, facilityAvg);
            System.out.printf("🚨 Critical Hotspot:  Zone [%d][%d] at %.1f°C%n", hotRow, hotCol, highestOverall);

            if (highestOverall >= alertThreshold) {
                System.out.println("⚠️ STATUS: HAZARD DETECTED! Emergency HVAC Cooling Activated.");
            } else {
                System.out.println("✅ STATUS: OPTIMAL! All rack temperatures within safety zone.");
            }
        }

        public double[] getSortedFlatTemperatures() {
            // Flatten 2D Grid into 1D Array for percentile calculation
            int total = 0;
            for (double[] row : thermalGrid) total += row.length;

            double[] flat = new double[total];
            int idx = 0;
            for (double[] row : thermalGrid) {
                for (double val : row) {
                    flat[idx++] = val;
                }
            }
            Arrays.sort(flat);
            return flat;
        }
    }

    public static void main(String[] args) {
        System.out.println("=================================================");
        System.out.println("📡 IOT SENSOR GRID TELEMETRY ANALYTICS ENGINE");
        System.out.println("=================================================
");

        // Simulating a 3-Rack server zone (Jagged grid: different sensor counts per rack)
        double[][] serverZoneGrid = {
            {34.5, 36.2, 38.0, 35.8},         // Rack 0: 4 sensors
            {41.2, 43.8, 48.5, 42.1, 40.0},   // Rack 1: 5 sensors (High load rack)
            {32.0, 33.4, 31.8}                // Rack 2: 3 sensors (Storage rack)
        };

        RackTelemetryProcessor processor = new RackTelemetryProcessor(serverZoneGrid, 45.0);
        processor.printThermalReport();

        // Percentile analysis using 1D sorted array
        double[] sortedTemps = processor.getSortedFlatTemperatures();
        System.out.println("
📈 Temperature Distribution (Sorted 1D):");
        System.out.println("   " + Arrays.toString(sortedTemps));

        double medianTemp = sortedTemps[sortedTemps.length / 2];
        System.out.printf("   Median Temperature: %.1f°C%n", medianTemp);
        System.out.println("=================================================");
    }
}