K-th የተለየ ንጥረ ነገር በአንድ ድርድር ውስጥ  


የችግር ደረጃ መካከለኛ
ውስጥ በተደጋጋሚ ተጠየቀ የ Adobe አማዞን ፓም ByteDance eBay Expedia ፌስቡክ google LinkedIn የ Microsoft በ Oracle Salesforce Spotify የዎልማርት ላብራቶሪዎች
አካፍል እና ድል እከክ

ኢንቲጀር ተሰጥቶዎታል ደርድር ሀ ፣ የ k-th ን የተለየ ክፍል በአንድ ድርድር ውስጥ ያትሙ። የተሰጠው ድርድር ብዜቶችን ሊኖረው ይችላል እና ውጤቱም በአንድ ድርድር ውስጥ ካሉ ልዩ ልዩ ንጥረ ነገሮች መካከል የ k-th ልዩ አካልን ማተም አለበት። K ከበርካታ የተለዩ አካላት በላይ ከሆነ ከዚያ ሪፖርት ያድርጉት።

ለምሳሌ  

ግቤት

ሀ [] = {3,4,4,1,2,3}

K = 2

ውጤት

K-th የማይደገም አባል 2 ነው።

ማብራሪያ:

የመጀመሪያው የማይደገም ንጥረ ነገር 1 ፣

ሁለተኛው የማይደገም አካል 2 ነው።

አቀራረብ 1 የጭካኔ ኃይል  

ዋናዉ ሀሣብ

ያገኘናቸውን የማይደጋገሙ አባላትን ቁጥር የሚያከማች ቆጠራ ተለዋዋጭ እንጠብቃለን ፡፡ አሁን በሁሉም ንጥረ ነገሮች ላይ እንመረምራለን እና ለእያንዳንዱ ንጥረ ነገር እንሰራለን ፣ ይህ የማይደጋገም አካል መሆኑን ወይም አለመሆኑን ለመፈተሽ በድርድሩ ላይ እናልፋለን ፣ ከሆነ ደግሞ ቆጠራውን በ 1. እንጨምራለን ፡፡ ከ K ጋር እኩል ነው ፣ ያንን ንጥረ ነገር እናተምበታለን።

በድርድር ውስጥ ለ K-th ልዩ ንጥረ ነገር አልጎሪዝም

  1. በድርድሩ ውስጥ ያሉትን የተለያዩ ንጥረ ነገሮችን ብዛት የሚቆጥር ተለዋዋጭ ቆጠራን ከዜሮ ጋር ያስጀምሩ።
  2. ከ 0 እስከ n-1 ባለው ክልል ውስጥ ለእኔ አንድ ዙር ያሂዱ
    1. ሀ [i] የሚደጋገም አካል ከሆነ እና ተቃራኒ ከሆነ እውነት የሆነውን ባንዲራ በሐሰት ያውጅ
    2. ከ 0 እስከ n-1 ባለው ክልል ውስጥ ለ j አንድ ዙር ያሂዱ
      1. እኔ እኩል ካልሆንኩ እና ኤ [i] ከ A [j] ጋር እኩል ከሆኑ ባንዲራን ይመድቡ = እውነተኛ እና ይሰብሩ
    3. ባንዲራ ሐሰተኛ ከሆነ ፣ የመደመር ቁጥር በ 1 ይቆጠር
    4. ቆጠራ ከኬ ጋር እኩል ከሆነ ይፈትሹ ሀ [i] ን ያትሙ ፡፡
  3. ተመለስ
ተመልከት
2 ተለዋጮችን በመጠቀም የፊቦናቺን ቅደም ተከተል ያትሙ

አፈጻጸም

C ++ ፕሮግራም

#include <bits/stdc++.h>
using namespace std;
void kthDistinctElement(vector<int> &A, int k)
{
    int n = A.size();
    int count = 0;
    for (int i = 0; i < n; i++)
    {
        bool flag = false;
        for (int j = 0; j < n; j++)
        {
            if (i != j and A[i] == A[j])
            {
                flag = true;
                break;
            }
        }
        if (!flag)
        {
            count++;
        }
        if (count == k)
        {
            cout << "K-th non-repeating element is: " << A[i] << endl;
            return;
        }
    }
    cout << "K is greater than number of distinct element in the array." << endl;
    return;
}
int main()
{
    vector<int> A = {3, 4, 4, 1, 2, 3};
    int k = 2;
    kthDistinctElement(A, k);
    return 0;
}
K-th non-repeating element is: 2

የጃቫ ፕሮግራም

public class Main
{
    static void kthDistinctElement(int A[], int k)
    {
        int n=A.length;
        int count = 0;
        for (int i = 0; i < n; i++)
        {
            boolean flag = false;
            for (int j = 0; j < n; j++)
            {
                if (i != j && A[i] == A[j])
                {
                    flag = true;
                    break;
                }
            }
            if (!flag)
            {
                count++;
            }
            if (count == k)
            {
                System.out.println("K-th non-repeating element is: " + A[i]);
                return;
            }
        }
        System.out.println("K is greater than number of distinct element in the array.");
    }
  public static void main(String[] args) {
    int A[] = {3, 4, 4, 1, 2, 3};
        int k = 2;
        kthDistinctElement(A, k);
  }
}
K-th non-repeating element is: 2

በአንድ ድርድር ውስጥ ለ K-th ልዩ ንጥረ ነገር ውስብስብነት ትንተና

የጊዜ ውስብስብነት

