ಫೋನ್ ಸಂಖ್ಯೆಯ ಅಕ್ಷರ ಸಂಯೋಜನೆಗಳು


ತೊಂದರೆ ಮಟ್ಟ ಮಧ್ಯಮ
ಆಗಾಗ್ಗೆ ಕೇಳಲಾಗುತ್ತದೆ ಅಮೆಜಾನ್ ಆಪಲ್ Atlassian ಕ್ಯಾಪಿಟಲ್ ಒನ್ ಡೇಟಾಬೇಕ್ಸ್ ಇಬೇ ಫೇಸ್ಬುಕ್ ಗೂಗಲ್ ಮೈಕ್ರೋಸಾಫ್ಟ್ ಮಾರ್ಗನ್ ಸ್ಟಾನ್ಲಿ ಒರಾಕಲ್ ಗುಣಗಳು ಟ್ವಿಲಿಯೊ ಉಬರ್ ವರೆ ವಾಲ್ಮಾರ್ಟ್ ಲ್ಯಾಬ್ಸ್
ಬ್ಯಾಕ್‌ಟ್ರಾಕಿಂಗ್ ಆಳದ ಮೊದಲ ಹುಡುಕಾಟ ಪುನರಾವರ್ತನೆ ಸ್ಟ್ರಿಂಗ್

ಫೋನ್ ಸಂಖ್ಯೆಯ ಸಮಸ್ಯೆಯ ಅಕ್ಷರ ಸಂಯೋಜನೆಯಲ್ಲಿ, ನಾವು a ಅನ್ನು ನೀಡಿದ್ದೇವೆ ಸ್ಟ್ರಿಂಗ್ 2 ರಿಂದ 9 ರವರೆಗಿನ ಸಂಖ್ಯೆಗಳನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ. ಪ್ರತಿ ಸಂಖ್ಯೆಗೆ ಕೆಲವು ಅಕ್ಷರಗಳನ್ನು ನಿಗದಿಪಡಿಸಿದರೆ ಆ ಸಂಖ್ಯೆಯಿಂದ ಪ್ರತಿನಿಧಿಸಬಹುದಾದ ಎಲ್ಲ ಸಂಯೋಜನೆಗಳನ್ನು ಕಂಡುಹಿಡಿಯುವುದು ಸಮಸ್ಯೆಯಾಗಿದೆ. ಸಂಖ್ಯೆಯ ನಿಯೋಜನೆಯನ್ನು ಟೆಲಿಫೋನ್ ಗುಂಡಿಗಳಂತೆಯೇ ಕೆಳಗೆ ನೀಡಲಾಗಿದೆ.

ಫೋನ್ ಸಂಖ್ಯೆಯ ಅಕ್ಷರ ಸಂಯೋಜನೆಗಳು

ಇಲ್ಲಿ 1 ಕ್ಕೆ ಯಾವುದೇ ಅಕ್ಷರವನ್ನು ನಿಗದಿಪಡಿಸಲಾಗಿಲ್ಲ ಎಂಬುದನ್ನು ಗಮನಿಸಿ

ಉದಾಹರಣೆ

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

ಗೆ ನಿಯೋಜಿಸಲಾದ ಅಕ್ಷರಗಳು "2" ಇವೆ “ಎಬಿಸಿ” ಮತ್ತು ಗೆ "3" ಇವೆ “DEF” ಆದ್ದರಿಂದ ಅಕ್ಷರಗಳ ಸಂಯೋಜನೆಯು “ಜಾಹೀರಾತು”, “ಎ”, “ಎಫ್”, “ಬಿಡಿ”, “ಬಿ”, “ಬಿಎಫ್”, “ಸಿಡಿ”, “ಸಿಇ” ಮತ್ತು “ಸಿಎಫ್” ಆಗಿರುತ್ತದೆ

