首页 > 试题广场 >

现在有一个手机,手机上的键盘上有这样的对应关系,2对应"ab

[问答题]
现在有一个手机,手机上的键盘上有这样的对应关系,2对应"abc",3对应"def".....手机里面有一个userlist用户列表,当我们输入942的时候出来拼音的对应可能是“xia”,“zha”,“xi”,“yi”等,当我们输入9264的时候出来是yang,可能是“样”,“杨”,“往”等,现在我们输入一个字符串数字,比如926等,要在电话簿userlist中查找出对应的用户名和电话号码并返回结果。 C++语言: 电话号码对应的英语单词(注意此题的非递归做法)
推荐

C++语言: 电话号码对应的英语单词(注意此题的非递归做法)


#include#include#define N 4 //电话号码个数  
 
using namespace std; 
 
char c[][10] = {"","","ABC","DEF","GHI","JKL","MNO","PQRS","TUV","WXYZ"};//存储各个数字所能代表的字符  
int number[N] = {2, 4 ,7, 9}; //存储电话号码  
int total[10] = {0, 0, 3, 3, 3, 3, 3, 4, 3, 4}; //各个数组所能代表的字符总数  
int answer[N]; //数字目前所代表的字符在其所能代表的字符集中的位置,初始为0  
 
void Search(int *number, int n); //非递归的办法  
void RecursiveSearch(int *number, int cur, char *ps, int n); //递归的办法 
int main() 
{ 
        //Search(number, N);  
        char ps[N+1] = {0}; 
        RecursiveSearch(number, 0, ps, N); 
        return 0; 
} 
 
 
void Search(int *number, int n) 
{ 
        int i; 
        while(1) 
        { 
                for(i=0; i= 0) 
                { 

if(answer[k] < total[number[k]]-1) { ++answer[k]; break; } else { answer[k] = 0; --k; } } if(k < 0) break; } } /*递归的解法: number为存储电话号码的数组,pos为当前处理的数字在number中的下标,初始为0 *ps为一外部数组,用于存放字母,n代表电话号码的长度(个数) * 此递归的方法好理解,比上面非递归的办法好写易懂 * */

void RecursiveSearch(int *number, int pos, char *ps, int n) 
{ 
        int i; 
        for(i=0; i<total[number[pos]]; ++i) 
        { 
                ps[pos] = c[number[pos]][i]; 
                if(pos == n-1) 
                        cout<<ps<<endl; 
                else 
                        RecursiveSearch(number, pos+1, ps, n); 
        } 
} 

发表于 2014-10-25 00:26:03 回复(0)
vector<string> letterCombinations(string digits) {
    vector<string> res;
    string charmap[10] = {"0", "1", "abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"};
    res.push_back("");
    for (int i = 0; i < digits.size(); i++)
    {
        vector<string> tempres;
        string chars = charmap[digits[i] - '0'];
        for (int c = 0; c < chars.size();c++)
            for (int j = 0; j < res.size();j++)
                tempres.push_back(res[j]+chars[c]);
        res = tempres;
    }
    return res;
}

发表于 2015-09-16 11:11:11 回复(0)
<pre class="prettyprint">根据中文姓名与拼音的映射关系以及拼音与键盘数字的映射关系,可以得到每个用户名对应的一串数字。以这串数字为关键字建立度为8的哈夫曼树,树的非叶结点中有编号0到7的结点指针分别代表从2到9的带权路径。叶结点包含一个链表,这个链表结点包含一个指向包含用户名和电话号码的结构体指针。根据输入的数字串,找到对应的结点,如果找到的是非叶结点,表明包含多个用户,则以这个非叶节点为根的树遍历输出;若找到叶结点,则输出叶节点链表中的用户。</pre> <br />
发表于 2015-08-27 16:48:14 回复(0)
     /*-------------------------------------
    *   日期:2015-03-30
    *   作者:SJF0115
    *   题目: 电话号码对应英语单词
    *   来源:百度
    *   博客:
    ------------------------------------*/
    #include <iostream>
    #include <vector>
    using namespace std;

    //每个数字键对应的字母个数
    vector<int> count = {0,0,3,3,3,3,3,4,3,4};
    vector<string> letter = {"","","ABC","DEF","GHI","JKL","MNO","PQRS","TUV","WXYZ"};

    // phone 电话号码 n 电话号码位数 index
    void RecursiveSearch(vector<int> phone,vector<char> &path,int index,int n,vector<vector<char> > &result){
        if(index == n){
            result.push_back(path);
            return;
        }//if
        int num = phone[index];
        for(int i = 0;i < count[num];++i){
            path.push_back(letter[num][i]);
            RecursiveSearch(phone,path,index+1,n,result);
            path.pop_back();
        }//for
        if(count[num] == 0){
            RecursiveSearch(phone,path,index+1,n,result);
        }//if
    }
    // 非递归
    vector<vector<char> > NoRecursiveSearch(vector<int> phone){
        vector<vector<char> > result;
        vector<char> path;
        int size = phone.size();
        if(size <= 0){
            return result;
        }//if
        // 数字键目前所代表的字符在所能代表的字符集中的位置
        vector<int> answer(size,0);
        while(true){
            for(int i = 0;i < size;++i){
                path.push_back(letter[phone[i]][answer[i]]);
            }//for
            result.push_back(path);
            path.clear();

            int k = size - 1;
            // 每一个数字对应的字母位置
            while(k >= 0){
                if(answer[k] < count[phone[k]] - 1){
                    answer[k]++;
                    break;
                }//if
                else{
                    answer[k] = 0;
                    k--;
                }//else
            }//while
            if(k < 0){
                break;
            }//if
        }//while
    }

    // 打印
    void Print(vector<vector<char> > result){
        for(int i = 0;i < result.size();++i){
            for(int j = 0;j < result[i].size();++j){
                cout<<result[i][j];
            }//for
            cout<<endl;
        }//for
    }

    int main(){
        vector<vector<char> > result;
        vector<char> path;
        vector<int> phone = {3,2,4};

        RecursiveSearch(phone,path,0,phone.size(),result);
        Print(result);
        cout<<endl;

        result = NoRecursiveSearch(phone);
        Print(result);
    }






