ਪਹਿਲੇ ਤੱਤ ਨੂੰ ਦੁਗਣਾ ਅਤੇ ਸਿਫ਼ਰ ਨੂੰ ਖ਼ਤਮ ਕਰਨ ਲਈ ਮੂਵ ਕਰੋ


ਮੁਸ਼ਕਲ ਪੱਧਰ ਦਰਮਿਆਨੇ
ਅਕਸਰ ਪੁੱਛਿਆ ਜਾਂਦਾ ਹੈ Microsoft ਦੇ ਜੋਹੋ
ਅਰੇ

ਸਮੱਸਿਆ ਦਾ ਬਿਆਨ

ਮੰਨ ਲਓ ਤੁਹਾਡੇ ਕੋਲ ਐਰੇ ਹੈ ਪੂਰਨ ਅੰਕ. ਇੱਥੇ “0” ਉਹ ਨੰਬਰ ਨਹੀਂ ਹੈ ਜਿਸ ਨੂੰ ਇੰਪੁੱਟ ਮੰਨਿਆ ਜਾਂਦਾ ਹੈ. ਇਹ ਇਥੇ ਵੈਧ ਇੰਪੁੱਟ ਨਹੀਂ ਹੈ. ਸਮੱਸਿਆ "ਪਹਿਲੇ ਤੱਤ ਨੂੰ ਦੂਹਰਾ ਕਰੋ ਅਤੇ ਸਿਫ਼ਰ ਨੂੰ ਅੰਤ ਤੇ ਲੈ ਜਾਉ" ਐਰੇ ਨੂੰ ਇਸ ਤਰੀਕੇ ਨਾਲ ਪੁਨਰਗਠਿਤ ਕਰਨ ਲਈ ਕਹਿੰਦਾ ਹੈ ਜੇ 0 ਤੋਂ ਇਲਾਵਾ ਕੋਈ ਹੋਰ ਸੰਖਿਆ ਮਿਲ ਗਈ ਹੈ ਅਤੇ ਉਸ ਦੀ ਅਗਲੀ ਸੰਖਿਆ ਉਹੀ ਸੰਖਿਆ ਹੈ ਜਿੰਨੀ ਕਿ ਇਹ ਦੁਗਣੀ ਹੈ ਅਤੇ ਨਿਸ਼ਾਨ ਲਗਾਉਂਦੀ ਹੈ ਅਗਲਾ ਨੰਬਰ 0 ਦੇ ਤੌਰ ਤੇ. ਅੰਤ ਵਿੱਚ ਸਾਰੇ ਜ਼ੀਰੋ ਨੂੰ ਧੱਕੋ.

ਉਦਾਹਰਨ

arr[] = {3, 3, 5, 0, 1, 0, 0, 1, 0}
6 5 1 1 0 0 0 0 0

ਸਪਸ਼ਟੀਕਰਨ: ਕਿਉਂਕਿ 3 ਇਕ ਨੰਬਰ ਹੁੰਦਾ ਹੈ ਜੋ ਲਗਾਤਾਰ ਹੁੰਦਾ ਹੈ, ਇਸ ਲਈ ਅਸੀਂ ਇਸ ਨੂੰ 3 ਬਣਾਉਣ ਲਈ ਪਹਿਲਾਂ 6 ਨੂੰ ਦੁਗਣਾ ਕਰਦੇ ਹਾਂ ਅਤੇ ਅਗਲੇ 3 ਨੂੰ 0 ਦੇ ਤੌਰ ਤੇ ਮਾਰਕ ਕਰਦੇ ਹਾਂ ਅਤੇ ਨਾਲ ਹੀ ਸਾਰੇ ਜ਼ੀਰੋ ਨੂੰ ਆਖਰੀ ਐਕਸ ਤੇ ਤਬਦੀਲ ਕਰ ਦਿੱਤਾ ਗਿਆ ਹੈ.

