נומערן מיט הויפּט פריקוואַנסיז גרעסער ווי אָדער גלייַך צו ק  


שוועריקייט לעוועל גרינג
אָפט געבעטן אין אַקקאָליטע אַמאַזאָן פאַקסעט פאָורקיטעס גריי אָראַנדזש פּינטערעסט Xome
מענגע האַש הויפּט נומער

פּראָבלעם סטאַטעמענט  

פּראָבלעם "נומערן מיט הויפּט פריקוואַנסיז גרעסער ווי אָדער גלייַך צו ק" שטאַטן אַז איר באַקומען אַ מענגע פון ​​ינטאַדזשערז נומער n און אַ ינטאַדזשער ווערט k. אַלע נומערן אין עס זענען הויפּט נומערן. די פּראָבלעם ויסזאָגונג פרעגט צו געפֿינען די נומערן וואָס זענען געוויזן אין די מענגע אין מינדסטער ק מאָל און אַ הויפּט נומער פון מאָל אין די מענגע.

בייַשפּיל  

arr[] = {29, 11, 37, 53, 53, 53, 29, 53, 29, 53}, k = 2
29 and 53

דערקלערונג: 29 און 53 דערשייַנען 3 מאָל און 5 מאָל ריספּעקטיוולי, וואָס אויך באַפרידיקן די צושטאַנד צו דערשייַנען אין מינדסטער ק מאָל

אַלגערידאַם צו געפֿינען נומערן מיט הויפּט פריקוואַנסיז גרעסער ווי אָדער גלייַך צו ק  

1. Declare a map and store all the numbers of the array in the map with their frequencies.
2. Traverse the map.
    1. Check if the frequency of each element is at least k or greater than k.
    2. Find if that frequency is a prime number or not.
    3. If the frequency is a prime number then print that key else go for other numbers.

דערקלערונג

מיר האָבן געגעבן אַ מענגע פון ​​ינטאַדזשערז און אַ ווערט k. כל די נומערן זענען אויך ערשטיק, מיר האָבן געבעטן צו געפֿינען אויס אויב די נומער איז לפּחות k מאָל און קיין הויפּט נומער מאָל אין די מענגע, און דרוק דעם נומער. צו סאָלווע דעם, מיר וועלן נוצן די האַשינג מעטאָד. מיר וועלן נוצן אַ מאַפּע. אונדזער אַרבעט איז צו געפֿינען די אויסזען פון אַ נומער, עס מיטל אַז מיר מוזן געפֿינען די פּאַסירונג פון יעדער עלעמענט, צו באַשליסן דאָס מיר וועלן נוצן אַ מאַפּע.

זע אויך
סומע פון ​​f (a [i], a [j]) איבער אַלע פּערז אין אַ מענגע פון ​​N ינטאַדזשערז

מיר וועלן אַריבער די מענגע און ציילן און קראָם יעדער עלעמענט און די אָפטקייַט אין די מאַפּע. אויב די נומער איז אַ נייַע פּאָזיציע אין די מאַפּע, מאַכן עס אַ פּלאַץ אין די מאַפּע און צייכן די אָפטקייַט ווי 1. אויב עס שוין יגזיסץ, באַקומען דיין אָפטקייַט און פאַרגרעסערן די אָפטקייַט מיט 1 און אַרייַן די אָפטקייַט ווידער מיט זייַן נומער. אויף דעם וועג, מיר קענען ציילן אַלע די פריקוואַנסיז פון יעדער נומער. איצט מיר דאַרפֿן צו קאָנטראָלירן צי די אָפטקייַט פון יעדער נומער, ערשטער, קיי נומער פון מאל, און די נומער פון מאָל עס איז אַ הויפּט נומער.

