笔试强训

已于 2023-10-23 00:21:12 修改
阅读量120 收藏
点赞数
文章标签： 算法
于 2023-09-25 11:18:58 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cefler/article/details/133268169
版权

在这里插入图片描述
在这里插入图片描述

题目录

👉🏻 Day3

字符串中找出最长的字符串

在这里插入图片描述
mycode：

#include <iostream>
#include<vector>

using namespace std;

int main() {
    vector<string> v;
    string str;
    getline(cin,str);
    for(int i =0;i<str.size();i++)
    {
        string s;
        while(isdigit(str[i]))
        {
            s.push_back(str[i++]);
        }
        v.push_back(s);
    }
    string longdigit = v[0];
    for(int i = 1;i<v.size();i++)
    {
          if(v[i].size()>longdigit.size())
          {
            longdigit = v[i];
          }
    }
    cout<<longdigit<<endl;

}

数组中出现超过一半的数字

在这里插入图片描述
mycode:

class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     *
     * @param numbers int整型vector
     * @return int整型
     */
    int MoreThanHalfNum_Solution(vector<int>& numbers) {
        //求出数组的一半长度
        int halfsize = 0;
        if (numbers.size() % 2)
            halfsize = (numbers.size() - 1) / 2;
        else
            halfsize = (numbers.size()) / 2;
        //对其排序
        sort(numbers.begin(), numbers.end());
        int maxnum;
        for (int i = 0; i < numbers.size(); i++)
        {
            int count = 1;
            while (i != numbers.size()-1 && numbers[i] == numbers[i + 1])
            {
                count++;
                i++;
            }
            if (count > halfsize)
            {
                maxnum = numbers[i - 1];
            }
        }
        return maxnum;
    }
};

👉🏻Day4

计算糖果

在这里插入图片描述
mycode:

#include <iostream>
using namespace std;

int main() {
    int num1,num2,num3,num4;
    cin>>num1>>num2>>num3>>num4;
    int A,B,C;
   //先求A，B 
    A = (num1+num3)/2;
    B = (num3-num1)/2;

    C = (num4 - num2)/2;
    
    if(A-B!=num1||B-C!=num2||A+B!=num3||B+C!=num4)
    printf("No");
    else
    printf("%d %d %d",A,B,C);
    
}

进制转换

在这里插入图片描述
mycode: 63.64%

#include <iostream>
#include <algorithm>
using namespace std;

int main() {
    int m,n;
    cin>>m>>n;
    string s;
    string tmp = "ABCDEF";
    while(m)
    {
        int rem = m%n;
        if(rem>9)
        {
            rem %=9;
            s.push_back(tmp[rem - 1]);
        }
        else
        s.push_back(rem + '0');
        m/=n;
    }
    //逆转s
    reverse(s.begin(),s.end());
    cout<<s<<endl;

}

👉🏻Day5

统计回文

在这里插入图片描述
mycode:100%

#include <iostream>
#include <algorithm>
using namespace std;

bool IsPalindromic(string s1)
{
    string s2 = s1;
    //将s2逆置后看看是否和s1相等
    reverse(s2.begin(),s2.end());
    if(s1 == s2)
    {
        return true;
    }
    else {
    return false;
    }
}
int main() {
    string s1,s2;
    int count = 0;
    getline(cin,s1);
    getline(cin,s2);
    for(int i = 0;i<=s1.size();i++)
    {
        string tmp = s1;
        tmp.insert(i, s2);
        if(IsPalindromic(tmp))
        count++;
    }
    cout<<count<<endl;
}

连续最大和

在这里插入图片描述
mycode:90%，超出时间复杂度

#include <iostream>
#include <vector>
using namespace std;

int main() {
    int n;
    int max = 0;
    vector<int> v;

    cin>>n;
    for(int i = 0;i<n;i++)
    {
        int num;
        cin>>num;
        v.push_back(num);
        max+=num;
    }
    for(int i = 0;i<n;i++)
    {
         int part_max = 0,part_sum = 0;
        for(int j = i;j<n;j++)
        {
              part_sum+=v[j];
              if(j == i)
              {
                part_max = part_sum;//先定一个最初的part_max
                continue;
              }
              if(part_sum>part_max)
                part_max = part_sum;
        }
        if(part_max>max)
         max = part_max;
    }
    cout<<max<<endl;

}

👉🏻Day6

不要二

在这里插入图片描述

思路：

在这里插入图片描述
mycode: 100%