ਪਹਿਲੇ ਤੱਤ ਨੂੰ ਦੁੱਗਣਾ ਕਰਨ ਲਈ ਐਲਗੋਰਿਦਮ ਅਤੇ ਸਿਫ਼ਰ ਨੂੰ ਅੰਤ ਤੇ ਭੇਜੋ

1. Traverse the array from 0 to n-1(inclusively).
2. Check if arr[i] is not equal to 0 and arr[i]==arr[i+1](next value is same as current value).
  1. If true, then make the current value twice of the self.
  2. Update next element as 0 and do i++.
3. Traverse the array from i = 0 to n-1(step of shifting all the zeroes to the end).
  1. Check if arr[i] != 0.
    1. Arr[count]=arr[i] and do count++.
4. From the traversal of till count is less than n.
  1. Arr[count]=0 and do count++.
5. Print the array.

ਕਥਾ

ਇਸ ਨੂੰ ਦਿੱਤੇ inੰਗ ਨਾਲ ਪੁਨਰ ਵਿਵਸਥ ਕਰਨ ਲਈ ਐਰੇ ਦਿੱਤੀ ਗਈ. ਅਸੀਂ ਅਗਲਾ ਨੰਬਰ ਬਦਲਣ ਲਈ ਕਿਹਾ ਹੈ ਜੇ ਮੌਜੂਦਾ ਨੰਬਰ ਅਗਲੇ ਨੰਬਰ ਦੇ ਸਮਾਨ ਹੈ. ਤਬਦੀਲੀ ਇਹ ਹੈ ਕਿ ਸਾਨੂੰ ਮੌਜੂਦਾ ਗਿਣਤੀ ਨੂੰ ਦੁਗਣਾ ਕਰਨਾ ਹੈ. ਅਤੇ ਅਗਲੇ ਨੰਬਰ ਨੂੰ 0 ਦੇ ਤੌਰ ਤੇ ਮਾਰਕ ਕਰੋ ਜੇ ਦਿੱਤੀ ਗਈ ਸ਼ਰਤ ਸੰਤੁਸ਼ਟ ਹੋ ਜਾਵੇ. ਇਸ ਸੋਧ ਤੋਂ ਬਾਅਦ, ਸਾਨੂੰ ਉਸ ਐਰੇ ਦੇ ਅਖੀਰਲੇ ਸਾਰੇ ਜ਼ੀਰੋਜ਼ ਨੂੰ ਸ਼ਿਫਟ ਕਰਨਾ ਹੈ ਜੋ ਅਸੀਂ ਬਣਾਇਆ ਹੈ ਜਾਂ ਜੋ ਪਹਿਲਾਂ ਹੀ ਐਰੇ ਵਿਚ ਮੌਜੂਦ ਹਨ. ਫਿਰ ਆਉਟਪੁੱਟ ਵਾਪਸ ਕਰਨ ਵਾਲੀ ਹੈ.

