第八届蓝桥杯大赛个人赛决赛（软件类）真题C++

哥德巴赫分解

哥德巴赫猜想认为：不小于4的偶数都可以表示为两个素数的和。

你不需要去证明这个定理，但可以通过计算机对有限数量的偶数进行分解，验证是否可行。

实际上，一般一个偶数会有多种不同的分解方案，我们关心包含较小素数的那个方案。
对于给定数值范围，我们想知道这些包含较小素数方案中最大的素数是多少。

比如，100以内，这个数是19，它由98的分解贡献。

你需要求的是10000以内，这个数是多少？

注意，需要提交的是一个整数，不要填写任何多余的内容（比如，说明性的文字）

答案：173

 #include <bits/stdc++.h>

 /**
 @author:d g w
 */
 using namespace std;
 typedef long long LL ;

 const int maxn=1e4;

 int prime[maxn];
 int pnum;
 int hashtable[maxn]={false};
 void f(){
     for(int i=;i<maxn;i++){
         if(hashtable[i]==false){
             prime[pnum++]=i;
             for(int j=i+i;j<maxn;j+=i){
                 hashtable[j]=true;
             }
         }
     }
 }

 int main()
 {
     f();
     for(int i=;i<pnum;i++){
         cout<<prime[i]<<" ";
    }cout<<endl;
    int ans[maxn]={},re=;bool flag=true;
     for(int i=;i<=;i+=){
         for(int j=;j<=i/;j++){
             if(hashtable[j]==false&&hashtable[i-j]==false){
                 cout<<i<<"="<<j<<"+"<<i-j<<endl;
                 ans[re++]=min(j,i-j);
                 break;
             }
         }
     }
     int res=;
     for(int j=;j<re;j++){
         res=max(res,ans[j]);
     }
     cout<<res;
     system("pause");
     return ;
 }

- 比较容易出错的枚举算法，很多细节需要注意；

#include <bits/stdc++.h>

/**
@author:d g w
*/
using namespace std;
typedef long long LL ;

const int maxn=1e5;

int prime[maxn];
int pnum;
int hashtable[maxn]= {false};
void f()
{
    for(int i=; i<maxn; i++)
    {
        if(hashtable[i]==false)
        {
            prime[pnum++]=i;
            for(int j=i+i; j<maxn; j+=i)
            {
                hashtable[j]=true;
            }
        }
    }
}

int main()
{
    f();
    for(int i=; i<pnum; i++)
    {
        cout<<prime[i]<<" ";
    }
    cout<<endl;
    int ans[]= {},re=;

    for(int i=; i<=; i+=)
    {
        bool flag=true;
        for(int j=; prime[j]<; j++)//200以内就够了，可以打印出来看看规律
        {
            for(int k=j+; prime[k]<; k++)//易错点 顶峰值必须相近 要保证有最小值另一个加数必须大
            {
                if((prime[j]+prime[k])==i)
                {
                    cout<<prime[j]<<"+"<<prime[k]<<endl;
                    ans[re++]=min(prime[j],prime[k]);
                    flag=false;
                }
            }
            if(flag==false)break;
        }
    }

    int res=;
    for(int j=; j<re; j++)
    {
        res=max(res,ans[j]);
    }
    cout<<res;
    system("pause");
    return ;
}

标题：数字划分

w星球的长老交给小明一个任务：
1,2,3...16 这16个数字分为两组。
要求：
这两组数字的和相同，
并且，两组数字的平方和也相同，
并且，两组数字的立方和也相同。

请你利用计算机的强大搜索能力解决这个问题。
并提交1所在的那个分组的所有数字。

这些数字要从小到大排列，两个数字间用一个空格分开。
即类似：1 4 5 8 ... 这样的答案。

注意，只提交这一组数字，不要填写任何多余的内容。

----------------------------------------
笨笨有话说：
只要一个组的成员确定了，另一个组的成员也就确定了。枚举一个组的成员就可以了。
凭直觉，两个组的成员数目不会差太多吧。
歪歪有话说：
既然求 1 所在的那个组，那只要枚举剩余的成员就可以了。
貌似都是8个成员的可能性很大啊。

