ఫోన్ నంబర్ యొక్క అక్షరాల కలయికలు


కఠినత స్థాయి మీడియం
తరచుగా అడుగుతుంది అమెజాన్ ఆపిల్ Atlassian కాపిటల్ వన్ డేటాబ్రిక్స్ eBay <span style="font-family: Mandali; ">ఫేస్‌బుక్ </span> గూగుల్ మైక్రోసాఫ్ట్ మోర్గాన్ స్టాన్లీ ఒరాకిల్ Qualtrics Twilio ఉబెర్ VMware వాల్‌మార్ట్ ల్యాబ్స్
బ్యాక్‌ట్రాకింగ్ లోతు మొదటి శోధన సూత్రం స్ట్రింగ్

ఫోన్ నంబర్ సమస్య యొక్క అక్షరాల కలయికలో, మేము ఒక ఇచ్చాము స్ట్రింగ్ 2 నుండి 9 వరకు సంఖ్యలను కలిగి ఉంటుంది. ప్రతి సంఖ్యకు కొన్ని అక్షరాలు కేటాయించినట్లయితే ఆ సంఖ్య ద్వారా సూచించబడే అన్ని కలయికలను కనుగొనడం సమస్య. సంఖ్య యొక్క అసైన్‌మెంట్ టెలిఫోన్ బటన్ల మాదిరిగానే ఇవ్వబడింది.

ఫోన్ నంబర్ యొక్క అక్షరాల కలయికలు

ఇక్కడ 1 కి ఏ అక్షరం కేటాయించబడలేదని గమనించండి

ఉదాహరణ

"23"
["ad", "ae", "af", "bd", "be", "bf", "cd", "ce", "cf"]

కేటాయించిన అక్షరాలు "2" ఉన్నాయి “ABC” మరియు "3" ఉన్నాయి “DEF” అందువల్ల అక్షరాల కలయిక “ప్రకటన”, “ae”, “af”, “bd”, “be”, “bf”, “cd”, “ce” మరియు “cf”

