တစ်ခု Array Leetcode ဖြေရှင်းချက်၏အဆင့်အသွင်ပြောင်း


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

အဆိုပါပြproblemနာတစ်ခု Array Leetcode ဖြေရှင်းချက်၏အဆင့်အသွင်ပြောင်းတစ်ခုနှင့်အတူကျွန်တော်တို့ကိုထောက်ပံ့ပေးခဲ့သည် အခင်းအကျင်း ကိန်း၏။ Array (သို့) ပေးထားသော sequence သည် unsorted ဖြစ်ပါတယ်။ ကိန်းတစ်ခုစီမှာကိန်းတစ်ခုစီကိုအဆင့်သတ်မှတ်ပေးရမယ်။ ရာထူးသတ်မှတ်ခြင်းများအတွက်အချို့သောကန့်သတ် s ရှိပါတယ်။

  1. ရာထူး 1 နဲ့စတင်ရမည်ဖြစ်သည်။
  2. နံပါတ်ကပိုကြီးလေ၊ အဆင့်အတန်းမြင့်လေလေဖြစ်တယ်။
  3. ကိန်းတစ်ခုသည်တစ်ခုချင်းစီအတွက်အနည်းဆုံးအဆင့်အတန်းသတ်မှတ်ရမည်။

တစ်ခု Array Leetcode ဖြေရှင်းချက်၏အဆင့်အသွင်ပြောင်း

ဒါဆိုဥပမာအချို့ကိုကြည့်ရအောင်။

arr = [40,10,20,30]
[4,1,2,3]

ရှင်းလင်းချက် - ပေးထားတဲ့သွင်းအားစုကိုအမျိုးအစားခွဲမယ်ဆိုရင်ဥပမာကိုနားလည်ဖို့ပိုလွယ်ကူပါလိမ့်မယ်။ sorting ပြီးနောက်, input ကို [10, 20, 30, 40] ဖြစ်လာသည်။ ယခုငါတို့ပေးထားသောစည်းမျဉ်းစည်းကမ်းတွေကိုလိုက်နာလျှင်။ အသစ်ပြုပြင်ထားသောခင်းကျင်းမှုနှုန်းအတိုင်းရာထူး [1, 2, 3, 4] ဖြစ်လိမ့်မည်။ ကျနော်တို့က output အတွက်ဒြပ်စင်ကိုက်ညီလျှင်။ သူတို့ကအတူတူပင်ဖြစ်ကြသည်ကို၎င်း, output ကို၏မှန်ကန်မှုကိုအတည်ပြု။

[100,100,100]
[1, 1, 1]

ရှင်းလင်းချက် - Input ထဲမှာရှိတဲ့ element အားလုံးအတူတူပါပဲ။ ထို့ကြောင့်အားလုံးသည် ၁ သည်တူညီသောအဆင့်ရှိရမည်။ ထို့ကြောင့် output သည်ဥပမာ ၁ ခုသာပါ ၀ င်သည်။

တစ်ခု Array Leetcode ဖြေရှင်းချက်၏အဆင့်အသွင်ပြောင်းဘို့ချဉ်းကပ်မှု

Array Leetcode Solution ၏ရာထူးပြောင်းလဲမှုပြRankနာကကျွန်ုပ်တို့အားပေးထားသောအစီအစဉ်ကိုရာထူးပေးရန်သတ်မှတ်ထားသည်။ တွေ့ဆုံရန်ခံရမည့်အခြေအနေများကိုပြproblemနာဖော်ပြချက်တွင်ဖော်ပြထားသည်။ ဒီတော့သူတို့ကိုထပ်မံဖော်ပြမယ့်အစား။ ကျနော်တို့ဖြေရှင်းချက်ကိုတိုက်ရိုက်သွားပါလိမ့်မယ်။ ဒီတော့ဥပမာထဲမှာမြင်သည်အတိုင်း။ ဒါဟာစီထားသော sequence ကိုမှရာထူးသတ်မှတ်ရန်ပိုမိုလွယ်ကူသည်။ ဒါကြောင့်ကျနော်တို့ကပေးထားသော input ကို sequence ကိုအတွက် element တွေကိုသိမ်းဆည်းရန်အမိန့်မြေပုံကိုအသုံးပြုပါ။ အော်ဒါမှာထားသည့်မြေပုံကိုအသုံးပြုခြင်းဖြင့်၎င်းဒြပ်စင်သည်ပုံမှန်အားဖြင့်ပုံမှန်ဖြစ်နေသည်ကိုသေချာစေသည်။

