קאָנטראָליר די פאָרמירונג פאָרמירונג דורך קאָנקאַטענאַטיאָן לעעטקאָדע סאַלושאַן  


שוועריקייט לעוועל גרינג
אָפט געבעטן אין ובער
אַלגערידאַמז מענגע קאָדעסיגנאַל קאָדירונג האַשמאַפּ אינטערוויו interviewprep LeetCode LeetCodeSolutions סאָרט

דער פּראָבלעם טשעק אַררייַ פאָרמירונג דורך קאַנקאַטאַניישאַן לעעטקאָדע סאַלושאַן האָט אונדז אַ פּלאַץ פון ערייז. צוזאמען מיט וואָס מיר אויך באַקומען אַ סיקוואַנס. דערנאָך מיר זאָגן צו געפֿינען אויב מיר קענען עפעס בויען די געגעבן סיקוואַנס ניצן מענגע פון ערייז. מיר קענען צולייגן די ערייז אין קיין סדר. אָבער, מיר קענען נישט ריעריינדזש די עלעמענטן אין די מענגע. מיר זייַנען אויך געזאָגט אַז די ינטאַדזשערז זענען יינציק אין די מענגע פון ​​ערייז. איידער איר קוק אין די לייזונג, מיר מוזן נעמען אַ ביסל ביישפילן.

קאָנטראָליר די פאָרמירונג פאָרמירונג דורך קאָנקאַטענאַטיאָן לעעטקאָדע סאַלושאַןשפּילקע

arr = [15,88], pieces = [[88],[15]]
true

דערקלערונג: מיר קענען צולייגן די עלעמענטן אין פאַרקערט סדר. אזוי די לעצטע מענגע וואָס איז 15 וועט קומען אין פראָנט. סימילאַרלי, דער ערשטער עלעמענט וועט זיין צוריק. אויף דעם וועג מיר קענען פאָרעם די געגעבן מענגע.

arr = [91,4,64,78], pieces = [[78],[4,64],[91]]
true

דערקלערונג: אויב מיר קאַנקאַטאַנייט די לעצטע עלעמענט ערשטער, דערנאָך די מיטל מענגע און אין די סוף דער ערשטער מענגע. אויף דעם וועג מיר קענען באַקומען די פארלאנגט סיקוואַנס.

אַפּפּראָאַטש פֿאַר פאָרמירונג פון טשעק אַרייז דורך קאַנקאַטאַניישאַן לעעטקאָדע לייזונג  

דער פּראָבלעם טשעק עריי פאָרמירונג דורך קאַנקאַטאַניישאַן לעעטקאָדע סאַלושאַן געבעטן אונדז צו קאָנטראָלירן צי מיר קענען באַקומען די פארלאנגט סיקוואַנס פון די ערייז. די פּראָבלעם מיינט צו זיין אַ רעקורסיווע פּראָבלעם, וווּ מיר דאַרפֿן צו קאָנטראָלירן אַלע די פּאַסאַבילאַטיז. אין אַ רעקורסיווע שטייגער, מיר ערשטער פּרובירן צו קלייַבן אַ מענגע און דעמאָלט קאָנטראָלירן אויב די קראַנט מענגע איז פּאַסיק און דורכפירן די זעלבע אָפּעראַציע ביז מיר ויסשעפּן די סיקוואַנס. אָבער די מייַלע וואָס מיר האָבן דאָ איז יינציק עלעמענטן. אַזוי, מיר פשוט קאָנטראָלירן בלויז דער ערשטער עלעמענט מיט דער ערשטער עלעמענט. אפילו אויב איר קאָנטראָלירן דאָס, מיר מאַכן זיכער אַז מיר קענען פאָרזעצן מיט די פּיקט מענגע.

זע אויך
תּלמיד באַדינגונג רעקאָרד איך לעעטקאָדע סאַלושאַן

נאָך פּיקינג אַ מענגע, מיר דורכפאָר אַלע עלעמענטן אין עס און קאָנטראָלירן אויב די מענגע האט אַלע די יסודות פון דער סיקוואַנס ביז מיר ויסמאַטערן עס. נאָך די יגזאָסטשאַן, דער זעלביקער פּראָצעס איז ריפּיטיד. אויב עס איז עטלעכע מיסמאַטשאַס אין די עלעמענט פון דער מענגע און די סיקוואַנס, מיר קערן פאַלש. אין די סוף, ווען מיר טאָן ניט געפֿינען קיין מיסמאַטש, מיר קערן אמת.

קאָד פֿאַר פאָרמירונג פון קאָנטראָלירונג אַרעאַס דורך קאָנקאַטענאַטיאָן לעעטקאָדע סאַלושאַן  

C ++ קאָד

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

bool canFormArray(vector<int>& arr, vector<vector<int>>& pieces) {
    unordered_map<int,int> entry;
    for(int i=0;i<pieces.size();i++)
        entry[pieces[i][0]] = i;
    int i =  0;
    while(i < arr.size()){
        if(entry.count(arr[i])){
            vector<int> &piece  = pieces[entry[arr[i]]];
            for(auto x: piece)
                if(x != arr[i++])
                    return false;
        } else {
            return false;
        }
    }
    return true;
}

int main(){
    vector<int> arr = {91, 4, 64, 78};
    vector<vector<int>> pieces = {{78},{4,64},{91}};
    cout<<(canFormArray(arr, pieces) ? "true" : "false");
}
true

Java קאָד

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

class Main
{
  public static boolean canFormArray(int[] arr, int[][] pieces) {
        HashMap<Integer, Integer> entry = new HashMap<Integer, Integer>();
        for(int i=0;i<pieces.length;i++)
            entry.put(pieces[i][0], i);
        int i =  0;
        while(i < arr.length){
            if(entry.containsKey(arr[i])){
                int n = pieces[entry.get(arr[i])].length;
                int k = entry.get(arr[i]);
                for(int j=0;j<n;j++)
                    if(pieces[k][j] != arr[i++])
                        return false;
            } else {
                return false;
            }
        }
        return true;
    }
    
  public static void main (String[] args) throws java.lang.Exception {
    int[] arr = {91, 4, 64, 78};
      int[][] pieces = {{78},{4,64},{91}};
      System.out.print(canFormArray(arr, pieces) ? "true" : "false");
  }
}
true

קאַמפּלעקסיטי אַנאַליסיס  

צייט קאַמפּלעקסיטי

אָ (N), וווּ N איז די גאַנץ נומער פון עלעמענטן אין דער געגעבן סיקוואַנס. די צייט קאַמפּלעקסיטי איז רידוסט צו לינעאַר ווייַל פון די באַניץ פון האַשמאַפּ.

אָרט קאַמפּלעקסיטי

אָ (ב), וווּ M איז די נומער פון די ערייז אין מענגע פון ​​ערייז.

1