అల్గారిథం

  1. ప్రకటించండి a క్యూ మరియు శ్రేణి జాబితా మరియు స్ట్రింగ్ అమరిక.
  2. స్ట్రింగ్ అర్రే ఇచ్చిన స్ట్రింగ్ కీవర్డ్‌ల వలె విలువలను నిల్వ చేయాలి [10] = {“”, “”, “ఎబిసి”, “డెఫ్”, “ఘి”, “జెకెఎల్”, “మ్నో”, “పిక్యూఆర్”, “టువ్”, “ wxyz ”};
  3. మొదట, ఖాళీ స్ట్రింగ్‌ను క్యూలోకి నెట్టండి
  4. క్యూలో కొన్ని విలువలు ఉన్నప్పటికీ, లూప్ మీద మళ్ళిస్తుంది.
  5. క్యూ ముందు విలువ తాత్కాలిక స్ట్రింగ్‌కు నిల్వ చేయండి
  6. తాత్కాలిక స్ట్రింగ్ యొక్క పొడవు n కు సమానమని తేలితే (ఇది ఇన్పుట్ విలువ పొడవు)
  7. జాబితా చేయడానికి తాత్కాలిక స్ట్రింగ్ విలువను జోడించండి.
  8. లేకపోతే, స్ట్రింగ్ విలువను కాపీ = కీలుగా ప్రారంభించిన లూప్‌ను తెరవండి [సంఖ్య [temp.length ()];
  9. ప్రతి కీవర్డ్ యొక్క సబ్‌స్ట్రింగ్‌కు (0, 1) తాత్కాలిక స్ట్రింగ్‌ను జోడించి క్యూలో ఉంచండి.
  10. క్యూలో విలువలు ఉన్నంత వరకు దానిపై మళ్ళిస్తుంది.
  11. రిటర్న్ జాబితా.

వివరణ

మనకు ఇన్పుట్ 23 గా ఇవ్వబడిందని అనుకుందాం. అప్పుడు మేము దానిని పూర్ణాంకానికి మారుస్తాము. మరియు మనకు లభించిన పద్ధతిలోనే దాన్ని అంకెల శ్రేణిగా మార్చండి. మరియు మేము ఇన్పుట్ విలువ మరియు ఆ ఇన్పుట్ విలువ యొక్క పొడవును కలయికగా పేరు పెట్టిన ఫంక్షన్ లోకి పంపుతాము.

ఆ ఫంక్షన్‌లో మేము మా కీలక పదాల స్ట్రింగ్ కీవర్డ్‌లను కూడా ప్రారంభించాము [10] = {“”, “”, “ఎబిసి”, ”డెఫ్”, “ఘి”, “జెకెఎల్”, ”మ్నో”, “పిక్ఆర్ఎస్”, “తువ్”, “ wxyz ”}

మేము ఈ విలువలను getCombination అని పిలిచే మరొక ఫంక్షన్లో పాస్ చేస్తాము, దీనిలో మనం అవుట్పుట్ పొందుతాము.

కాబట్టి మేము 23 ని ఉదాహరణగా తీసుకుంటాము, ఇది వరుసగా 2, 3 సూచిక వద్ద శ్రేణి = {0, 1 in లో నిల్వ చేయబడుతుంది.

కాబట్టి ఇప్పుడు ఒక ఫంక్షన్లో, మేము క్యూ మరియు మా అవుట్పుట్ను నిల్వ చేయబోయే జాబితాను ప్రకటించాము.

మేము ఖాళీ స్ట్రింగ్‌ను క్యూలోకి నెట్టివేస్తాము;
que = “”;

లో ప్రవేశించడం a లూప్ అయితే: మేము క్యూ యొక్క ముందు భాగాన్ని తాత్కాలికంగా పొందుతాము మరియు దానిని క్యూ నుండి తీసివేస్తాము,
టెంప్ = “”

విలువలు టెంప్ మరియు ఎన్ నుండి భిన్నంగా ఉన్నందున ఇప్పుడు ఒక భాగం అమలు చేయకపోతే. కనుక ఇది వేరే భాగాన్ని అమలు చేస్తుంది
కాపీ = temp.length = 0 => సంఖ్య [0] = 2 => కీలు [2] = “abc”
అంటే కాపీ = “ఎబిసి”;

ఇప్పుడు అది లూప్ కోసం మళ్ళించబోతోంది
మరియు a, b మరియు c లలో క్యూ జోడించండి.

ఇప్పుడు మళ్ళీ తనిఖీ చేస్తుంది (! Que.isEmpty ()) మరియు ఇది నిజం కాబట్టి ఇది కొనసాగుతూనే ఉంటుంది మరియు ఇది క్యూలో ముందు భాగంలో “a” అని టెంప్‌లో పడుతుంది మరియు తొలగించండి.
కాపీ = temp.length = 1 => సంఖ్య [1] = 3 => కీలు [3] = “డెఫ్”
కాబట్టి ఇప్పుడు అది d, e మరియు f లతో కలిపి వరుసగా క్యూలో నెట్టబడుతుంది.

ఇప్పుడు మళ్ళీ తనిఖీ చేస్తుంది (!
కాపీ = temp.length = 1 => సంఖ్య [1] = 3 => కీలు [3] = “డెఫ్”
కాబట్టి ఇప్పుడు అది d, e మరియు f లతో b ని జోడించి వరుసగా క్యూలో నెట్టేస్తుంది.

(! Que.isEmpty ()) అయితే ఇప్పుడు మళ్ళీ తనిఖీ చేస్తుంది మరియు ఇది నిజం కాబట్టి ఇది కొనసాగుతూనే ఉంటుంది మరియు ఇది క్యూ ముందు భాగంలో టెంప్‌లో పడుతుంది “c” మరియు c ని తొలగించండి.
కాపీ = temp.length = 1 => సంఖ్య [1] = 3 => కీలు [3] = “డెఫ్”
కాబట్టి ఇప్పుడు అది d, e మరియు f లతో c ని జోడించి వరుసగా క్యూలో నెట్టేస్తుంది.

ఇప్పుడు అది క్యూలో ముందు భాగంలో తీసుకుంటే, temp.length n కి సమానం అని కనుగొన్నారు. మరియు తాత్కాలికతను జోడించి, క్రమంగా అది మనకు లభించే ప్రతి కలయికను జోడించబోతోంది.
మరియు మేము అవుట్పుట్ను పొందుతాము: (ప్రకటన, ae, af, bd, be, bf, cd, ce, cf)

అమలు

ఫోన్ నంబర్ యొక్క లెటర్ కాంబినేషన్లను కనుగొనడానికి సి ++ ప్రోగ్రామ్

#include<iostream>
#include<queue>
#include<sstream>
using namespace std;

vector<string> getCombination( int inputValue[], int n, string keyWords[])
{
    vector<string> list;

    queue<string> que;
    que.push("");

    while (!que.empty())
    {
        string temp = que.front();
        que.pop();
        if (temp.length() == n)
            list.push_back(temp);
        else
            for (auto getword : keyWords[inputValue[temp.length()]])
                que.push(temp + getword);
    }

    return list;
}

void combination( int inputValue[], int n)
{

    string keyWords[10]
        = { "", "", "abc", "def", "ghi", "jkl",
            "mno", "pqrs", "tuv", "wxyz"
          };

    vector<string> list= getCombination(inputValue, n, keyWords);

    for (auto word : list)
        cout << word << " ";

    return;
}

int main()
{
    string s="23";
    stringstream comb(s);
    int le=s.length();
    int inputValue[le];
    int i=0,x=0;
    comb>>x;
    while(x>0)
    {
        inputValue[le-i-1]=x%10;
        x/=10;
        i++;
    }
    int lengths = sizeof(inputValue) / sizeof(inputValue[0]);

    combination(inputValue, lengths);
    return 0;
}
ad ae af bd be bf cd ce cf

ఫోన్ నంబర్ యొక్క లెటర్ కాంబినేషన్లను కనుగొనడానికి జావా ప్రోగ్రామ్

import java.util.*;

class combinationNumber {
  static ArrayList<String> getCombination(int[] number, int n, String[] keys) {
    ArrayList<String> getList = new ArrayList<>();

    Queue<String> que = new LinkedList<>();

    que.add("");

    while (!que.isEmpty()) {
      String temp = que.remove();

      if (temp.length() == n)
        getList.add(temp);
      else {
        String copy = keys[number[temp.length()]];
        for (int i = 0; i<copy.length(); i++) {
          que.add(temp + copy.charAt(i));
        }
      }
    }
    return getList;
  }

  static void combination(int[] inputValue, int n) {
    String[] keyWords = {
      "", "", "abc", "def", "ghi", "jkl",
      "mno", "pqrs", "tuv", "wxyz"
    };

    ArrayList<String> output = getCombination(inputValue, n, keyWords);

    for (int i = 0; i<output.size(); i++) {
      System.out.print(output.get(i) + " ");
    }
  }

  public static void main(String args[]) {
    String s = "23";
    int numb = Integer.valueOf(s);
    int i = 0;
    int[] inputValue = new int[s.length()];
    while (numb > 0) {
      inputValue[s.length() - i - 1] = numb % 10;
      numb /= 10;
      i++;
    }

    int lengths = inputValue.length;
    combination(inputValue, lengths);
  }
}
ad ae af bd be bf cd ce cf

సంక్లిష్టత విశ్లేషణ

సమయం సంక్లిష్టత

ఓ (3N × 4M) ఇక్కడ N అంటే 3 అక్షరాలు (ఉదా: 2,3,4) కేటాయించిన అంకెలు మరియు M అంటే 4 అక్షరాలు (ఉదా: 7,9) కేటాయించిన అంకెలు.

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

ఓ (3N × 4M) ఇక్కడ N అంటే 3 అక్షరాలు (ఉదా: 2,3,4) కేటాయించిన అంకెలు మరియు M అంటే 4 అక్షరాలు (ఉదా: 7,9) కేటాయించిన అంకెలు.