រកឃើញធាតុផ្សេងគ្នាដែលមានលក្ខណៈទូទៅចំពោះជួរដេកទាំងអស់នៃម៉ាទ្រីស  


កម្រិតលំបាក រឹង
សួរញឹកញាប់ BlackRock Expedia ដោយឡែកក្រុមហ៊ុន JP Morgan ក្រុមហ៊ុន qualcomm Snapdeal Yatra Zoho
ហាសហាស។ ម៉ាទ្រីស តម្រៀប

សេចក្តីថ្លែងការណ៍បញ្ហា។  

យើងត្រូវបានផ្តល់ម៉ាទ្រីសនៃចំនួនគត់ទាំងអស់។ បញ្ហា“ រកឃើញធាតុផ្សេងគ្នាដែលមានជាទូទៅចំពោះជួរដេកទាំងអស់នៃម៉ាទ្រីស” ស្នើឱ្យរកឃើញធាតុខុសគ្នាទាំងអស់ដែលអាចកើតមានប៉ុន្តែជារឿងធម្មតានៅក្នុងជួរនីមួយៗដែលមាននៅក្នុងម៉ាទ្រីស។

ឧទាហរណ៍  

arr[]={ {11, 12, 3, 10},

{11, 5, 8, 3},

{7, 11, 3, 10},

{9, 10, 11, 3}}
3 11

ការពន្យល់ៈ ៣ និង ១១ គឺជាលេខពីរដែលខុសគ្នានិងជារឿងធម្មតាដែរនៅក្នុងជួរនីមួយៗក្នុងម៉ាទ្រីសដែលបានផ្តល់។

ក្បួនដោះស្រាយដើម្បីរកឃើញធាតុផ្សេងគ្នាដែលមានលក្ខណៈទូទៅចំពោះជួរដេកទាំងអស់នៃម៉ាទ្រីស  

1. Declare a Set “SETValue”.
2. Add all the values of the first row of a matrix into the “SETValue”.
3. Traverse the matrix from the second row of a given matrix.
  1. Declare a new set let’s say “temp”, every time for each row of a matrix.
    1. Add all the values of that particular row in “temp” Set.
  2. Iterate over the set “SETValue” in which we stored our first row values.
    1. Check if temp contains any of the value of SETValue.
      1. If it contains, then removes that value from the SETValue.
  3. If SETValue size is equal to 0, then break the loop.
4. Traverse SETValue and print all the values in it.

ការពន្យល់

ដែលបានផ្តល់ឱ្យម៉ាទ្រីសនៃចំនួនគត់។ ភារកិច្ចរបស់យើងគឺស្វែងរកតម្លៃដែលអាចធ្វើបាននៃម៉ាទ្រីសដែលខុសគ្នាពីគ្នាទៅវិញទៅមក។ ហើយក៏ជារឿងធម្មតាផងដែរនៅក្នុងជួរនីមួយៗនៅក្នុងម៉ាទ្រីស។ យើងនឹងប្រើសំណុំទិន្នន័យរចនាសម្ព័ន្ធក្នុងការដោះស្រាយសំណួរនេះ។ រចនាសម្ព័ន្ធទិន្នន័យសំណុំនេះជួយក្នុងការដកចេញឬមិនទទួលយកធាតុដែលបានចម្លង។ យើងនឹងឆ្លងកាត់ម៉ាទ្រីសពីជួរទីពីរនៃម៉ាទ្រីស។ ដោយសារតែជួរទីមួយយើងនឹងត្រូវបានកំណត់ទៅសំណុំរួចហើយ។

សូម​មើល​ផង​ដែរ
Subarray តូចជាងគេបំផុតជាមួយនឹងលេខ k ខុសគ្នា

យើងនឹងប្រកាសឈុតដំបូងហៅថា SETValue ហើយបន្ថែមតម្លៃទាំងអស់នៃជួរទីមួយរបស់ម៉ាទ្រីសទៅក្នុងសំណុំ។ នេះគឺដោយសារតែយើងត្រូវពិនិត្យមើលធាតុទាំងអស់ដែលពួកគេគួរតែមានជាទូទៅនៅក្នុងជួរទាំងអស់។ ដូច្នេះយើងអាចប្រើជួរដេកដំបូងដែលនឹងត្រូវបានកំណត់ទៅសំណុំជាឯកសារយោង។

