ਵੈਧ ਅਨਗਰਾਮ


ਮੁਸ਼ਕਲ ਪੱਧਰ ਸੌਖੀ
ਅਕਸਰ ਪੁੱਛਿਆ ਜਾਂਦਾ ਹੈ ਐਮਾਜ਼ਾਨ ਗੋਲਡਮੈਨ ਸਾਕਸ ਗੂਗਲ Microsoft ਦੇ ਨਾਗਰੋ
Anagram ਹੈਸ਼ਿੰਗ

“ਵੈਧ ਅਨਗ੍ਰਾਮਜ਼” ਦੀ ਸਮੱਸਿਆ ਵਿਚ ਅਸੀਂ ਦੋ ਦਿੱਤੇ ਹਨ ਸਤਰ str1 ਅਤੇ str2. ਇਹ ਪਤਾ ਲਗਾਓ ਕਿ ਦੋਵੇਂ ਸਤਰ ਅਨਗਰਾਮ ਹਨ ਜਾਂ ਨਹੀਂ. ਜੇ ਉਹ ਹਨ Anagrams ਸੱਚ ਨੂੰ ਵਾਪਸ ਪਰ, ਝੂਠੇ ਨੂੰ ਵਾਪਸ.

ਉਦਾਹਰਨ

ਇੰਪੁੱਟ:

str1 = “ਅਬਬੈਕ”

str2 = “aabbcc”

ਆਉਟਪੁੱਟ:

ਇਹ ਸੱਚ ਹੈ,

ਸਪਸ਼ਟੀਕਰਨ:

ਕਿਉਂਕਿ str2, str1 ਦੇ ਸਾਰੇ ਸ਼ਬਦਾਂ ਨੂੰ ਦੁਬਾਰਾ ਸੰਗਠਿਤ ਕਰਕੇ ਬਣਾਇਆ ਜਾ ਸਕਦਾ ਹੈ, ਤਾਂ ਕਿ ਆਉਟਪੁਟ ਹੋਵੇਗਾ "ਸੱਚ ".

ਐਲਗੋਰਿਥਮ

  1. ਦੋਵਾਂ ਸਤਰਾਂ ਦੀ ਲੰਬਾਈ ਦਾ ਪਤਾ ਲਗਾਓ
  2. ਦੋਵਾਂ ਸਤਰਾਂ ਨੂੰ ਵਰਨਮਾਲਾ ਅਨੁਸਾਰ ਕ੍ਰਮਬੱਧ ਕਰੋ
  3. ਦੋਨੋ ਸਤਰ ਦੀ ਤੁਲਨਾ ਕਰੋ
  4. ਜੇ ਬਰਾਬਰ ਵਾਪਸੀ “ਸੱਚਾ” ਹੋਰ ਵਾਪਸ “ਝੂਠੇ”

ਕਥਾ

ਐਂਗਰਾਮ ਇਕੋ ਸ਼ਬਦ ਹਨ ਜੋ ਇਕ ਤਰਤੀਬ ਵਿਚ ਵਿਵਸਥਿਤ ਕੀਤੇ ਜਾ ਸਕਦੇ ਹਨ ਜਿਸ ਵਿਚ ਦੋਵੇਂ ਸਤਰ ਇਕੋ ਜਿਹੇ ਦਿਖਾਈ ਦਿੰਦੇ ਹਨ ਅਤੇ ਉਹਨਾਂ ਨੂੰ ਮੁੜ ਵਿਵਸਥਿਤ ਕਰਨ ਤੋਂ ਬਾਅਦ ਇਕੋ ਅਤੇ ਇਕੋ ਜਿਹੇ ਸ਼ਬਦ ਬਣਾਉਂਦੇ ਹਨ.

ਸਾਬਕਾ: ਚੁੱਪ ਉਹ ਸ਼ਬਦ ਹੈ ਜੋ ਇਕ ਤਰਤੀਬ ਅਨੁਸਾਰ ਵਿਵਸਥਿਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ ਅਤੇ ਇਕ ਸ਼ਬਦ ਨੂੰ ਸੁਣਨ ਲਈ ਬਣਾਉਂਦਾ ਹੈ, ਇਸ ਲਈ ਦੋਵੇਂ ਸ਼ਬਦ ਇਕ ਦੂਜੇ ਦੇ ਅਨਗ੍ਰਾਮ ਹਨ.

