2n ကိန်းများကို a1-b1-a2-b2-a3-b3 - .. bn အဖြစ်အပိုနေရာများမသုံးပဲသွေဖည်ပါ။


ခက်ခဲအဆင့် အလယ်အလတ်
မကြာခဏမေးတယ် Adobe က DE Shaw Expedia ဝါသနာရှင်များ တကယ်ပါပဲ PayU
အခင်းအကျင်း သွေးခွဲနှင့်အောင်နိုင် နေ့တိုင်းပြန်လည်စတင်မည်

ပြProbleနာဖော်ပြချက်

မင်းကိုပေးထားတယ် အခင်းအကျင်း of ကိန်း။ ပြ “နာ က“ အပိုနေရာမရှိဘဲ ၂ ဘီလီယံကိန်းသေများကို a2-b1-a1-b2-a2-b3 - .. bn” ဟုပြtheနာက array ထဲရှိနံပါတ်များအားလုံးကဲ့သို့ဖြစ်သော (x3, x0, x1) x2, y3, y0, y1, y2) ကိုဒီပုံစံနဲ့ x3, y0, x0, y1, x1, y2, x2, 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 အဖြစ်ပြောင်းရန် Algorithm ကအပိုအာကာသမပါဘဲ

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 ကိန်း။  ပြီးတဲ့အခါမှာကိန်းပြည့်တန်ဖိုးတွေအားလုံးကိုအထူးသဖြင့်ပေးထားတဲ့ပုံစံနဲ့ရောမွှေပါ။ ကျနော်တို့ခင်းကျင်း၏ထက်ဝက်သာဖြတ်သန်းလိမ့်မည်။ ပြီးတော့ algorithm အရလာတဲ့တန်ဖိုးအားလုံးကိုလဲလှယ်လိုက်တယ်။ ပထမ ဦး စွာကျွန်ုပ်တို့သည် array အား null မဖြစ်စေရန်စစ်ဆေးပါမည်။ Ans လည်း Array ရဲ့အရှည်ကတောင်ညီတယ်။ ထိုကြောင့်ကျွန်ုပ်တို့သည် arrays length သည်မဖြစ်သင့်သောအခြေအနေကိုစစ်ဆေးသည်။ အထက်ဖော်ပြပါအခြေအနေများသည်မှားယွင်းပါကရလဒ်ထွက်ပေါ်လာလိမ့်မည်မဟုတ်ပါ။

ကျနော်တို့ array ၏အလယ်အညွှန်းကိန်းကိုရှာတွေ့လိမ့်မည်။ ထို့နောက်ထိုအညွှန်း၏တန်ဖိုးနှင့်၎င်း၏နောက်အညွှန်းတန်ဖိုးကိုစစ်ဆေးပြီးယင်းကိုလဲလှယ်လိုက်သည်။ ၎င်းအတွက် nested ကိုအသုံးပြုမည် နေစဉ်ကွင်းဆက် ပထမ ဦး ဆုံးနေစဉ်ကွင်းဆက်၌တည်၏။ ထိုအခါကျွန်ုပ်တို့သည်လက်ရှိအညွှန်းကိန်းမှ ၀ သို့သွားပြီးအလယ်အညွှန်း၏တန်ဖိုးကိုဆက်လက်ကျဆင်းသွားမည်ဖြစ်သည်။ အတွင်းပိုင်းအတွင်းပိုင်း နေစဉ်ကွင်းဆက်, ကျွန်ုပ်တို့သည် swappingIndex သို့လက်ရှိအညွှန်းနှင့်တူညီသောတန်ဖိုးကိုသိမ်းဆည်းပြီး swappingIndex တန်ဖိုးနှင့်၎င်း၏နောက်တန်ဖိုးကိုယူပြီးလဲပါလိမ့်မည်။ ဒုတိယ swap အတွက် swappingIndex ၏တန်ဖိုးကိုတိုးမြှင့်ပြီး swappingIndex နှင့်၎င်း၏နောက် index ၏တန်ဖိုးကိုလဲလှယ်ပါ။

လာမယ့်ဖြတ်သန်းဘို့ငါတို့အလယ်တန်းအညွှန်းကိန်း၏တန်ဖိုးကိုလျော့ချလိမ့်မယ်။ ဒါကြောင့် array ရဲ့အရှေ့ဘက်ကတန်ဖိုးတွေကိုယူနိုင်ပါတယ်။ အလားတူစွာ count နှင့် swappingIndex သည် index index ၏တန်ဖိုးနှင့်အတူတူပင်ဖြစ်လိမ့်မည်။ ၎င်းသည် array ၏အစောပိုင်းတန်ဖိုးများကိုဖြတ်သန်းသွားသည်။ ကြှနျုပျတို့ပွုပွငျဖလှယ်မှုပြီးနောက်ရှိသမျှတို့သည်၎င်းခင်းကျင်းမှုကိုပုံနှိပ်ထုတ်ဝေမည်ဖြစ်ပြီးနံပါတ်များအားလုံးသည်သတ်မှတ်ထားသောပုံစံဖြင့်ပြောင်းလဲသွားလိမ့်မည်။

ကုဒ်

C ++ ကုဒ်ကို 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

Java Code သည် Shiftle 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

ရှုပ်ထွေးဆန်းစစ်ခြင်း

အချိန်ရှုပ်ထွေး

အို (n ^ ၂) ဘယ်မှာ “ n” သည် array ထဲရှိ element အရေအတွက်ဖြစ်သည်။ အချိန်တိုင်းတွင်ကျွန်ုပ်တို့သည် middleIndex ကိုတစ် ဦး တည်းလျှော့ချသည်။ သို့သော်အတွင်းပိုင်းကွင်းဆက်သည် middleIndex အကြိမ်အရေအတွက်အတွက်ပြေးသည်။ အဲဒါကို i = 0 to n မှအတွင်းကွင်းဆက် i + 1 ကနေလည်ပတ်တဲ့ရိုးရှင်းတဲ့ nested loops နှစ်ခုအဖြစ်သတ်မှတ်နိုင်ပါတယ်။ ထို့ကြောင့်အချိန် - ရှုပ်ထွေး polynomial ဖြစ်ပါတယ်။

အာကာသရှုပ်ထွေးမှု

အို (၁)၊ ဘာဖြစ်လို့လဲဆိုတော့ algorithm ကို in-place algorithm လို့ပဲ။ ဆိုလိုသည်မှာလုပ်ဆောင်မှုအားလုံးသည်ကန ဦး array element များနေရာတွင်အစားထိုးနေသည်။ ထို့အပြင် Array အသစ်များမပြုလုပ်ပါ။