ಉಪ-ಸರಣಿಗಳ ಲೀಟ್‌ಕೋಡ್ ಪರಿಹಾರವನ್ನು ಹಿಮ್ಮುಖಗೊಳಿಸುವ ಮೂಲಕ ಎರಡು ಅರೇಗಳನ್ನು ಸಮಾನಗೊಳಿಸಿ


ತೊಂದರೆ ಮಟ್ಟ ಸುಲಭ
ಆಗಾಗ್ಗೆ ಕೇಳಲಾಗುತ್ತದೆ ಫೇಸ್ಬುಕ್
ಅರೇ

ಉಪ-ಅರೇಗಳನ್ನು ಹಿಮ್ಮುಖಗೊಳಿಸುವ ಮೂಲಕ ಎರಡು ಅರೇಗಳನ್ನು ಸಮಾನವಾಗಿಸುವ ಸಮಸ್ಯೆ ಲೀಟ್‌ಕೋಡ್ ಪರಿಹಾರವು ನಮಗೆ ಎರಡನ್ನು ಒದಗಿಸುತ್ತದೆ ಸರಣಿಗಳು. ಅವುಗಳಲ್ಲಿ ಒಂದು ಟಾರ್ಗೆಟ್ ಅರೇ ಮತ್ತು ಇನ್ನೊಂದು ಇನ್ಪುಟ್ ಅರೇ. ಇನ್ಪುಟ್ ರಚನೆಯನ್ನು ಬಳಸಿ, ನಾವು ಗುರಿ ಶ್ರೇಣಿಯನ್ನು ಮಾಡಬೇಕಾಗಿದೆ. ಇನ್ಪುಟ್ ಅರೇನಲ್ಲಿ ನಾವು ಯಾವುದೇ ಉಪ-ಶ್ರೇಣಿಯನ್ನು ಹಿಮ್ಮುಖಗೊಳಿಸಬಹುದು. ಆದರೆ ಇನ್ಪುಟ್ ರಚನೆಯ ಅಂಶಗಳನ್ನು ನಾವು ಬದಲಾಯಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ. ಕುಶಲತೆಯನ್ನು ಹೇಗೆ ನಿರ್ವಹಿಸಬೇಕು ಎಂಬುದಕ್ಕೆ ನಾವು ಒಂದು ಮಾರ್ಗವನ್ನು ಕಂಡುಹಿಡಿಯಬೇಕಾಗಿಲ್ಲ. ಸಾಧ್ಯವಾದರೆ ಸುಳ್ಳಾಗಿದ್ದರೆ ನಿಜಕ್ಕೆ ಹಿಂತಿರುಗಿ. ಆದ್ದರಿಂದ, ಎಂದಿನಂತೆ ದ್ರಾವಣದಲ್ಲಿ ಆಳವಾಗಿ ಧುಮುಕುವ ಮೊದಲು ನಾವು ಕೆಲವು ಉದಾಹರಣೆಗಳನ್ನು ನೋಡೋಣ.

ಉಪ-ಸರಣಿಗಳ ಲೀಟ್‌ಕೋಡ್ ಪರಿಹಾರವನ್ನು ಹಿಮ್ಮುಖಗೊಳಿಸುವ ಮೂಲಕ ಎರಡು ಅರೇಗಳನ್ನು ಸಮಾನಗೊಳಿಸಿ

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

ವಿವರಣೆ: ನಾವು ಮೊದಲ ಉಪ-ಶ್ರೇಣಿಯನ್ನು ಸೂಚ್ಯಂಕ 0 ರಿಂದ 2 ಕ್ಕೆ ಹಿಮ್ಮುಖಗೊಳಿಸಬಹುದು, ನಂತರ ನಾವು ಉಪ-ಶ್ರೇಣಿಯನ್ನು 1 ರಿಂದ 2 ಕ್ಕೆ ಹಿಮ್ಮುಖಗೊಳಿಸಬಹುದು. ಕೊನೆಯಲ್ಲಿ, ನಾವು ಸೂಚ್ಯಂಕ 2 ರಿಂದ 3 ಕ್ಕೆ ಹಿಮ್ಮುಖಗೊಳಿಸುತ್ತೇವೆ. ಮತ್ತು ಈ ರೀತಿಯಾಗಿ, ನಾವು ಗುರಿ ಶ್ರೇಣಿಯನ್ನು ಮಾಡಬಹುದು . ಮೇಲಿನ ಚಿತ್ರವನ್ನು ನೋಡುವುದರ ಮೂಲಕ ಅದನ್ನು ಚೆನ್ನಾಗಿ ಅರ್ಥಮಾಡಿಕೊಳ್ಳಬಹುದು.

