வரம்பின் காணாமல் போன கூறுகளைக் கண்டறியவும்


சிரமம் நிலை எளிதாக
அடிக்கடி கேட்கப்படுகிறது Delhivery கிரே ஆரஞ்சு லின்க்டு இன் நாகரோ வேலை சினாப்சிஸ்
ஹாஷ் லார்சன் & டூப்ரோ வரிசையாக்க

ஒரு வரம்பின் விடுபட்ட கூறுகளைக் கண்டுபிடிப்பதில் சிக்கல் ”உங்களுக்கு வழங்கப்பட்டுள்ளது என்று கூறுகிறது வரிசை ஒரு குறிப்பிட்ட வரம்பிற்குள் தனித்துவமான கூறுகள் மற்றும் குறைந்த மற்றும் உயர் என வழங்கப்படும் வரம்பு. ஒரு வரிசையில் இல்லாத அனைத்து வரம்புகளையும் காணவில்லை. வெளியீடு வரிசைப்படுத்தப்பட்ட வரிசையில் இருக்க வேண்டும்.

உதாரணமாக

வரம்பின் காணாமல் போன கூறுகளைக் கண்டறியவும்

arr[] = [1, 3, 5, 7, 8, 9]

low=1 high = 10
2, 4, 6, 10

விளக்கம்

குறைந்த மற்றும் உயர் அதாவது 1 மற்றும் 10 என வழங்கப்பட்ட வரம்பிற்குள் வரிசையில் காணாமல் போன எண்கள் இவை.

arr[] = [2, 3, 7, 8]

low=1 high = 9
1, 4, 5, 6, 9

விளக்கம்

குறைந்த மற்றும் உயர் அதாவது 1 மற்றும் 10 என வழங்கப்பட்ட வரம்பிற்குள் வரிசையில் காணாமல் போன எண்கள் இவை.

அல்காரிதம்

  1. ஒரு அறிவிக்கவும் தொகுப்பு.
  2. வரிசைக்குச் சென்று அனைத்து உறுப்புகளையும் தொகுப்பில் வைக்கவும்.
  3. “நான்” என்பது குறைந்த மற்றும் “நான்” என்பது உயர்விற்கு சமமானதாகும்.
    • ஒரு தொகுப்பில் “நான்” இல்லை என்றால்.
      • 'நான்' அச்சிடுக.

விளக்கம்

ஒரு வரிசையில் காணாமல் போன அனைத்து உறுப்புகளையும் ஒரு குறிப்பிட்ட வரம்பிற்குள் குறைந்த மற்றும் உயர்ந்ததாகக் கண்டுபிடிக்கக் கேட்கும் சிக்கல் அறிக்கை எங்களுக்கு வழங்கப்பட்டுள்ளது. இதைத் தீர்க்க நாம் ஒரு தொகுப்பைப் பயன்படுத்துவோம், கொடுக்கப்பட்ட வரிசையின் தொகுப்பில் மதிப்புகளைச் சேமிக்கப் போகிறோம். எங்களுக்கு குறைந்த மற்றும் உயர்ந்த வரம்பு வழங்கப்பட்டுள்ளது, எல்லா உறுப்புகளையும் குறைந்த மற்றும் உயர்ந்த அனைத்தையும் உள்ளடக்கியதாக அச்சிட வேண்டும்.

அந்த வரிசையைப் பெற, நாங்கள் ஏற்கனவே வரிசை கூறுகளை தொகுப்பில் சேமிக்கிறோம். 'நான்' குறைவாக துவக்கி ஒரு சுழற்சியை இயக்க வேண்டும். 'i' இன் மதிப்பு அதிகமாக இருக்கும் வரை நாம் லூப்பை இயக்குகிறோம். தொகுப்பில் 'i' மதிப்பு இல்லையா என்று சரிபார்க்கவும், பின்னர் 'i' ஐ அச்சிடவும். எனவே ஒரு வரிசையில் இருந்து காணாமல் போன அனைத்து கூறுகளையும் ஒரு குறிப்பிட்ட வரம்பிற்குள் பெறுவோம். ஒரு உதாரணத்தைக் கருத்தில் கொள்வோம்.