እኛ ሁለት የተጠለፉ ቀለበቶችን እየተጠቀምን ነው ፣ ሁለቱም መጠናቸው N. ስለዚህ ፣ አጠቃላይ የጊዜ ውስብስብነቱ ነው ኦ (N ^ 2).

የቦታ ውስብስብነት

ምንም ተጨማሪ ቦታ እየተጠቀምን አይደለም ፣ ስለሆነም የቦታ ውስብስብነት ነው ኦ (1).

አቀራረብ 2-ሀሺሽን መጠቀም  

ዋናዉ ሀሣብ

የእያንዲንደ የሰሌዳውን ንጥረ ነገር ድግግሞሽ በሃሽ ሰንጠረዥ ውስጥ እናከማቸዋለን። ያገኘናቸውን የማይደጋገሙ አባላትን ቁጥር የሚያከማች ቆጠራ ተለዋዋጭ እንጠብቃለን ፡፡ በመቀጠልም በሁሉም ንጥረ ነገሮች ላይ እንመረምራለን ፣ እና ለእያንዳንዱ ንጥረ ነገር ፣ ድግግሞሹ ከ 1 ይበልጣል ወይም አይበልጥም ፣ ከ 1 ጋር እኩል ከሆነ ፣ ከዚያ ቆጠራውን በ 1. እንጨምራለን። ከ K ጋር እኩል ነው ፣ ያንን ንጥረ ነገር እናተማለን።

ተመልከት
ክብ ድርድርን በመጠቀም የዲኪን ተግባራዊ ማድረግ

በድርድር ውስጥ ለ K-th ልዩ ንጥረ ነገር አልጎሪዝም

  1. የአንድን ድርድር እያንዳንዱን ንጥረ ነገር ድግግሞሽ የሚያከማች የሃሽ ሰንጠረዥ ያውጁ።
  2. በድርድሩ ውስጥ ያሉትን የተለያዩ ንጥረ ነገሮችን ብዛት የሚቆጥር ተለዋዋጭ ቆጠራን ከዜሮ ጋር ያስጀምሩ።
  3. ከ 0 እስከ n-1 ባለው ክልል ውስጥ ለእኔ አንድ ዙር ያሂዱ
    1. የ A [i] ድግግሞሽ 1 ከሆነ ፣ የመደመር ብዛት በ 1።
    2. ቆጠራ ከኬ ጋር እኩል ከሆነ ሀ [i] ን ያትሙ።
  4. ተመለስ

ለምሳሌ:

ሀ [] = {3,4,4,1,2,3}

K = 2

የሃሽ ጠረጴዛው እንደዚህ ይመስላል ፣

K-th የተለየ ንጥረ ነገር በአንድ ድርድር ውስጥ

አፈጻጸም

C ++ ፕሮግራም

#include <bits/stdc++.h>
using namespace std;
void kthDistinctElement(vector<int> &A, int k)
{
    int n = A.size();
    int count = 0;
    unordered_map<int, int> hash_table;
    for (int i = 0; i < n; i++)
    {
        hash_table[A[i]]++;
    }
    for (int i = 0; i < n; i++)
    {
        if (hash_table[A[i]] == 1)
        {
            count++;
        }
        if (count == k)
        {
            cout << "K-th non-repeating element is: " << A[i] << endl;
            return;
        }
    }
    cout << "K is greater than number of distinct element in the array." << endl;
    return;
}
int main()
{
    vector<int> A = {3, 4, 4, 1, 2, 3};
    int k = 2;
    kthDistinctElement(A, k);
    return 0;
}
K-th non-repeating element is: 2

የጃቫ ፕሮግራም

import java.util.*; 
public class Main
{
    static void kthDistinctElement(int A[], int k)
    {
        int n=A.length;
        int count = 0;
        HashMap <Integer, Integer> hash_table = new HashMap<Integer, Integer> ();  
        for (int i = 0; i < n; i++)  
        { 
            if(hash_table.containsKey(A[i])) 
                hash_table.put(A[i], hash_table.get(A[i]) + 1); 
            else
                hash_table.put(A[i], 1); 
        } 
        for (int i = 0; i < n; i++)
        {
            if (hash_table.get(A[i])==1)
            {
                count++;
            }
            if (count == k)
            {
                System.out.println("K-th non-repeating element is: " + A[i]);
                return;
            }
        }
        System.out.println("K is greater than number of distinct element in the array.");
    }
  public static void main(String[] args) {
    int A[] = {3, 4, 4, 1, 2, 3};
        int k = 2;
        kthDistinctElement(A, k);
  }
}
K-th non-repeating element is: 2

በአንድ ድርድር ውስጥ ለ K-th ልዩ ንጥረ ነገር ውስብስብነት ትንተና

የጊዜ ውስብስብነት

በድርድሩ ላይ ሁለቴ ብቻ እየሰራን ነው ፡፡ ስለዚህ ፣ አጠቃላይ የጊዜ ውስብስብነቱ ነው ኦ (ኤን).

ተመልከት
ከብዙ ተደጋጋሚ አባሎች መካከል በንባብ ድርድር ውስጥ ማንኛውንም ያግኙ

የቦታ ውስብስብነት

በድርድሩ ውስጥ ያሉትን ንጥረ ነገሮች ድግግሞሽ ለማስቀመጥ የሃሽ ሰንጠረዥን እንጠብቃለን። ስለዚህ, የቦታ ውስብስብነት ነው ኦ (ኤን).

ማጣቀሻዎች