தொலைபேசி எண்ணின் கடிதம் சேர்க்கைகள்


சிரமம் நிலை நடுத்தர
அடிக்கடி கேட்கப்படுகிறது அமேசான் ஆப்பிள் அட்லாசியன் மூலதன ஒன்று தரவுத்தளங்கள் ஈபே பேஸ்புக் கூகிள் மைக்ரோசாப்ட் மோர்கன் ஸ்டான்லி ஆரக்கிள் Qualtrics Twilio கிழித்து , VMware வால்மார்ட் ஆய்வகங்கள்
பின்வாங்கல் ஆழம் முதல் தேடல் மறுசுழற்சி சரம்

தொலைபேசி எண் சிக்கலின் கடித சேர்க்கைகளில், நாங்கள் ஒரு கொடுத்துள்ளோம் சரம் 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 எனப்படும் மற்றொரு செயல்பாட்டில் அனுப்புகிறோம், அதில் நாம் வெளியீட்டைப் பெறுகிறோம்.

எனவே 23 ஐ ஒரு எடுத்துக்காட்டுக்கு எடுத்துக்கொள்கிறோம், இது முறையே 2, 3 குறியீட்டில் வரிசை = {0, 1 in இல் சேமிக்கப்படுகிறது.

எனவே இப்போது ஒரு செயல்பாட்டில், எங்கள் வெளியீட்டை சேமிக்கப் போகும் வரிசை மற்றும் பட்டியலை அறிவித்தோம்.

நாங்கள் ஒரு வெற்று சரத்தை க்யூவுக்குள் தள்ளுகிறோம்;
que = “”;

ஒரு நுழைகிறது லூப் போது: நாங்கள் வரிசையின் முன்பக்கத்தை தற்காலிகமாகப் பெறுகிறோம், அதை வரிசையிலிருந்து அகற்றுவோம்,
தற்காலிக = “”

இப்போது ஒரு பகுதி இயங்கவில்லை என்றால் மதிப்புகள் தற்காலிக மற்றும் n இலிருந்து வேறுபடுகின்றன. எனவே இது வேறு பகுதியை செயல்படுத்துகிறது
நகலெடு = temp.length = 0 => எண் [0] = 2 => விசைகள் [2] = “abc”
அதாவது நகல் = “ஏபிசி”;

இப்போது அது வளையத்திற்கு மீண்டும் செல்லும்
A, b மற்றும் c இல் வரிசையைச் சேர்க்கவும்.

இப்போது மீண்டும் (! Que.isEmpty ()) சரிபார்க்கிறது, அது உண்மைதான், எனவே அது தொடர்ந்து கொண்டே இருக்கிறது, மேலும் அது வரிசையின் முன் பகுதியை "a" என்று எடுத்துக்கொண்டு a ஐ நீக்குகிறது.
நகலெடு = temp.length = 1 => எண் [1] = 3 => விசைகள் [3] = “டெஃப்”
எனவே இப்போது அது d, e மற்றும் f உடன் ஒரு முறையைச் சேர்த்து முறையே வரிசையில் தள்ளும்.

இப்போது மீண்டும் (! Que.isEmpty ()) சரிபார்க்கிறது, அது உண்மைதான், எனவே அது தொடர்ந்து கொண்டே இருக்கிறது, அது வரிசையின் முன் பகுதியை தற்காலிகமாக "b" என்று எடுத்துக்கொண்டு b ஐ நீக்குகிறது.
நகலெடு = 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) ஒதுக்கப்பட்டுள்ள இலக்கங்களின் எண்ணிக்கையாகும்.