#include <iostream>
#include <vector>
using namespace std;
int h,w;
bool PosIsLegal(int r, int c, vector<vector<int>>& vv)
{
    //判断坐标合法：1.是否被排查过2.其范围是否合理
    if (r<0 || r>=h || c<0 || c>=w|| vv[r][c] == 1)//vv[r][c] == 1判断放在后面，防止越界访问情况
        return false;
    else
        return true;
}
void JudgeAround(int r, int c, int& sum, vector<vector<int>>& vv)
{
    //判断左右
    for (int i = -2; i <= 2; i += 4)
    {
        if (PosIsLegal(r + i, c,vv))
        {
            sum--;
            vv[r + i][c] = 1;//被标记已读
        }
    }
    //判断上下
    for (int i = -2; i <= 2; i += 4)
    {
        if (PosIsLegal(r, c+i,vv))
        {
            sum--;
            vv[r][c+i] = 1;//被标记已读
        }
    }

}
int main() {
     cin>>h>>w;
     vector<int> v(w,0);
     vector<vector<int>> vv;
     for(int i = 0;i<h;i++)
     {
        vv.push_back(v);
     }
     int sum = h*w;
     for(int i = 0;i<h;i++)
     {
        for(int j = 0;j<w;j++)
        {
             //先判断是否已经排查过
             if(vv[i][j]!=1)
             {
                JudgeAround(i,j,sum,vv);
             }
        }
     }
     cout<<sum<<endl;
}

把字符串转换为整数

在这里插入图片描述
mycode: 100%

class Solution {
public:
    int StrToInt(string str) {
        //如果字符串首位既不是数字也不是+/-，则返回0
        if(str[0]!='+'&&str[0]!='-'&&!isdigit(str[0]))
         return 0;
        int len = str.size(),flag = 1;
        switch(str[0])
        {
            case '+':
             len--;
             break;
            case '-':
             len--;
             flag*=-1;
             break;
             default:
             break;
        }
        int res = 0;
        for(int i = 0;i<len;i++)
        {
            char ch = str.back();
            str.pop_back();
            if(!isdigit(ch))
               return 0;
            res+= (ch-'0')*pow(10,i);
        }
        return flag*res;
    }
};

👉🏻Day7

合法括号序列判断

在这里插入图片描述
mycode:100%

#include <stack>
class Parenthesis {
public:
    bool chkParenthesis(string A, int n) {
        //若遍历A遇到非括号字符return false
        //遇到左括号入栈，遇到右括号出栈，如果此时栈为空,return false/看看出栈的括号是否和右括号匹配，若不匹配，return false
        stack<char> st;
        for(auto ch:A)
        {
            if(ch!='('&&ch!=')')
            return false;
            if(ch == '(')
            st.push(ch);
            else
             {
                 if(st.empty()||st.top()!='(')//其实这边不用再判断st.top()!='('，因为入栈的只可能是'('
                  return false;
                  st.pop();
             }
        }
        return true;
    }
};

Fibonacci数列

在这里插入图片描述
mycode:90%

#include <iostream>
using namespace std;
int Fib(int n)
{
    if(n==0)
    return 0;
    else if(n == 1)
    return 1;
    else
     return Fib(n-1)+Fib(n-2);
}
int main() {
   int n;
   cin>>n;
   for(int i = 0;i<n;i++)
   {
      int ret = Fib(i);
      if(ret>=n)
      {
        if(ret==n)
        {
            cout<<0<<endl;
            return 0;
        }
        else 
        {
          int left = n-Fib(i-1);
          int right = ret-n;
          int minstep = left<right?left:right;
          cout<<minstep<<endl;
          return 0;
        }
      }
   }
   return 0;
}

👉🏻Day8

求最小公倍数

在这里插入图片描述
mycode：c++:100%

#include <iostream>
using namespace std;

int main() {
    int a,b;
    cin>>a>>b;
    int max = std::max(a,b);
    int add = max;
    while(1)
    {
        if(max%a==0&&max%b==0)
        {
                cout<<max;
                break;
        }
        max+=add;
    }
    return 0;
}

两种排序方法

在这里插入图片描述
mycode:c++:100%

#include <iostream>
#include <vector>
#include<algorithm>
using namespace std;
bool cmp(const string& a, const string& b) {
    return a.length() < b.length();
}
int main() {
    int n;
    cin>>n;
    vector<string> v(n);
    for(int i = 0;i<n;i++)
    {
        cin>>v[i];
    }
    vector<string> tmp1 = v,tmp2 = v;
    //对tmp1进行字典序排序，对tmp2进行长度排序。而后判断
    //tmp1!=v&&tmp2==v,长度排序;tmp1==v&&tmp2!=v,字典序排序；如果tmp1==v&&tmp2==v,则既是长度排序也是字典序排序，tmp1!=v&&tmp2!=v,都不是
    sort(tmp1.begin(),tmp1.end());
    sort(tmp2.begin(),tmp2.end(),cmp);
    if(tmp1!=v&&tmp2==v)
        cout<<"lengths";
    else if(tmp1==v&&tmp2!=v)
        cout<<"lexicographically";
    else if(tmp1==v&&tmp2==v)
        cout<<"both";
    else
        cout<<"none";

}

