c++刷题（33/100）笔试题1

笔试总共2小时，三道题，时间挺充裕的，但是最后只做了一道，原因在于自己很浮躁，不审题，不仔细思考。没过的两道都是稍微改一下代码就能过，但是没过就是没过，要引以为戒

题目1：

小W有一个电子时钟用于显示时间，显示的格式为HH:MM:SS，HH，MM，SS分别表示时，分，秒。其中时的范围为[‘00’,‘01’…‘23’]，分的范围为[‘00’,‘01’…‘59’]，秒的范围为[‘00’,‘01’…‘59’]。

但是有一天小W发现钟表似乎坏了，显示了一个不可能存在的时间“98:23:00”，小W希望改变最少的数字，使得电子时钟显示的时间为一个真实存在的时间，譬如“98:23:00”通过修改第一个’9’为’1’，即可成为一个真实存在的时间“18:23:00”。修改的方法可能有很多，小W想知道，在满足改变最少的数字的前提下，符合条件的字典序最小的时间是多少。其中字典序比较为用“HHMMSS”的6位字符串进行比较。

思路：一开始觉得这个题很麻烦，后面觉得想了一下只有4位要判断的，就是时位上的两个和分位上的第一个以及秒位上的第一个，剩下怎么样都不会不合法

首先第一位，只能是0~2，如果出错，那么就改成0，因为要字典序最小

然后第二位，这里我栽了跟头，也是我这道题没过的原因，就是如果第一位上不是2的话，那么第二位0~9都合法，然而是第一位2的话，第二位就只能是0~3，关键来了，如果第二位不合法，要把第二位变成0吗？因为第一位是这样做的，所以会想当然的这样想，然而这样是错的，第二位不合法可以通过修改第一位使第二位合法，将第一位修改为0的话字典序更小

后面的两位，如果大于5则改成0

#include 
#include 
using namespace std ;
int main(){
    int n ;
    cin >> n ;
    while(n--){
        string time ;
        cin >> time ;
        for(int i=0;i){
            int num = time[i] - '0' ;
            if(i==0&&num>2){
                time[i] = '0' ;
            }
            if(i==1){
                if(time[0]=='2'&&num>3){
                    time[0] = '0' ;
                }
            }
            if(i==3&&num>5){
                time[i] = '0' ;
            }
            if(i==6&&num>5){
                time[i] = '0' ;
            }
        }
        cout << time << endl ;
    }
}

第二题：

小云正在参与开发一个即时聊天工具，他负责其中的会话列表部分。

会话列表为显示为一个从上到下的多行控件，其中每一行表示一个会话，每一个会话都可以以一个唯一正整数id表示。

当用户在一个会话中发送或接收信息时，如果该会话已经在会话列表中，则会从原来的位置移到列表的最上方；如果没有在会话列表中，则在会话列表最上方插入该会话。

小云在现在要做的工作是测试，他会先把会话列表清空等待接收信息。当接收完大量来自不同会话的信息后，就输出当前的会话列表，以检查其中是否有bug。

#include 
#include 
using namespace std ;
int main(){
    vector<long> list ;
    int n, m, id ;
    long reIdx ;
    cin >> n ;
    while(n--){
        cin >> m ;
        list.clear() ;
        for(int i=0;i){
            cin >> id ;
            if(list.empty()){
                list.push_back(id) ;
            }else{
                reIdx = -1 ;
                for(int j=0;j){
                    if(list[j]==id){
                        reIdx = j ;
                    }
                }
                if(reIdx==-1){
                    list.push_back(id) ;
                    reIdx = list.size()-1;
                }
                for(int k=reIdx;k>=1;k--){
                    int temp = list[k] ;
                    list[k] = list[k-1] ;
                    list[k-1] = temp ;
                }
            }
        }
        for(int i=0;i){
            cout << list[i] << " " ;
        }
        cout << list[list.size()-1] << endl ;
    }
}

