අරාවෙහි 0s සහ 1s වෙන් කරන්න  


දුෂ්කරතා මට්ටම පහසු
නිතර අසනු ලැබේ ඇසොලයිට් ඇමේසන් ෆැබ් MakeMyTrip පේපෑල් Paytm Zoho
අරා

ගැටළු ප්රකාශය  

ඔබට අ නිඛිල අරාව. “අරාවෙහි 0s සහ 1s වෙන් කරන්න” යන ගැටළුව මඟින් අරාව කොටස් දෙකකින්, 0s හා 1s වලින් වෙන් කිරීමට අසයි. 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.

අරාවෙහි 0s සහ 1s වෙන් කිරීම සඳහා පැහැදිලි කිරීම  

දෙනලද අරාව නිඛිලවල, පූර්ණ සංඛ්‍යා වලදී, එය ගබඩා කරන්නේ 0s සහ 1s අරාව තුළ පමණි. අරාව නැවත සකසන්න සියලු ශුන්‍යයන් අරාවෙහි වම් පැත්තට ගෙන යන අතර අරාවේ සියලුම 1s අංග අරාවේ දකුණු පැත්තට ගෙන යනු ලැබේ. මේ සඳහා, අපි සියලු ශුන්යයන් ගණනය කිරීමට යන්නෙමු. අරාවෙහි වම් පැත්තේ ඇති ශුන්‍යයන් සලකුණු කිරීමට එම ශුන්‍ය ගණනය කිරීම් අපට උපකාරී වනු ඇත.

මෙයද බලන්න
ඊළඟ විශාල අංගය

අරාවෙහි ඇති සියලුම ශුන්‍ය ගණන ගණනය කිරීම සඳහා කේතයේ පළමු වරට අරාව හරහා ගමන් කරන්න, මෙම ගණන් කිරීම අරාවේ වම් පසින් ඇති ස්ථාන ගණන ගණනය කිරීමට අපට උපකාරී වනු ඇත. එබැවින් ඒ සඳහා අපි අරාව හරහා ගමන් කර අර [i] හි එක් එක් අගය පරීක්ෂා කරමු, එය 0 ට සමානද, එය 0 ට සමාන බව සොයාගතහොත්, ගණන් කිරීමේ අගය 1 කින් වැඩි කරන්න. අපි ප්‍රකාශ කළ යුතුව තිබුණි සහ ලූපයට ඇතුළු වීමට පෙර ගණන් කිරීමේ අගය 0 දක්වා ආරම්භ කිරීම. ගමන් කිරීමෙන් පසු අපට ගණන් ලැබුණි.

අපි වරින් වර ලූප ගණනය නොකර, ආර් [i] හි සෑම අගයක්ම 0 සිට සලකුණු කරමුth ස්ථාන ගණනට දර්ශකය. දැන්, අරාවෙහි වම් පැත්තෙහි ශුන්‍යයන් ඇත. දැන් අපි අරාව ගණනය කිරීමේ සිට n දක්වා ගමන් කළ යුතු අතර n යනු අරාවෙහි දිග වේ. එබැවින් ගණනය කිරීමේ වටිනාකම කුමක් වුවත් i = ගණන් කිරීමෙන් පටන් ගෙන, සියලු අගයන් 1 දක්වා යාවත්කාලීන කරන්න. සියලු මෙහෙයුම් වලින් පසුව, අපට අපේක්ෂිත අරාව ඇත, අරාවෙහි වම් පැත්තේ 1s සහ අරාවෙහි දකුණු පැත්තේ 0s .

අරාවෙහි 0s සහ 1s වෙන් කරන්නපින්

ක්රියාත්මක කිරීම  

අරාවෙහි 0s සහ 1s වෙන් කිරීම සඳහා C ++ වැඩසටහන

#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 සහ 1s සඳහා අරාවකින් වෙන් කරන්න

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

අරාවෙහි 0s සහ 1s වෙන් කිරීම සඳහා සංකීර්ණ විශ්ලේෂණය  

කාල සංකීර්ණත්වය

සාමාන්ය (n) එහිදී “N” යනු අරාවෙහි ඇති මූලද්‍රව්‍ය ගණන වේ.

මෙයද බලන්න
සෘජුකෝණාස්රාකාර ලීට්කෝඩ් විසඳුම සාදන්න

අභ්‍යවකාශ සංකීර්ණතාව

සාමාන්ය (n) එහිදී “N” යනු අරාවෙහි ඇති මූලද්‍රව්‍ය ගණන වේ.

විමර්ශන