answer:1 4 5 8 9 10 15 16

 #include <bits/stdc++.h>
 /**
 @author:d g w
 */
 using namespace std;
 typedef long long LL ;

 const int maxn=1e5;

 int prime[maxn];
 int pnum;
 int hashtable[maxn]= {false};
 void f()
 {
     for(int i=; i<maxn; i++)
     {
         if(hashtable[i]==false)
         {
             prime[pnum++]=i;
             for(int j=i+i; j<maxn; j+=i)
             {
                 hashtable[j]=true;
             }
         }
     }
 }
 int a[]={,,,,,,,,,,,,,,,};
 int main()
 {   int flag=true;
     do{
         if(!flag)break;
         //1 4 5 8
         if(a[]==&&a[]==&&a[]==&&a[]==){
             int x=a[]+a[]+a[]+a[]+a[]+a[]+a[]+a[];
             int y=a[]+a[]+a[]+a[]+a[]+a[]+a[]+a[];
             if(x==y){
                 if((x*x)==(y*y)){
                     if((x*x*x)==(y*y*y)){
                         //a[0]+a[1]+[2]+a[3]+a[4]+a[5]+a[6]+a[7]
                         if(a[]<a[]&&a[]<a[]&&a[]<a[]&&a[]<a[]&&a[]<a[]&&a[]<a[]&&a[]<a[]){
                         cout<<a[]<<' '<<a[]<<' '<<a[]<<' '<<a[]<<' '<<a[]<<' '<<a[]<<' '<<a[]<<' '<<a[]<<endl;
                         flag=false;
                         }
                     }
                 }
             }
         }

     }while(next_permutation(a+,a+));
     system("pause");
     return ;
 }

标题：表达式计算

虽然我们学了许久的程序设计，但对于简单的四则混合运算式，如果让我们完全白手起家地编程来解析，还是有点棘手。

这里，我们简化一下问题，假设只有加法和乘法，并且没有括号来改变优先级。
再假设参加运算的都是正整数。

在这么多的限制条件下，表达式的解析似乎简单了许多。
下面的代码解决了这个问题。请仔细阅读源码，并填写划线部分缺少的代码。

#include <stdio.h>

int f3(const char* s, int begin, int end)
{
int sum = ;
int i;
for(i=begin; i<end; i++){
if(s[i]==' ') continue;
sum = sum *  + (s[i]-'');
}
return sum;
}

int f2(const char* s, int begin, int end)
{
int p = begin;
int pro = ;
while(){
int p0 = p;
while(p!=end && s[p]!='*') p++;
pro *= _______________________________; //填空
if(p==end) break;
p++;
}
printf("f2: pro=%d\n", pro);
return pro;
}

int f(const char* s)
{
int p = ;
int sum = ;
while(){
int p0 = p;
while(s[p]!= && s[p]!='+') p++;
sum += f2(s,p0,p);
if(s[p]==) break;
p++;
}

return sum;
}

int main()
{
int x = f("12+18+5*4*3+10");
printf("%d\n", x);
return ;
}

answer：f3(s,p0,p)

注意：只填写划线处缺少的内容，不要填写已有的代码或符号，也不要填写任何解释说明文字等。

标题： 小数第n位

我们知道，整数做除法时，有时得到有限小数，有时得到无限循环小数。
如果我们把有限小数的末尾加上无限多个0，它们就有了统一的形式。

本题的任务是：在上面的约定下，求整数除法小数点后的第n位开始的3位数。

输入：
一行三个整数：a b n，用空格分开。a是被除数，b是除数，n是所求的小数后位置（0<a,b,n<1000000000）
输出：
一行3位数字，表示：a除以b，小数后第n位开始的3位数字。

比如：
输入：
1 8 1 0.125

程序应该输出：
125

再比如：
输入：
1 8 3

程序应该输出：
500

