Array တွင်အများဆုံးအကွာအဝေး


ခက်ခဲအဆင့် လွယ်ကူသော
မကြာခဏမေးတယ် Adobe က အမေဇုံ Google Oracle က
အခင်းအကျင်း hash

“ Array in Maximum Distance” ပြTheနာကသင့်အားပေးသည်ဟုဖော်ပြသည် “ n” မဟုတ်ဘူး ၏ Array ကိုအပေါင်းတို့နှင့် Array ကိုတက်နိုင်ရန်အတွက်ပေးနေကြသည်။ သင်၏လုပ်ငန်းတာဝန်မှာနံပါတ်နှစ်ခု၏အမြင့်ဆုံးကွာခြားမှု / အကြွင်းမဲ့ကွာခြားမှုကိုရှာဖွေရန်ဖြစ်သည် အခင်းအကျင်း နံပါတ်နှစ်ခုအကြားအများဆုံးအကွာအဝေးကိုကျွန်ုပ်တို့သတ်မှတ်နိုင်သည် abs | ab |။ မတူညီသော Array များကိုဖွဲ့စည်းရန်နှင့်ရှာရန်နံပါတ်နှစ်ခုကိုသင်ရွေးချယ်နိုင်သည် abs | ab | အများဆုံးခြားနားချက်အဖြစ်။

နမူနာ

[  [1,2,3],
[0,2,3],
[1,4,5] ]
5

ရှင်းလင်းချက်

အဘယ်ကြောင့်ဆိုသော်ဒုတိယခင်းကျင်းချက်ရှိ '0' နှင့်တတိယအခင်း၌ရှိသောနံပါတ် '၅' သည်အလုံးအရင်းတစ်ခုလုံးအတွက်အကြွင်းမဲ့ကွာခြားချက်ကိုပေးသောကြောင့်ဖြစ်သည်။

algorithm

  1. Variable output တစ်ခုကိုကြေငြာပြီး 0 လို့သတ်မှတ်ပါ။
  2. အဖြစ်နိမ့်ဆုံး၏တန်ဖိုးသတ်မှတ်မည် ရေ[0] [0] ။
  3. အများဆုံး၏တန်ဖိုးသတ်မှတ်မည် varray ရဲ့ ပထမအတန်းအရှည်ဆိုလိုသည်မှာ အများဆုံး= varray [0] [0th အတန်းအရှည် -1] ။
  4. ပထမ ဦး ဆုံးအခင်းကျင်း၏ပထမ ဦး ဆုံးဒြပ်စင်နှင့်ဒုတိယခင်းကျင်းနောက်ဆုံး element တို့အကြားကွာခြားချက်၏ max တန်ဖိုးနှင့်ပထမခင်းကျင်းမှု၏နောက်ဆုံးဒြပ်စင်နှင့်ဒုတိယခင်းကျင်း၏ပထမ element ကိုအကြားခြားနားချက်ကိုရှာပါ
  5. ထို့ကြောင့်အထက်ဖော်ပြပါစာကြောင်းမှထုတ်လုပ်သောတန်ဖိုးနှင့်ထုတ်လုပ်မှုတန်ဖိုးအကြားအများဆုံးတန်ဖိုးကိုရှာပြီး၎င်းကိုသိုလှောင်ထားပါ။
  6. အကြားသေးငယ်တန်ဖိုးကိုရှာပါ varray [i] [0] နှင့် အနည်းဆုံး နှင့်နိမ့်ဆုံးကထားကြ၏။
  7. အကြားပိုကြီးတဲ့တန်ဖိုးကိုရှာပါ varray [i] [row_size-1] နှင့် အများဆုံး နှင့်အများဆုံးကထားကြ၏။
  8. အထက်ပါ process ကို array ရဲ့အဆုံးတိုင်အောင်ပြန်လုပ်ပါ။
  9. output ကိုပြန်သွားပါ။

Array အတွက်အများဆုံးအကွာအဝေးတစ်ခုရှင်းပြချက်

ကျွန်ုပ်တို့၏တာ ၀ န်မှာမတူညီသော Array များတွင်နံပါတ်နှစ်ခု၏အမြင့်ဆုံးခြားနားချက်ကိုရှာဖွေရန်ဖြစ်သည် nested 'for loop' ကိုသာ သုံး၍ နံပါတ်များအားလုံး၏အများဆုံးကွာခြားချက်ကိုရှာဖွေခြင်းဖြင့်လွယ်ကူစေသည်။

