ការកើតឡើងជាក្រុមច្រើននៃធាតុអារេដែលបានបញ្ជាដោយការកើតឡើងលើកដំបូង


កម្រិតលំបាក មានភាពងាយស្រួល
សួរញឹកញាប់ គួរឱ្យគោរព កម្មវិធី Adob ​​e ក្រុមហ៊ុន Amazon ដេលីវ៉ាយ Fourkites
អារេ ហាស់

អ្នកត្រូវបានគេផ្តល់ឱ្យសំណួរដែលអ្នកបានផ្តល់ឱ្យដែលមិនបានតម្រៀបមួយ អារេ ជាមួយការកើតឡើងច្រើននៃលេខ។ ភារកិច្ចគឺដើម្បីដាក់ជាក្រុមនូវការកើតឡើងច្រើនដងនៃធាតុអារេដែលបានបញ្ជាដោយការកើតឡើងដំបូង។ ទន្ទឹមនឹងនេះការបញ្ជាទិញគួរតែដូចគ្នានឹងលេខដែលបានមក។

ឧទាហរណ៍

បញ្ចូល:

[២, ៣,៤,៣,១,៣,២,៤]

លទ្ធផល:

[២ ២ ៣ ៣ ៤ ៤ ១]

បញ្ចូល:

[១៩៤៥៩១២២]

លទ្ធផល:

[២ ២ ៣ ៣ ៤ ៤ ១]

ក្បួនដោះស្រាយ

  1. ប្រកាស ហាស់ម៉ាប់.
  2. ឆ្លងកាត់អារេហើយដាក់ធាតុទាំងអស់និងប្រេកង់របស់វាទៅក្នុងហាស់ម៉ាស។
  3. ខណៈពេលដែលឆ្លងកាត់អារេនិងទទួលបានភាពញឹកញាប់នៃធាតុនីមួយៗ។
    1. ព្រីនកូនសោរនោះរហូតដល់ម៉ោងប្រេកង់នោះ។
    2. យកចំនុចនោះចេញ [i] (កូនសោ) ។

ការពន្យល់សម្រាប់ក្រុមច្រើនដងនៃធាតុអារេ

យើងនឹងប្រើហាស់សម្រាប់វា។ ហាន់ស៍ផ្តល់នូវលក្ខណៈពិសេសនៃការរក្សាទុកធាតុជាគូតម្លៃសំខាន់។ នៅក្នុងសំណួរនេះយើងនឹងប្រើកូនសោជាធាតុអារេនិងតម្លៃដែលជាប្រេកង់នៃធាតុនីមួយៗ។ យើងគ្រាន់តែបញ្ចូលធាតុប្រសិនបើវាមិនមាននៅក្នុងតារាងហាស។ ផ្សេងទៀតបង្កើនចំនួន (តម្លៃគ្រាប់ចុច) នៃធាតុ។

ដំបូងយើងនឹងប្រកាស HashMap និយាយថា“ MyMap” ។ បន្ទាប់មកយើងឆ្លងកាត់អារេទាំងមូលហើយរាប់និងរក្សាទុក ប្រេកង់ នៃធាតុនីមួយៗ។

ចូរយើងពិចារណាឧទាហរណ៍ហើយយល់ពីវា។

ឧទាហរណ៍

មកដល់ = [៥, ៤, ១, ៥, ៤, ១, ៥, ៦]

i = 0, មកដល់ [ខ្ញុំ] = ៥

myMap = {៥: ១}

i = 1, មកដល់ [ខ្ញុំ] = ៥

myMap = {៤: ១.៥: ១}

i = 2, មកដល់ [ខ្ញុំ] = ៥

myMap = {1: 1,4: 1,5: 1}

i = 3, មកដល់ [ខ្ញុំ] = ៥

myMap = {1: 1,4: 1,5: 2}

i = 4, មកដល់ [ខ្ញុំ] = ៥

myMap = {1: 1,4: 2,5: 2}

i = 5, មកដល់ [ខ្ញុំ] = ៥

myMap = {1: 2,4: 2,5: 2}

i = 6, មកដល់ [ខ្ញុំ] = ៥

myMap = {1: 2,4: 2,5: 3}

i = 6, មកដល់ [ខ្ញុំ] = ៥

myMap={1:2,4:2,5:3,6:1}

ឥឡូវយើងនឹងមាន myMap និងតម្លៃនៅក្នុងវា។

យើងនឹងទទួលបានប្រេកង់បន្ទាប់ពីឆ្លងកាត់អារេម្តងទៀតជាមួយធាតុដែលបានបញ្ជាទិញនៅក្នុងអារេ។ ចាប់យកធាតុអារេនីមួយៗជាមួយនឹងប្រេកង់របស់វាហើយបង្កើតរង្វិលជុំរហូតដល់ពេលវេលាប្រេកង់នោះហើយបន្ទាប់ពីបោះពុម្ពធាតុអារេទាំងអស់រហូតដល់ពេលប្រេកង់ដោះសោអារេនោះចេញដូច្នេះវានឹងមិនបោះពុម្ពម្តងទៀតនៅក្នុងដំណើរឆ្លងកាត់។

