પેટા-એરે લીટકોડ સોલ્યુશનને બદલીને બે એરે સમાન બનાવો


મુશ્કેલી સ્તર સરળ
વારંવાર પૂછવામાં આવે છે ફેસબુક
અરે

પેટા-એરે લીટકોડ સોલ્યુશનને બદલીને બે એરે સમાન બનાવો સમસ્યા અમને બે પ્રદાન કરે છે એરે. તેમાંથી એક લક્ષ્ય એરે છે અને બીજો ઇનપુટ એરે છે. ઇનપુટ એરેનો ઉપયોગ કરીને, અમારે લક્ષ્ય એરે બનાવવાની જરૂર છે. આપણે ઇનપુટ એરેમાં કોઈપણ પેટા-એરે ઉલટાવી શકીએ છીએ. પરંતુ અમે ઇનપુટ એરેના તત્વોને બદલી શકતા નથી. હેરાફેરી કેવી રીતે કરવી તે માટે અમારે કોઈ રસ્તો શોધવાની જરૂર નથી. જો શક્ય હોય તો સાચું પાછા ફરો. તેથી, ઉકેલમાં ivingંડે ડાઇવ કરતા પહેલાં હંમેશની જેમ ચાલો આપણે થોડા ઉદાહરણો જોઈએ.

પેટા-એરે લીટકોડ સોલ્યુશનને બદલીને બે એરે સમાન બનાવો

target = [1,2,3,4], arr = [2,4,1,3]
true

સમજૂતી: આપણે અનુક્રમણિકા 0 થી 2 સુધીના પ્રથમ પેટા એરેને ઉલટાવી શકીએ છીએ, પછી આપણે પેટા-એરેને 1 થી 2 સુધી ઉલટાવી શકીએ છીએ, અંતે, આપણે અનુક્રમણિકા 2 થી 3 વિરુદ્ધ કરીએ છીએ અને આ રીતે, આપણે લક્ષ્યને એરે બનાવી શકીએ છીએ. . ઉપરોક્ત છબી પર એક નજર નાખીને તે વધુ સારી રીતે સમજી શકાય છે.

પેટા-એરે લીટકોડ સોલ્યુશનને બદલીને બે એરે બરાબર બનાવો માટેનો અભિગમ

ગણતરીની પદ્ધતિનો ઉપયોગ કરીને સમસ્યા સરળતાથી ઉકેલી શકાય છે. ગણતરીની પદ્ધતિ એ કેટલાક માનક ગાણિતીક નિયમો છે. તેનો ઉપયોગ ગણતરીના સ inર્ટમાં તેમજ અન્ય ઘણા પ્રશ્નોમાં થાય છે. તેથી અહીં આપણે લક્ષ્ય એરેથી તત્વોની ગણતરી રાખીશું. પછી આપણે ઇનપુટ એરેના તત્વોને વટાવીએ છીએ. જ્યારે અમને કોઈ તત્વ મળે છે, ત્યારે આપણે તેની ગણતરી ફ્રીક્વન્સી અથવા ગણતરીના એરેથી ઘટાડીએ છીએ. જો કોઈ રીતે આ કામગીરી દરમિયાન, કોઈપણ અનુક્રમણિકા નકારાત્મક મૂલ્ય ધરાવે છે અમે ખોટા વળતર આપીએ છીએ.

આવર્તન એરેમાં નકારાત્મક ગણતરી બતાવે છે કે ઇનપુટ એરેમાં કોઈ તત્વ માટે મોટી સંખ્યા હોય છે. પરંતુ આ કેવી રીતે કરવાથી સમસ્યા હલ થાય છે? એકવાર તમે અવલોકન જાણ્યા પછી તેનો જવાબ સરળ છે. એકવાર તમે પેટા-એરેના કેટલાક વિપરીત કરવાનો પ્રયાસ કરો. તમે સરળતાથી સમજી શકો છો કે તમે ઇચ્છો ત્યાં કોઈપણ જગ્યાએ ઇનપુટ એરેના કોઈપણ તત્વને મૂકી શકો છો. તેથી, આ નિયમનો ઉપયોગ કરીને આપણે તપાસવાની જરૂર છે કે લક્ષ્ય એરેમાં તત્વો ઇનપુટ એરે જેવા જ છે કે કેમ.

પેટા એરે લીટકોડ સોલ્યુશનને બદલીને બે એરે સમાન બનાવો માટેનો કોડ

સી ++ કોડ

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

bool canBeEqual(vector<int>& target, vector<int>& arr) {
    vector<int> cnt(1001, 0);
    for(int i=0;i<target.size();i++)
        ++cnt[target[i]];
    for (int i=0;i<arr.size();i++) {
        if (--cnt[arr[i]] < 0) {
            return false;
        }
    }
    return true;
}

int main(){
    vector<int> target = {1, 2, 3, 4};
    vector<int> arr = {2, 3, 1, 4};
    cout<<(canBeEqual(target, arr) ? "true" : "false");
}
true

જાવા કોડ

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

class Main
{
  public static boolean canBeEqual(int[] target, int[] arr) {
        int[] cnt = new int[1001];
        for(int i=0;i<target.length;i++)
            ++cnt[target[i]];
        for (int i=0;i<arr.length;i++) {
            if (--cnt[arr[i]] < 0) {
                return false;
            }
        }
        return true;
    }
    
  public static void main (String[] args) throws java.lang.Exception
  {
    int[] target = {1, 2, 3, 4};
      int[] arr = {2, 3, 1, 4};
      System.out.print(canBeEqual(target, arr) ? "true" : "false");
  }
}
true

જટિલતા વિશ્લેષણ

સમય જટિલતા

ઓ (એન), કારણ કે આપણે એરેના બધા તત્વોને વટાવીએ છીએ.

અવકાશ જટિલતા

ઓ (1), કારણ કે અમે સતત કદની આવર્તન અથવા ગણતરીના એરેનો ઉપયોગ કર્યો છે.