ဒါပေမယ့် nested loops တွေကိုသုံးပြီး array ရဲ့ element အားလုံးကိုဖြတ်မယ့်အစား။ ရိုးရိုးလေးသုံးလို့ရတယ် ဘို့ ကွင်းဆက်နှင့်ထိရောက်သောဖြေရှင်းချက်ရှိသည်။ အပေါငျးတို့သဒြပ်စင် input ကိုခင်းကျင်းအတွက်နိုင်ရန်အတွက်တက်ကန ဦး အတွက်စီထားသောနေကြသည်ကတည်းက။ ကျနော်တို့ကွဲပြားခြားနားသော Array ကို၏နောက်ဆုံးနှင့်ပထမ element တွေကိုအကြားခြားနားချက်များကိုရှာဖွေဖို့လိုအပ်ပါတယ်။ ဘာလို့လဲဆိုတော့ဒီ positioned နှစ်ခုကသာအများဆုံးကွာခြားမှုကိုပေးနိုင်တယ်။ ပြီးနောက်တွင် array တစ်ခုစီကိုစီပြီးပထမ element သည်အခြားသူများအကြားအနည်းဆုံးသို့မဟုတ်အနည်းဆုံးဖြစ်သည်။ နောက်ဆုံး element သည် array ၏အကြီးဆုံးအရေအတွက်ဖြစ်လိမ့်မည်။

ဒီမှာနမူနာတစ်ခုယူပြီးဖြေရှင်းကြည့်ရအောင်။

input: arr [] [] = {{0,2,4}, {2,3}, {4,5,6}};

output = 0 အများဆုံး = 4 နိမ့်ဆုံး = 0, ဈ = 1

output = std :: max ကို (output ကို,

std :: max (abs (varray [i] [varray [i] .size () - ၁] - အနိမ့်ဆုံး),

abs (အများဆုံး varray [i] [0])))

Output သည် 3 အဖြစ်သိုလှောင်သည်

အမြင့်ဆုံးသည် 4 ဖြစ်သကဲ့သို့အနိမ့်ဆုံးသည် 0 ဖြစ်သကဲ့သို့ကျန်ရှိနေသည် i i = 2

output = std :: max ကို (output ကို,

std :: max (abs (varray [i] [varray [i] .size () - ၁] - အနိမ့်ဆုံး),

abs (အများဆုံး varray [i] [0])))

ကွဲပြားခြားနားသော Array ကို၏နောက်ဆုံးနှင့်ပထမ ဦး ဆုံးဒြပ်စင်အကြားခြားနားချက်များ

၀ နဲ့ ၆ က ၆ ကအများဆုံးကွာခြားချက်ဖြစ်လို့ output က ၆ ဖြစ်လာလိမ့်မယ်

ပြန်လာ 6 ။

Array တွင်အများဆုံးအကွာအဝေး

Array ၌အများဆုံးအကွာအဝေးများအတွက် C ++ အစီအစဉ်

#include <iostream>
#include<vector>
#include<cstdlib>
using namespace std;
int getMaxDistance(vector<vector <int>> varray)
{
    int output=0;
    int minimum=varray[0][0];
    int maximum=varray[0][varray[0].size()-1];

    for(int i = 1 ; i < varray.size() ; i++ )
    {
        output=std::max(output, std::max( abs( varray[i][varray[i].size()-1] - minimum ), abs(maximum-varray[i][0]) ) );
        minimum=std::min( minimum, varray[i][0] );
        maximum=std::max( maximum, varray[i][varray[i].size()-1]);
    }
    return output;

}
int main()
{
    vector<vector<int>> vec= {{0,2,4},{2,3,4},{4,5,6}};
    cout<<"Maximum distance is:"<<getMaxDistance(vec);
    return 0;
}
Maximum distance is: 6

Array ရှိအများဆုံးအကွာအဝေးအတွက် Java အစီအစဉ်

import java.util.*;
import java.io.*;

class maximumDistance
{
    public static int getMaxDistance(int array[][])
    {
        int output=0;
        int minimum=array[0][0];
        int maximum=array[0][array[0].length-1];

        for(int i = 1 ; i < array.length ; i++ )
        {
            output=Math.max(output, Math.max(Math.abs( array[i][array[i].length-1] - minimum ), Math.abs(maximum-array[i][0]) ) );
            minimum=Math.min( minimum, array[i][0] );
            maximum=Math.max( maximum, array[i][array[i].length-1]);
        }
        return output;

    }
    public static void main(String args[])
    {
        int arr[][]= {{0,2,4},{2,3},{4,5,6}};
        System.out.println("Maximum distance is:"+(getMaxDistance(arr)));
    }
}
Maximum distance is: 6

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

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

အို (ဎ) အဘယ်မှာ n n ခင်းကျင်းအတွက် element များ၏အရေအတွက်သည်။ အဘယ်ကြောင့်ဆိုသော်ကျွန်ုပ်တို့သည် 2D ခင်းကျင်းခြင်း (သို့) matrix ၏အတန်းများကိုဖြတ်သန်းသွားသောကြောင့်ဖြစ်သည်။ ဒါပေမယ့်ကျနော်တို့ input ကို matrix ၏ကော်လံဖြတ်သန်းဘယ်တော့မှမ။

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

အို (၁) ကျွန်တော်တစ် ဦး စဉ်ဆက်မပြတ်အာကာသကိုအသုံးပြုခဲ့သည်အဖြစ်။ ကျနော်တို့ variable တွေကိုသာစဉ်ဆက်မပြတ်အရေအတွက်ကအသုံးပြုခဲ့ကြကတည်းက။ အဆိုပါချဉ်းကပ်မှုစဉ်ဆက်မပြတ်အာကာသရှုပ်ထွေးရှိပါတယ်။

ကိုးကား