אין דעם פאַל, מיר וועלן דורכגיין יעדער שליסל אין אַ מאַפּע און באַקומען די אָפטקייַט. מיר האָבן געמאכט אַ פֿונקציע וואָס קאָנטראָלירט אויב די אָפטקייַט איז אַ הויפּט נומער אָדער נישט. פֿאַר הויפּט נומער, עס זאָל נישט זיין 1, און עס זאָל נישט זיין דיוויזאַבאַל דורך אן אנדער נומער ווי זיך. אויב עס איז דיווייזאַבאַל דורך קיין נומער, קערט פאַלש צוריק. אויב עס איז צעטיילט, דרוק דעם שליסל איז די נומער פון די אָפטקייַט און גיינ ווייַטער פֿאַר אן אנדער נומער.

 

נומערן מיט הויפּט פריקוואַנסיז גרעסער ווי אָדער גלייַך צו ק

 

קאָדעקס  

C ++ קאָד צו געפֿינען נומערן מיט הויפּט פריקוואַנסיז גרעסער ווי אָדער גלייַך צו ק

#include<iostream>
#include<unordered_map>

using namespace std;

bool checkIfPrime(int n)
{
    if (n <= 1)
        return false;

    for (int i = 2; i < n; i++)
        if (n % i == 0)
            return false;

    return true;
}
void numberWithPrimeFreq(int arr[], int k)
{
    unordered_map<int, int> MAP;

    for (int i = 0; i < 12; i++)
        MAP[arr[i]]++;

    for (auto x : MAP)
    {
        if (checkIfPrime(x.second) && x.second >= k)
            cout << x.first << endl;
    }
}
int main()
{
    int arr[] = { 29,11,37,53,53,53,29,53,29,53 };
    int k = 2;

    numberWithPrimeFreq(arr, k);
    return 0;
}
29
53

Java קאָד צו געפֿינען נומערן מיט הויפּט פריקוואַנסיז גרעסער ווי אָדער גלייַך צו ק

import java.util.HashMap;
import java.util.Map;

public class  Frequencies_PrimeNumber
{
  public static void numberWithPrimeFreq(int[] arr, int k)
  {
    Map<Integer, Integer> MAP = new HashMap<>();

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

      int freq;
      if (MAP.containsKey(val))
      {
        freq = MAP.get(val);
        freq++;
      }
      else
        freq = 1;
      MAP.put(val, freq);
    }
    for (Map.Entry<Integer, Integer> entry :MAP.entrySet())
    {
      int TEMP = entry.getValue();
      if (checkIfPrime(TEMP) && TEMP >= k)
        System.out.println(entry.getKey());
    }
  }
  private static boolean checkIfPrime(int n)
  {
    if ((n > 2 && n % 2 == 0) || n == 1)
      return false;

    for (int i = 2 ; i <n;	i ++)
    {
      if (n % i == 0)
        return false;
    }
    return true;
  }
  public static void main(String[] args)
  {
    int[] arr = { 29,11,37,53,53,53,29,53,29,53 };
    int k = 2;

    numberWithPrimeFreq(arr, k);
  }
}
53
29

קאַמפּלעקסיטי אַנאַליסיס  

צייט קאַמפּלעקסיטי

דאָ, באַטראַכטן מיר האָבן n / k עלעמענטן מיט אָפטקייַט k, אַזוי אַז יעדער פּרימאַליטי וועט זיין אָפּגעשטעלט. די פּרימאַליטי קאָנטראָלירונג נעמט בלויז אָ (n) צייט. דאָ N איז די אָפטקייַט. אפילו אין די ערגסט פאַל, די גאנצע אַלגערידאַם קענען לויפן אין לינעאַר צייט. אָ (N) ווו "N"  איז די נומער פון עלעמענטן אין דער מענגע.

זע אויך
ינטעגער צו ענגליש ווערטער

ספעיס קאַמפּלעקסיטי

ווייַל פון די פּלאַץ פארלאנגט פֿאַר סטאָרידזש די ינפּוט, אָ (N) ווו "N"  איז די נומער פון עלעמענטן אין דער מענגע.