arr [] = {2, 3, 7, 8} low = 1, high = 9

நாம் வரிசையை கடந்து, ஒரு வரிசையின் அனைத்து கூறுகளையும் தொகுப்பில் வைக்க வேண்டும். எங்கள் தொகுப்பு மாறும்

set = [2,3,7,8]

ஒரு சுழற்சியில் நான் முதல் குறைந்த வரை துவக்கி, லூப் உயர் வரை இயங்கும், இதன் பொருள் 'நான்' குறைந்த = 1 மற்றும் உயர் = 9 க்கு சமம்

i = 1, தொகுப்பில் நான் இல்லை என்றால், 1 ஐ அச்சிடுகிறது

[1]

i = 2, தொகுப்பு '2' மதிப்பைக் கொண்டுள்ளது மற்றும் எதுவும் செய்யாது.

i = 3, தொகுப்பு '3' மதிப்பைக் கொண்டுள்ளது மற்றும் எதுவும் செய்யாது.

i = 4, தொகுப்பில் நான் இல்லை என்றால், 4 ஐ அச்சிடுகிறது

[1, 4]

i = 5, தொகுப்பில் நான் இல்லை என்றால், 5 ஐ அச்சிடுகிறது

[1, 4, 5]

i = 6, தொகுப்பில் நான் இல்லை என்றால், 6 ஐ அச்சிடுகிறது

[1, 4, 5, 6]

i = 7, தொகுப்பு '7' மதிப்பைக் கொண்டுள்ளது மற்றும் எதுவும் செய்யாது.

i = 8, தொகுப்பு '8' மதிப்பைக் கொண்டுள்ளது மற்றும் எதுவும் செய்யாது.

i = 9, தொகுப்பில் நான் இல்லை என்றால், 1 ஐ அச்சிடுகிறது

[1, 4, 5, 6, 9]

எங்கள் வெளியீடு இதுவாக மாறும்: [1, 4, 5, 6, 9]

குறியீடு

வரம்பின் காணாமல் போன கூறுகளைக் கண்டறிய சி ++ குறியீடு

#include <unordered_set>
#include<iostream>

using namespace std;

void getMissingElements(int arr[], int n, int low, int high)
{
    unordered_set<int> myset;
    for (int i = 0; i < n; i++)
        myset.insert(arr[i]);

    for (int x = low; x <= high; x++)
        if (myset.find(x) == myset.end())
            cout << x << " ";
}
int main()
{
    int arr[] = { 2,3,7,8 };
    int low = 1, high = 9;
    int n = sizeof(arr) / sizeof(arr[0]);
    getMissingElements(arr, n, low, high);
    return 0;
}
1 4 5 6 9

வரம்பின் காணாமல் போன கூறுகளைக் கண்டறிய ஜாவா குறியீடு

import java.util.HashSet;

class RangeMissingElements
{
    public static void getMissingElements(int arr[], int low, int high)
    {
        HashSet<Integer> myset = new HashSet<>();

        for (int i = 0; i < arr.length; i++)
        {
            myset.add(arr[i]);
        }

        for (int i = low; i <= high; i++)
        {
            if (!myset.contains(i))
            {
                System.out.print(i + " ");
            }
        }
    }
    public static void main(String[] args)
    {
        int arr[] = {2,3,7,8};
        int low = 1, high = 9;
        getMissingElements(arr, low, high);
    }
}
1 4 5 6 9

சிக்கலான பகுப்பாய்வு

நேர சிக்கலானது

O (n + (உயர்-குறைந்த + 1)) எங்கே “N” என்பது வரிசையில் உள்ள உறுப்புகளின் எண்ணிக்கை, “உயர்” மற்றும் "குறைந்த" வழங்கப்பட்ட உள்ளீடு.

விண்வெளி சிக்கலானது

ஓ (என்), மிக மோசமான நிலையில், எல்லா கூறுகளும் தனித்தனியாக இருந்தால். நாங்கள் அனைத்து உறுப்புகளையும் சேமிக்க வேண்டும். இதனால் வழிமுறையை உருவாக்குவதற்கு நேரியல் நேரம் தேவைப்படுகிறது.