முழு எண்களின் வரிசையில் மீண்டும் மீண்டும் வரும் உறுப்பைக் கண்டறியவும்


சிரமம் நிலை எளிதாக
அடிக்கடி கேட்கப்படுகிறது அமேசான் வெறியர்கள் MAQ மைக்ரோசாப்ட் ஆரக்கிள்
அணி ஹேஷிங்

சிக்கல் அறிக்கை

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

உதாரணமாக

arr[] = {2,6,9,3,1,9,1}
9

விளக்கம்: கொடுக்கப்பட்ட வரிசையில் இரண்டு எண்கள் உள்ளன, அவை மீண்டும் மீண்டும் வருகின்றன, ஆனால் முதல் மீண்டும் 9 ஆகும்.

arr[] = {1,4,7,0,2,5}
No repeating number.

விளக்கம்: கொடுக்கப்பட்ட வரிசையில் மீண்டும் மீண்டும் எண் இல்லை.

முதல் தொடர்ச்சியான தன்மையைக் கண்டறிய வழிமுறை

1. Set flag to -1.
2. Declare a Set.
3. Start traversing the array from the right to left.
    1. If the number is repeating then update the value of flag to the index of the current array element.
    2. Else, insert the each array’s element into the declared set.
4. Check if flag value is still -1, then we have found no repeating element.
5. Else print flag index position of array.

விளக்கம்

முழு எண்களின் வரிசையில் மீண்டும் மீண்டும் வரும் உறுப்பைக் கண்டறியவும்

 

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

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

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

குறியீடு

முதல் மீண்டும் எழுத்துக்குறியைக் கண்டுபிடிக்க சி ++ குறியீடு

#include<bits/stdc++.h>

using namespace std;

void getFirstRepeatedElement(int arr[], int n)
{
    int Flag = -1;

    unordered_set<int> SET;

    for (int i = n - 1; i >= 0; i--)
    {
        if (SET.find(arr[i]) != SET.end())
            Flag = i;

        else
            SET.insert(arr[i]);
    }
    if (Flag!= -1)
        cout << "The first repeating element is " << arr[Flag];
    else
        cout << "There are no repeating elements";
}
int main()
{
    int arr[] = {2,6,9,3,1,9,1};

    int n = sizeof(arr) / sizeof(arr[0]);
    getFirstRepeatedElement (arr, n);
}
The first repeating element is 9

மீண்டும் மீண்டும் வரும் எழுத்தைக் கண்டுபிடிக்க ஜாவா குறியீடு

import java.util.HashSet;

class FirstRepeatingElement
{
    public static void getFirstRepeatedElement (int arr[])
    {
        int Flag = -1;

        HashSet<Integer> SET = new HashSet<>();

        for (int i=arr.length-1; i>=0; i--)
        {
            if (SET.contains(arr[i]))
                Flag = i;

            else
                SET.add(arr[i]);
        }
        if (Flag!= -1)
            System.out.println("First repeating element is " + arr[Flag]);
        else
            System.out.println("No repeated element");
    }
    public static void main (String[] args)
    {
        int arr[] = {2,6,9,3,1,9,1};
        getFirstRepeatedElement(arr);
    }
}
First repeating element is 9

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

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

ஓ (n) எங்கே “N” என்பது வரிசையில் உள்ள உறுப்புகளின் எண்ணிக்கை. நாங்கள் ஒரு ஹாஷ்செட்டைப் பயன்படுத்துவதால், ஓ (1) செயல்பாடுகளில் செருகவும் தேடலும் செய்யலாம்.

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

ஓ (n) எங்கே “N” என்பது வரிசையில் உள்ள உறுப்புகளின் எண்ணிக்கை.