យើងនឹងឆ្លងកាត់ម៉ាទ្រីសឥឡូវនេះពីធាតុជួរដេកទីពីរពីព្រោះយើងបានគ្របដណ្តប់ជួរទីមួយរួចហើយហើយពីជួរទីពីរយើងនឹងយកថ្មី កំណត់ តាមពិតរចនាសម្ព័ន្ធទិន្នន័យយើងនឹងយករចនាសម្ព័ន្ធទិន្នន័យថ្មីសម្រាប់ជួរនីមួយៗនៃម៉ាទ្រីសដែលបានផ្តល់ឱ្យនៅក្នុងដំណើរឆ្លងកាត់។ ពីព្រោះយើងត្រូវទុកធាតុជួរដេកជាក់លាក់ទាំងនោះទៅក្នុងឈុតថ្មីហៅថា“ បណ្ដោះអាសន្ន” ។ បន្ទាប់មកយើងនឹងពិនិត្យមើលថាតើតម្លៃណាមួយនៃតម្លៃ SETValue មាននៅក្នុង temp ប្រសិនបើមានវត្តមានបន្ទាប់មកយើងនឹងយកធាតុនោះចេញ។ ដូចគ្នានេះផងដែរយើងបានដាក់លក្ខខណ្ឌមួយនៅទីនោះដើម្បីពិនិត្យមើលតម្លៃលើកលែងព្រួញកណ្តុរ។ ប្រសិនបើទំហំនៃសំណុំ SETValue នឹងក្លាយជា 0 នោះវានឹងបំបែករង្វិលជុំហើយនឹងមិនមានកំហុសពេលរត់ទេ។

នៅពេលយើងដកធាតុចេញពី SETValue យើងមានតំលៃលទ្ធផលនៅទីនោះបន្ទាប់ពីឆ្លងកាត់ដូច្នេះយើងនឹងបោះពុម្ពតម្លៃទាំងនោះ។

រកឃើញធាតុផ្សេងគ្នាដែលមានលក្ខណៈទូទៅចំពោះជួរដេកទាំងអស់នៃម៉ាទ្រីសពិន

លេខកូដ  

លេខកូដ C ++ ដើម្បីរកឃើញធាតុផ្សេងគ្នាដែលមានលក្ខណៈទូទៅចំពោះជួរដេកទាំងអស់នៃម៉ាទ្រីស

#include<unordered_set>
#include<iostream>

using namespace std;

const int MAX = 100;

void getDistinctCommonElements (int mat[][MAX], int n)
{
    unordered_set<int> SETValue;

    for (int i=0; i<n; i++)
        SETValue.insert(mat[0][i]);

    for (int i=1; i<n; i++)
    {
        unordered_set<int> temp;

        for (int j=0; j<n; j++)
            temp.insert(mat[i][j]);

        unordered_set<int>:: iterator itr;

        for (itr=SETValue.begin(); itr!=SETValue.end(); itr++)

            if (temp.find(*itr) == temp.end())
                SETValue.erase(*itr);

        if (SETValue.size() == 0)
            break;
    }
    unordered_set<int>:: iterator itr;
    for (itr=SETValue.begin(); itr!=SETValue.end(); itr++)
        cout << *itr << " ";
}
int main()
{
    int mat[][MAX] =  { {11, 12, 3, 10},
        {11, 5, 8, 3},
        {7, 11, 3, 1},
        {9, 0, 11, 3}
    };
    int n = 4;
    getDistinctCommonElements (mat, n);
    return 0;
}
3 11

កូដចាវ៉ាដើម្បីរកឃើញធាតុប្លែកៗជាទូទៅចំពោះជួរដេកទាំងអស់នៃម៉ាទ្រីស

import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.Collection;

class DistinctCommonElements
{
    public static void getDistinctCommonElements(int mat[][], int n)
    {
        Collection<Integer> removeElements = new LinkedList<Integer>();
        HashSet<Integer> SETValue=new HashSet<>();

        for (int i=0; i<n; i++)
            SETValue.add(mat[0][i]);

        for (int i=1; i<n; i++)
        {
            HashSet<Integer> temp= new HashSet<Integer>();
            for (int j=0; j<n; j++)
                temp.add(mat[i][j]);

            for(Integer element : SETValue)
                if(!(temp.contains(element)))
                    removeElements.add(element);

            SETValue.removeAll(removeElements);

            if (SETValue.size() == 0)
                break;
        }
        Iterator<Integer> itr=SETValue.iterator();
        while(itr.hasNext())
            System.out.print(itr.next()+" ");
    }
    public static void main(String [] args)
    {
        int mat[][] = { {11, 12, 3, 10},
            {11, 5, 8, 3},
            {7, 11, 3, 10},
            {9, 10, 11, 3}
        };
        int n = 4;
        getDistinctCommonElements (mat, n);
    }
}
3 11

ការវិភាគស្មុគស្មាញ  

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

នៅទីនេះយើងបានប្រើរង្វិលជុំដែលបានដាក់ជាពីរហើយការប្រើពេលវេលាមិនត្រឹមត្រូវ / ហាស់សេតបានផ្តល់ពេលវេលាស្មុគស្មាញដល់យើង។ ឱ (ន។ )2) ដែលជាកន្លែងដែល “ n” គឺជាទំហំនៃម៉ាទ្រីស។

សូម​មើល​ផង​ដែរ
ធាតុទីមួយកើតឡើង k ដងក្នុងអារេមួយ

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

អូរ (n) ដែលជាកន្លែងដែល “ n” គឺជាទំហំនៃម៉ាទ្រីសសម្រាប់រក្សាទុកធាតុបញ្ចូលនិងរក្សាទុកក្នុងហាស់សិន។