ਜਾਂਚ ਕਰੋ ਕਿ ਕੀ ਦੋ ਸਤਰ ਐਰੇ ਬਰਾਬਰ ਦਾ ਲੀਟਕੋਡ ਹੱਲ ਹਨ


ਮੁਸ਼ਕਲ ਪੱਧਰ ਸੌਖੀ
ਅਕਸਰ ਪੁੱਛਿਆ ਜਾਂਦਾ ਹੈ ਫੇਸਬੁੱਕ
ਸਤਰ

ਸਮੱਸਿਆ ਦੀ ਜਾਂਚ ਕਰੋ ਕਿ ਕੀ ਦੋ ਸਤਰ ਐਰੇ ਬਰਾਬਰ ਦੇ ਲੀਟਕੋਡ ਹੱਲ ਸਾਨੂੰ ਦੋ ਪ੍ਰਦਾਨ ਕਰਦੇ ਹਨ ਐਰੇ ਤਾਰਾਂ ਦੀ. ਫਿਰ ਸਾਨੂੰ ਇਹ ਦੱਸਣ ਲਈ ਕਿਹਾ ਜਾਂਦਾ ਹੈ ਕਿ ਕੀ ਇਹ ਦੋ ਸਤਰ ਐਰੇ ਬਰਾਬਰ ਹਨ ਜਾਂ ਨਹੀਂ. ਇੱਥੇ ਬਰਾਬਰਤਾ ਇਸ ਤੱਥ ਦਾ ਹਵਾਲਾ ਦਿੰਦੀ ਹੈ ਕਿ ਜੇ ਐਰੇ ਵਿਚਲੀਆਂ ਤਾਰਾਂ ਨੂੰ ਇਕੱਠਾ ਕੀਤਾ ਜਾਵੇ. ਫਿਰ ਕੰਨਟੇਨਟੇਸ਼ਨ ਤੋਂ ਬਾਅਦ, ਦੋਵੇਂ ਸਤਰਾਂ ਇਕਸਾਰ ਜਾਂ ਇਕੋ ਹੋਣਗੀਆਂ. ਇਸ ਲਈ ਘੋਲ ਨੂੰ ਡੂੰਘਾਈ ਨਾਲ ਡੁੱਬਣ ਤੋਂ ਪਹਿਲਾਂ, ਆਓ ਪਹਿਲਾਂ ਕੁਝ ਉਦਾਹਰਣਾਂ 'ਤੇ ਗੌਰ ਕਰੀਏ.

ਉਦਾਹਰਨ

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

ਵਿਆਖਿਆ: ਜੇ ਅਸੀਂ ਸਾਰੀਆਂ ਸਤਰਾਂ ਨੂੰ ਜੋੜਦੇ ਹਾਂ ਤਾਂ ਦੋਵੇਂ ਐਰੇ “ਏਬੀਸੀ” ਬਣਾਉਂਦੀਆਂ ਹਨ. ਇਸ ਲਈ, ਉਹ ਬਰਾਬਰ ਹਨ.

ਜਾਂਚ ਕਰੋ ਕਿ ਕੀ ਦੋ ਸਤਰ ਐਰੇ ਬਰਾਬਰ ਦਾ ਲੀਟਕੋਡ ਹੱਲ ਹਨ

ਜਾਂਚ ਲਈ ਪਹੁੰਚ ਜੇ ਦੋ ਸਤਰ ਐਰੇ ਬਰਾਬਰ ਦੇ ਲੀਟਕੋਡ ਹੱਲ ਹਨ

