បំបែកលេខ ០ និង ១ ក្នុងអារេ


កម្រិតលំបាក មានភាពងាយស្រួល
សួរញឹកញាប់ គួរឱ្យគោរព ក្រុមហ៊ុន Amazon Fab MakeMyTrip បានតាមរយៈការ Paytm Zoho
អារេ

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

ឧបមាថាអ្នកមាន integer អារេ។ បញ្ហា“ Segregate 0s និង 1s នៅក្នុងជួរមួយ” ស្នើឱ្យបែងចែកអារេជាពីរផ្នែកគឺលេខ 0 និងលេខ 1 ។ លេខ ០ គួរតែស្ថិតនៅផ្នែកខាងឆ្វេងនៃអារេនិង ១ នៅខាងស្តាំអារេ។

ឧទាហរណ៍

arr[]={1,0,1,1,0,1,1,0}
0 0 0 1 1 1 1 1
ការពន្យល់: លេខ ០ ទាំងអស់ត្រូវបានប្តូរទៅខាងឆ្វេងហើយលេខ ១ ត្រូវបានប្តូរទៅខាងស្តាំ។

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

1. Traverse the array and get the count of total zero’s in the array.
2. Push ‘0’ that

រាប់ចំនួនដងក្នុងជួរអារេ

.
3. Push ‘1’ (n – count) no of times in the array from the next position of 0 where we left inserting 0.
4. Print the array.

ការពន្យល់សម្រាប់ស៊្រីស៊្រីតលេខ ៩ និង ១ នៅក្នុងអារេ

ដែល​បាន​ផ្ដល់​ឱ្យ អារេ នៃចំនួនគត់ក្នុងចំនួនគត់វានឹងផ្ទុកតែលេខ ០ និង ១ នៅក្នុងអារេ។ រៀបចំអារេឡើងវិញតាមរបៀបមួយដែលសូន្យទាំងអស់នឹងត្រូវប្តូរទៅផ្នែកខាងឆ្វេងនៃអារេហើយធាតុ ១ ទាំងអស់នៃអារេនឹងត្រូវប្តូរទៅផ្នែកខាងស្តាំនៃអារេ។ ចំពោះបញ្ហានេះយើងនឹងធ្វើការរាប់ចំនួនសូន្យទាំងអស់។ ចំនួនសូន្យនោះនឹងជួយយើងក្នុងការសម្គាល់សូន្យនៅខាងឆ្វេងនៃជួរអារេ។

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

យើងនឹងឆ្លងកាត់រង្វិលជុំមិនរាប់ដងហើយសម្គាល់រាល់តម្លៃរបស់អា [ពី] ពីលេខ ០th លិបិក្រមទៅចំនួនទី ១ នៃកន្លែង។ ឥឡូវនេះយើងមានលេខសូន្យនៅផ្នែកខាងឆ្វេងនៃអារេ។ ឥឡូវយើងត្រូវឆ្លងកាត់អារេពីរាប់ទៅ n ដែល n គឺជាប្រវែងនៃអារេ។ ដូច្នេះចាប់ផ្តើមពី i = រាប់ថាតើតម្លៃនៃការរាប់នឹងត្រូវបន្តធ្វើបច្ចុប្បន្នភាពតម្លៃទាំងអស់ទៅ ១. បន្ទាប់ពីប្រតិបត្តិការទាំងអស់យើងមានអារេដែលចង់បានគឺលេខ ០ នៅផ្នែកខាងឆ្វេងនៃអារេនិង ១ នៅផ្នែកខាងស្តាំនៃអារេ។ ។

បំបែកលេខ ០ និង ១ ក្នុងអារេ

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

កម្មវិធី C ++ សំរាប់ Segregate 0s និង 1s នៅក្នុងអារេ

#include<iostream>

using namespace std;

void segregateZeroesOnes(int arr[], int n)
{
    int count = 0;

    for (int i = 0; i < n; i++)
    {
        if (arr[i] == 0)
            count++;
    }
    for (int i = 0; i < count; i++)
        arr[i] = 0;

    for (int i = count; i < n; i++)
        arr[i] = 1;
}

void printArray(int arr[], int n)
{
    for (int i = 0; i < n; i++)
        cout << arr[i] << " ";
}

int main()
{
    int arr[] = {1,0,1,1,0,1,1,0};
    int n = sizeof(arr) / sizeof(arr[0]);

    segregateZeroesOnes(arr, n);
    printArray(arr, n);

    return 0;
}
0 0 0 1 1 1 1 1

កម្មវិធីចាវ៉ាសំរាប់ស៊ែលស៊្រីស ០ និង ១ នៅក្នុងអារេ

class segregateZeroesOnes
{
    public static void segregateZeroesOnes(int arr[], int n)
    {
        int count = 0;

        for (int i = 0; i < n; i++)
        {
            if (arr[i] == 0)
                count++;
        }
        for (int i = 0; i < count; i++)
            arr[i] = 0;

        for (int i = count; i < n; i++)
            arr[i] = 1;
    }
    
    public static void printArray(int arr[], int n)
    {
        for (int i = 0; i < n; i++)
            System.out.print(arr[i] + " ");
    }
    
    public static void main(String[] args)
    {
        int arr[] = new int[] { 1,0,1,1,0,1,1,0 };
        int n = arr.length;

        segregateZeroesOnes(arr, n);
        printArray(arr, n);

    }
}
0 0 0 1 1 1 1 1

ការវិភាគស្មុគស្មាញសម្រាប់ស៊្រីស៊្រីសនិងលេខ ១ ក្នុងអារេ

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

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

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

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

ឯកសារយោង