PHP प्रोग्राम: एरे में मिसिंग नंबर ढूंढना

एरे में मिसिंग नंबर ढूंढना

उदाहरण (बग्स के साथ)

<?php
function missing_nums($my_arr, $arr_len, $val) {
    sort($my_arr);
    sort($my_arr, $arr_len); // गलत: दूसरा पैरामीटर फ्लैग है
    $i = 0;
    while ($i < $n && $my_arr[$i] <= 0) $i++; // बग: $n अपरिभाषित
    $count = 0; $current_num = 1;
    while ($count < $k && $i < $arr_len) { // बग: $k अपरिभाषित
        if ($arr[$i] != $current_num) { // बग: $arr नहीं $my_arr
            echo $current_num . " ";
            $count++;
        } else {
            $i++;
        }
        $current_num++;
    }
    while ($count < $val) {
        echo $current_num . " ";
        $current_num++;
        $count++;
    }
}

$my_arr = array(6, 7, 9);
$arr_len = sizeof($my_arr);
$val = 5;
print_r("The missing numbers in the array is ");
missing_nums($my_arr, $arr_len, $val);
?>

आउटपुट

The missing numbers in the array is 1 2 3 4 5

कोड में बग्स

1. sort($my_arr, $arr_len) - दूसरा पैरामीटर सॉर्ट फ्लैग है (SORT_NUMERIC आदि)
2. $n और $k अपरिभाषित वेरिएबल्स
3. $arr के बजाय $my_arr उपयोग किया गया
4. डुप्लीकेट्स और नेगेटिव नंबर्स हैंडल नहीं

सही और मजबूत इम्प्लीमेंटेशन

<?php
function findMissingNumbers(array $arr, int $count): array {
    // केवल पॉजिटिव यूनिक नंबर्स
    $positive = array_unique(array_filter($arr, fn($x) => $x > 0));
    sort($positive);
    $positive = array_values($positive);
    
    $missing = [];
    $expected = 1;
    $index = 0;
    $len = count($positive);
    
    while (count($missing) < $count) {
        if ($index < $len && $positive[$index] == $expected) {
            $index++;
            // डुप्लीकेट्स स्किप (array_unique के बाद आवश्यक नहीं लेकिन सुरक्षित)
            while ($index < $len && $positive[$index] == $expected) {
                $index++;
            }
        } else {
            $missing[] = $expected;
        }
        $expected++;
    }
    
    return $missing;
}

// उपयोग
$my_arr = [6, 7, 9, 1, 1, -2, 0];
$missing = findMissingNumbers($my_arr, 5);
echo "Missing: " . implode(", ", $missing);
// आउटपुट: Missing: 2, 3, 4, 5, 8
?>

एल्गोरिदम

1. एरे को फिल्टर करें: केवल पॉजिटिव, यूनिक, सॉर्टेड
2. $expected = 1 से शुरू करें
3. एरे के साथ तुलना करें:
   • मैच: अगले एरे एलिमेंट और अगले एक्सपेक्टेड पर जाएं
   • नॉट मैच: $expected मिसिंग है, इसे रिजल्ट में जोड़ें, केवल $expected बढ़ाएं
4. आवश्यक मिसिंग नंबर मिलने तक दोहराएं

समय जटिलता

• सॉर्टिंग: O(n log n)
• स्कैनिंग: O(n + k) जहां k मिसिंग नंबर्स की संख्या
• कुल: O(n log n)