கூடுதல் இடத்தைப் பயன்படுத்தாமல் 2n முழு எண்களை a1-b1-a2-b2-a3-b3 - .. bn ஆக மாற்றவும்


சிரமம் நிலை நடுத்தர
அடிக்கடி கேட்கப்படுகிறது அடோப் டி.இ ஷா Expedia வெறியர்கள் உண்மையில் PayU
அணி பிரித்து வெல்லுங்கள் மறுசுழற்சி

சிக்கல் அறிக்கை

உங்களுக்கு ஒரு வழங்கப்படுகிறது வரிசை of முழு. “2n முழு எண்களை a1-b1-a2-b2-a3-b3 - .. bn கூடுதல் இடத்தைப் பயன்படுத்தாமல் மாற்றவும்” என்ற சிக்கல் வரிசையில் உள்ள அனைத்து எண்களையும் மாற்றும்படி கேட்கிறது, அதாவது எண்கள் (x0, x1, x2, x3, y0, y1, y2, y3) இந்த முறையில் x0, y0, x1, y1, x2, y2, x3, y3 போன்றவற்றை மாற்றும்.

உதாரணமாக

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

விளக்கம்

முதல் மூன்று எண்களிலிருந்து ஒப்பிட்டுப் பார்த்தால் x0, x1, x2 போலவும், அடுத்த மூன்று எண்கள் y0, y1, y2 போலவும் இருக்கும், மேலும் இது x0, y0, x1, y1, x2, y2 இல் ஏற்பாடு செய்யப்படும்.

கூடுதல் இடத்தைப் பயன்படுத்தாமல் 2n முழு எண்களை a1-b1-a2-b2-a3-b3 - .. bn ஆக மாற்றவும்

கூடுதல் இடத்தைப் பயன்படுத்தாமல் 2n முழு எண்களை a1-b1-a2-b2-a3-b3 - .. bn ஆக மாற்றுவதற்கான வழிமுறை

1. Find out the middle index of the array.
2. While middleIndex greater than 0, set count and swappingIndex to middleIndex.
  1. While the count is greater than 0, do the following steps.
    1. Swap the values at swappingIndex and swappingIndex +1(value next to swappingIndex).
    2. Increase the value of swapping index by 1.
  2. Decrease the value of middleIndex by 1.
3. Print the array.

விளக்கம்

நாங்கள் ஒரு கொடுத்துள்ளோம் வரிசை of முழு.  அனைத்து முழு மதிப்புகளையும் குறிப்பாக, கொடுக்கப்பட்ட முறையில் மாற்றுமாறு கேட்கப்படுகிறோம். நாங்கள் வரிசையில் பாதி மட்டுமே பயணிப்போம். அல்காரிதம் படி வரும் அனைத்து மதிப்புகளையும் மாற்றுவது. முதலில், வரிசை பூஜ்யமாக இருக்கக்கூடாது என்பதை நாங்கள் சரிபார்க்கப் போகிறோம். பதில், வரிசையின் நீளம் சமமாக இருக்க வேண்டும். அதனால்தான் வரிசைகளின் நீளம் ஒற்றைப்படையாக இருக்கக்கூடாது என்ற நிலையை நாங்கள் சரிபார்க்கிறோம். மேலே குறிப்பிட்டுள்ள நிபந்தனைகள் ஏதேனும் தவறானவை என்றால், அது ஒரு வெளியீட்டை உருவாக்காது.

வரிசையின் நடுத்தர குறியீட்டைக் கண்டுபிடித்து, அந்த குறியீட்டின் மதிப்பு மற்றும் அதன் அடுத்த குறியீட்டு மதிப்பைச் சரிபார்த்து அதை மாற்றிக் கொள்வோம். அதற்காக, நாங்கள் உள்ளமைவைப் பயன்படுத்தப் போகிறோம் லூப் போது முதல் சுழற்சியில். பின்னர் நாம் அதை தற்போதைய குறியீட்டிலிருந்து 0 ஆகக் கடந்து, நடுத்தரக் குறியீட்டின் மதிப்பைக் குறைத்துக்கொண்டே இருக்கப் போகிறோம். உள் உள்ளே லூப் போது, தற்போதைய குறியீட்டின் அதே மதிப்பை ஸ்வாப்பிங்இண்டெக்ஸுக்கு சேமித்து, பின்னர் ஸ்வாப்பிங்இண்டெக்ஸ் மதிப்பு மற்றும் அதன் அடுத்த மதிப்பை எடுத்து அதை மாற்றுவோம். இரண்டாவது இடமாற்றுக்கு, ஸ்வாப்பிங்இண்டெக்ஸின் மதிப்பை அதிகரிக்கவும், தற்போதைய ஸ்வாப்பிங்இண்டெக்ஸ் மற்றும் அதன் அடுத்த குறியீட்டின் மதிப்பை மாற்றவும்.

