એરેમાં 0s અને 1s ને અલગ કરો


મુશ્કેલી સ્તર સરળ
વારંવાર પૂછવામાં આવે છે ભેગા એમેઝોન ફેબ MakeMyTrip પેપાલ પેટીએમ ઝોહો
અરે

સમસ્યા નિવેદન

ધારો કે તમારી પાસે એક પૂર્ણાંક એરે. સમસ્યા "એરેમાં 0s અને 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 અને 1s એરેમાં સંગ્રહિત કરશે. એરેને ફરીથી ગોઠવો એવી રીતે કે બધા ઝીરો એરેની ડાબી બાજુ ફેરવાશે અને એરેના બધા 1s એલિમેન્ટ્સ એરેની જમણી બાજુ ફેરવાશે. આ માટે, અમે બધા શૂન્યની ગણતરી કરવા જઈ રહ્યા છીએ. એ શૂન્ય ગણતરીઓ એરેની ડાબી બાજુએ શૂન્ય માર્ક કરવામાં અમને મદદ કરશે.

એરેમાં તમામ ઝીરોની ગણતરી મેળવવા માટે કોડમાં પ્રથમ વખત એરેને વટાવી દો, આ ગણતરી એરેની ડાબી બાજુથી બધી ગણતરીની સંખ્યાને ચિહ્નિત કરવામાં મદદ કરશે. તેથી તે માટે આપણે એરેને પસાર કરીશું અને એરેના દરેક મૂલ્યની તપાસ કરીશું [i], તે 0 ની બરાબર છે, જો તે 0 ની બરાબર હોવાનું જણાય છે, તો પછી ગણતરીનું મૂલ્ય 1 દ્વારા વધારવું જોઈએ. અને લૂપમાં પ્રવેશતા પહેલા ગણતરીના મૂલ્યની શરૂઆત 0 કરી. ચાલ્યા પછી અમને ગણતરી મળી.

આપણે લૂપની ગણતરીમાં કોઈ સમય પસાર કરીશું નહીં, અને એઆર [i] ના દરેક મૂલ્યને 0 થી ચિહ્નિત કરીશુંth સ્થાનોની ગણતરી -1 સંખ્યાને અનુક્રમણિકા. હવે, આપણી પાસે એરેની ડાબી બાજુએ શૂન્ય છે. હવે આપણે એરેને ગણતરીથી n તરફ જવું પડશે જ્યાં n એરેની લંબાઈ છે. તેથી ગણતરીની કિંમત જે હશે તે i = ગણતરીથી શરૂ કરીને, બધા મૂલ્યોને 1 માં અપડેટ કરવાનું ચાલુ રાખો. તમામ કામગીરી પછી, આપણી પાસે એરેની ડાબી બાજુએ ઇચ્છિત એરે, 0s અને એરેની જમણી બાજુ 1s છે. .

એરેમાં 0s અને 1s ને અલગ કરો

અમલીકરણ

એરેમાં સેગરેગેટ 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

એરેમાં અલગ 0s અને 1 સે માટે જટિલતા વિશ્લેષણ

સમય જટિલતા

ઓ (એન) જ્યાં “એન” એરેમાં તત્વોની સંખ્યા છે.

અવકાશ જટિલતા

ઓ (એન) જ્યાં “એન” એરેમાં તત્વોની સંખ્યા છે.

સંદર્ભ