បំលែងអារេទៅជាម៉ូតហ្ស៊ី - ហ្សាក


កម្រិតលំបាក មានភាពងាយស្រួល
សួរញឹកញាប់ Accenture ក្រុមហ៊ុន Amazon Fourkites តេរ៉ាតាតា Xome
អារេ

សេចក្តីថ្លែងការណ៍បញ្ហា។

បញ្ហា“ បំលែងអារេទៅជាម៉ូតហ្ស៊ី - ហ្សាក” បញ្ជាក់ថាអ្នកត្រូវបានផ្តល់អោយ - នៃចំនួនគត់។ សេចក្តីថ្លែងការណ៍បញ្ហាស្នើឱ្យតម្រៀបអារេតាមបែប zig -zag ដូចជាធាតុនៅក្នុងអារេនឹងមើលទៅដូចជាà  a <b> c <d> e <f.

ឧទាហរណ៍

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

ការពន្យល់

៥ ធំជាងធាតុ ១ និង ២ (ធាតុនៅជាប់គ្នា) ៧ ធំជាងធាតុទាំងពីរដែលនៅជិតគ្នាដូច្នេះ ៨ ។

ក្បួនដោះស្រាយ

1. Mark flag is equal to true.
2. Traverse the array from 0 to n-2, where n is the length of the array.
  1. Check if the flag is true
    1. Check if the current element is greater than the next element.
      1. Swap those values.
    2. Else, check if the current element is greater than the next element,
      1. Check if the current element is lesser than the next element.
        1. Swap those values.
3. Flip the value of the flag.

ការពន្យល់

យើងបានផ្តល់ឱ្យ អារេ of ចំនួនគត់។ ភារកិច្ចរបស់យើងគឺរៀបចំជួរអារេឡើងវិញទៅជាលក្ខណៈហ្សីហ្ស៊ីហ្គាស។ យើងបានផ្តល់លក្ខខណ្ឌដូចជាថាធាតុលេខគួរតែធំជាងធាតុនៅជាប់គ្នាពីររបស់វាតាមលក្ខណៈនៃa <b> c <d> e <f '។ យើងអាចឃើញនៅទីនេះថាខនិងឃគឺធំជាងធាតុនៅជាប់គ្នាពីររបស់វាគឺ 'a' និង 'c' គឺតូចជាងធាតុនៅជាប់គ្នាពីររបស់វា។ ភារកិច្ចរបស់យើងគឺដើម្បីរៀបចំអារេដែលបានផ្តល់ឱ្យដូចនេះ។ ចំពោះបញ្ហានេះយើងនឹងផ្លាស់ប្តូរតម្លៃខណៈពេលឆ្លងកាត់ជួរអារេដែលត្រូវបានរៀបចំតាមរបៀប zigzag ។

យើងនឹងត្រូវបានសម្គាល់មួយ ប៊ូលីន តម្លៃទៅពិតបន្ទាប់មកយើងនឹងចាប់ផ្តើមឆ្លងកាត់រង្វិលជុំហើយពិនិត្យមើលថាតើទង់ជាតិពិតរឺអត់។ ប្រសិនបើវាជាការពិតនោះយើងនឹងពិនិត្យមើលតម្លៃបច្ចុប្បន្នប្រសិនបើតម្លៃបច្ចុប្បន្នធំជាងតម្លៃបន្ទាប់របស់វា។ បន្ទាប់មកយើងនឹងប្តូរតម្លៃទាំងនោះ។ ហើយសម្គាល់តម្លៃប៊ូលីនថាមិនពិត។ យើងគ្រាន់តែប្តូរតម្លៃរបស់វាឡើងវិញប្រសិនបើវាជាការពិតបន្ទាប់មកធ្វើបច្ចុប្បន្នភាពវាទៅជាមិនពិតប្រសិនបើវាមិនពិតសូមធ្វើបច្ចុប្បន្នភាពវាទៅជាការពិត។ ដូច្នេះជាមួយរាល់ដំណើរឆ្លងកាត់ជំនួសសម្រាប់រាល់ការនិយាយឡើងវិញនឹងមានតម្លៃទង់ផ្សេងៗគ្នា។ ដូច្នេះជាមួយនេះមានតែផ្នែកមួយប៉ុណ្ណោះដែលនឹងត្រូវបានប្រតិបត្តិទាំងផ្នែកឬផ្នែកផ្សេងទៀត។

