បន្សំលិខិតលេខទូរស័ព្ទ

សំណួរសំភាសន៍រចនាប្រព័ន្ធ អាចជាការបើកចំហរ ដូច្នេះវាពិបាកពេកក្នុងការដឹងពីវិធីត្រឹមត្រូវក្នុងការរៀបចំ។ ឥឡូវនេះខ្ញុំអាចបំបែកការរចនានៃ Amazon, Microsoft និង Adobe បន្ទាប់ពីទិញ សៀវភៅ​នេះ. ពិនិត្យឡើងវិញប្រចាំថ្ងៃ សំណួររចនា ហើយខ្ញុំសន្យាថាអ្នកអាចបំបែកការរចនាជុំ។

នៅក្នុងបន្សំលិខិតនៃបញ្ហាលេខទូរស័ព្ទយើងបានផ្តល់ឱ្យ ខ្សែអក្សរ មានលេខពីលេខ ២ ដល់លេខ ៩ បញ្ហាគឺត្រូវស្វែងរកបន្សំដែលអាចកើតមានទាំងអស់ដែលអាចត្រូវបានតំណាងដោយលេខនោះប្រសិនបើលេខទាំងអស់មានអក្សរខ្លះដែលបានកំណត់។ ការចាត់ចែងលេខត្រូវបានផ្តល់ឱ្យនៅខាងក្រោមវាគឺដូចជាប៊ូតុងទូរស័ព្ទដែរ។

ពិន

ចំណាំថាមិនមានលិខិតណាមួយត្រូវបានកំណត់ទៅលេខ ១ ទេ

ឧទាហរណ៍

"23"

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

អក្សរដែលបានប្រគល់ឱ្យ "2" មាន “ អេប៊ីស៊ី” និងទៅ "3" មាន “ DEF” ដូច្នេះការរួមបញ្ចូលគ្នានៃអក្សរនឹងត្រូវបាន“ ផ្សាយពាណិជ្ជកម្ម”“ អេ”“ អា”“ ខ”“ ប៊ី”“ ខ”“ ស៊ីឌី”“ ស៊ី” និង“ ស៊ីហ្វ”

ក្បួនដោះស្រាយ

1. ប្រកាសក ជួរ និង ArrayList និងខ្សែអក្សរ អារេ.
2. អារេខ្សែអក្សរគួរតែរក្សាទុកតម្លៃដូចជាអក្សរខ្សែអក្សរដែលបានផ្តល់ [១០] = {“”,“,“ abc”,“ def”,“ ghi”,“ jkl”,“ mno”,“ pqrs”,“ tuv”,“ wxyz”};
3. ដំបូងរុញខ្សែរទទេទៅក្នុងជួរ
4. ខណៈពេលដែលជួរមានតម្លៃមួយចំនួននៅក្នុងវា iterates លើរង្វិលជុំ។
5. ទុកតម្លៃនៃជួរជួរមុខទៅខ្សែអក្សរបណ្តោះអាសន្ន
6. ប្រសិនបើប្រវែងនៃខ្សែបណ្តោះអាសន្នត្រូវបានរកឃើញថាស្មើនឹង n (ដែលជាប្រវែងតម្លៃបញ្ចូល)
7. បន្ថែមតម្លៃនៃខ្សែបណ្តោះអាសន្នដើម្បីរាយ។
8. ផ្សេងទៀតបើករង្វិលជុំដែលតម្លៃខ្សែអក្សរត្រូវបានចាប់ផ្តើមជាច្បាប់ចម្លង = គ្រាប់ចុច [លេខ [temp.length ()]];
9. បន្ថែមខ្សែអក្សរបណ្ដោះអាសន្នទៅគ្រប់ខ្សែរងនៃពាក្យគន្លឹះ (០, ១) និងរុញវាចូលជួរ។
10. បំបែកលើវារហូតដល់ជួរមានតម្លៃនៅក្នុងវា។
11. បញ្ជីត្រឡប់មកវិញ។

ការពន្យល់

ឧបមាថាយើងត្រូវបានផ្តល់ការបញ្ចូលដូចលេខ 23 ។ បន្ទាប់មកយើងប្តូរវាទៅជាលេខគត់។ ហើយបំលែងវាទៅជាអារេនៃតួរលេខតាមរបៀបដែលយើងបានទទួល។ ហើយយើងនឹងបញ្ជូនតម្លៃបញ្ចូលនិងរយៈពេលនៃតម្លៃបញ្ចូលទៅក្នុងមុខងារដែលយើងបានដាក់ឈ្មោះថាជាបន្សំមួយ។

នៅក្នុងមុខងារនោះយើងក៏បានចាប់ផ្តើមពាក្យគន្លឹះនៃពាក្យគន្លឹះ KeyWords [10] = {“”“”“ abc”“ def”“ ហ្គី”“ ជេក”””””“ ផេក”““ វី”“ wxyz”}

យើងហុចតម្លៃទាំងនេះនៅក្នុងមុខងារមួយទៀតហៅថា getCombination ដែលយើងទទួលបានលទ្ធផល។

