第八届蓝桥杯大赛个人赛决赛（软件类）真题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 ;

}

巴特西

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

哥德巴赫分解

标题：数字划分

标题：表达式计算

标题：小数第n位

扑克牌

最新文章

热门文章

巴特西

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

哥德巴赫分解

标题：数字划分

标题：表达式计算

标题： 小数第n位

扑克牌

最新文章

热门文章

标题：小数第n位