លេខជាប់គ្នាអតិបរមាបង្ហាញជាអារេ


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

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

ឧបមាថាអ្នកមានអារេមួយ ចំនួនគត់ នៃទំហំអិនបញ្ហា“ លេខជាប់គ្នាអតិបរិមាដែលមាននៅក្នុងអារេ” ស្នើឱ្យស្វែងយល់ពីចំនួនអតិបរមានៃលេខជាប់គ្នាដែលអាចខ្ចាត់ខ្ចាយជាជួរ។

ឧទាហរណ៍

arr[] = {2, 24, 30, 26, 99, 25}
3

ការពន្យល់: លេខតគ្នាគឺ, ២៤, ២៥, ២៦ (ឈុត ៣) ។

arr[] = { -8, 9 , -1, -6, -5}
2

ការពន្យល់: លេខជាប់គ្នាគឺ⇒ -៦, -៥ (ឈុត ២) ។

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

1. Declare a set.
2. Do traversing of the array, and insert all the values of array into the Set.
3. Set output to 0.
4. Traverse the array from i=0, to i<n(length of the array).
  1. Check if Set contains the arr[i].
    1. If true, then pick the current array element and store it to temp.
  2. While Set contains the temp, repeatedly increases the values of temp.
  3. Find out the maximum between output and temp-arr[i] and store it into the output.
5. Return output.

ការពន្យល់

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

យើងនឹងបន្ថែមតម្លៃទាំងអស់នៃអារេទៅក្នុងសំណុំ។ ពីព្រោះនៅពេលក្រោយយើងនឹងពិនិត្យមើលលេខបន្តបន្ទាប់ផងដែរ។ យើងនឹងឆ្លងកាត់អារេម្តងទៀតដោយជ្រើសរើសយកធាតុនីមួយៗហើយពិនិត្យមើលថាតើមាន ផែនទី មាននោះមកដល់ [ខ្ញុំ] បើពិតអញ្ចឹងយើងនឹងជ្រើសរើសយកធាតុនោះទៅជាអថេរបណ្តោះអាសន្នហើយពិនិត្យមើលម្តងទៀតប្រសិនបើផែនទីមានបណ្ដុំ temp នោះប្រសិនបើពិតបន្ទាប់មកបង្កើនតំលៃនៃ temp ដោយ ១ ហើយបន្ទាប់មកពិនិត្យម្តងទៀតហើយ បង្កើនវាជាថ្មីម្តងទៀតបន្តរហូតដល់ផែនទីមិនមានតំលៃបន្ថែម។ ឥលូវនៅពេលយើងចេញពីរង្វិលជុំនេះយើងនឹងទទួលបានគុណតម្លៃបន្ថែមទៀតនៃធាតុអារេបច្ចុប្បន្នដែលមាននៅក្នុងផែនទីយើងក៏បង្កើនវាដោយចំនួន ១ ដែរដូច្នេះវាក៏នឹងមានលេខជាប់គ្នាដែរ។

ឥលូវនេះយើងត្រូវរកឱ្យឃើញនូវលទ្ធផលអតិបរិមានិងភាពខុសគ្នានៃបណ្ដោះអាសន្ន [កុំ] កុំគិតថាដូចជាភាពខុសគ្នានេះផ្តល់នូវចំនួនខុសនៃការរាប់ដូចដែលយើងនឹងទទួលបាននូវតម្លៃកើនឡើងនៃបណ្ដោះអាសន្នពេលចេញពី រង្វិលជុំយើងនឹងទទួលបានចំនួនត្រឹមត្រូវនៃលេខជាប់គ្នា។ បន្ទាប់មកយើងនឹងរក្សាទុកអតិបរិមារវាងទិន្នផលនិងភាពខុសគ្នានៃបណ្ដោះអាសន្ន [អាយ] (ទិន្នផល, temp-arr [i]) ។ មកដល់ [ខ្ញុំ] គ្រាន់តែជាចំណុចចាប់ផ្តើមនៃលេខបន្តបន្ទាប់និងបណ្ដុំៗដែលជាចំនុចបញ្ចប់។ ជំហានទាំងនេះនឹងត្រូវបានធ្វើម្តងទៀតរហូតដល់យើងរកឃើញលទ្ធផលអតិបរមាបន្ទាប់ពីខណៈពេលឆ្លងកាត់អារេទាំងមូល។

លេខជាប់គ្នាអតិបរមាបង្ហាញជាអារេ

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

កម្មវិធី C ++ ដើម្បីស្វែងរកលេខជាប់គ្នាអតិបរិមាដែលមាននៅក្នុងអារេ

#include<iostream>
#include<unordered_set>

using namespace std;

int getMaxConsecutiveNumber(int arr[], int n)
{
    unordered_set<int> SET;
    for (int i = 0; i < n; i++)
        SET.insert(arr[i]);

    int output = 0;
    for (int i = 0; i < n; i++)
    {
        if (SET.find(arr[i] - 1) == SET.end())
        {
            int temp = arr[i];

            while (SET.find(temp) != SET.end())
                temp++;

            output = max(output, temp - arr[i]);
        }
    }
    return output;
}
int main()
{
    int arr[] = {2, 24, 30, 26, 99, 25 };
    int n = sizeof(arr) / sizeof(int);
    cout << "Largest Set found : "<<getMaxConsecutiveNumber(arr, n)<< endl;
    return 0;
}
Largest Set found : 3

កម្មវិធីចាវ៉ាដើម្បីស្វែងរកលេខជាប់គ្នាអតិបរមាបង្ហាញជាអារេ

import java.util.HashSet;

class LargestConsecutiveSet
{
    public static int getMaxConsecutiveNumber(int arr[], int n)
    {
        HashSet<Integer> SET = new HashSet<Integer>();
        for (int i = 0; i < n; i++)
        {
            SET.add(arr[i]);
        }
        int output = 0;
        for (int i = 0; i < n; i++)
        {
            if(SET.contains(arr[i]))
            {
                int temp = arr[i];
                while (SET.contains(temp))
                    temp ++;

                output = Math.max(output, temp - arr[i]);
            }
        }
        return output;
    }
    public static void main(String[] args)
    {
        int arr[] = {2, 24, 30, 26, 99, 25};
        int n = arr.length;
        System.out.println("Largest Set found : "+getMaxConsecutiveNumber(arr, n));
    }
}
Largest Set found : 3

ការវិភាគស្មុគស្មាញសម្រាប់រកលេខជាប់គ្នាអតិបរិមាដែលមានបង្ហាញជាអារេ

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

អូរ (n) ដែលជាកន្លែងដែល “ n” គឺជាចំនួនធាតុក្នុងអារេ។ ដោយសារតែយើងបានប្រើហាស់សេតដែលអនុញ្ញាតឱ្យការបញ្ចូលការលុបនិងប្រតិបត្តិការស្វែងរកក្នុងពេលវេលាថេរ។

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

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

ឯកសារយោង