华为机试题-统计字符串中的数字等信息、称砝码、迷宫问题

例1:统计字符串中的数字、字母、空格等信息

题目描述

输入一行字符，分别统计出包含英文字母、空格、数字和其它字符的个数。

    /**
     * 统计出英文字母字符的个数。
     * 
     * @param str 需要输入的字符串
     * @return 英文字母的个数
     */
    public static int getEnglishCharCount(String str)
    {
        return 0;
    }
    
    /**
     * 统计出空格字符的个数。
     * 
     * @param str 需要输入的字符串
     * @return 空格的个数
     */
    public static int getBlankCharCount(String str)
    {
        return 0;
    }
    
    /**
     * 统计出数字字符的个数。
     * 
     * @param str 需要输入的字符串
     * @return 英文字母的个数
     */
    public static int getNumberCharCount(String str)
    {
        return 0;
    }
    
    /**
     * 统计出其它字符的个数。
     * 
     * @param str 需要输入的字符串
     * @return 英文字母的个数
     */
    public static int getOtherCharCount(String str)
    {
        return 0;
    }

输入描述:

输入一行字符串，可以有空格

输出描述:

统计其中英文字符，空格字符，数字字符，其他字符的个数

示例1

输入

1qazxsw23 edcvfr45tgbn hy67uj m,ki89ol.\\/;p0-=\\][

输出

26
3
10
12

代码：

#include <iostream>
#include <string>

using namespace std;

int main(){
    string str;
    while(std::getline(cin,str)){
        int len=str.length();
        int p[4]={0};
        for(int i=0;i<len;i++){
            if((str[i]>='a'&&str[i]<='z')||(str[i]>='A'&&str[i]<='Z')){
                p[0]++;
            }
            else if(str[i]==' '){
                p[1]++;
            }
            else if(str[i]>='0'&&str[i]<='9'){
                p[2]++;
            }
            else{
                p[3]++;
            }
        }
        for(int i=0;i<4;i++){
            cout << p[i] << endl;
        }
    }
    return 0;
}

 

例2:称砝码

题目描述：

现有一组砝码，重量互不相等，分别为m1,m2,m3…mn；
每种砝码对应的数量为x1,x2,x3...xn。现在要用这些砝码去称物体的重量(放在同一侧)，问能称出多少种不同的重量。 

注： 

称重重量包括0 

方法原型：public static int fama(int n, int[] weight, int[] nums)

输入描述:

输入包含多组测试数据。

对于每组测试数据：

第一行：n --- 砝码数(范围[1,10])

第二行：m1 m2 m3 ... mn --- 每个砝码的重量(范围[1,2000])

第三行：x1 x2 x3 .... xn --- 每个砝码的数量(范围[1,6])

输出描述:

利用给定的砝码可以称出的不同的重量数

示例1

输入

2
1 2
2 1

输出

5

代码：

#include <iostream>
#include <string>
#include <vector>
#include <algorithm>

using namespace std;

int main(){
    int n;
    while(cin>>n){
        int m[10]={0};
        int x[10]={10};
        for(int i=0;i<n;i++){
            cin>>m[i];
        }
        for(int i=0;i<n;i++){
            cin>>x[i];
        }
        
        vector<int> weight;
        weight.push_back(0);   //一定要初始化
        for(int i=1;i<=x[0];i++){
            weight.push_back(i*m[0]);
        }
        for(int i=1;i<n;i++){
            int len=weight.size();
            for(int j=1;j<=x[i];j++){
                for(int k=0;k<len;k++){
                    int w=weight[k]+j*m[i];
                    if(find(weight.begin(),weight.end(),w)==weight.end()){
                        weight.push_back(w);
                    }
                }
            }
        }
        cout << weight.size() << endl;
        
    }
    return 0;
}

 

例3:迷宫问题

题目描述

定义一个二维数组N*M（其中2<=N<=10;2<=M<=10），如5 × 5数组下所示： 

int maze[5][5] = {

        0, 1, 0, 0, 0,

        0, 1, 0, 1, 0,

        0, 0, 0, 0, 0,

        0, 1, 1, 1, 0,

        0, 0, 0, 1, 0,

};

它表示一个迷宫，其中的1表示墙壁，0表示可以走的路，只能横着走或竖着走，不能斜着走，要求编程序找出从左上角到右下角的最短路线。入口点为[0,0],既第一空格是可以走的路。

Input

一个N × M的二维数组，表示一个迷宫。数据保证有唯一解,不考虑有多解的情况，即迷宫只有一条通道。

Output

左上角到右下角的最短路径，格式如样例所示。

Sample Input

0 1 0 0 0

0 1 0 1 0

0 0 0 0 0

0 1 1 1 0

0 0 0 1 0

Sample Output

(0, 0)

(1, 0)

(2, 0)

(2, 1)

(2, 2)

(2, 3)

(2, 4)

(3, 4)

(4, 4)

输入描述:

输入两个整数，分别表示二位数组的行数，列数。再输入相应的数组，其中的1表示墙壁，0表示可以走的路。数据保证有唯一解,不考虑有多解的情况，即迷宫只有一条通道。

输出描述:

左上角到右下角的最短路径，格式如样例所示。

示例1

输入

5 5
0 1 0 0 0
0 1 0 1 0
0 0 0 0 0
0 1 1 1 0
0 0 0 1 0

输出

(0,0)
(1,0)
(2,0)
(2,1)
(2,2)
(2,3)
(2,4)
(3,4)
(4,4)

代码：

#include<iostream>
#include<vector>
using namespace std;
typedef pair<int,int> loc;
int n, m; //迷宫的尺寸n*m的声明
vector<vector<int>> maze(n,vector<int>(m));//迷宫存储数组的声明
vector<loc> path;//最短路径存储向量的声明
 
void track(int x, int y) //找出从迷宫中某点loc(x,y)走到出口的最短路径，并存储到全局向量vector<loc> path中
{
    maze[x][y] = -1;//表示当前节点已走，不可再走
    path.push_back(loc(x,y));//将当前节点的位置加入到最短路径中
  
    if (x==n-1 && y==m-1) //判断是否到达终点，若到达即为第一次到达，此时path中存储的路径即为最短路径，return；终止track函数的运行
        return ;
     
    int dx[4]={1,0,-1,0},dy[4]={0,1,0,-1};//分别对应下右上左四个前进方向的行列位置变化
    for(int i=0;i<4;i++)
    {
        if(   x+dx[i]>=0 && x+dx[i]<n && y+dy[i]>=0 && y+dy[i]<m //不越界
           && maze[x+dx[i]][y+dy[i]]==0 //不碰墙且未走过
          )
            track(x+dx[i], y+dy[i]); //问题转化为找出从loc(x+dx[i], y+dy[i])走到出口的最短路径，并存储到全局向量vector<loc> path中
    }
}
 
int main()
{
    while (cin >> n >> m)
    {
        maze = vector<vector<int>>(n, vector<int>(m));
        for(int i=0;i<n;i++)
            for(int j=0;j<m;j++)
                cin>>maze[i][j];
        path.clear();//因为path为全局向量，所以还残留着上一个用例的最短路径，需清空
        track(0,0); 
        for(int i=0;i<path.size();i++)
            cout << '(' << path[i].first << ',' << path[i].second << ')' << endl;
    }
    return 0;
}