再比如：
输入：
282866 999000 6
282866 999 6
程序应该输出：
914

资源约定：
峰值内存消耗 < 256M
CPU消耗 < 1000ms

请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。

所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。

注意: main函数需要返回0
注意: 只使用ANSI C/ANSI C++ 标准，不要调用依赖于编译环境或操作系统的特殊函数。
注意: 所有依赖的函数必须明确地在源文件中 #include <xxx>， 不能通过工程设置而省略常用头文件。

提交时，注意选择所期望的编译器类型。

----------------------------------------
笨笨有话说：
这个除法小学就会算啊，模拟手算除法的过程就可以了吧。
只是数有点大啊....
管它呢，能算多远算多远....

歪歪有话说：
如果我能确定循环节从哪里开始到哪里结束，再大的数不过就是与它取模的余数等价啊

#include <bits/stdc++.h>
/**
@author:d g w
*/
using namespace std;
typedef long long LL ;

const int maxn=1e3;

LL MOD=1e9+;
LL P=1e7+;

int main()
{
    stringstream ss;
    string str,str2;

    LL a,b,n;
    cin>>a>>b>>n;
    cout<<setprecision()<<(double)a/b<<endl;
    ss<<setprecision()<<(double)a/b;
    ss>>str;
    int j=;
    cout<<str<<endl;
    for(int i=n+;i<str.length();i++){
           str2[j++]=str[i];
    }
    if(j==){
        cout<<str2[]<<"";
    }else{
        for(int i=;i<j&&i<;i++){
            cout<<str2[i];
        }
    }
    system("pause");
    return ;
}

扑克牌

给定4张扑克牌 点数为：1~10
用+ - * / 运算，3个运算符结果正好为24

#include <bits/stdc++.h>
/**
@author:d g w
*/
using namespace std;
typedef long long LL ;

const int maxn=1e3;

LL MOD=1e9+;
LL P=1e7+;

const int N=1e5;

char rand_op(){
    int x=rand()%;
    if(x==)return '+';
    if(x==)return '-';
    if(x==)return '*';
    return '/';
}

char op(int a,int b,char opr){
    if(opr=='+')return (a+b)+'';
    if(opr=='*')return (a*b)+'';
    if(opr=='-')return (a-b)+'';
    if(a%b!=) return 'n';
    return a/b;
}

bool ji_suan(char buf[]){
      stack<char> stk;
      for(int i=;i<;i++){
          if(buf[i]=='+'||buf[i]=='-'||buf[i]=='*'||buf[i]=='/'){
                int a=stk.top()-'';stk.pop();
                int b=stk.top()-'';stk.pop();
                if(op(a,b,buf[i])=='n'){
                    return false;
                }else{
                    stk.push(op(a,b,buf[i]));
                }
          }else{
            stk.push(buf[i]);
          }
      }
    if(stk.size()== && (stk.top()-'')==)
            return true;
    return false;
}
void show(char buf[]){
    stack<char> stk;
      for(int i=;i<;i++){
          if(buf[i]=='+'||buf[i]=='-'||buf[i]=='*'||buf[i]=='/'){
                int a=stk.top()-'';stk.pop();
                int b=stk.top()-'';stk.pop();
                if(op(a,b,buf[i])=='n'){
                    //return false;
                }else{
                    stk.push('('+stk.top()+buf[i]+stk.top()+')');
                }

          }else{
            stk.push(buf[i]);
          }
      }
    cout<<stk.top();
}

void f(char str[]){
    for(int z=;z<1e4;z++){
        char buf[];
        for(int i=;i<;i++)buf[i]==str[i];
        for(int i=;i<;i++)buf[i]==rand_op();

        random_shuffle(buf,buf+);
        if(ji_suan(buf)){
            show(buf);
        }
    }

}

int main()
{
    srand((unsigned)time(NULL));
    char s[];
    while(){
        cout<<"input number 4"<<endl;
        for(int i=;i<;i++){
            cin>>s[i];
        }
        f(s);
    }
    system("pause");
    return ;
}