קוק אויב צוויי סטרינגס ערייז זענען עקוויוואַלענט לעעטקאָדע לייזונג


שוועריקייט לעוועל גרינג
אָפט געבעטן אין facebook
שטריקל

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

ביישפילן

word1[] = {"ab", "c"}
word2[] = {"a", "bc"}
true

דערקלערונג: ביידע אַרייז מאַכן "אַבק" אויב מיר קאַנקאַטאַנייט אַלע די סטרינגס. אַזוי, זיי זענען עקוויוואַלענט.

קוק אויב צוויי סטרינגס ערייז זענען עקוויוואַלענט לעעטקאָדע לייזונג

צוגאַנג צו קאָנטראָלירן אויב צוויי שטריקל ערייז זענען עקוויוואַלענט לעעטקאָדע לייזונג

די פּראָבלעם האט אונדז צוויי ערייזאַז פון סטרינגס. עס קען זיין מער סטרינגס אין איינער פון די צוויי ווי די אנדערע. אָבער ווען קאַנקאַטאַנייטיד, ביידע די ריזאַלטיד סטרינגס וועט זיין די זעלבע. אויב זיי פּאַסירן צו זיין די זעלבע מיר צוריקקומען אמת אַנדערש מיר צוריקקומען פאַלש.
איצט, אַ פּשוט און גרינג צו ינסטרומענט לייזונג איז צו נאָר אַריבער אַלע די סטרינגס אין יעדער פון די ערייז. בשעת טראַסעסינג, מיר קאַנקאַטאַנייט די סטרינגס און מאַכן צוויי ריזאַלטאַנט סטרינגס. נאָך דעם קאַנקאַטאַניישאַן אָפּעראַציע, מיר וועלן קאָנטראָלירן אויב די סטרינגס זענען די זעלבע. אָבער די אָפּעראַציע ריקווייערז אונדז צו שאַפֿן די סטרינגס. דער פּראָצעס דאַרף עקסטרע פּלאַץ. אָבער, מיר קענען אויך סאָלווע די פּראָבלעם אָן אַן עקסטרע פּלאַץ.
מיר נוצן פיר וועריאַבאַלז, צוויי פֿאַר יעדער מענגע. די וועריאַבאַלז וועט שפּילן ווי ינדאַסיז אין די מענגע און דערנאָך ינדיסיז פֿאַר די שטריקל. אויף דעם וועג צוויי פון זיי וועט זאָגן אונדז אַז זיי זענען ביי די J1 כאַראַקטער פון די i1 שטריקל אין דער ערשטער מענגע. סימילאַרלי, די j2 טה כאַראַקטער פון די i2 טה שטריקל איז רעפּריזענטיד דורך i2 און j2. איצט אַלץ וואָס איז לינקס איז ימפּלאַמענטיישאַן.
מיר נוצן אַ בשעת שלייף ין וואָס מיר קאָנטראָלירן עטלעכע טנאָים. אויב די קראַנט כאַראַקטער אין ביידע ערייז טאָן ניט גלייַכן, מיר קערן פאַלש. אַנדערש מיר קאָנטראָלירן אויב מיר זענען ביי די לעצטע כאַראַקטער פון די שטריקל. אויב דאָס כאַפּאַנז, מיר ינקראַמענט די אינדעקס געניצט פֿאַר שטריקל (i) און שטעלן דעם כאַראַקטער אינדעקס (j) צו 0. אַנדערש, נאָר ינקראַמענט דזש. אין די סוף, אויב ביידע ערייז זענען ויסגעמאַטערט סיימאַלטייניאַסלי, מיר קומען צוריק אמת, אַנדערש פאַלש.

קאָדעקס

C ++ קאָד פֿאַר טשעק אויב צוויי סטרינג ערייז זענען עקוויוואַלענט לעעטקאָדע סאַלושאַן

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

bool arrayStringsAreEqual(vector<string>& word1, vector<string>& word2) {
    int i1 = 0, j1 = 0, i2 = 0, j2 = 0;
    while(true){
        if(word1[i1][j1] != word2[i2][j2]) return false;
        if(j1 == word1[i1].size()-1)i1++, j1 = 0;
        else j1++;
        if(j2 == word2[i2].size()-1)i2++, j2 = 0;
        else j2++;
        if(i1 == word1.size() && i2 == word2.size())
            return true;
        else if(i1 == word1.size() || i2 == word2.size())
            return false;
    }
}

int main() {
  vector<string> word1 = {"ab", "c"};
  vector<string> word2 = {"a", "bc"};
  cout<<(arrayStringsAreEqual(word1, word2) ? "true" : "false");
  return 0;
}
true

דזשאַוואַ קאָד צו קאָנטראָלירן אויב צוויי שטריקל ערייז זענען עקוויוואַלענט לעעטקאָדע סאַלושאַן

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

class Main
{
  public static boolean arrayStringsAreEqual(String[] word1, String[] word2) {
        int i1 = 0, j1 = 0, i2 = 0, j2 = 0;
        while(true){
            if(word1[i1].charAt(j1) != word2[i2].charAt(j2)) return false;
            if(j1 == word1[i1].length()-1){i1++; j1 = 0;}
            else j1++;
            if(j2 == word2[i2].length()-1){i2++; j2 = 0;}
            else j2++;
            if(i1 == word1.length && i2 == word2.length)
                return true;
            else if(i1 == word1.length || i2 == word2.length)
                return false;
        }
    }

  public static void main (String[] args) throws java.lang.Exception
  {
    String[] word1 = {"ab", "c"};
    String[] word2 = {"a", "bc"};
    System.out.print((arrayStringsAreEqual(word1, word2) ? "true" : "false"));
    return 0;
  }
}
true

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

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

אָ (מין (N, M)) ווייַל מיר גיין דורך יעדער כאַראַקטער פון דער קלענערער שטריקל. דאָ N און M רעפּראַזענץ די נומער פון אותיות אין דער ערשטער מענגע און רגע מענגע ריספּעקטיוולי.

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

אָ (1), ווייַל מיר געוויינט אַ קעסיידערדיק נומער פון וועריאַבאַלז.