👉🏻Day9

另类加法

在这里插入图片描述
mycode:c++:100%:

class UnusualAdd {
public:
    int addAB(int A, int B) {
        //a^a = 0,a^0=a,b^b = 0,b^0 = b
        if(!A) return B;
        if(!B) return A;
        int a = A^B;
        int b = (A&B)<<1;
        return addAB(a,b);
    }
};

走方格的方案数

在这里插入图片描述

在这里插入图片描述
mycode:c++：100%

#include <iostream>
using namespace std;
int n,m;
int sum = 0;
void func(int right,int down)
{
    if(right==n&&down==m)
    {
        sum++;
        return;
    }
    else {
      if(right<n)
      func(right+1,down);
      if(down<m)
      func(right,down+1);
    }
}
int main() {
   cin>>n>>m;
    func(0,0);
    cout<<sum<<endl;
}

👉🏻Day10

井字棋

在这里插入图片描述
mycode:c++:100%

class Board {
public:
    bool checkWon(vector<vector<int> > board) {
        //只需要遍历5个位置，左右：a[0,1],a[2,1];上下:a[1,0],a[1,2];对角线:a[1,1]
        for(int i = 0,j = 1;i<3;i+=2)
        {
            if(board[i][j]==1&&board[i][j-1]==1&&board[i][j+1]==1)
            return true;
        }
       for(int i = 1,j = 0;j<3;j+=2)
        {
            if(board[i][j]==1&&board[i-1][j]==1&&board[i+1][j]==1)
            return true;
        }
       if((board[1][1]==1&&board[0][0]==1&&board[2][2]==1)||(board[1][1]==1&&board[0][2]==1&&board[2][0]==1))
       return true;
       return false;
    }
};

密码强度等级

mycode:c++:100%

#include <iostream>
using namespace std;

int main() {
    string code;
    getline(cin,code);
    int score = 0;
    //需要4个变量作为最后的奖励评判标准，letter(判断是否有字母)，digit(是否有数字),symbol（是否有符号）,up(是否有大写字母),down(是否有小写字母)
    //需要digitcount记录数字个数，symbolcount记录符号个数，
    int letter = 0,digit = 0,symbol = 0,up = 0,down = 0;
    int digitcount = 0,symbolcount = 0;
    for(auto ch:code)
    {
        if(isupper(ch))
        {
            letter = 1;
            up = 1;
        }
        if(islower(ch))
        {
            letter = 1;
            down = 1;
        }
        if(isdigit(ch))
        {
            digit = 1;
            digitcount++;
        }
        if(!isalnum(ch))
        {
            symbol = 1;
            symbolcount++;
        }
    }
    //开始加分
    //密码长度
    if(code.size()<=4)
    score+=5;
    else if(code.size()>=5&&code.size()<=7)
    score+=10;
    else
     score+=25;
    //字母
    if(down&&up)
    score+=20;
    else if(down||up)
    score+=10;
    else
     score+=0;
     //数字
     if(digitcount==1)
     score+=10;
     else if(digitcount>1)
     score+=20;
     else
      score+=0;
      //符号
      if(symbolcount==1)
      score+=10;
      else if(symbolcount>1)
      score+=25;
      else 
      score+=0;
      //奖励
      while(true)
      {
        if(up&&down&&digit&&symbol)
        {
            score+=5;
            break;
        }
        if(letter&&digit&&symbol)
        {
            score+=3;
            break;
        }
        if(letter&&digit)
        {
            score+=2;
            break;
        }
        break;
      }
      //输出分数
      if(score>=90)
         cout<<"VERY_SECURE";
      else if(score>=80)
         cout<<"SECURE";
      else if(score>=70)
         cout<<"VERY_STRONG";
      else if(score>=60)
         cout<<"STRONG";
      else if(score>=50)
         cout<<"AVERAGE";
       else if(score>=25)
         cout<<"WEAK";
         else 
         cout<<"VERY_WEAK";

}
// 64 位输出请用 printf("%lld")

👉🏻Day11

最近公共祖先

在这里插入图片描述
mycode:c++:100%

class LCA {
public:
    int getLCA(int a, int b) {
        --a,--b;
        int parent_a = (a-1)/2;
        int parent_b = (b-1)/2;
        int ancestor_com;
        while(true)
        {
            if(parent_a==parent_b)
            break;
            //哪个parent的编号较小，先让另一个结点继续向前找parent，等一等，因为可能某个结点的父亲是另一个结点的爷爷，那个结点要找两次才能找到
            if(parent_a<parent_b)
            parent_b = (parent_b-1)/2;
            if(parent_a>parent_b)
            parent_a = (parent_a-1)/2;
        }
        ancestor_com = parent_a+1;
        return ancestor_com;
    }
};