编辑于 2015-03-30 20:45:19 回复(0)
#include <iostream>  
#include <cstdlib>  
#define N 4 //电话号码个数  
  
using namespace std;  
  
char c[][10] = {"","","ABC","DEF","GHI","JKL","MNO","PQRS","TUV","WXYZ"};//存储各个数字所能代表的字符  
int number[N] = {2, 4 ,7, 9}; //存储电话号码  
int total[10] = {0, 0, 3, 3, 3, 3, 3, 4, 3, 4}; //各个数组所能代表的字符总数  
int answer[N]; //数字目前所代表的字符在其所能代表的字符集中的位置,初始为0  
  
void Search(int *number, int n); //非递归的办法  
void RecursiveSearch(int *number, int cur, char *ps, int n); //递归的办法  
[cpp] view plaincopyprint?
int main()  
{  
        //Search(number, N);  
        char ps[N+1] = {0};  
        RecursiveSearch(number, 0, ps, N);  
        return 0;  
}  
  
  
void Search(int *number, int n)  
{  
        int i;  
        while(1)  
        {  
                for(i=0; i<n; ++i)  
                        printf("%c", c[number[i]][answer[i]]);  
                printf("\n");  
                int k = n-1;    //用k和while循环来解决扩展性问题,模拟了递归  
                while(k >= 0)  
                {  
                        if(answer[k] < total[number[k]]-1)  
                        {  
                                ++answer[k];  
                                break;  
                        }  
                        else  
                        {  
                                answer[k] = 0;  
                                --k;  
                        }  
                }  
                if(k < 0)  
                        break;  
        }  
}  
  
  
/*递归的解法: number为存储电话号码的数组,pos为当前处理的数字在number中的下标,初始为0 
*ps为一外部数组,用于存放字母,n代表电话号码的长度(个数) 
* 此递归的方法好理解,比上面非递归的办法好写易懂 
* */  
void RecursiveSearch(int *number, int pos, char *ps, int n)  
{  
        int i;  
        for(i=0; i<total[number[pos]]; ++i)  
        {  
                ps[pos] = c[number[pos]][i];  
                if(pos == n-1)  
                        cout<<ps<<endl;  
                else  
                        RecursiveSearch(number, pos+1, ps, n);  
        }  
}  