ಕ್ರಮಾವಳಿ

  1. ಎ ಘೋಷಿಸಿ ಕ್ಯೂ ಮತ್ತು ಅರೇಲಿಸ್ಟ್ ಮತ್ತು ಸ್ಟ್ರಿಂಗ್ ಸರಣಿ.
  2. ಸ್ಟ್ರಿಂಗ್ ಅರೇ ನೀಡಿರುವ ಸ್ಟ್ರಿಂಗ್ ಕೀವರ್ಡ್‌ಗಳಂತೆ ಮೌಲ್ಯಗಳನ್ನು ಸಂಗ್ರಹಿಸಬೇಕು [10] = {“”, “”, “ಎಬಿಸಿ”, “ಡೆಫ್”, “ಘಿ”, “ಜೆಕೆಎಲ್”, “ಮ್ನೋ”, “ಪಿಕ್ಯರ್ಸ್”, “ಟುವ್”, “ wxyz ”};
  3. ಮೊದಲಿಗೆ, ಖಾಲಿ ದಾರವನ್ನು ಸರದಿಗೆ ತಳ್ಳಿರಿ
  4. ಕ್ಯೂ ಅದರಲ್ಲಿ ಕೆಲವು ಮೌಲ್ಯಗಳನ್ನು ಹೊಂದಿದ್ದರೂ ಲೂಪ್ ಮೇಲೆ ಪುನರಾವರ್ತಿಸುತ್ತದೆ.
  5. ಕ್ಯೂನ ಮುಂಭಾಗದ ಮೌಲ್ಯವನ್ನು ತಾತ್ಕಾಲಿಕ ಸ್ಟ್ರಿಂಗ್‌ಗೆ ಸಂಗ್ರಹಿಸಿ
  6. ತಾತ್ಕಾಲಿಕ ಸ್ಟ್ರಿಂಗ್‌ನ ಉದ್ದವು n ಗೆ ಸಮನಾಗಿರುವುದು ಕಂಡುಬಂದರೆ (ಅದು ಇನ್‌ಪುಟ್ ಮೌಲ್ಯದ ಉದ್ದ)
  7. ಪಟ್ಟಿಗೆ ತಾತ್ಕಾಲಿಕ ಸ್ಟ್ರಿಂಗ್‌ನ ಮೌಲ್ಯವನ್ನು ಸೇರಿಸಿ.
  8. ಇಲ್ಲದಿದ್ದರೆ, ಸ್ಟ್ರಿಂಗ್ ಮೌಲ್ಯವನ್ನು ನಕಲು = ಕೀಲಿಗಳಾಗಿ ಪ್ರಾರಂಭಿಸುವ ಲೂಪ್ ತೆರೆಯಿರಿ [ಸಂಖ್ಯೆ [temp.length ()]];
  9. ಪ್ರತಿ ಕೀವರ್ಡ್‌ನ ಸಬ್‌ಸ್ಟ್ರಿಂಗ್‌ಗೆ (0, 1) ಟೆಂಪ್ ಸ್ಟ್ರಿಂಗ್ ಸೇರಿಸಿ ಮತ್ತು ಅದನ್ನು ಸರದಿಯಲ್ಲಿ ತಳ್ಳಿರಿ.
  10. ಕ್ಯೂ ಅದರಲ್ಲಿ ಮೌಲ್ಯಗಳನ್ನು ಹೊಂದುವವರೆಗೆ ಅದರ ಮೇಲೆ ಪುನರಾವರ್ತಿಸುತ್ತದೆ.
  11. ರಿಟರ್ನ್ ಪಟ್ಟಿ.

ವಿವರಣೆ

ನಮಗೆ ಇನ್ಪುಟ್ ಅನ್ನು 23 ಎಂದು ನೀಡಲಾಗಿದೆ ಎಂದು ಭಾವಿಸೋಣ. ನಂತರ ನಾವು ಅದನ್ನು ಪೂರ್ಣಾಂಕಕ್ಕೆ ಬದಲಾಯಿಸುತ್ತೇವೆ. ಮತ್ತು ನಾವು ಅದನ್ನು ಪಡೆದ ರೀತಿಯಲ್ಲಿಯೇ ಅದನ್ನು ಅಂಕೆಗಳ ಶ್ರೇಣಿಯಾಗಿ ಪರಿವರ್ತಿಸಿ. ಮತ್ತು ನಾವು ಇನ್ಪುಟ್ ಮೌಲ್ಯ ಮತ್ತು ಆ ಇನ್ಪುಟ್ ಮೌಲ್ಯದ ಉದ್ದವನ್ನು ನಾವು ಸಂಯೋಜನೆಯಾಗಿ ಹೆಸರಿಸಿದ ಕಾರ್ಯಕ್ಕೆ ರವಾನಿಸುತ್ತೇವೆ.