ដូច្នេះយើងយក ២៣ ជាឧទាហរណ៍វាត្រូវបានរក្សាទុកក្នុងអារេ = {២, ៣} នៅ ០, ១ លិបិក្រមរៀងៗខ្លួន។

ឥឡូវនៅក្នុងមុខងារយើងប្រកាសជួរនិងបញ្ជីដែលនឹងរក្សាទុកលទ្ធផលរបស់យើង។

យើងរុញខ្សែរទទេទៅក្នុងជួរ;
que =“”;

ចូលក្នុងក ខណៈពេលដែលរង្វិលជុំ: យើងយកជួរមុខចូលក្នុងបណ្ដោះអាសន្នហើយយកវាចេញពីជួរ។
Temp =“”

ឥឡូវប្រសិនបើផ្នែកមួយមិនប្រតិបត្តិពីព្រោះតម្លៃខុសគ្នាពីបណ្ដោះអាសន្ននិង n ។ ដូច្នេះវាប្រតិបត្តិផ្នែកផ្សេងទៀតដែលនឹងធ្វើ
ចំលង = temp.length = 0 => លេខ [0] = ២ => កូនសោ [២] =“ abc”
ដែលមានន័យថាចំលង =“ abc”;

ឥឡូវនេះវានឹង iterate នៅសម្រាប់រង្វិលជុំ
ហើយបន្ថែមជួរក្នុង a, b និង c ។

ឥឡូវពិនិត្យមើលម្តងទៀតពេល (! que.isEmpty ()) ហើយវាជាការពិតដូច្នេះវានៅតែបន្តទៅមុខទៀតហើយវាត្រូវចំណាយពេលខាងមុខជួរជួរនៅលើបណ្ដោះអាសន្នដែលជា“ ក” ហើយយកក។
ចំលង = temp.length = 1 => លេខ [១] = ៣ => កូនសោ [៣] =“ def”
ដូច្នេះឥឡូវវានឹងបន្ថែមខាងចុងជាមួយឃ, អ៊ីនិង F ហើយរុញវាជាជួររៀងៗខ្លួន។

ឥឡូវពិនិត្យមើលម្តងទៀតនៅពេល (! que.isEmpty ()) ហើយវាជាការពិតដូច្នេះវានៅតែបន្តទៅមុខទៀតហើយវាត្រូវឈរនៅខាងមុខជួរជួរភ្នំដែល "ខ" ឥឡូវយក b ។
ចំលង = temp.length = 1 => លេខ [១] = ៣ => កូនសោ [៣] =“ def”
ដូច្នេះឥលូវវានឹងបន្ថែមខជាមួយឃ, អ៊ីនិង F ហើយរុញវាជាជួររៀងៗខ្លួន។

ឥឡូវពិនិត្យមើលម្តងទៀតនៅពេល (! que.isEmpty ()) ហើយវាជាការពិតដូច្នេះវានៅតែបន្តទៅមុខទៀតហើយវាត្រូវឈរនៅខាងមុខជួរជួរភ្នំដែល "គ" ហើយយកគ។
ចំលង = temp.length = 1 => លេខ [១] = ៣ => កូនសោ [៣] =“ def”
ដូច្នេះឥលូវវានឹងបន្ថែម c ជាមួយនឹងឃ, e និង f ហើយរុញវាជាជួររៀងៗខ្លួន។

ឥឡូវប្រសិនបើវាស្ថិតនៅជួរជួរមុខក្នុងបណ្ដោះអាសន្នហើយរកឃើញថារយៈទទឹងគឺស្មើនឹង n ។ ហើយបន្ថែមបណ្ដោះអាសន្នហើយបន្តទៀតវានឹងបន្ថែមរាល់បន្សំដែលយើងទទួលបាន។
ហើយយើងទទួលបានលទ្ធផល: (ការផ្សាយពាណិជ្ជកម្មអេ។ អេ។ ប៊ី។ ប៊ី។ ប៊ី។ ស៊ី។ ស៊ី។ ស៊ី។ ស៊ី។ អិល)

ការអនុវត្តន៍

កម្មវិធី C ++ ដើម្បីស្វែងរកបន្សំអក្សរលេខទូរស័ព្ទ

#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

ការវិភាគស្មុគស្មាញ

ស្មុគស្មាញពេលវេលា

ឱ (២^N × ៣^M) កន្លែង N ជាចំនួនតួរលេខដែលមាន ៣ អក្សរ (ឧ។ ២,៣,៤) ប្រគល់អោយវាហើយ M ជាចំនួនតួរលេខដែលមាន ៤ តួ (ឧ។ ៧.៩) ប្រគល់អោយ។

ភាពស្មុគស្មាញនៃលំហ

ឱ (២^N × ៣^M) កន្លែង N ជាចំនួនតួរលេខដែលមាន ៣ អក្សរ (ឧ។ ២,៣,៤) ប្រគល់អោយវាហើយ M ជាចំនួនតួរលេខដែលមាន ៤ តួ (ឧ។ ៧.៩) ប្រគល់អោយ។