ਐਰੇ ਨੂੰ 0 ਤੋਂ n ਤੱਕ ਕਰੋ - 1. ਜਾਂਚ ਕਰੋ ਕਿ ਕੀ ਹਰੇਕ ਦਾ ਮੁੱਲ 0 ਦੇ ਬਰਾਬਰ ਨਹੀਂ ਹੈ, ਕਿਉਂਕਿ ਸਾਨੂੰ 0 ਦੇ ਮੁੱਲ ਵਿੱਚ ਕੋਈ ਤਬਦੀਲੀ ਕਰਨ ਦੀ ਆਗਿਆ ਨਹੀਂ ਹੈ. ਅਤੇ ਜਾਂਚ ਕਰੋ ਕਿ ਕੀ ਮੌਜੂਦਾ ਤੱਤ ਅਗਲੇ ਐਲੀਮੈਂਟ ਦੇ ਬਰਾਬਰ ਹੈ ਜਿਵੇਂ ਕਿ ਅਰਰ [i] = = ਏਰ [i + 1]. ਅਸੀਂ ਐਨ -1 ਨੂੰ ਟਰੈਵਲ ਦੇ ਆਖਰੀ ਬਿੰਦੂ ਵਜੋਂ ਲਿਆ ਹੈ ਕਿਉਂਕਿ ਅਸੀਂ ਮੌਜੂਦਾ ਨੰਬਰ ਤੋਂ ਅਗਲੇ ਨੰਬਰ ਦੀ ਭਾਲ ਕਰ ਰਹੇ ਹਾਂ. ਇਸ ਲਈ ਜੇ ਅਸੀਂ n ਨੂੰ ਲੱਭਣ ਲਈ ਆਖਰੀ ਤੱਤ ਦੇ ਤੌਰ ਤੇ ਜਾਂਦੇ ਹਾਂ, ਤਾਂ ਅਸੀਂ ਨਲ ਪੁਆਇੰਟਰ ਅਪਵਾਦ ਪ੍ਰਾਪਤ ਕਰਾਂਗੇ. ਜੇ ਦਿੱਤੀਆਂ ਗਈਆਂ ਸ਼ਰਤਾਂ ਪੂਰੀਆਂ ਹੋ ਜਾਂਦੀਆਂ ਹਨ ਤਾਂ ਅਸੀਂ ਮੌਜੂਦਾ ਤੱਤ ਨੂੰ ਚੁਣਦੇ ਹਾਂ ਅਤੇ ਇਸ ਨੂੰ ਮੌਜੂਦਾ ਮੁੱਲ ਤੋਂ ਦੁਗਣਾ ਕਰਦੇ ਹਾਂ ਅਤੇ ਅਗਲਾ ਮੁੱਲ 0 ਤੇ ਅਪਡੇਟ ਕਰਦੇ ਹਾਂ. ਸਾਨੂੰ ਐਰੇ ਦੇ ਸਾਰੇ ਮੁੱਲ ਲਈ ਇਹ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ.

ਹੁਣ ਸਾਰੇ ਵੈਲਿ 0ਜ਼ ਨੂੰ 0 ਦੇ ਰੂਪ ਵਿੱਚ ਆਖਰੀ ਵੱਲ ਸਿਫਟ ਕਰੋ. ਇਸ ਦੇ ਲਈ ਐਰੇ ਨੂੰ ਦੁਬਾਰਾ ਪਾਰ ਕਰੋ, ਅਤੇ ਜਾਂਚ ਕਰੋ ਕਿ ਕੀ ਮੁੱਲ ਬਰਾਬਰ ਨਹੀਂ ਹੈ, ਫਿਰ ਇਸ ਨੂੰ ਖੱਬੇ ਪਾਸੇ ਸਿਫਟ ਕਰੋ, ਸਾਰੇ ਵੈਲਯੂਜ ਨੂੰ ਖੱਬੇ ਪਾਸੇ ਬਦਲਣ ਤੋਂ ਬਾਅਦ, ਸਾਡੇ ਕੋਲ ਆਖਰੀ ਸਿਫਟ ਕੀਤੇ ਵੈਲਯੂ ਦਾ ਇੰਡੈਕਸ ਹੈ, ਉਸ ਕਾਉਂਟ ਤੋਂ ਅਸੀਂ ਇਕ ਲਈ ਜਾਵਾਂਗੇ. ਲੂਪ ਅਤੇ ਉਸ ਗਿਣਤੀ ਤੋਂ n ਦੇ ਮੁੱਲ ਤੱਕ, ਅਸੀਂ ਸਾਰੇ ਵੈਲਯੂਜ XNUMX ਨੂੰ ਅਪਡੇਟ ਕਰਾਂਗੇ. ਅਖੀਰ ਵਿਚ ਐਰੇ ਨੂੰ ਪ੍ਰਿੰਟ ਕਰੋ.

ਪਹਿਲੇ ਤੱਤ ਨੂੰ ਦੁਗਣਾ ਅਤੇ ਸਿਫ਼ਰ ਨੂੰ ਖ਼ਤਮ ਕਰਨ ਲਈ ਮੂਵ ਕਰੋ