求最大连续bit数

在这里插入图片描述
mycode:c++:100%

#include <iostream>
#include <vector>
using namespace std;

int main() {
    int num;
    cin>>num;
    vector<int> v(32);
    for(int i  = 0;i<32;i++)
    {
        int tmp = (num>>i)&1;
        if(tmp==1)
        v[i] = 1;
        else
         v[i] = 0;
    }
    int max_len = 0,len = 0;
    for(int i  = 0;i<32;i++)
    {
        if(v[i]==1)
        len++;
        else
         len = 0;
        if(len>max_len)
        max_len = len;
    }
    cout<<max_len<<endl;
}

👉🏻Day12

查找一个偶数最接近的两个素数

在这里插入图片描述
mycode：c++:100%

#include <iostream>
#include <math.h>
using namespace std;
bool IsPrime(int n)
{
    if(n>1)
    {
        for(int i = 2;i<n;i++)
        {
            if(n%i==0)
                return false;
        }
        return true;
    }
    return false;
}
int main() {
   int num;
   int mingap = 1000,input1,input2;
   cin>>num;
   for(int i = 2;i<num;i++)
   {
    int tmp1 = i,tmp2 = num-i;
    if(IsPrime(tmp1)&&IsPrime(tmp2))
    {
        int gap = fabs(tmp1-tmp2);
        if(gap<mingap)
        {
            mingap = gap;
            input1 = min(tmp1,tmp2);
            input2 = max(tmp1,tmp2);
        }
    }
   }
   cout<<input1<<endl;
   cout<<input2<<endl;
}

二进制插入

在这里插入图片描述
mycode:c++:100%

class BinInsert {
public:
    int binInsert(int n, int m, int j, int i) {
        vector<int> v(32,0);
        int sum = 0;
        for(int i = 0;i<32;i++)
        {
            int tmp = (m>>i)&1;
            if(tmp == 1)
            {
                v[i] = i;
                sum+=pow(2,v[i]+j);
            }
        }
       return n+sum;
    }
};

answer code:
在这里插入图片描述

👉🏻Day13

跳石板（动态规划）

在这里插入图片描述
解题思路：
在这里插入图片描述

  • 从编号为n的石板开始跳，假设当前n石板上有x种（即x个不包括1和本身的约数）跳向下一个石板的跳法
  • 将x个可能跳向的石板都标记为1，此为，从起始石板跳向这些石板只需1步
  • 接下来，对于这些x个石板，每个石板，仍然存在着y、z……种跳向下一个石板的跳法
  • 仍然依次对x个石板依次标记从当前石板跳向下一个石板，如果下一个石板的位置大于第一次跳的所有石板中离最初起跳位置最远的石板，则该石板被标记为2，此为，从起始石板跳向这些石板只需2步
  • 接下来的操作重复如上
  • 直到某个位置的石板下一个跳向的石板恰好是目标石板

answer code:

#include <climits>
#include <iostream>
#include <vector>
#include <limits>
#include <math.h>
using namespace std;
void get_divnum(int n,vector<int>& a)
{
    for(int i = 2;i<=sqrt(n);i++)//时间复杂度优化
    {
        if(n%i==0)
        {
            a.push_back(i);
            if(n/i!=i)
            a.push_back(n/i);
        }
    }
}
int Jump(int n,int m)
{
    vector<int> step(m+1,INT_MAX);
    //INT_MAX这里表示某些位置不可能抵达，即不管什么约数相加都抵达不了
    //我们全部先设置不可抵达，后面若有符合可抵达的，我们在可抵达处标记从起始位置到可抵达位置的步数
    step[n] = 0;//将起始位置先初始化为0 ，因为起始位置跳到当前位置是可抵达的，且为0步
    for(int i = n;i<m;i++)
    {
        if(step[i]==INT_MAX)//如果该位置不可抵达，就没有继续的必要了
        continue;
        vector<int> a;//该容器用来存储当前位置可用的约数
        get_divnum(i,a);

        //接下来查看所有可能约数加上后跳向的石板位置
        for(int j = 0; j<a.size();j++)
        {
            if(a[j]+i<=m&&step[a[j]+i]!=INT_MAX)//step[a[j]+i]!=INT_MAX表示当前位置已经可以抵达了
            {
                //在已可以抵达的位置中，我们需要从中选择出可抵达到当前这个位置的最小步数
                step[a[j]+i] = step[a[j]+i]<step[i]+1?step[a[j]+i]:step[i]+1;
                //这个如何理解呢？
                //假设当前位置i的上一个位置为prev_pos
                //在当前位置i,在可选择的约数中跳向下一个石板，假设某个下一个石板为next_pos
                //存在一种可能，prev_pos到i的步数和到prev_pos到next_pos的步数是一样的
                //所以此时，从整体来看，跳向next_pos最好选择就是从prev_pos开始跳，不从i的位置开始跳了
                //因为若从prev_pos跳到i,i又跳到next_pos又会再增加一步，不是最优解
            }
            else if(a[j]+i<=m)
            {
                //这个情况是该位置是可以抵达位置，但是还没被抵达过，所以我们就给该位置赋值一下从起始位置到可抵达位置的步数
                step[a[j]+i] = step[i]+1;
            }
        }
       
    }
     return step[m]==INT_MAX?-1:step[m];
}
int main() {
    int n,m;
    int min_step;
    cin>>n>>m;
    min_step = Jump(n,m);
    cout<<min_step<<endl;
}