រឿងដដែលនេះយើងនឹងធ្វើជាមួយផ្នែកផ្សេងទៀតដើម្បីប្តូរតម្លៃ។ ប្រសិនបើតម្លៃបច្ចុប្បន្ននៃអារេនៅក្នុងដំណើរឆ្លងកាត់គឺតិចជាងតម្លៃបន្ទាប់។ ហើយបន្ទាប់ពីការឆ្លងកាត់យើងគ្រាន់តែត្រូវបោះពុម្ពអារេដែលយើងបានធ្វើបច្ចុប្បន្នភាព។

បំលែងអារេទៅជាម៉ូតហ្ស៊ី - ហ្សាក

 

លេខកូដ

លេខកូដ C ++ ដើម្បីបំលែងអារេទៅជាម៉ូតហ្ស៊ីជីហ្សា

#include <iostream>

using namespace std;

void sortZigZag(int arr[], int n)
{
    bool flag = true;

    for (int i=0; i<=n-2; i++)
    {
        if (flag)
        {
            if (arr[i] > arr[i+1])
                swap(arr[i], arr[i+1]);
        }
        else
        {
            if (arr[i] < arr[i+1])
                swap(arr[i], arr[i+1]);
        }
        flag = !flag;
    }
}
int main()
{
    int arr[] = {2,4,5,1,7,6,8};
    int n = sizeof(arr)/sizeof(arr[0]);
    sortZigZag(arr, n);
    for (int i=0; i<n; i++)
        cout << arr[i] << " ";
    return 0;
}
2 5 1 7 4 8 6

កូដចាវ៉ាដើម្បីបំលែងអារេទៅជាម៉ូតហ្ស៊ីជីហ្សា

import java.util.Arrays;

class zigzagArray
{
    public static void sortZigZag(int arr[])
    {
        boolean flag = true;

        int temp =0;

        for (int i=0; i<=arr.length-2; i++)
        {
            if (flag)
            {
                if (arr[i] > arr[i+1])
                {
                    temp = arr[i];
                    arr[i] = arr[i+1];
                    arr[i+1] = temp;
                }

            }
            else
            {
                if (arr[i] < arr[i+1])
                {
                    temp = arr[i];
                    arr[i] = arr[i+1];
                    arr[i+1] = temp;
                }
            }
            if(flag==true)
                flag=false;
            else
                flag=true;
        }
    }
    public static void main(String[] args)
    {
        int arr[] = {2,4,5,1,7,6,8};
        sortZigZag(arr);
        System.out.println(Arrays.toString(arr));
    }
}
[2, 5, 1, 7, 4, 8, 6]

ការវិភាគស្មុគស្មាញ

ស្មុគស្មាញពេលវេលា

អូរ (n) ដែលជាកន្លែងដែល “ n” គឺជាចំនួនធាតុក្នុងអារេ។ ចាប់តាំងពីយើងទើបតែឆ្លងកាត់ធាតុនៅក្នុងអារេ។ ភាពស្មុគស្មាញនៃពេលវេលាគឺលីនេអ៊ែរ។

ភាពស្មុគស្មាញនៃលំហ

ឱ (១) ដោយមិនចាំបាច់មានទំហំបន្ថែម។ ដោយសារយើងមិនបានប្រើកន្លែងទំនេរបន្ថែមភាពស្មុគស្មាញនៃលំហគឺថេរ។