រាប់ចំនួនត្រីកោណជាមួយផលិតផលស្មើនឹងចំនួនដែលបានផ្តល់


កម្រិតលំបាក មធ្យម
សួរញឹកញាប់ គួរឱ្យគោរព ក្រុមហ៊ុន Amazon ស៊ីស្កូ Flipkart គុលលីហ្សា Publicis Sapient
អារេ ហាស់ ទ្រនិចពីរ

បញ្ហា“ រាប់ចំនួនត្រីគុណដែលមានចំនួនស្មើនឹងចំនួនដែលបានផ្តល់ឱ្យ” ចែងថាយើងត្រូវបានគេផ្តល់នូវចំនួនគត់និងលេខ m។ សេចក្តីថ្លែងការណ៍បញ្ហាស្នើឱ្យរកចំនួនសរុបនៃចំនួនបីនៃផលិតផលស្មើនឹងចំនួនម៉ែត្រ។

ឧទាហរណ៍

arr[] = {1,5,2,6,10,3}
m=30
3

ការពន្យល់

ត្រីគុណដែលបានបង្កើតឡើងស្មើនឹងម៉ែត្រគឺ (១.៥.៦) (៥.២,៣) និង (១.៣,១០)

រាប់ចំនួនត្រីកោណជាមួយផលិតផលស្មើនឹងចំនួនដែលបានផ្តល់

arr[] = {2,4,5,1,10}
m=20
2

ការពន្យល់

ត្រីគុណដែលបានបង្កើតឡើងស្មើនឹងម៉ែត្រគឺ (២,១,១០), (៤.៥,១)

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

  1. ប្រកាសក ផែនទី.
  2. រក្សាទុកលិបិក្រមនៃធាតុនីមួយៗទៅក្នុងផែនទីដោយឆ្លងកាត់ឯកសារ អារេ.
  3. កំណត់លទ្ធផលទៅ ០ ។
  4. ឆ្លងកាត់អារេម្តងទៀតដោយប្រើរង្វិលជុំនៅខាងចុង៖
    1. ពិនិត្យមើលថាតើ ((ទៅដល់ [ខ្ញុំ] * ដល់ [ជ]] = = ម) && (មកដល់ [ខ្ញុំ] * មកដល់ [ជ]! = ០) && (ម៉ែ% (arr [ខ្ញុំ] * មកដល់ [ជ]) == ០ )) ។
      1. ប្រសិនបើវាត្រូវបានគេរកឃើញថាជាការពិតសូមស្វែងរក m / (arr [i] * arr [j]) ហើយស្វែងរកវានៅក្នុងផែនទី។
    2. ពិនិត្យរកមើលផងដែរធាតុទីបីដែលយើងបានរកឃើញថាមិនស្មើនឹងធាតុពីរបច្ចុប្បន្ន (arr [i] និង arr [j]) ។
      1. ប្រសិនបើលក្ខខណ្ឌពេញចិត្តបន្ទាប់មកបង្កើនចំនួនទិន្នផលដោយ 1 ។
  5. ត្រឡប់លទ្ធផល។

ការពន្យល់

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

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

បន្ទាប់ពីការឆ្លងកាត់នៃអារេយើងមានតំលៃនៅក្នុងហាស។ កំណត់តម្លៃនៃលទ្ធផលទៅ ០ ។ ឥលូវនេះយើងនឹងប្រើរង្វិលជុំដែលនៅខាងចុង។ នៅក្នុងនោះយើងយកធាតុមួយនៅក្នុងរង្វិលជុំខាងក្រៅហើយនៅក្នុងរង្វិលជុំខាងក្នុងបន្ទាប់ជ្រើសរើសយកធាតុមួយទៀត។ បន្ទាប់មកយើងនឹងរកឃើញធាតុទីបី។ លក្ខខណ្ឌទាំងអស់ដែលមាននៅក្នុង 'ប្រសិនបើសេចក្តីថ្លែងការណ៍' ត្រូវបានប្រើដើម្បីរកធាតុទីបី។ បន្ទាប់ពីធ្វើការមកដល់ [ខ្ញុំ] * [[]] អ្វីដែលយើងត្រូវរកគឺធាតុទីបី។ ដូច្នេះនៅលើកំណត់សំគាល់សាមញ្ញប្រសិនបើ a * b * c = m ⇒បន្ទាប់មក c = m / a * b ។

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

