ಅರೇನಲ್ಲಿ 0 ಸೆ ಮತ್ತು 1 ಸೆಗಳನ್ನು ಪ್ರತ್ಯೇಕಿಸಿ


ತೊಂದರೆ ಮಟ್ಟ ಸುಲಭ
ಆಗಾಗ್ಗೆ ಕೇಳಲಾಗುತ್ತದೆ ಅಕೋಲೈಟ್ ಅಮೆಜಾನ್ ಫ್ಯಾಬ್ MakeMyTrip ಪೇಪಾಲ್ ಪೇಟ್ಮ್ ಜೊಹೊ
ಅರೇ

ಸಮಸ್ಯೆ ಹೇಳಿಕೆ

ನೀವು ಹೊಂದಿದ್ದೀರಿ ಎಂದು ಭಾವಿಸೋಣ ಪೂರ್ಣಾಂಕ ರಚನೆ. “ಒಂದು ಶ್ರೇಣಿಯಲ್ಲಿ 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 ಸೆಗಳನ್ನು ಮಾತ್ರ ಸಂಗ್ರಹಿಸುತ್ತದೆ. ಎಲ್ಲಾ ಸೊನ್ನೆಗಳನ್ನು ರಚನೆಯ ಎಡಭಾಗಕ್ಕೆ ವರ್ಗಾಯಿಸುವ ರೀತಿಯಲ್ಲಿ ರಚನೆಯನ್ನು ಮರುಹೊಂದಿಸಿ ಮತ್ತು ರಚನೆಯ ಎಲ್ಲಾ 1 ಸೆ ಅಂಶಗಳನ್ನು ರಚನೆಯ ಬಲಭಾಗಕ್ಕೆ ವರ್ಗಾಯಿಸಲಾಗುತ್ತದೆ. ಇದಕ್ಕಾಗಿ, ನಾವು ಎಲ್ಲಾ ಸೊನ್ನೆಗಳ ಎಣಿಕೆಯನ್ನು ಮಾಡಲಿದ್ದೇವೆ. ಆ ಶೂನ್ಯ ಎಣಿಕೆಗಳು ರಚನೆಯ ಎಡಭಾಗದಲ್ಲಿ ಸೊನ್ನೆಗಳನ್ನು ಗುರುತಿಸಲು ನಮಗೆ ಸಹಾಯ ಮಾಡುತ್ತವೆ.

ಶ್ರೇಣಿಯಲ್ಲಿನ ಎಲ್ಲಾ ಸೊನ್ನೆಗಳ ಸಂಖ್ಯೆಯನ್ನು ಪಡೆಯಲು ಕೋಡ್‌ನಲ್ಲಿ ಮೊದಲ ಬಾರಿಗೆ ವ್ಯೂಹವನ್ನು ಹಾದುಹೋಗಿರಿ, ರಚನೆಯ ಎಡಭಾಗದಿಂದ ಎಲ್ಲಾ ಎಣಿಕೆ ಸ್ಥಳಗಳನ್ನು ಗುರುತಿಸಲು ಈ ಎಣಿಕೆ ನಮಗೆ ಸಹಾಯ ಮಾಡುತ್ತದೆ. ಆದ್ದರಿಂದ ಅದಕ್ಕಾಗಿ ನಾವು ವ್ಯೂಹವನ್ನು ಹಾದುಹೋಗುತ್ತೇವೆ ಮತ್ತು ಅರ್ [i] ನ ಪ್ರತಿಯೊಂದು ಮೌಲ್ಯವನ್ನು ಪರಿಶೀಲಿಸುತ್ತೇವೆ, ಅದು 0 ಗೆ ಸಮನಾಗಿದೆಯೇ, ಅದು 0 ಗೆ ಸಮನಾಗಿರುವುದು ಕಂಡುಬಂದರೆ, ಎಣಿಕೆಯ ಮೌಲ್ಯವನ್ನು 1 ರಿಂದ ಹೆಚ್ಚಿಸಿ. ನಾವು ಘೋಷಿಸಿರಬೇಕು ಮತ್ತು ಲೂಪ್‌ಗೆ ಪ್ರವೇಶಿಸುವ ಮೊದಲು ಎಣಿಕೆಯ ಮೌಲ್ಯವನ್ನು 0 ಕ್ಕೆ ಪ್ರಾರಂಭಿಸಲಾಗಿದೆ. ಸಂಚರಿಸಿದ ನಂತರ ನಮಗೆ ಎಣಿಕೆ ಸಿಕ್ಕಿತು.

ನಾವು ಯಾವುದೇ ಬಾರಿ ಲೂಪ್ ಎಣಿಕೆಯನ್ನು ಹಾದುಹೋಗುವುದಿಲ್ಲ ಮತ್ತು ಅರ್ [i] ನ ಪ್ರತಿಯೊಂದು ಮೌಲ್ಯವನ್ನು 0 ರಿಂದ ಗುರುತಿಸುತ್ತೇವೆth ಎಣಿಕೆ -1 ಸಂಖ್ಯೆಯ ಸ್ಥಳಗಳಿಗೆ ಸೂಚ್ಯಂಕ. ಈಗ, ನಾವು ರಚನೆಯ ಎಡಭಾಗದಲ್ಲಿ ಸೊನ್ನೆಗಳನ್ನು ಹೊಂದಿದ್ದೇವೆ. ಈಗ ನಾವು ಶ್ರೇಣಿಯನ್ನು ಎಣಿಕೆಯಿಂದ n ಗೆ ಹಾದುಹೋಗಬೇಕು, ಅಲ್ಲಿ n ಎಂಬುದು ರಚನೆಯ ಉದ್ದವಾಗಿದೆ. ಆದ್ದರಿಂದ ನಾನು ಎಣಿಸುವ ಮೌಲ್ಯವು ಏನೇ ಇರಲಿ, ಎಲ್ಲಾ ಮೌಲ್ಯಗಳನ್ನು 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 ಸೆಗಾಗಿ ಸಂಕೀರ್ಣತೆ ವಿಶ್ಲೇಷಣೆ

ಸಮಯ ಸಂಕೀರ್ಣತೆ

ಓ (ಎನ್) ಅಲ್ಲಿ “ಎನ್” ರಚನೆಯ ಅಂಶಗಳ ಸಂಖ್ಯೆ.

ಬಾಹ್ಯಾಕಾಶ ಸಂಕೀರ್ಣತೆ

ಓ (ಎನ್) ಅಲ್ಲಿ “ಎನ್” ರಚನೆಯ ಅಂಶಗಳ ಸಂಖ್ಯೆ.

ರೆಫರೆನ್ಸ್