参数解析

在这里插入图片描述
code：100%

#include <iostream>
#include<string>
#include <vector>
using namespace std;
void cmdLineParse(const string& s)
{
    string tmp = "";
    vector<string> v;
    bool  flag = false;//假设一开始未遇到引号
    for(int i = 0;i<s.size();i++)
    {
        if(s[i]=='"')
        {
            //如果遇到"号，则说明该"内的空格不划分字符串
            flag = !flag;//出字符串时要改回false状态
        }
        else if(s[i]==' '&&!flag)
        {
            v.push_back(tmp);
            tmp = "";
        }
        else
        {
            tmp.push_back(s[i]);
        }
    }
    //记得追加最后一个空格后面的参数
    v.push_back(tmp);
    cout<<v.size()<<endl;
    for(int i = 0;i<v.size();i++)
    cout<<v[i]<<endl;

}
int main() {
    
   string str;
   getline(cin,str);
   cmdLineParse(str);
   
}

👉🏻Day14

幸运的袋子

在这里插入图片描述
mycode:c++:20%超过空间限制

#include <iostream>
#include <vector>
#include <set>
using namespace std;
int add_sum(const vector<int>& v)
{
    int sum = 0;
    for (auto e : v)
    {
        sum += e;
    }
    return sum;
}
int mul_sum(const vector<int>& v)
{
    int sum = 1;
    for (auto e : v)
    {
        sum *= e;
    }
    return sum;
}
void getSubsets(const vector<int>& nums, int start, int count, vector<int>& subset, vector<vector<int>>& result)
{
    if (count >= 2)
    {
        result.push_back(subset);
    }

    for (int i = start; i < nums.size(); i++)
    {
        subset.push_back(nums[i]);
        getSubsets(nums, i + 1, count + 1, subset, result);
        subset.pop_back();
    }
}
int main() {
    int n;
    cin >> n;
    vector<int> v(n);
    for (int i = 0; i < n; i++)
    {
        cin >> v[i];
    }
    //移除就是看能从该袋子中组成几组数量最少为2的子集，所以一个数量n个的袋子，最多可以移除n-2个球
    //我们需要写个函数获取所有符合数量大于等于2的子集
    vector<vector<int>> vv;
    vector<int> subset;
    getSubsets(v, 0, 0, subset, vv);
    //有些子集可能元素完全相同，我们需要去重
    set<vector<int>> st(vv.begin(), vv.end());
    int count = 0;
    for (auto e : st)
    {
        int sum1 = add_sum(e);
        int sum2 = mul_sum(e);
        if (sum1 > sum2)
            count++;
    }
    cout << count << endl;

}

计算日期到天数转换

在这里插入图片描述
mycode:c++:100%

#include <iostream>
#include <vector>
using namespace std;
bool isLeapyear(int n)
{
    if(n%400==0||(n%4==0&&n%100!=0))
    return true;
    else
     return false;
}
int main() {
    int y,m,d;
    //31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31
    vector<int> mon_days = {0,31,28,31,30,31,30,31,31,30,31,30,31};
    cin>>y>>m>>d;
    if(isLeapyear(y))
    mon_days[2]++;
    int total_days = 0;
    for(int i = 1;i<m;i++)
    {
        total_days+=mon_days[i];
    }
    total_days+=d;
    cout<<total_days<<endl;
}

👉🏻Day15

查找整数的二进制数

在这里插入图片描述
mycode:c++:100%

#include <iostream>
using namespace std;
int cal_twonums(int n )
{
    int count = 0;
    for(int i = 0;i<32;i++)
    {
        int tmp = (n>>i)&1;
        if(tmp==1)
        count++;
    }
    return count;
}
int main() {
    int a;
    while (cin >> a) { // 注意 while 处理多个 case
       int count = cal_twonums(a);
       cout<<count<<endl;
    }
}

拿手套

在这里插入图片描述
code:

#include <climits>
class Gloves {
public:
    int findMinimum(int n, vector<int> left, vector<int> right) {
        //sum-min+1可以至少取出一边手套所有种（不包括0）
        int left_sum = 0,left_min = INT_MAX;
        int right_sum = 0,right_min = INT_MAX;
        int sum = 0;
        for(int i = 0;i<n;i++)
        {
            if(left[i]*right[i]==0)//一边手套为0，需要累加求和，这个情况是如果一边为0，只需要保证一边的该颜色手套拿了即可
            sum+=left[i]+right[i];
            else
             {
                left_sum+=left[i];
                left_min = left_min<left[i]?left_min:left[i];
                right_sum +=right[i];
                right_min = right_min<right[i]?right_min:right[i];
             }
        }
        return sum+min(left_sum-left_min+1,right_sum-right_min+1)+1;

    }
};

👉🏻Day16

扑克牌大小

在这里插入图片描述
mycode:94%

#include <iostream>
#include<vector>
#include <string>
using namespace std;
int s1_type[6] = {0},s2_type[6] = {0};//下标1~5分别对应1~5张牌
vector<string> com = {"3","4","5","6","7","8","9","10","J","Q","K","A","2","joker","JOKER"};
int flag = 0;//1表示大于，0表示小于
int com_index(string& s)//寻找字符串在com中的下标
{
    int pos = 0;
    for(int i = 0;i<com.size();i++)
    {
        if(com[i] == s )
        {
            return i;
        }
    }
    return -1;
}
bool Compare(vector<string>& v1,vector<string>& v2)
{
    //个子、对子比较
    if(s1_type[1]&&s2_type[1]
    ||(s1_type[2]&&s2_type[2])
    ||(s1_type[3]&&s2_type[3])||s1_type[4]&&s2_type[4]||s1_type[5]&&s2_type[5])
    {
        if(com_index(v1[0])>com_index(v2[0]))
        {
            flag = 1;
            return true;
        }
    }
   else {
     //剩下的情况要么除了不能对比，就是用炸弹和王炸和其它类型牌对比
     //如果某一个手牌为两张，且某一张为小王或大王，则该手牌为大王
     if(s1_type[2]||s2_type[2])
     {
        if(com_index(v1[0])>=13||com_index(v2[0])>=13)
        {
            if(com_index(v1[0])>=13)
            {
                flag = 1;
            }
            return true;
        }
        
     }
     //如果某个手牌为炸弹，有炸弹、炸弹；炸弹、其它
     if(s1_type[4]||s2_type[4])
     {
        if(s1_type[4]&&s2_type[4])//炸弹，炸弹
        {
            if(com_index(v1[0])>com_index(v2[0]))
        {
            flag = 1;
            return true;
        }
        }
        else {
        //炸弹，其它；谁是炸弹谁大
        if(s1_type[4])
        {
            flag = 1;
            return true;
        }
        }
     }
     //上述情况都不满足，则不能比较
     return false;
   }
    return true;
}
int main() {
    string str;
    getline(cin,str);
    //先分离两个手牌
    size_t pos = str.find("-");
    string s1(str.begin(),str.begin()+pos),s2(str.begin()+pos+1,str.end());
        string s1_tmp = s1, s2_tmp = s2;

    //判断手牌类型
    vector<string> v1,v2;
    size_t pos1 = 0,pos2 = 0;
    while((pos1=s1.find(" "))!=string::npos)
    {
        string tmp = s1.substr(0,pos1);
        v1.push_back(tmp);
        s1.erase(0,pos1+1);
    }
        v1.push_back(s1);//记得尾插

    while((pos2=s2.find(" "))!=string::npos)
    {
        string tmp = s2.substr(0,pos2);
        v2.push_back(tmp);
        s2.erase(0,pos2+1);
    }
    v2.push_back(s2);
    s1_type[v1.size()] = 1,s2_type[v2.size()] = 1;
    if(Compare(v1, v2))
    {
        if (flag)
        {
            cout << s1_tmp << endl;
        }
        else {
            cout << s2_tmp << endl;
        }
    }
    else {
    cout<<"ERROR"<<endl;
    }
    return 0;

}

完全数计算

在这里插入图片描述
mycode:100%

#include <iostream>
using namespace std;
bool IsPerfect(int n)
{
    int sum = 0;
    for(int i = 1;i<n;i++)
    {
        if(n%i==0)
        sum+=i;
    }
    return sum==n;
}
int main() {
   int n;
   cin>>n;
   int count = 0;
   for(int i = 1;i<n;i++)
   {
      if(IsPerfect(i))
      count++;
         }
    cout<<count<<endl;
}

👉🏻Day17

计算某字符出现次数

在这里插入图片描述
mycode:92%

#include <iostream>
#include <string>
using namespace std;

int main() {
    string str;
    char c;
    getline(cin,str);
    cin>>c;
    int count = 0;
    for(auto ch:str)
    {
        if(isalpha(ch))
        {
          if(ch==c||ch+32==c||ch-32==c)
        {
            count++;

        }
        }
        else {
         if(ch==c)
         count++;
        }
        
    }
    cout<<count<<endl;
}