அடுத்த பயணத்திற்கு, நடுத்தர குறியீட்டின் மதிப்பைக் குறைப்போம். இதனால் அது வரிசையின் முன்னால் மதிப்புகளை எடுக்க முடியும். இதேபோல், எண்ணிக்கையும் இடமாற்றமும்இண்டெக்ஸ் என்பது நடுத்தர குறியீட்டு மதிப்பின் மதிப்புக்கு சமமாக இருக்கும், இது வரிசையின் முந்தைய மதிப்புகளைக் கடக்க நாங்கள் குறைத்தோம். நாங்கள் செய்த எல்லா இடமாற்றங்களுக்கும் பிறகு, நாங்கள் அந்த வரிசையை அச்சிடப் போகிறோம், மேலும் அனைத்து எண்களும் கொடுக்கப்பட்ட முறையில் மாற்றப்படும்.

குறியீடு

கூடுதல் இடத்தைப் பயன்படுத்தாமல் 2n முழு எண்களை a1-b1-a2-b2-a3-b3 - .. bn ஆக மாற்றுவதற்கான சி ++ குறியீடு

#include<iostream>
using namespace std;

void shuffleInt(int arr[], int n)
{
    if (arr == NULL || n % 2 == 1)
        return;

    int middleIndex = (n - 1) / 2;

    while (middleIndex > 0)
    {
        int countIndex = middleIndex, swappingIndex = middleIndex;

        while (countIndex -- > 0)
        {
            int temp = arr[swappingIndex + 1];
            arr[swappingIndex + 1] = arr[swappingIndex];
            arr[swappingIndex] = temp;
            swappingIndex++;
        }
        middleIndex--;
    }
}
int main()
{
    int arr[] = {1, 9, 25, 4, 16, 36};
    int n = sizeof(arr) / sizeof(arr[0]);
    shuffleInt(arr, n);
    for (int i = 0; i < n; i++)
        cout << arr[i]<<" ";
}
1 4 9 16 25 36

ஜாவா குறியீடு 2n முழு எண்களை a1-b1-a2-b2-a3-b3 - .. bn ஆக கூடுதல் இடத்தைப் பயன்படுத்தாமல்

class Shuffle2nIntegers
{
    public static void shuffleInt(int[] arr)
    {

        if (arr == null || arr.length % 2 == 1)
            return;

        int middleIndex = (arr.length - 1) / 2;


        while (middleIndex > 0)
        {
            int countIndex = middleIndex, swappingIndex = middleIndex;

            while (countIndex -- > 0)
            {
                int temp = arr[swappingIndex + 1];
                arr[swappingIndex + 1] = arr[swappingIndex];
                arr[swappingIndex] = temp;
                swappingIndex++;
            }
            middleIndex--;
        }
    }

    public static void main(String[] args)
    {
        int arr[] = {1, 9, 25, 4, 16, 36};
        shuffleInt(arr);
        for (int i = 0; i < arr.length; i++)
            System.out.print( arr[i]+" ");
        System.out.println();
    }
}
1 4 9 16 25 36

சிக்கலான பகுப்பாய்வு

நேர சிக்கலானது

O (n ^ 2) எங்கே “N” என்பது வரிசையில் உள்ள உறுப்புகளின் எண்ணிக்கை. ஒவ்வொரு முறையும் நாம் மிடில்இண்டெக்ஸை ஒவ்வொன்றாகக் குறைத்து வருகிறோம். ஆனால் உள் வளைய மிடில்இண்டெக்ஸ் எண்ணிக்கையில் இயங்கும். வெளிப்புற வளையம் i = 0 முதல் n வரை இயங்கும் எளிய இரண்டு உள்ளமை சுழல்களாக இதை நீங்கள் கருதலாம். உள் வளையம் i + 1 முதல் இயங்கும். இதனால் நேர-சிக்கலானது பல்லுறுப்புறுப்பு ஆகும்.

விண்வெளி சிக்கலானது

ஓ (1), ஏனெனில் வழிமுறை ஒரு இடத்தில் உள்ள வழிமுறை. செய்யப்படும் அனைத்து செயல்பாடுகளும் ஆரம்ப வரிசை கூறுகளை மாற்றும். மேலும் புதிய வரிசைகள் எதுவும் செய்யப்படவில்லை.