发表于 2014-12-11 09:55:12 回复(0)
流头像
mutilmap建立数字与拼音的对应,在深搜。
发表于 2014-12-10 17:06:54 回复(0)
使用键树
发表于 2014-12-01 19:58:43 回复(0)
xxj头像 xxj
  1. C++语言: 电话号码对应的英语单词(注意此题的非递归做法)  
  2. #include <iostream>   
  3. #include <cstdlib>   
  4. #define N 4 //电话号码个数   
  5.   
  6. using   namespace  std;  
  7.   
  8. char  c[][10] = { "" , "" , "ABC" , "DEF" , "GHI" , "JKL" , "MNO" , "PQRS" , "TUV" , "WXYZ" }; //存储各个数字所能代表的字符   
  9. int  number[N] = {2, 4 ,7, 9};  //存储电话号码   
  10. int  total[10] = {0, 0, 3, 3, 3, 3, 3, 4, 3, 4};  //各个数组所能代表的字符总数   
  11. int  answer[N];  //数字目前所代表的字符在其所能代表的字符集中的位置,初始为0   
  12.   
  13. void  Search( int  *number,  int  n);  //非递归的办法   
  14. void  RecursiveSearch( int  *number,  int  cur,  char  *ps,  int  n);  //递归的办法
  1. int  main()  
  2. {  
  3.         //Search(number, N);   
  4.         char  ps[N+1] = {0};  
  5.         RecursiveSearch(number, 0, ps, N);  
  6.         return  0;  
  7. }  
  8.   
  9.   
  10. void  Search( int  *number,  int  n)  
  11. {  
  12.         int  i;  
  13.         while (1)  
  14.         {  
  15.                 for (i=0; i<n; ++i)  
  16.                         printf("%c" , c[number[i]][answer[i]]);  
  17.                 printf("\n" );  
  18.                 int  k = n-1;     //用k和while循环来解决扩展性问题,模拟了递归   
  19.                 while (k >= 0)  
  20.                 {  
  21.                         if (answer[k] < total[number[k]]-1)  
  22.                         {  
  23.                                 ++answer[k];  
  24.                                 break ;  
  25.                         }  
  26.                         else   
  27.                         {  
  28.                                 answer[k] = 0;  
  29.                                 --k;  
  30.                         }  
  31.                 }  
  32.                 if (k < 0)  
  33.                         break ;  
  34.         }  
  35. }  
  36.   
  37.   
  38. /*递归的解法: number为存储电话号码的数组,pos为当前处理的数字在number中的下标,初始为0 
  39. *ps为一外部数组,用于存放字母,n代表电话号码的长度(个数) 
  40. * 此递归的方法好理解,比上面非递归的办法好写易懂 
  41. * */   
  42. void  RecursiveSearch( int  *number,  int  pos,  char  *ps,  int  n)  
  43. {  
  44.         int  i;  
  45.         for (i=0; i<total[number[pos]]; ++i)  
  46.         {  
  47.                 ps[pos] = c[number[pos]][i];  
  48.                 if (pos == n-1)  
  49.                         cout<<ps<<endl;  
  50.                 else   
  51.                         RecursiveSearch(number, pos+1, ps, n);  
  52.         }  
发表于 2014-11-28 10:37:35 回复(0)
#include <iostream>
#include <cstdlib>
#define N 4 //电话号码个数

using namespace std;

char c[][10] = {"","","ABC","DEF","GHI","JKL","MNO","PQRS","TUV","WXYZ"};//存储各个数字所能代表的字符
int number[N] = {2, 4 ,7, 9}; //存储电话号码
int total[10] = {0, 0, 3, 3, 3, 3, 3, 4, 3, 4}; //各个数组所能代表的字符总数
int answer[N]; //数字目前所代表的字符在其所能代表的字符集中的位置,初始为0

void Search(int *number, int n); //非递归的办法

int main()
{
        Search(number, N);
       return 0;
}

//C++语言: 电话号码对应的英语单词(注意此题的非递归做法) 
void Search(int *number, int n)
{
        int i;
        while(1)
        {
                for(i=0; i<n; ++i)
                        printf("%c", c[number[i]][answer[i]]);
                printf("\n");
                int k = n-1;    //用k和while循环来解决扩展性问题,模拟了递归
                while(k >= 0)
                {
                        if(answer[k] < total[number[k]]-1)
                        {
                                ++answer[k];
                                break;
                        }
                        else
                        {
                                answer[k] = 0;
                                --k;
                        }
                }
                if(k < 0)
                        break;
        }
}
发表于 2014-11-26 11:51:19 回复(0)
发表于 2014-11-19 22:52:38 回复(0)
撒头像
rttrtr
发表于 2014-11-18 21:29:37 回复(0)
#define N 4 //电话号码个数  
 
using namespace std; 
 
char c[][10] = {"","","ABC","DEF","GHI","JKL","MNO","PQRS","TUV","WXYZ"};//存储各个数字所能代表的字符  
int number[N] = {2, 4 ,7, 9}; //存储电话号码  
int total[10] = {0, 0, 3, 3, 3, 3, 3, 4, 3, 4}; //各个数组所能代表的字符总数  
int answer[N]; //数字目前所代表的字符在其所能代表的字符集中的位置,初始为0  
 
void Search(int *number, int n); //非递归的办法  
void RecursiveSearch(int *number, int cur, char *ps, int n); //递归的办法 
int main() 
{ 
        //Search(number, N);  
        char ps[N+1] = {0}; 
        RecursiveSearch(number, 0, ps, N); 
        return 0; 
} 
 
 
void Search(int *number, int n) 
{ 
        int i; 
        while(1) 
        { 
                for(i=0; i= 0) 
                { 
                        if(answer[k] < total[number[k]]-1) 
                        { 
                                ++answer[k]; 
                                break; 
                        } else { 
                                answer[k] = 0; --k; 
                        } 
                } 
                if(k < 0) break; 
        } 
} /*递归的解法: number为存储电话号码的数组,pos为当前处理的数字在number中的下标,初始为0 *ps为一外部数组,用于存放字母,n代表电话号码的长度(个数) *
发表于 2014-10-25 00:26:07 回复(1)