એરેને ફરીથી ગોઠવો જેમ કે ઇન્ડેક્સ તત્વો પણ નાના હોય છે અને વિચિત્ર અનુક્રમણિકા તત્વો વધારે હોય છે


મુશ્કેલી સ્તર સરળ
વારંવાર પૂછવામાં આવે છે અવલારા એપિક સિસ્ટમો ફોરકાઇટ્સ Roblox ટેસ્લા
અરે

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

તમે એક આપ્યો છે એરે of પૂર્ણાંક. સમસ્યા "એરેને ફરીથી ગોઠવો જેમ કે અનુક્રમણિકા તત્વો પણ નાના હોય છે અને વિચિત્ર અનુક્રમણિકા તત્વો વધારે હોય છે" એરેને ફરીથી ગોઠવવાનું કહે છે, જેથી સુધારેલા એરેમાં પણ અનુક્રમણિકા તત્વો વિચિત્ર અનુક્રમણિકા તત્વો કરતા નાના હોવા જોઈએ.

ઉદાહરણ

arr[]={ 2,5,7,1,3,4 }
2 7 1 5 3 4

સમજૂતી: 2 એ પણ અનુક્રમણિકા સ્થિતિમાં છે (0 અનુક્રમણિકા) તેથી તે આગલા વિચિત્ર અનુક્રમણિકા તત્વ કરતાં નાનું છે, 1 એ 5 કરતા ઓછું છે જે વિચિત્ર અનુક્રમિત તત્વ પર છે.

એરેને ફરીથી ગોઠવવા માટે અલ્ગોરિધમનો કે અનુક્રમિત તત્વો પણ વિચિત્ર અનુક્રમિત કરતા નાના હોય છે

1. Traverse the array from 0 to n-1(less than the length of the array).
2. Check if the index is even and the next element is smaller than the current element then swap both of the numbers.
3. Check if the index is odd and the next element is greater than the current element, then swap both of the numbers.
4. Print the array.

સમજૂતી

લંબાઈનો એરે આપ્યો n. અમને એરેને એવી રીતે ગોઠવવા માટે કહેવામાં આવે છે કે સમાન અનુક્રમણિકા તત્વો વિચિત્ર અનુક્રમિત તત્વો કરતા નાના હોય. જો પરિસ્થિતિઓ સંતોષાય નહીં તો તત્વોને અદલાબદલ કરીને આ કરીશું. પ્રથમ, આપણે તેનો પ્રકાર કાં તો તે સરખું કે વિચિત્ર છે તે તપાસવું પડશે પછી આપણે તેમાં ફેરફાર કરવો પડશે એરે.

0 થી n-1 કરતા ઓછી તરફ એરેનો પ્રવાસ જ્યાં n એરેની લંબાઈ છે. ટ્રાવર્સલ સુધી એન -1 કરતા થોડું ઓછું લો કારણ કે જો આપણે એરેમાં હાજર હોઈએ તો પછીના તત્વ સાથે તેની તુલના કરીશું. તેથી આપણે તે સ્થાનને તુલના માટે છોડવું પડશે નહીં તો તે ભૂલ દ્વારા થશે. જો આપણે n કરતા ઓછા સુધી લૂપ કરીએ, તો તે અનુક્રમણિકાને ફટકારે છે જે એરેમાં અસ્તિત્વમાં નથી. તેથી જ અમે 0 થી n - 1 ટ્રversવર્સલ કરતા ઓછા લીધા.

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

હવે આપણે એક સાથે તપાસ કરીશું કે 'i' ની વેલ્યુ વિચિત્ર છે કે કેમ અને જો આ ઈન્ડેક્સ પરનું એલિમેન્ટ અગાઉના એલિમેન્ટ કરતા નાનું હોય તો પણ આપણે એરેમાં વેલ્યુ સ્વેપ કરીશું. બધા સંભવિત મૂલ્યોને અદલાબદલ કર્યા પછી, જેથી રચાયેલી એરે અંતિમ અને ઇચ્છિત આઉટપુટ હશે.

એરેને ફરીથી ગોઠવો જેમ કે ઇન્ડેક્સ તત્વો પણ નાના હોય છે અને વિચિત્ર અનુક્રમણિકા તત્વો વધારે હોય છે

કોડ

સી ++ કોડ એરેને ફરીથી ગોઠવવા માટે કે અનુક્રમિત તત્વો પણ વિચિત્ર અનુક્રમિત કરતા નાના હોય છે

#include <iostream>
using namespace std;

void evenOddComparison (int* arr, int n)
{
    for (int i = 0; i < n - 1; i++)
    {
        if (i % 2 == 0 && arr[i] > arr[i + 1])
            swap(arr[i], arr[i + 1]);

        if (i % 2 != 0 && arr[i] < arr[i + 1])
            swap(arr[i], arr[i + 1]);
    }
}

void printArray(int arr[], int size)
{
    for (int i = 0; i < size; i++)
        cout << arr[i] << " ";

    cout << endl;
}

int main()
{
    int arr[] = {  2,5,7,1,3,4  };
    int n = sizeof(arr) / sizeof(arr[0]);

    evenOddComparison (arr, n);

    printArray(arr, n);

    return 0;
}
2 7 1 5 3 4

જાવા કોડ એરેને ફરીથી ગોઠવવા માટે કે અનુક્રમિત તત્વો પણ વિચિત્ર અનુક્રમિત કરતા નાના હોય છે

class rearrangeArray
{
    public static void evenOddComparison(int arr[], int n)
    {

        int temp;
        for (int i = 0; i < n - 1; i++)
        {
            if (i % 2 == 0 && arr[i] > arr[i + 1])
            {
                temp = arr[i];
                arr[i] = arr[i + 1];
                arr[i + 1] = temp;
            }
            if (i % 2 != 0 && arr[i] < arr[i + 1])
            {
                temp = arr[i];
                arr[i] = arr[i + 1];
                arr[i + 1] = temp;
            }
        }
    }
    public static void printArray(int arr[], int size)
    {
        for (int i = 0; i < size; i++)
            System.out.print(arr[i] + " ");

        System.out.println();
    }
    public static void main(String[] args)
    {
        int arr[] = { 2,5,7,1,3,4 };
        int n = arr.length;

        evenOddComparison (arr, n);

        printArray(arr, n);
    }
}
2 7 1 5 3 4

જટિલતા વિશ્લેષણ

સમય જટિલતા

ઓ (એન) જ્યાં “એન” એરેમાં તત્વોની સંખ્યા છે. અમે હમણાં જ એરે ઓળંગી છે અને તત્વોને અદલાબદલી કરી છે તેથી સમય જટિલતા રેખીય હોય છે.

અવકાશ જટિલતા

ઓ (1) કારણ કે આપણે સતત જગ્યા વાપરી છે પરંતુ આખા પ્રોગ્રામમાં O (n) સ્પેસ લાગે છે.