ਸਾਡਾ ਕੋਡ ਇਹ ਪਤਾ ਲਗਾਉਣ ਲਈ ਹੈ ਕਿ ਦਿੱਤੀਆਂ ਗਈਆਂ ਤਾਰਾਂ ਯੋਗ ਹਨ ਜਾਂ ਨਹੀਂ Anagrams ਜਾਂ ਨਹੀਂ, ਇਸ ਲਈ ਸਾਡਾ ਮੁੱਖ ਵਿਚਾਰ ਪਹਿਲਾਂ ਸਤਰ ਦੀ ਲੰਬਾਈ ਦਾ ਪਤਾ ਲਗਾਉਣਾ ਹੈ, ਜੇ ਦੋਵੇਂ ਸਤਰਾਂ ਦੀ ਲੰਬਾਈ ਇਕੋ ਜਿਹੀ ਹੁੰਦੀ ਹੈ ਤਾਂ ਅਸੀਂ ਸਿਰਫ ਅੱਗੇ ਵਧਦੇ ਹਾਂ, ਨਹੀਂ ਤਾਂ ਨਹੀਂ, ਕਿਉਂਕਿ ਤਾਰਾਂ ਅਣਗਿਣਤ ਨਹੀਂ ਹੋ ਸਕਦੀਆਂ ਜੇ ਉਨ੍ਹਾਂ ਦੀ ਲੰਬਾਈ ਹੈ. ਸਮਾਨ ਨਹੀਂ. ਇਸ ਲਈ ਉੱਥੋਂ, ਅਸੀਂ ਗਲਤ ਵਾਪਸ ਆਉਂਦੇ ਹਾਂ.

ਸਾਡਾ ਅਗਲਾ ਤਰਕ ਉਹਨਾਂ ਨੂੰ ਚੜ੍ਹਨ ਵਾਲੇ ਕ੍ਰਮ ਵਿੱਚ ਪ੍ਰਬੰਧ ਕਰਨਾ ਹੈ ਤਾਂ ਕਿ ਹਰੇਕ ਅੱਖਰ ਕ੍ਰਮ ਵਿੱਚ ਆਵੇ, ਇਸ ਲਈ ਅਸੀਂ ਇੱਕ ਕਾਰਜ "ਲੜੀਬੱਧ" ਦੀ ਪਰਿਭਾਸ਼ਾ ਦਿੱਤੀ. ਦੋਵੇਂ ਸਟਰਿੰਗਜ ਜੋ ਸੌਰਟ ਫੰਕਸ਼ਨ ਵਿੱਚ ਅਸਥਾਈ ਐਰੇ ਵਿੱਚ ਬਦਲੀਆਂ ਜਾਂਦੀਆਂ ਹਨ ਜੋ ਐਰੇ ਨੂੰ ਸੌਰਟ ਕਰਨ ਜਾ ਰਹੀ ਹੈ ਅਤੇ ਸਟਰਿੰਗ ਨੂੰ str1 ਵਿੱਚ ਵਾਪਸ ਕਰਨ ਜਾ ਰਹੀ ਹੈ, ਇਸਲਈ ਸਟਰਿੰਗ ਨੂੰ ਸਟਰਿੰਗ ਸਟੋਰ ਵਿੱਚ ਇੱਕ ਹੀ ਸਤਰ ਵਿੱਚ ਸਟੋਰ ਕੀਤਾ ਜਾਏਗਾ, ਇਹ ਦੋਹਾਂ ਸਤਰਾਂ ਨਾਲ ਹੋਵੇਗਾ, ਅਤੇ ਸਾਨੂੰ ਕ੍ਰਮਬੱਧ ਤਾਰਾਂ ਮਿਲਦੀਆਂ ਹਨ.

ਚੁੱਪ = [s, i, l, e, n, t] // ਅੱਖਰ ਐਰੇ
ਸੁਣੋ = [l, i, s, t, e, n] // ਅੱਖਰ ਐਰੇ

ਕ੍ਰਮਬੱਧ ਕੀਤਾ ਐਰੇ = [e, i, l, n, s, t] // ਕ੍ਰਮਬੱਧ ਕਰਨ ਵਾਲੀ ਐਰੇ ਨੂੰ str1 ਵਿੱਚ ਸਟੋਰ ਕੀਤਾ ਗਿਆ
ਕ੍ਰਮਬੱਧ ਐਰੇ = [ਈ, ਆਈ, ਐਲ, ਐਨ, ਐਸ, ਟੀ] // ਕ੍ਰਮਬੱਧ ਸੁਣਨ ਦੀ ਐਰੇ ਨੂੰ str2 ਵਿੱਚ ਸਟੋਰ ਕੀਤਾ ਗਿਆ

