చెల్లుబాటు అయ్యే అనాగ్రామ్స్


కఠినత స్థాయి సులువు
తరచుగా అడుగుతుంది అమెజాన్ గోల్డ్మన్ సాచ్స్ గూగుల్ మైక్రోసాఫ్ట్ నాగరో
అనాగ్రం హ్యాషింగ్

“చెల్లుబాటు అయ్యే అనాగ్రామ్స్” సమస్యలో మేము రెండు ఇచ్చాము తీగలను str1 మరియు str2. రెండు తీగలను అనాగ్రాములు కాదా అని తెలుసుకోండి. వారు ఉంటే అనగ్రామ్స్ తిరిగి నిజమైనది తప్ప తప్పుడు తిరిగి.

ఉదాహరణ

ఇన్పుట్:

str1 = “abcbac”

str2 = “aabbcc”

అవుట్పుట్:

నిజమైన

వివరణ:

Str2 యొక్క అన్ని పదాలను క్రమాన్ని మార్చడం ద్వారా str1 ఏర్పడుతుంది కాబట్టి అవుట్పుట్ ఉంటుంది "నిజం ”.

అల్గారిథం

  1. రెండు స్ట్రింగ్ యొక్క పొడవును కనుగొనండి
  2. స్ట్రింగ్ రెండింటినీ అక్షరక్రమంగా క్రమబద్ధీకరించండి
  3. స్ట్రింగ్ రెండింటినీ పోల్చండి
  4. సమాన రాబడి ఉంటే “నిజం” లేకపోతే తిరిగి “తప్పుడు”

వివరణ

అనాగ్రామ్స్ ఒకే పదాలు, వీటిని రెండు తీగలను ఒకేలా కనిపించే క్రమంలో అమర్చవచ్చు మరియు వాటిని క్రమాన్ని మార్చిన తర్వాత ఒకే మరియు ఒకేలాంటి పదాన్ని చేస్తుంది.

ఉదా: సైలెంట్ అంటే ఒక క్రమంలో అమర్చవచ్చు మరియు ఒక పదాన్ని వినవచ్చు, కాబట్టి రెండు పదాలు ఒకదానికొకటి అనాగ్రామ్‌లు.

ఇచ్చిన తీగలను చెల్లుబాటు అవుతుందో లేదో తెలుసుకోవడం మా కోడ్ అనగ్రామ్స్ లేదా కాదు, కాబట్టి స్ట్రింగ్ యొక్క పొడవును మొదట కనుగొనడం మా ప్రధాన ఆలోచన, రెండు స్ట్రింగ్ యొక్క పొడవు సమానంగా ఉన్నట్లు తేలితే, మనం మాత్రమే మరింత ముందుకు వెళ్తాము, లేకపోతే కాదు, ఎందుకంటే తీగలు వాటి పొడవు ఉంటే అనాగ్రామ్‌లు కావు సారూప్యత లేదు. కాబట్టి అక్కడ నుండి, మేము తప్పుడు తిరిగి.

మా తదుపరి తర్కం వాటిని ఆరోహణ క్రమంలో అమర్చడం, తద్వారా ప్రతి అక్షరం క్రమంగా వస్తుంది, కాబట్టి మేము “విధమైన” ఫంక్షన్‌ను నిర్వచించాము. క్రమబద్ధీకరణ ఫంక్షన్‌లోకి పంపబడిన రెండు తీగలను తాత్కాలిక శ్రేణిగా మార్చారు, ఇది శ్రేణిని క్రమబద్ధీకరించడానికి మరియు స్ట్రింగ్‌ను str1 గా తిరిగి ఇవ్వబోతోంది, కాబట్టి స్ట్రింగ్ నిల్వ చేసిన స్ట్రింగ్ స్టోర్‌ను ఒకే స్ట్రింగ్‌లో క్రమబద్ధీకరించారు, ఇది రెండు తీగలతో జరుగుతుంది, మరియు మేము క్రమబద్ధీకరించిన తీగలను పొందుతాము.

నిశ్శబ్ద = [s, i, l, e, n, t] // అక్షర శ్రేణి
listen = [l, i, s, t, e, n] // అక్షర శ్రేణి

క్రమబద్ధీకరించబడిన శ్రేణి = [e, i, l, n, s, t] // str1 లో నిల్వ చేయబడిన నిశ్శబ్ద శ్రేణి
sorted array = [e, i, l, n, s, t] // 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 స్ట్రింగ్ యొక్క పరిమాణం. ఇక్కడ మనం స్ట్రింగ్‌ను అక్షరాల ఆధారంగా క్రమబద్ధీకరిస్తాము, ఇది nlogn సమయం పడుతుంది.

అంతరిక్ష సంక్లిష్టత

O (1) ఎందుకంటే మేము ఇక్కడ అదనపు స్థలాన్ని ఉపయోగించము.