ഒരു അറേയിൽ 0 സെ, 1 സെ എന്നിവ വേർതിരിക്കുക  


വൈഷമ്യ നില എളുപ്പമായ
പതിവായി ചോദിക്കുന്നു അക്കോലൈറ്റ് ആമസോൺ ഫാഷ് MakeMyTrip പേപാൽ Paytm Zoho
അറേ

പ്രശ്നം പ്രസ്താവന  

നിങ്ങൾക്ക് ഒരു ഉണ്ടെന്ന് കരുതുക പൂർണ്ണസംഖ്യ അറേ. “ഒരു അറേയിലെ 0 സെ, 1 സെ എന്നിവ വേർതിരിക്കുക” എന്ന പ്രശ്നം അറേയെ രണ്ട് ഭാഗങ്ങളായി, 0 സെയിലും 1 സെയിലും വേർതിരിക്കാൻ ആവശ്യപ്പെടുന്നു. 0 കൾ അറേയുടെ ഇടതുവശത്തും 1 ന്റെ അറേയുടെ വലതുവശത്തും ആയിരിക്കണം.

ഉദാഹരണം  

arr[]={1,0,1,1,0,1,1,0}
0 0 0 1 1 1 1 1
വിശദീകരണം: എല്ലാ 0 കളും ഇടത്തേക്ക് മാറ്റുകയും 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.

ഒരു അറേയിലെ 0 സെ, 1 സെ എന്നിവ വേർതിരിക്കുക  

നൽകപ്പെട്ട ശ്രേണി പൂർണ്ണസംഖ്യകളിൽ, പൂർണ്ണസംഖ്യകളിൽ, അത് അറേയിൽ 0 സെ, 1 സെ എന്നിവ മാത്രമേ സംഭരിക്കുകയുള്ളൂ. എല്ലാ പൂജ്യങ്ങളും അറേയുടെ ഇടതുവശത്തേക്ക് മാറ്റുന്ന തരത്തിൽ അറേ പുന range ക്രമീകരിക്കുക, അറേയുടെ എല്ലാ 1 സെ ഘടകങ്ങളും അറേയുടെ വലതുവശത്തേക്ക് മാറ്റപ്പെടും. ഇതിനായി, ഞങ്ങൾ എല്ലാ പൂജ്യങ്ങളും കണക്കാക്കാൻ പോകുന്നു. അറേയുടെ ഇടതുവശത്ത് പൂജ്യങ്ങൾ അടയാളപ്പെടുത്താൻ ആ പൂജ്യം എണ്ണം ഞങ്ങളെ സഹായിക്കും.

ഇതും കാണുക
അടുത്ത വലിയ ഘടകം

അറേയിലെ എല്ലാ പൂജ്യങ്ങളുടെയും എണ്ണം ലഭിക്കുന്നതിന് കോഡിൽ ആദ്യമായി അറേയിലൂടെ സഞ്ചരിക്കുക, അറേയുടെ ഇടത് വശത്ത് നിന്ന് സ്ഥലങ്ങളുടെ എണ്ണം എണ്ണാൻ ഈ എണ്ണം ഞങ്ങളെ സഹായിക്കും. അതിനാൽ അതിനായി ഞങ്ങൾ അറേയിലൂടെ സഞ്ചരിച്ച് അറയുടെ ഓരോ മൂല്യവും പരിശോധിക്കും, അത് 0 ന് തുല്യമാണോ, അത് 0 ന് തുല്യമാണെന്ന് കണ്ടെത്തിയാൽ, എണ്ണത്തിന്റെ മൂല്യം 1 വർദ്ധിപ്പിക്കുക. ഞങ്ങൾ പ്രഖ്യാപിച്ചിരിക്കണം ഒപ്പം ലൂപ്പിലേക്ക് പ്രവേശിക്കുന്നതിന് മുമ്പ് എണ്ണത്തിന്റെ മൂല്യം 0 ആക്കി. സഞ്ചരിച്ച ശേഷം ഞങ്ങൾക്ക് എണ്ണം ലഭിച്ചു.

ഞങ്ങൾ ലൂപ്പുകളുടെ എണ്ണം ഒരു തവണയും സഞ്ചരിക്കില്ല, കൂടാതെ arr [i] ന്റെ എല്ലാ മൂല്യങ്ങളും 0 മുതൽ അടയാളപ്പെടുത്തുംth സ്ഥലങ്ങളുടെ എണ്ണം -1 എണ്ണം സൂചിക. ഇപ്പോൾ, അറേയുടെ ഇടതുവശത്ത് നമുക്ക് പൂജ്യങ്ങളുണ്ട്. ഇപ്പോൾ നമ്മൾ അറേയുടെ എണ്ണത്തിൽ നിന്ന് n ലേക്ക് സഞ്ചരിക്കണം, ഇവിടെ n എന്നത് അറേയുടെ നീളം. അതിനാൽ, എണ്ണത്തിന്റെ മൂല്യം എന്തായാലും i = എണ്ണത്തിൽ നിന്ന് ആരംഭിച്ച്, എല്ലാ മൂല്യങ്ങളും 1 ലേക്ക് അപ്‌ഡേറ്റുചെയ്യുന്നത് തുടരുക. എല്ലാ പ്രവർത്തനങ്ങൾക്കും ശേഷം, ഞങ്ങൾക്ക് ആവശ്യമുള്ള അറേ, അറേയുടെ ഇടതുവശത്ത് 0 സെ, അറേയുടെ വലതുവശത്ത് 1 സെ. .

ഒരു അറേയിൽ 0 സെ, 1 സെ എന്നിവ വേർതിരിക്കുകമൊട്ടുസൂചി

നടപ്പിലാക്കൽ  

ഒരു അറേയിലെ 0 സെ, 1 സെ എന്നിവ വേർതിരിച്ചെടുക്കുന്നതിനുള്ള സി ++ പ്രോഗ്രാം

#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

ഒരു അറേയിലെ 0 സെ, 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

ഒരു അറേയിലെ 0 സെ, 1 സെ എന്നിവയ്‌ക്കായുള്ള സങ്കീർണ്ണത വിശകലനം  

സമയ സങ്കീർണ്ണത

O (n) എവിടെ “N” അറേയിലെ ഘടകങ്ങളുടെ എണ്ണം.

ഇതും കാണുക
ദീർഘചതുരം ലീറ്റ്കോഡ് പരിഹാരം നിർമ്മിക്കുക

ബഹിരാകാശ സങ്കീർണ്ണത

O (n) എവിടെ “N” അറേയിലെ ഘടകങ്ങളുടെ എണ്ണം.

അവലംബം