លេខកូដ C ++ ដើម្បីរាប់ចំនួនបីដងជាមួយនឹងផលិតផលស្មើនឹងចំនួនដែលបានផ្តល់

#include<iostream>
#include<unordered_map>
using namespace std;

int getProductTriplets(int arr[], int n, int m)
{
    unordered_map<int, int> numindex;
    for (int i = 0; i < n; i++)
        numindex[arr[i]] = i;

    int output = 0;

    for (int i = 0; i < n - 1; i++)
    {
        for (int j = i + 1; j < n; j++)
        {
            if ((arr[i] * arr[j] <= m) && (arr[i] * arr[j] != 0) && (m % (arr[i] * arr[j]) == 0))
            {
                int third = m / (arr[i] * arr[j]);
                auto it = numindex.find(third);

                if (third != arr[i] && third != arr[j]&& it != numindex.end() && it->second > i&& it->second > j)
                    output++;
            }
        }
    }
    return output;
}
int main()
{
    int arr[] = {1,5,2,6,10,3};
    int n = sizeof(arr) / sizeof(arr[0]);
    int m = 30;

    cout <<"Total product triplets are: "<<getProductTriplets(arr, n, m);
    return 0;
}
Total product triplets are: 3

កូដចាវ៉ាដើម្បីរាប់ចំនួនត្រីគុណដែលមានផលិតផលស្មើនឹងចំនួនដែលបានផ្តល់

import java.util.HashMap;

class TripletProductPair
{
    public static int getProductTriplets(int arr[], int n, int m)
    {
        HashMap<Integer, Integer> numindex = new HashMap<Integer, Integer>(n);
        for (int i = 0; i < n; i++)
            numindex.put(arr[i], i);

        int output = 0;
        for (int i = 0; i < n - 1; i++)
        {
            for (int j = i + 1; j < n; j++)
            {

                if ((arr[i] * arr[j] <= m) && (arr[i] * arr[j] != 0) && (m % (arr[i] * arr[j]) == 0))
                {
                    int third = m / (arr[i] * arr[j]);

                    numindex.containsKey(third);
                    if (third != arr[i] && third != arr[j]&& numindex.containsKey(third) && numindex.get(third) > i && numindex.get(third) > j)
                    {
                        output++;
                    }
                }
            }
        }
        return output;
    }
    public static void main(String[] args)
    {
        int arr[] = {1,5,2,6,10,3};
        int m = 30;
        System.out.println("Total product triplets are: "+getProductTriplets(arr, arr.length, m));
    }
}
Total product triplets are: 3

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

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

ឱ (ន។ )2ដែលជាកន្លែងដែល “ n” គឺជាចំនួនធាតុក្នុងអារេ។ ចាប់តាំងពីយើងបានប្រើរង្វិលជុំដែលមានពីរហើយបានប្រើហាស់ម៉ាសដើម្បីស្វែងរកធាតុទីបី។ ដូច្នេះប្រតិបត្តិការស្វែងរកនេះកំពុងត្រូវបានធ្វើឡើងដោយហាស់ម៉ាប់នៅអូរ (១) ដែលត្រូវបានធ្វើពីមុននៅក្នុងពេលវេលាអូ (N) តាមវិធីឆោតល្ងង់។ ដូច្នេះការបង្កើនល្បឿននេះគឺដោយសារតែកម្មវិធី HashMap ។

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

អូរ (n) ដែលជាកន្លែងដែល “ n” គឺជាចំនួនធាតុក្នុងអារេ។ ពីព្រោះយើងនឹងរក្សាទុកធាតុទាំងអស់នៅក្នុងផែនទី។ ភាពស្មុគស្មាញនៃលំហគឺលីនេអ៊ែរ។