ਫੇਰ ਲੂਪ ਦੇ ਨਾਲ ਅਸੀਂ ਦੋਹਾਂ ਸਤਰਾਂ ਦੇ ਹਰੇਕ ਇਕੋ ਇੰਡੈਕਸ ਦੀ ਤੁਲਨਾ ਕਰਾਂਗੇ ਜੇ ਉਹੀ ਪਾਤਰ ਇਕੋ ਜਿਹੇ ਪਾਏ ਗਏ ਹਨ, ਤਾਂ ਉਹ ਅਨਗਰਾਮ ਹਨ ਅਤੇ ਸਹੀ ਅਤੇ “ਸਹੀ” ਪ੍ਰਿੰਟਸ ਅਤੇ ਝੂਠੇ ਪ੍ਰਿੰਟਸ ਵਾਪਸ ਕਰਦੇ ਹਨ ਜੇ ਇਹ ਗਲਤ ਹੈ.

ਲਾਗੂ

ਵੈਧ ਅਨਗ੍ਰਾਮਾਂ ਲਈ ਸੀ ++ ਪ੍ਰੋਗਰਾਮ

#include <iostream>
#include<stdio.h>
#include<algorithm>
using namespace std;

bool areAnagram(string str1, string str2)
{
    //getting length of both the strings
    int n1 = str1.length();
    int n2 = str2.length();

    //Checking if both the strings are of same length
    if (n1 != n2)
        return false;

    //Sorting both the string alphabetically
    sort(str1.begin(), str1.end());
    sort(str2.begin(), str2.end());

    //checking each character of string is equal to
    //another character of string
    if (str1 != str2)
        return false;

    return true;
}

int main ()
{
    string str1 = "silent";
    string str2 = "listen";
    if(areAnagram(str1,str2))
        cout << "true";
    else
        cout << "false";
    return 0;
}
true

ਵੈਧ ਅਨਗ੍ਰਾਮਾਂ ਲਈ ਜਾਵਾ ਪ੍ਰੋਗਰਾਮ

import java.util.Arrays;
import java.util.Scanner;
class validAnagrams
{
  public static String sort(String str)
  {
      char temp[] = str.toCharArray();
      Arrays.sort(temp);
      return new String(temp);
  }
  public static boolean areAnagram(String str1, String str2)
  {
    //getting length of both the strings
    int length1 = str1.length();
    int length2 = str2.length();

    //Checking if both the strings are of same length
    if (length1 != length2)
    {
      return false;
    }

    //Sorting both the string alphabetically
    str1=sort(str1);
    str2=sort(str2);

    //checking each character of string is equal to
    //another character of string
    for (int i = 0; i < length1; i++)
    {
        if (str1.charAt(i) != str2.charAt(i))
        {
            return false;
      }
    }

        return true;
    }
  public static void main(String [] args)
  {
    String str1 = "silent";
    String str2 = "listen";
    System.out.println(areAnagram(str1,str2)?"true":"false");

  }
}
true

ਵੈਧ ਅਨਗ੍ਰਾਮਾਂ ਲਈ ਜਟਿਲਤਾ ਵਿਸ਼ਲੇਸ਼ਣ

ਟਾਈਮ ਜਟਿਲਤਾ

O (nlogn) ਜਿੱਥੇ ਕਿ n ਸਤਰ ਦਾ ਅਕਾਰ ਹੈ. ਇੱਥੇ ਅਸੀਂ ਅੱਖਰਾਂ ਦੇ ਅਧਾਰ ਤੇ ਸਤਰ ਨੂੰ ਕ੍ਰਮਬੱਧ ਕਰਦੇ ਹਾਂ ਜੋ ਕਿ ਸਮਾਂ ਕੱ takesਦਾ ਹੈ.

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

ਓ (1) ਕਿਉਂਕਿ ਅਸੀਂ ਇਥੇ ਕੋਈ ਵਧੇਰੇ ਥਾਂ ਦੀ ਵਰਤੋਂ ਨਹੀਂ ਕਰਦੇ.