杨辉三角的变形

在这里插入图片描述
mycode:66%

#include <iostream>
using namespace std;

int main() {
    int n;
    cin >> n;
    int arr[1000][1000] = { 0 };
    for (int i = 0; i < n; i++)
        arr[i][1] = 1;
    for (int i = 1; i < n; i++)
    {
        for (int j = 2; j <=2 * i + 2; j++)
        {
            arr[i][j] = arr[i - 1][j] + arr[i - 1][j - 1] + arr[i - 1][j -2];
        }
    }
    int pos = 0;
    //遍历第n行的数据
    for (int i = 1; i <= 2 * (n - 1)+1 ; i++)
    {
        if (arr[n - 1][i] % 2 == 0)
        {
            pos = i ;
            break;
        }
    }
    cout << pos << endl;
}
// 64 位输出请用 printf("%lld")

👉🏻Day 18

统计每个月兔子的总数

在这里插入图片描述
mycode:100%

#include <iostream>
using namespace std;
int n;
int func(int n)
{
    if(n<=2)
    return 1;
    else
     return func(n-1)+func(n-2);
}
int main() {
    //哪个月出生，过两个月给我生小兔子；起始：第一个月有一个小兔子
    cin>>n;
    cout<<func(n);

}

字符串通配符

在这里插入图片描述
mycode:

👉🏻Day19

汽水瓶

在这里插入图片描述
mycode:100%

#include <iostream>
using namespace std;
void  func(int n,int& count)
{
    if(n<3)
    {
        if(n==2)
        count++;
        return;
    }
    else
     {
        count+=(n/3);
        func(n/3+n%3,count);
     }
}
int main() {
    int n;
    while(cin>>n)
    {
        if(n==0)
        break;
        int count = 0;
        func(n,count);
       cout<<count<<endl;
    }
    return 0;
}

查找最长公共子串

在这里插入图片描述
mycode:15%

#include <iostream>
#include <vector>
#include <string>
using namespace std;