មកដល់ [ខ្ញុំ] = ៥ ប្រេកង់ = ៣

៥ នឹងត្រូវបានបោះពុម្ព ៣ ដងបន្ទាប់មកយើងនឹងដកកូនសោនោះចេញនៅក្នុង myMap ដូច្នេះរាល់ពេលដែលយើងអានលេខ ៥ ក្នុងជួរមួយវានឹងមិនមាននៅក្នុងហាសនិងមិនបោះពុម្ពទេ។

មកដល់ [ខ្ញុំ] = ៥ ប្រេកង់ = ៣

៤ នឹងត្រូវបានបោះពុម្ព ២ ដងគ្រាប់ចុចនឹងត្រូវបានដកចេញនៅក្នុង myMap ដូច្នេះរាល់ពេលដែលយើងអាន ៤ ក្នុងជួរមួយវានឹងមិនមាននៅក្នុងហាស់ម៉ាសនិងមិនបោះពុម្ពទេ។

មកដល់ [ខ្ញុំ] = ៥ ប្រេកង់ = ៣

១ នឹងត្រូវបោះពុម្ព ២ ដងបន្ទាប់មកយើងនឹងដកកូនសោនោះចេញនៅក្នុង myMap ដូច្នេះរាល់ពេលយើងអានលេខ ៥ ជាជួរហើយវានឹងមិនមាននៅក្នុងហាស់ម៉ាសនិងមិនបោះពុម្ពទេ។

ឥលូវនេះ ៥ បានតំរៀបជាជួរប៉ុន្តែវានឹងមិនមាននៅក្នុង HashMap ទេហើយវាកើតឡើងដូចគ្នានិងមិនធ្វើអ្វីទាល់តែរកឃើញធាតុដែលមាននៅក្នុង HashMap ។

មកដល់ [ខ្ញុំ] = ប្រេកង់ ៦ = ១

៦ នឹងត្រូវបានបោះពុម្ព ១ ដងគ្រាប់ចុចនឹងត្រូវបានដកចេញនៅក្នុង myMap ដូច្នេះរាល់ពេលដែលយើងអាន ៤ ក្នុងជួរវានឹងមិនមាននៅក្នុងហាសនិងមិនបោះពុម្ពទេ។

ឥឡូវនេះយើងនឹងទទួលបានលទ្ធផលដូច ៥ ៥ ៥ ៤ ៤ ១ ១ ៦ ។

ការអនុវត្តន៍

កម្មវិធី C ++ សម្រាប់ការកើតឡើងជាក្រុមច្រើននៃធាតុអារេដែលត្រូវបានបញ្ជាដោយការកើតឡើងលើកដំបូង

#include<iostream>
#include<unordered_map>

using namespace std;
void arrangeInOrder(int arr[], int n)
{
    unordered_map<int, int> myMap;

    for (int i=0; i<n; i++)
    {
        myMap[arr[i]]++;
    }
    for (int i=0; i<n; i++)
    {
        int count = myMap[arr[i]];
        for (int j=0; j<count; j++)
            cout<<arr[i]<< " ";

        myMap.erase(arr[i]);
    }
}
int main()
{
    int arr[] = {10, 5, 3, 10, 10, 4, 1, 3};
    int n=sizeof(arr)/sizeof(arr[0]);
    arrangeInOrder(arr,n);
    return 0;
}
10 10 10 5 3 3 4 1

កម្មវិធីចាវ៉ា

import java.util.HashMap;

class multipleOccurences
{
    public static void arrangeInOrder(int arr[])
    {
        HashMap<Integer, Integer> myMap= new HashMap<Integer, Integer>();

        for (int i=0; i<arr.length; i++)
        {
            Integer current = myMap.get(arr[i]);
            if (current == null)
                current = 0;

            myMap.put(arr[i], current + 1);
        }
        for (int i=0; i<arr.length; i++)
        {
            Integer count = myMap.get(arr[i]);
            if (count != null)
            {
                for (int j=0; j<count; j++)
                {
                    System.out.print(arr[i] + " ");
                }
                myMap.remove(arr[i]);
            }
        }
    }
    public static void main (String[] args)
    {
        int arr[] = {10, 5, 3, 10, 10, 4, 1, 3};
        arrangeInOrder(arr);
    }
}
10 10 10 5 3 3 4 1

ការវិភាគស្មុគស្មាញសម្រាប់ការកើតឡើងច្រើនក្រុមនៃធាតុអារេ

ស្មុគស្មាញពេលវេលា

អូរ (n) ដែលជាកន្លែងដែល “ n” គឺជាចំនួនធាតុក្នុងអារេ។

ភាពស្មុគស្មាញនៃលំហ

អូរ (n) ដែលជាកន្លែងដែល “ n” គឺជាចំនួនធាតុក្នុងអារេ។

ឯកសារយោង