ऐसे क्रम को पुनर्व्यवस्थित करें, जिसमें इंडेक्स तत्व भी छोटे हों और विषम इंडेक्स तत्व अधिक हों


कठिनाई स्तर आसान
में अक्सर पूछा Avalara एपिक सिस्टम चौपाई 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.

व्याख्या

लंबाई की एक सरणी को देखते हुए एन। हमें सरणी को इस तरह से पुनर्व्यवस्थित करने के लिए कहा जाता है कि सम अनुक्रमित तत्व विषम अनुक्रमित तत्वों से छोटे होते हैं। यदि स्थिति संतुष्ट नहीं है तो हम तत्वों की अदला-बदली करके ऐसा करेंगे। पहले, हमें इसके प्रकार की जाँच करनी होगी या तो यह विषम है या फिर हमें इसे संशोधित करना होगा सरणी.

सरणी को 0 से घटाकर n-1 से कम पर जहाँ n सरणी की लंबाई है। ट्रैवर्सल तक n-1 से एक कम लें क्योंकि हम सरणी में मौजूद होने पर अगले तत्व के साथ इसकी तुलना करने जा रहे हैं। इसलिए हमें उस स्थान को तुलना के लिए छोड़ना होगा, यह एक त्रुटि के माध्यम से होगा। यदि हम n से कम समय तक लूप करते हैं, तो यह इंडेक्स को हिट करेगा जो कि सरणी में मौजूद नहीं है। इसलिए हमने 0 से n - 1 ट्रैवर्सल से कम लिया।

हम एरे को आगे बढ़ाएंगे और 'i' के प्रत्येक मान की जांच करेंगे, यह सम या विषम है यदि यह सम है और एरे भी है [i] अगले तत्व से अधिक है। इसका मतलब है कि अगले तत्व की स्थिति जैसा कि मैं निश्चित रूप से विषम है, और वह विषम तैनात तत्व भी तैनात तत्व से कम है। इसलिए हम तत्वों को स्वैप करने जा रहे हैं क्योंकि गिरफ्तारी [i] वर्तमान सम तत्व है और गिरफ्तार [i + 1] अगला विषम स्थिति वाला तत्व है।

अब एक साथ हम जाँचते हैं कि क्या 'i' का मान विषम है और यह भी कि यदि इस सूचकांक में मौजूद तत्व पिछले तत्व से छोटा है तो हम सरणी में मानों को स्वैप करने जा रहे हैं। सभी संभावित मानों की अदला-बदली करने के बाद, बनाई गई सरणी अंतिम और वांछित आउटपुट होगी।

ऐसे क्रम को पुनर्व्यवस्थित करें, जिसमें इंडेक्स तत्व भी छोटे हों और विषम इंडेक्स तत्व अधिक हों

कोड

C ++ कोड को सरणी को फिर से व्यवस्थित करने के लिए जैसे कि अनुक्रमित तत्व विषम अनुक्रमित से छोटे होते हैं

#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

जटिलता विश्लेषण

समय जटिलता

पर) जहां "N" सरणी में तत्वों की संख्या है। हमने सरणी को अभी-अभी ट्रैक किया है और तत्वों की अदला-बदली की है, इस प्रकार समय जटिलता रैखिक है।

अंतरिक्ष जटिलता

ओ (1) क्योंकि हमने निरंतर स्थान का उपयोग किया है, लेकिन एक पूरे के रूप में कार्यक्रम O (n) स्थान लेता है।