思路：这题过了，题也不难，唯一值得注意的就是我使用vector操作的，将队尾的元素塞进队首我是一个一个交换上去的，但是发现答案里有在塞id的时候判断有没有重复，如果有就删了加到队尾，最后利用reverse方法翻转vector，比我的好多了

#include 
#include 
#include 
using namespace std;
 
int main()
{
    int n,m,id;
    vectorint>> res;
    cin >> n;
    for(int i = 0;i < n;i++)
    {
        vector<int> per;
        vector<int>::iterator it;
        cin >> m;
        //输入ID号码
        for(int j = 0;j < m;j++)
        {
            cin >> id;
            it = find(per.begin(),per.end(),id);
            if(it != per.end())
            {
                per.erase(it);
            }
            per.push_back(id);
        }
        reverse(per.begin(),per.end());
        res.push_back(per);
    }
     
    for(int i = 0;i < res.size();i++)
    {
        for(int j = 0;j < res[i].size();j++)
        {
            if(j == res[i].size() - 1)
                cout << res[i][j] <<endl;
            else
                cout << res[i][j] << " ";
        }
    }
    return 0;
}

第三题：

字符迷阵是一种经典的智力游戏。玩家需要在给定的矩形的字符迷阵中寻找特定的单词。

在这题的规则中，单词是如下规定的：

1. 在字符迷阵中选取一个字符作为单词的开头；

2. 选取右方、下方、或右下45度方向作为单词的延伸方向；

3. 以开头的字符，以选定的延伸方向，把连续得到的若干字符拼接在一起，则称为一个单词。

以图1为例，如果要在其中寻找单词"WORD"，则绿色框所标示的都是合法的方案，而红色框所标示的都是不合法的方案。

现在的问题是，给出一个字符迷阵，及一个要寻找的单词，问能在字符迷阵中找到多少个该单词的合法方案。注意合法方案是可以重叠的，如图1所示的字符迷阵，其中单词"WORD"的合法方案有4种

思路：这个题看起来很吓人，而且一开始我还写的是搜索，真是蠢啊，其实仔细一想就是每个位置开始判断符合条件的三种方式有没有合法的就行了，然而到最后我还是没A，原因是在输入矩阵的时候我以为是一个字一个字输入的，其实人家的输入是每行一个字符串。

然后这个错误我一直没找到，然后就跪了。以后要仔细看题啊。

#include 
#include 
#include 
using namespace std ;
void findWord(vectorchar>> mtr,int x,int y,string target,int &cnt){
    if(target[0]!=mtr[x][y]) return ;
    int R , D ,RD ;
    R = 1 ;
    D = 1 ;
    RD = 1 ;
    for(int i=1;i){
        if((x+i)>=mtr.size()||mtr[x+i][y]!=target[i]){
            D = 0;
        }
        if((y+i)>=mtr[0].size()||mtr[x][y+i]!=target[i]){
            R = 0 ;
        }
        if((x+i)>=mtr.size()||(y+i)>=mtr[0].size()||mtr[x+i][y+i]!=target[i]){
            RD = 0 ;
        }
    }
    cnt = cnt + R + D + RD ;
}
int main(){
    int t , n , m , ans;
    string row ;
    string target ;
    cin >> t ;
    while(t--){
        cin >> m >> n ;
        vectorchar>> mtr(m,vector<char>(n)) ;
        ans = 0 ;
        for(int i=0;i){
            cin >> row ;
            for(int j=0;j){
                mtr[i][j] = row[j] ;
            }
        }
        cin >> target ;
        for(int i=0;i){
            for(int j=0;j){
                findWord(mtr,i,j,target,ans) ;
            }
        }
        cout << ans << endl ;
    }
}

初始化2维vector

vectorchar>> mtr(m,vector<char>(n)) ;

 

转载于:https://www.cnblogs.com/maskmtj/p/9401437.html