အခုငါတို့တတိယအခြေအနေကိုကိုင်တွယ်ရမယ်။ တတိယအခွအေနေအရကျွန်ုပ်တို့သည်အသေးဆုံးရာထူးများကိုအတတ်နိုင်ဆုံးတတ်နိုင်သမျှသတ်မှတ်ရမည်။ ထို့ကြောင့်ကျွန်ုပ်တို့သည် 1 မှနံပါတ်များကိုမြေပုံပေါ်ရှိသော့များသို့သတ်မှတ်သည်။ ၎င်းသည်ချမှတ်ထားသည့်အခြေအနေ ၃ ခုစလုံးကိုဂရုစိုက်သည်။ ပိုကြီးတဲ့နံပါတ်များ၏ရာထူးပိုမိုမြင့်မားသည်။ အဆင့် ၁ ကနေစမယ်။ သူတို့တတ်နိုင်သမျှသေးငယ်တယ်။

ယခုကျွန်ုပ်တို့သည် input sequence ကိုဖြတ်ပြီးမြေပုံတွင်ဖော်ပြထားသောရာထူးများကိုရိုးရိုးရှင်းရှင်းသတ်မှတ်လိုက်သည်။

ကုဒ်

Array Leetcode Solution ၏ရာထူးပြောင်းလဲခြင်းအတွက် C ++ code

#include <bits/stdc++.h>
using namespace std;

vector<int> arrayRankTransform(vector<int>& arr) {
    map<int, int> m;
    for(auto x: arr)
        m[x] = 1;
    int lst = 0;
    for(auto x: m){
        m[x.first] = lst + 1;
        lst++;
    }
    for(int i=0;i<arr.size();i++)
        arr[i] = m[arr[i]];
    return arr;
}

int main(){
    vector<int> input = {40, 10, 30, 20};
    vector<int> output = arrayRankTransform(input);
    for(auto x: input)
        cout<<x<<" ";
}
4 1 3 2

Array Leetcode Solution ၏ Java Code အဆင့်ပြောင်းလဲခြင်း

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

class Main
{
  public static int[] arrayRankTransform(int[] arr) {
        Map<Integer, Integer> m = new TreeMap<Integer, Integer>();
        for(int x: arr)
            m.put(x, 1);
        int lst = 0;
        for(Integer x: m.keySet()){
            m.put(x, lst + m.get(x));
            lst = m.get(x);
        }
        for(int i=0;i<arr.length;i++)
            arr[i] = m.get(arr[i]);
        return arr;
    }
    
  public static void main (String[] args) throws java.lang.Exception
  {
    int[] input = {40, 10, 30, 20};
    int[] output = arrayRankTransform(input);
    for(int x: output)
      System.out.print(x+" ");
  }
}
4 1 3 2

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

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

အို (NlogN), ကျွန်ုပ်တို့မှာအမှာစာမြေပုံတစ်ခုကိုအသုံးပြုပြီးကတည်းကထည့်သွင်းခြင်း၊ ဖျက်ခြင်းနှင့်ရှာဖွေခြင်းအတွက်လော်ဂရစ်သမ်အချက်များရှိသည်။

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

အို (N)၊ ဘာလို့လဲဆိုတော့ကျွန်တော်တို့ဟာ input ထဲမှာ element တွေကိုသိမ်းထားဖို့အမှာစာမြေပုံကိုသုံးထားလို့ပဲ။