ಆ ಕಾರ್ಯದಲ್ಲಿ ನಾವು ನಮ್ಮ ಕೀವರ್ಡ್ಗಳ ಸ್ಟ್ರಿಂಗ್ ಕೀವರ್ಡ್‌ಗಳನ್ನು ಸಹ ಪ್ರಾರಂಭಿಸಿದ್ದೇವೆ [10] = {“”, “”, “ಎಬಿಸಿ”, ”ಡೆಫ್”, “ಘಿ”, “ಜೆಕೆಎಲ್”, “ಮ್ನೋ”, “ಪಿಕ್ಯರ್ಸ್”, “ಟುವ್”, “ wxyz ”}

ನಾವು ಈ ಮೌಲ್ಯಗಳನ್ನು getCombination ಎಂಬ ಮತ್ತೊಂದು ಕಾರ್ಯದಲ್ಲಿ ರವಾನಿಸುತ್ತೇವೆ, ಇದರಲ್ಲಿ ನಾವು get ಟ್‌ಪುಟ್ ಪಡೆಯುತ್ತೇವೆ.

ಆದ್ದರಿಂದ ನಾವು 23 ಅನ್ನು ಉದಾಹರಣೆಯಾಗಿ ತೆಗೆದುಕೊಳ್ಳುತ್ತೇವೆ ಅದನ್ನು ಕ್ರಮವಾಗಿ 2, 3 ಸೂಚ್ಯಂಕದಲ್ಲಿ ಅರೇ = {0, 1 in ನಲ್ಲಿ ಸಂಗ್ರಹಿಸಲಾಗಿದೆ.

ಈಗ ಒಂದು ಕಾರ್ಯದಲ್ಲಿ, ನಾವು ಕ್ಯೂ ಮತ್ತು ನಮ್ಮ .ಟ್‌ಪುಟ್ ಅನ್ನು ಸಂಗ್ರಹಿಸಲಿರುವ ಪಟ್ಟಿಯನ್ನು ಘೋಷಿಸಿದ್ದೇವೆ.

ನಾವು ಖಾಲಿ ದಾರವನ್ನು ಕ್ಯೂಗೆ ತಳ್ಳುತ್ತೇವೆ;
que = “”;

ಪ್ರವೇಶಿಸುವುದು a ಲೂಪ್ ಮಾಡುವಾಗ: ನಾವು ಕ್ಯೂನ ಮುಂಭಾಗವನ್ನು ತಾತ್ಕಾಲಿಕವಾಗಿ ಪಡೆಯುತ್ತೇವೆ ಮತ್ತು ಅದನ್ನು ಕ್ಯೂನಿಂದ ತೆಗೆದುಹಾಕುತ್ತೇವೆ,
ತಾತ್ಕಾಲಿಕ = “”

ಈಗ ಒಂದು ಭಾಗವು ಕಾರ್ಯಗತಗೊಳಿಸದಿದ್ದರೆ ಮೌಲ್ಯಗಳು ಟೆಂಪ್ ಮತ್ತು ಎನ್ ನಿಂದ ಭಿನ್ನವಾಗಿರುತ್ತದೆ. ಆದ್ದರಿಂದ ಅದು ಬೇರೆ ಭಾಗವನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುತ್ತದೆ
ನಕಲಿಸಿ = temp.length = 0 => ಸಂಖ್ಯೆ [0] = 2 => ಕೀಲಿಗಳು [2] = “ಎಬಿಸಿ”
ಇದರರ್ಥ ನಕಲು = “ಎಬಿಸಿ”;

ಈಗ ಅದು ಲೂಪ್‌ಗಾಗಿ ಪುನರಾವರ್ತಿಸುತ್ತದೆ
ಮತ್ತು ಎ, ಬಿ ಮತ್ತು ಸಿಗಳಲ್ಲಿ ಕ್ಯೂ ಸೇರಿಸಿ.

ಈಗ ಮತ್ತೆ (! Que.isEmpty ()) ಪರಿಶೀಲಿಸುತ್ತದೆ ಮತ್ತು ಅದು ನಿಜ ಆದ್ದರಿಂದ ಅದು ಮುಂದುವರಿಯುತ್ತದೆ ಮತ್ತು ಅದು ಕ್ಯೂನಲ್ಲಿ ಮುಂಭಾಗವನ್ನು "a" ಎಂದು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ ಮತ್ತು ಅದನ್ನು ತೆಗೆದುಹಾಕುತ್ತದೆ.
ನಕಲಿಸಿ = temp.length = 1 => ಸಂಖ್ಯೆ [1] = 3 => ಕೀಲಿಗಳು [3] = “ಡೆಫ್”
ಈಗ ಅದು ಡಿ, ಇ ಮತ್ತು ಎಫ್ ನೊಂದಿಗೆ ಸೇರಿಸುತ್ತದೆ ಮತ್ತು ಅದನ್ನು ಕ್ರಮವಾಗಿ ಸರದಿಯಲ್ಲಿ ತಳ್ಳುತ್ತದೆ.

ಈಗ ಮತ್ತೆ (! Que.isEmpty ()) ಪರಿಶೀಲಿಸುತ್ತದೆ ಮತ್ತು ಅದು ನಿಜ ಆದ್ದರಿಂದ ಅದು ಮುಂದುವರಿಯುತ್ತದೆ ಮತ್ತು ಅದು ಈಗ ಕ್ಯೂನಲ್ಲಿ ಮುಂಭಾಗವನ್ನು "ಬಿ" ಎಂದು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ ಮತ್ತು ಬಿ ಅನ್ನು ತೆಗೆದುಹಾಕುತ್ತದೆ.
ನಕಲಿಸಿ = temp.length = 1 => ಸಂಖ್ಯೆ [1] = 3 => ಕೀಲಿಗಳು [3] = “ಡೆಫ್”
ಈಗ ಅದು ಡಿ, ಇ ಮತ್ತು ಎಫ್ ನೊಂದಿಗೆ ಬಿ ಅನ್ನು ಸೇರಿಸುತ್ತದೆ ಮತ್ತು ಅದನ್ನು ಕ್ರಮವಾಗಿ ಸರದಿಯಲ್ಲಿ ತಳ್ಳುತ್ತದೆ.

ಈಗ ಮತ್ತೆ ಅದು (! Que.isEmpty ()) ಪರಿಶೀಲಿಸುತ್ತದೆ ಮತ್ತು ಅದು ನಿಜ ಆದ್ದರಿಂದ ಅದು ಮುಂದುವರಿಯುತ್ತದೆ ಮತ್ತು ಅದು ಕ್ಯೂನ ಮುಂಭಾಗವನ್ನು "c" ಎಂದು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ ಮತ್ತು c ಅನ್ನು ತೆಗೆದುಹಾಕುತ್ತದೆ.
ನಕಲಿಸಿ = temp.length = 1 => ಸಂಖ್ಯೆ [1] = 3 => ಕೀಲಿಗಳು [3] = “ಡೆಫ್”
ಈಗ ಅದು ಡಿ, ಇ ಮತ್ತು ಎಫ್ ನೊಂದಿಗೆ ಸಿ ಅನ್ನು ಸೇರಿಸುತ್ತದೆ ಮತ್ತು ಅದನ್ನು ಕ್ರಮವಾಗಿ ಸರದಿಯಲ್ಲಿ ತಳ್ಳುತ್ತದೆ.

ಈಗ ಅದು ಕ್ಯೂನಲ್ಲಿ ಮುಂಭಾಗವನ್ನು ಟೆಂಪ್ನಲ್ಲಿ ತೆಗೆದುಕೊಂಡರೆ ಮತ್ತು ಟೆಂಪ್.ಲೆಂಗ್ತ್ n ಗೆ ಸಮಾನವಾಗಿರುತ್ತದೆ ಎಂದು ಕಂಡುಕೊಂಡರೆ. ಮತ್ತು ತಾತ್ಕಾಲಿಕವನ್ನು ಸೇರಿಸಿ ಮತ್ತು ಅನುಕ್ರಮವಾಗಿ ಅದು ನಾವು ಪಡೆಯುವ ಪ್ರತಿಯೊಂದು ಸಂಯೋಜನೆಯನ್ನು ಸೇರಿಸಲಿದೆ.
ಮತ್ತು ನಾವು output ಟ್‌ಪುಟ್ ಪಡೆಯುತ್ತೇವೆ: (ಜಾಹೀರಾತು, ಎಇ, ಎಫ್, ಬಿಡಿ, ಬಿ, ಬಿಎಫ್, ಸಿಡಿ, ಸಿಇ, ಸಿಎಫ್)

ಅನುಷ್ಠಾನ

ಫೋನ್ ಸಂಖ್ಯೆಯ ಅಕ್ಷರ ಸಂಯೋಜನೆಗಳನ್ನು ಕಂಡುಹಿಡಿಯಲು ಸಿ ++ ಪ್ರೋಗ್ರಾಂ

#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) ನಿಗದಿಪಡಿಸಿದ ಅಂಕೆಗಳ ಸಂಖ್ಯೆ.