ਸਮੱਸਿਆ ਨੇ ਸਾਨੂੰ ਦੋ ਤਾਰਾਂ ਦਿੱਤੀਆਂ. ਇੱਕ ਨਾਲੋਂ ਦੂਜੇ ਵਿੱਚ ਵਧੇਰੇ ਤਾਰਾਂ ਹੋ ਸਕਦੀਆਂ ਹਨ. ਪਰ ਜਦੋਂ ਠੰ .ਾ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਨਤੀਜੇ ਵਜੋਂ ਆਉਣ ਵਾਲੀਆਂ ਦੋਵੇਂ ਸਤਰਾਂ ਇਕੋ ਜਿਹੀਆਂ ਹੋਣਗੀਆਂ. ਜੇ ਉਹ ਇਕੋ ਜਿਹੇ ਹੋਣ ਤਾਂ ਅਸੀਂ ਸੱਚਾ ਵਾਪਸ ਹੁੰਦੇ ਹਾਂ ਹੋਰ ਅਸੀਂ ਝੂਠੇ ਵਾਪਸ ਆਉਂਦੇ ਹਾਂ.
ਹੁਣ, ਇੱਕ ਅਸਾਨ ਅਤੇ ਹੱਲ ਲਾਗੂ ਕਰਨਾ ਅਸਾਨ ਹੈ ਕਿ ਹਰ ਐਰੇ ਵਿਚਲੀਆਂ ਸਾਰੀਆਂ ਸਤਰਾਂ ਨੂੰ ਸਿੱਧਾ ਪਾਰ ਕਰਨਾ. ਟਰੈਵਰ ਕਰਦੇ ਸਮੇਂ, ਅਸੀਂ ਤਾਰਾਂ ਨੂੰ ਜੋੜਦੇ ਹਾਂ ਅਤੇ ਨਤੀਜੇ ਵਜੋਂ ਦੋ ਤਾਰਾਂ ਬਣਾਉਂਦੇ ਹਾਂ. ਤਾਂ, ਇਸ ਕੰਨਟੇਨਟੇਸ਼ਨ ਆਪ੍ਰੇਸ਼ਨ ਤੋਂ ਬਾਅਦ, ਅਸੀਂ ਜਾਂਚ ਕਰਾਂਗੇ ਕਿ ਕੀ ਇਹ ਸਤਰਾਂ ਇਕੋ ਜਿਹੀਆਂ ਹਨ ਜਾਂ ਨਹੀਂ. ਪਰ ਇਸ ਓਪਰੇਸ਼ਨ ਲਈ ਸਾਨੂੰ ਸਤਰਾਂ ਬਣਾਉਣ ਦੀ ਜ਼ਰੂਰਤ ਹੈ. ਇਸ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਵਧੇਰੇ ਥਾਂ ਦੀ ਜ਼ਰੂਰਤ ਹੈ. ਪਰ ਅਸੀਂ ਸਮੱਸਿਆ ਨੂੰ ਇਕ ਅਜਿਹੀ ਜਗ੍ਹਾ 'ਤੇ ਵੀ ਹੱਲ ਕਰ ਸਕਦੇ ਹਾਂ ਜੋ ਬਿਨਾਂ ਵਧੇਰੇ ਜਗ੍ਹਾ ਦੀ ਵਰਤੋਂ ਦੇ ਹੈ.
ਅਸੀਂ ਚਾਰ ਵੇਰੀਏਬਲਸ ਦੀ ਵਰਤੋਂ ਕਰਾਂਗੇ, ਹਰ ਐਰੇ ਲਈ ਦੋ. ਇਹ ਵੇਰੀਏਬਲ ਐਰੇ ਵਿਚਲੇ ਸੂਚਕਾਂਕ ਦੇ ਰੂਪ ਵਿਚ ਕੰਮ ਕਰਨਗੇ ਅਤੇ ਫਿਰ ਸਤਰ ਦੇ ਸੂਚਕਾਂਕ. ਇਸ ਤਰੀਕੇ ਨਾਲ ਉਨ੍ਹਾਂ ਵਿੱਚੋਂ ਦੋ ਸਾਨੂੰ ਦੱਸਣਗੇ ਕਿ ਉਹ ਪਹਿਲੀ ਐਰੇ ਵਿੱਚ i1 ਵੀ ਸਤਰ ਦੇ j1 ਵੇਂ ਚਰਿੱਤਰ ਵਿੱਚ ਹਨ. ਇਸੇ ਤਰ੍ਹਾਂ, i2th ਸਤਰ ਦਾ j2th ਅੱਖਰ i2 ਅਤੇ j2 ਦੁਆਰਾ ਦਰਸਾਇਆ ਗਿਆ ਹੈ. ਹੁਣ ਜੋ ਬਚਿਆ ਹੈ ਉਹ ਲਾਗੂ ਕਰਨਾ ਹੈ.
ਅਸੀਂ ਕੁਝ ਸਮੇਂ ਦੀ ਲੂਪ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਾਂ ਜਿਸਦੇ ਅੰਦਰ ਅਸੀਂ ਕੁਝ ਸ਼ਰਤਾਂ ਦੀ ਜਾਂਚ ਕਰਦੇ ਹਾਂ. ਜੇ ਦੋਵੇਂ ਐਰੇ ਵਿਚਲਾ ਮੌਜੂਦਾ ਪਾਤਰ ਮੇਲ ਨਹੀਂ ਖਾਂਦਾ ਤਾਂ ਅਸੀਂ ਗਲਤ ਵਾਪਸ ਜਾਵਾਂਗੇ. ਨਹੀਂ ਤਾਂ ਅਸੀਂ ਜਾਂਚ ਕਰਦੇ ਹਾਂ ਕਿ ਕੀ ਅਸੀਂ ਸਤਰ ਦੇ ਆਖਰੀ ਪਾਤਰ ਤੇ ਹਾਂ. ਜੇ ਅਜਿਹਾ ਹੁੰਦਾ ਹੈ ਤਾਂ ਅਸੀਂ ਸਤਰ (i) ਲਈ ਵਰਤੇ ਜਾਣ ਵਾਲੇ ਇੰਡੈਕਸ ਨੂੰ ਵਧਾਉਂਦੇ ਹਾਂ ਅਤੇ ਅੱਖਰ ਸੂਚਕਾਂਕ (ਜੇ) ਨੂੰ 0 ਤੇ ਨਿਰਧਾਰਤ ਕਰਦੇ ਹਾਂ. ਨਹੀਂ ਤਾਂ, ਬਸ ਵਾਧਾ j. ਅੰਤ ਵਿੱਚ, ਜੇ ਦੋਵੇਂ ਐਰੇ ਇੱਕੋ ਸਮੇਂ ਖਤਮ ਹੋ ਜਾਣ, ਤਾਂ ਅਸੀਂ ਸੱਚੇ, ਵਾਪਸ ਗਲਤ ਹੋਵਾਂਗੇ.

ਕੋਡ

ਸੀ ++ ਕੋਡ ਚੈੱਕ ਲਈ ਕੀ ਦੋ ਸਤਰ ਐਰੇ ਬਰਾਬਰ ਲੀਟਕੋਡ ਹੱਲ ਹਨ

#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 ਕ੍ਰਮਵਾਰ ਪਹਿਲੇ ਐਰੇ ਅਤੇ ਦੂਸਰੇ ਐਰੇ ਵਿੱਚ ਅੱਖਰਾਂ ਦੀ ਸੰਖਿਆ ਨੂੰ ਦਰਸਾਉਂਦੇ ਹਨ.

ਸਪੇਸ ਦੀ ਜਟਿਲਤਾ

ਓ (1), ਕਿਉਂਕਿ ਅਸੀਂ ਵੇਰੀਏਬਲ ਦੀ ਨਿਰੰਤਰ ਗਿਣਤੀ ਵਰਤੀ ਹੈ.