ಉಪ-ಸರಣಿಗಳ ಲೀಟ್‌ಕೋಡ್ ಪರಿಹಾರವನ್ನು ಹಿಮ್ಮುಖಗೊಳಿಸುವ ಮೂಲಕ ಎರಡು ಅರೇಗಳನ್ನು ಸಮಾನವಾಗಿಸುವ ವಿಧಾನ

ಎಣಿಕೆಯ ವಿಧಾನವನ್ನು ಬಳಸಿಕೊಂಡು ಸಮಸ್ಯೆಯನ್ನು ಸುಲಭವಾಗಿ ಪರಿಹರಿಸಬಹುದು. ಎಣಿಕೆಯ ವಿಧಾನವು ಕೆಲವು ಪ್ರಮಾಣಿತ ಕ್ರಮಾವಳಿಗಳಾಗಿವೆ. ಇದನ್ನು ಎಣಿಕೆ ವಿಂಗಡಣೆಯಲ್ಲಿ ಮತ್ತು ಇತರ ಹಲವು ಪ್ರಶ್ನೆಗಳಲ್ಲಿ ಬಳಸಲಾಗುತ್ತದೆ. ಆದ್ದರಿಂದ ಇಲ್ಲಿ ನಾವು ಗುರಿ ರಚನೆಯ ಅಂಶಗಳ ಎಣಿಕೆಯನ್ನು ಇಡುತ್ತೇವೆ. ನಂತರ ನಾವು ಇನ್ಪುಟ್ ರಚನೆಯ ಅಂಶಗಳನ್ನು ಹಾದುಹೋಗುತ್ತೇವೆ. ನಾವು ಯಾವುದೇ ಅಂಶವನ್ನು ಎದುರಿಸಿದಾಗ, ನಾವು ಅದರ ಸಂಖ್ಯೆಯನ್ನು ಆವರ್ತನ ಅಥವಾ ಎಣಿಕೆ ರಚನೆಯಿಂದ ಕಡಿಮೆ ಮಾಡುತ್ತೇವೆ. ಈ ಕಾರ್ಯಾಚರಣೆಯ ಸಮಯದಲ್ಲಿ ಹೇಗಾದರೂ, ಯಾವುದೇ ಸೂಚ್ಯಂಕವು negative ಣಾತ್ಮಕ ಮೌಲ್ಯವನ್ನು ಹೊಂದಿದ್ದರೆ ನಾವು ಸುಳ್ಳನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತೇವೆ.

ಆವರ್ತನ ಶ್ರೇಣಿಯಲ್ಲಿನ count ಣಾತ್ಮಕ ಎಣಿಕೆ ಇನ್ಪುಟ್ ರಚನೆಯು ಒಂದು ಅಂಶಕ್ಕೆ ದೊಡ್ಡ ಎಣಿಕೆ ಹೊಂದಿದೆ ಎಂದು ತೋರಿಸುತ್ತದೆ. ಆದರೆ ಇದನ್ನು ಮಾಡುವುದರಿಂದ ಸಮಸ್ಯೆಯನ್ನು ಹೇಗೆ ಪರಿಹರಿಸುತ್ತದೆ? ನೀವು ವೀಕ್ಷಣೆಯನ್ನು ತಿಳಿದ ನಂತರ ಉತ್ತರ ಸರಳವಾಗಿದೆ. ಒಮ್ಮೆ ನೀವು ಉಪ-ಸರಣಿಗಳ ಕೆಲವು ಹಿಮ್ಮುಖಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಪ್ರಯತ್ನಿಸಿ. ಇನ್ಪುಟ್ ರಚನೆಯ ಯಾವುದೇ ಅಂಶವನ್ನು ನೀವು ಎಲ್ಲಿ ಬೇಕಾದರೂ ಎಲ್ಲಿ ಇರಿಸಬಹುದು ಎಂದು ನೀವು ಸುಲಭವಾಗಿ ಕಂಡುಹಿಡಿಯಬಹುದು. ಆದ್ದರಿಂದ, ಈ ನಿಯಮವನ್ನು ಬಳಸಿಕೊಂಡು ನಾವು ಗುರಿ ರಚನೆಯ ಅಂಶಗಳು ಇನ್ಪುಟ್ ರಚನೆಯಂತೆಯೇ ಇದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸಬೇಕು.

ಉಪ-ಸರಣಿಗಳ ಲೀಟ್‌ಕೋಡ್ ಪರಿಹಾರವನ್ನು ಹಿಮ್ಮುಖಗೊಳಿಸುವ ಮೂಲಕ ಎರಡು ಅರೇಗಳನ್ನು ಸಮಾನವಾಗಿಸಲು ಕೋಡ್

ಸಿ ++ ಕೋಡ್

#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), ಏಕೆಂದರೆ ನಾವು ಸ್ಥಿರ ಗಾತ್ರದ ಆವರ್ತನ ಅಥವಾ ಎಣಿಕೆ ರಚನೆಯನ್ನು ಬಳಸಿದ್ದೇವೆ.