int main() {
    string s1,s2;
    vector<string> v;
    cin>>s1>>s2;
    for(int i = 0;i<s1.size();i++)
    {
        string common;
        for(int j = i+1;j<=s1.size()-1;j++)
        {
            string substr = s1.substr(i,j);
            if(s2.find(substr)!=string::npos&&substr.size()>common.size())
            common = substr;
        }
        v.push_back(common);
    }
    string maxstr = v[0];
    for(int i = 1;i<v.size();i++)
    {
        if(v[i].size()>maxstr.size())
        maxstr = v[i];
    }
    cout<<maxstr<<endl;
}
cefler
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
笔试强训48天——day4
Ll_R_lL的博客
10-17 819
输入为一行，一共4个整数，分别为A - B，B - C，A + B，B + C，用空格隔开。A,B,C三个人是好朋友,每个人手里都有一些糖果,我们不知道他们每个人手上具体有多少个糖果,但是我们知道。A - B, B - C, A + B, B + C. 这四个数值.每个字母代表每个人所拥有的糖果数.输出为一行，如果存在满足的整数A，B，C则按顺序输出A，B，C，用空格隔开，行末无空格。按位异或^：遇到1就是1，两个相同都是1或都是0，就是0。假设：数组X的起始地址为start，总共有m行，n列。
48天C++笔试强训 001
小萌新的博客
03-20 2889
讲解48天笔试强训第一天的题目
【笔试强训】Day 3
qq_42996461的博客
11-26 1323
但行好事，莫问前程
笔试强训(二)
m0_60631323的博客
09-08 270
笔试强训题目总结
笔试强训day22
weixin_58030464的博客
04-30 709
一、选择题 1、若某线性表最常用的操作是存取任一指定序号的元素和在最后进行插入和删除运算，则利用（）存储方式最节省时间。 A 顺序表 B 双链表 C 带头结点的双循环链表 D 单循环链表 他的回答： D (错误) 正确答案： A 参考答案： 数组取、尾插、尾删元素O（1） 2、下列数据结构具有记忆功能的是？ A 队列 B 循环队列 C 栈 D 顺序表 他的回答： D (错误) 正确答案： C 3、循环两列放在一维数组A[0…M-1]中，end1指向队头元素，end2指向队尾元素的后一个位置。假设队列两端均可
笔试强训(7)
weixin_61518137的博客
12-26 578
每天进步一点点，坚持迎来大改变
笔试强训day6
weixin_58030464的博客
03-28 640
文章目录一、选择题二、编程题 一、选择题 1、关于抽象类与最终类，下列说法错误的是？ A 抽象类能被继承，最终类只能被实例化。 B 抽象类和最终类都可以被声明使用 C 抽象类中可以没有抽象方法，最终类中可以没有最终方法 D 抽象类和最终类被继承时，方法可以被子类覆盖 他的回答： A (错误) 正确答案： D 参考答案： final修饰的类(就是最终类)不能被继承 2、已知表达式int m[]={0，1，2，3，4，5，6}；下面哪个表达式的值与数组下标量最大值相等？ A m. length() B m. l
笔试强训 day7
weixin_58030464的博客
03-30 948
文章目录一、选择题二、编程题 一、选择题 1、JAVA属于（ ）。 A 操作系统 B 办公软件 C 数据库系统 D 计算机语言 他的回答： D (正确) 正确答案： D 参考答案： 计算机软件主要分为系统软件与应用软件两大类。系统软件主要包括操作系统、语言处理系统、数据库管理系统和系统辅助处理程序。应用软件主要包括办公软件和多媒体处理软件。Java是一门面向对象编程语言，属于计算机语言。故正确答案为D选项。 2、类声明中，声明抽象类的关键字是 ( ) A public B abstract C final
笔试强训day05
最新发布
2301_79420799的博客
09-08 174
【代码】笔试强训day05。
笔试强训day33
weixin_58030464的博客
05-20 712
一、选择题 1、若一个用户进程通过read 系统调用读取一个磁盘文件中的数据，则下列关于此过程的叙述中，正确的是（ ）。 Ⅰ． 若该文件的数据不在内存中，则该进程进入睡眠等待状态 Ⅱ． 请求 read 系统调用会导致 CPU 从用户态切换到核心态 Ⅲ． read 系统调用的参数应包含文件的名称 A 仅Ⅰ、 Ⅱ B 仅Ⅰ、 Ⅲ C 仅Ⅱ、 Ⅲ D Ⅰ、 Ⅱ和Ⅲ 他的回答： C (错误) 正确答案：A 2、Linux文件权限一共10位长度，分成四段，第三段表示的内容是（）？ A 文件类型 B 文件所有者的权限
笔试强训day2选择题
05-10
"Java笔试强训Day2选择题知识点总结" 本节笔试强训Day2选择题主要涵盖了Java语言的基础知识点，包括继承、方法调用、变量声明、静态方法、抽象类和构造方法等。下面是对每个知识点的详细解释： 1. Java继承机制 ...
笔试强训选择题错误总结
08-25
笔试强训选择题错误总结
【nowcoder】笔试强训Day16
m0_50987960的博客
01-02 773
十道选择题以及两道编程题-扑克牌大小和完全数计算
算法练习题13——除自身以外数组的乘积（动态规划）
hello77的blogggg 祝你得偿所愿
09-04 874
给你一个整数数组nums，返回 数组answer，其中answer[i]等于nums中除nums[i]之外其余各元素的乘积。
【大数据分析与挖掘算法】matlab实现——Apriori关联规则算法
Robbi_的博客
09-04 636
四、实验结果。
树状数组记录
volcan的博客
09-06 606
树状数组（Fenwick Tree）是一种用于维护数组前缀和的数据结构，支持高效的单点更新和区间查询操作。它的查询和更新时间复杂度为Ologn，适用于需要频繁更新和查询的场景。
力扣刷题--1534. 统计好三元组【简单】
m0_75266675的博客
09-04 357
力扣刷题--1534. 统计好三元组【简单】
【算法】单词出现次数和位置统计
Hanbuhuic的博客
09-04 376
编写一个程序，用于统计一个给定单词在一段文本中出现的次数以及第一次出现的位置。如果单词在文本中出现，则输出出现次数和第一次出现的位置（位置从0开始计算）。如果单词没有出现，则输出-1。
【数据结构-二维前缀和】力扣1277. 统计全为 1 的正方形子矩阵
sjsjs11的博客
09-06 335
该题和力扣221.最大正方形类似，以某一格为右下角能形成最大正方形的边长，就是以该格为右下角的正方形数量。给你一个 m * n 的矩阵，矩阵中的元素不是 0 就是 1，请你统计并返回其中完全由 1 组成的 正方形 子矩阵的个数。正方形的总数 = 10 + 4 + 1 = 15.正方形的总数 = 6 + 1 = 7.边长为 1 的正方形有 10 个。边长为 2 的正方形有 4 个。边长为 3 的正方形有 1 个。边长为 1 的正方形有 6 个。边长为 2 的正方形有 1 个。输入：matrix =
全国计算机二级笔试强化3：关键知识点解析
本资源是一份针对全国计算机二级笔试的强化训练答案，包含了选择题部分，主要涵盖软件概念、软件测试方法、面向对象编程、程序设计原则、数据结构和数据库管理等关键知识点。 1. 软件定义: - 软件是程序、数据和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值