ਕੋਡ

ਪਹਿਲੇ ਤੱਤ ਨੂੰ ਦੁੱਗਣਾ ਕਰਨ ਲਈ ਸੀ ++ ਕੋਡ ਅਤੇ ਸਮੱਸਿਆ ਨੂੰ ਖਤਮ ਕਰਨ ਲਈ ਜ਼ੀਰੋ 'ਤੇ ਜਾਓ

#include<iostream>

using namespace std;

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

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

    while (count < n)
        arr[count++] = 0;
}
void arrayModification(int arr[], int n)
{
    if (n == 1)
        return;
    for (int i = 0; i < n - 1; i++)
    {
        if ((arr[i] != 0) && (arr[i] == arr[i + 1]))
        {
            arr[i] = 2 * arr[i];

            arr[i + 1] = 0;

            i++;
        }
    }
    shiftZeroAtLast(arr, n);
}
void printArray(int arr[], int n)
{
    for (int i = 0; i < n; i++)
        cout << arr[i] << " ";
}
int main()
{
    int arr[] = {3,3,5,0,1,0,0,1,0};
    int n = sizeof(arr) / sizeof(arr[0]);

    arrayModification(arr, n);

    cout << "Modified array: ";
    printArray(arr, n);

    return 0;
}
Modified array: 6 5 1 1 0 0 0 0 0

ਪਹਿਲੇ ਐਲੀਮੈਂਟ ਨੂੰ ਦੁੱਗਣਾ ਕਰਨ ਲਈ ਜਾਵਾ ਕੋਡ ਅਤੇ ਸਮੱਸਿਆ ਨੂੰ ਖਤਮ ਕਰਨ ਲਈ ਜ਼ੀਰੋ 'ਤੇ ਜਾਓ

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

        for (int i = 0; i < n; i++)
            if (arr[i] != 0)

                arr[count++] = arr[i];

        while (count < n)
            arr[count++] = 0;
    }
    public static void arrayModification(int arr[], int n)
    {
        if (n == 1)
            return;

        for (int i = 0; i < n - 1; i++)
        {
            if ((arr[i] != 0) && (arr[i] == arr[i + 1]))
            {
                arr[i] = 2 * arr[i];

                arr[i + 1] = 0;

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


        arrayModification(arr, n);

        System.out.print("Modified array: ");
        printArray(arr, n);
    }
}
Modified array: 6 5 1 1 0 0 0 0 0

ਜਟਿਲਤਾ ਵਿਸ਼ਲੇਸ਼ਣ

ਟਾਈਮ ਜਟਿਲਤਾ

ਓ (ਐਨ) ਜਿੱਥੇ ਕਿ “ਐਨ” ਐਰੇ ਵਿਚਲੇ ਤੱਤਾਂ ਦੀ ਗਿਣਤੀ ਹੈ. ਅਸੀਂ ਐਰੇ ਨੂੰ ਸਿਰਫ਼ ਦੋ ਵਾਰ ਉਲਟਾ ਦਿੱਤਾ ਹੈ ਜੋ ਐਲਗੋਰਿਦਮ ਨੂੰ ਰੇਖਿਕ ਸਮੇਂ ਵਿਚ ਚਲਾਉਣ ਲਈ ਬਣਾਉਂਦਾ ਹੈ.

ਸਪੇਸ ਦੀ ਜਟਿਲਤਾ

ਐਲਗੋਰਿਦਮ ਦੀ ਲੋੜ ਹੈ ਓ (1) ਵਾਧੂ ਸਪੇਸ ਪਰ ਪ੍ਰੋਗਰਾਮ ਇਨਪੁਟ ਨੂੰ ਸਟੋਰ ਕਰਨ ਲਈ O (N) ਦੀ ਕੁੱਲ ਸਪੇਸ ਲੈਂਦਾ ਹੈ.