蓝桥杯 2012省赛 (1--10题)

最新推荐文章于 2022-04-17 16:02:44 发布
最新推荐文章于 2022-04-17 16:02:44 发布
阅读量626 收藏 2
点赞数
分类专栏： 蓝桥杯 技巧&&思想
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yanghui07216/article/details/50799885
版权

一、微生物增殖

假设有两种微生物 X 和 Y

X出生后每隔3分钟分裂一次（数目加倍），Y出生后每隔2分钟分裂一次（数目加倍）。 一个新出生的X，半分钟之后吃掉1个Y，并且，从此开始，每隔1分钟吃1个Y。

现在已知有新出生的 X=10, Y=89，求60分钟后Y的数目。

如果X=10，Y=90 呢？

本题的要求就是写出这两种初始条件下，60分钟后Y的数目。

题目的结果令你震惊吗？这不是简单的数字游戏！真实的生物圈有着同样脆弱的性质！也许因为你消灭的那只 Y 就是最终导致 Y 种群灭绝的最后一根稻草！

 

#include<stdio.h>
#include<string.h>
#include<algorithm>
#define INF 0x3f3f3f3f
#define ll long long
#define N 1010
using namespace std;
ll a[N];
ll b[N];
int main()
{
	int x,y,i,k;//k表示第几分钟 
	while(scanf("%d%d%d",&x,&y,&k)!=EOF)
	{
		a[0]=x;b[0]=y;
		for(i=1;i<=60;i++)
		{
			if(i%3==0)
				a[i]=a[i-1]*2;
			else
				a[i]=a[i-1];
		}
		for(i=1;i<=60;i++)
		{
			if(i%2==0)
				b[i]=(b[i-1]-a[i-1])*2;
			else
				b[i]=b[i-1]-a[i-1];
		}
		printf("%lld\n",b[k]);
	}
	return 0;
}


二、古堡算式

 

福尔摩斯到某古堡探险，看到门上写着一个奇怪的算式：

ABCDE * ? = EDCBA

他对华生说：“ABCDE应该代表不同的数字，问号也代表某个数字！”

华生：“我猜也是！”

于是，两人沉默了好久，还是没有算出合适的结果来。

请你利用计算机的优势，找到破解的答案。

把 ABCDE 所代表的数字写出来。

#include<stdio.h>
#include<string.h>
#include<algorithm>
#define INF 0x3f3f3f3f
#define ll long long
#define N 10010
using namespace std;
int s[11];
int init()
{
	int i,j;
	int a,b,c,d,e;
	for(i=10000;i<100000;i++)
	{
		int k=i;
		a=k/10000;k%=10000;
		b=k/1000;k%=1000;
		c=k/100;k%=100;
		d=k/10;k%=10;
		e=k%10;
		int m=e*10000+d*1000+c*100+b*10+a;
		if(a==b || a==c || a==d || a==e || b==c || b==d || b==e || c==d || c==e || d==e)
            continue;
        for(j=1;j<=9;j++)
        {
        	if(i*j==m)
        	{
        		printf("ABCDE=%d\n",i);
        		printf("?=%d\n",j);
        		printf("EDCBA=%d\n",m);
        	}
        }
	}
}
int main()
{
	init();
	return 0;
}


 


 
#include<stdio.h>
#include<string.h>
#include<algorithm>
#define INF 0x3f3f3f3f
#define ll long long
#define N 10010
using namespace std;
int s[11];
int init()
{
	int i,j;
	int a,b,c,d,e;
	for(i=10000;i<100000;i++)
	{
		int k=i;
		a=k/10000;k%=10000;
		b=k/1000;k%=1000;
		c=k/100;k%=100;
		d=k/10;k%=10;
		e=k%10;
		int m=e*10000+d*1000+c*100+b*10+a;
		if(a==b || a==c || a==d || a==e || b==c || b==d || b==e || c==d || c==e || d==e)
            continue;
        for(j=1;j<=9;j++)
        {
        	if(i*j==m)
        	{
        		printf("ABCDE=%d\n",i);
        		printf("?=%d\n",j);
        		printf("EDCBA=%d\n",m);
        	}
        }
	}
}
int main()
{
	init();
	return 0;
}


三、比酒量

有一群海盗（不多于20人），在船上比拼酒量。过程如下：打开一瓶酒，所有在场的人平分喝下，有几个人倒下了。再打开一瓶酒平分，又有倒下的，再次重复...... 直到开了第4瓶酒，坐着的已经所剩无几，海盗船长也在其中。当第4瓶酒平分喝下后，大家都倒下了。

等船长醒来，发现海盗船搁浅了。他在航海日志中写到：“......昨天，我正好喝了一瓶.......奉劝大家，开船不喝酒，喝酒别开船......”

请你根据这些信息，推断开始有多少人，每一轮喝下来还剩多少人。

如果有多个可能的答案，请列出所有答案，每个答案占一行。

格式是：人数,人数,...

例如,有一种可能是：20,5,4,2,0

#include<stdio.h>
#include<string.h>
#include<algorithm>
#define INF 0x3f3f3f3f
#define ll long long
#define N 10010
using namespace std;
int main()
{
	int i,j,k,l;
	for(i=1;i<=20;i++)
	{
		for(j=1;j<i;j++)
		{
			for(k=1;k<j;k++)
			{
				for(l=1;l<k;l++)
				{
					double sum=1.0/i+1.0/j+1.0/k+1.0/l;
					if(sum==1.0)
						printf("%d,%d,%d,%d,0\n",i,j,k,l);
				}
			}
		}
	}
	return 0;
}


 

四、奇怪的比赛

某电视台举办了低碳生活大奖赛。题目的计分规则相当奇怪：

每位选手需要回答10个问题（其编号为1到10），越后面越有难度。答对的，当前分数翻倍；答错了则扣掉与题号相同的分数（选手必须回答问题，不回答按错误处理）。

每位选手都有一个起步的分数为10分。

某获胜选手最终得分刚好是100分，如果不让你看比赛过程，你能推断出他（她）哪个题目答对了，哪个题目答错了吗？

如果把答对的记为1，答错的记为0，则10个题目的回答情况可以用仅含有1和0的串来表示。例如：0010110011 就是可能的情况。

你的任务是算出所有可能情况。每个答案占一行。


 
#include<stdio.h>
#include<string.h>
#include<algorithm>
#define INF 0x3f3f3f3f
#define ll long long
#define N 1010
using namespace std;
int ans[11];
int s;
void dfs(int cnt,int s)
{
	if(cnt==11&&s==100)
	{
		for(int i=1;i<=10;i++)
			printf("%d ",ans[i]);
		printf("\n");
		return ;
	}
	if(cnt>10)
		return ;
	s-=cnt;
	ans[cnt]=0;
	dfs(cnt+1,s);
	s=(s+cnt)<<1;
	ans[cnt]=1;
	dfs(cnt+1,s);
}
int main()
{
	s=10;
	dfs(1,10);
	return 0;
}


五、转方阵

对一个方阵转置，就是把原来的行号变列号，原来的列号变行号

例如，如下的方阵：

1 2 3 4

5 6 7 8

9 10 11 12

13 14 15 16

转置后变为：

1 5 9 13

2 6 10 14

3 7 11 15

4 8 12 16

但，如果是对该方阵顺时针旋转（不是转置），却是如下结果：

13 9 5 1

14 10 6 2

15 11 7 3

16 12 8 4

下面的代码实现的功能就是要把一个方阵顺时针旋转。

#include <stdio.h>

#include <malloc.h>

 

void rotate(int* x, int rank)

{

    ————————————————// 填空

    for(int i=0; i<rank * rank; i++)

    {

       ——————————————  // 填空

    }

    for(int i=0; i<rank*rank; i++)

    {

        x[i] = y[i];

    }

    free(y);

}

 

int main(int argc, char* argv[])

{

    int x[4][4] = {{1,2,3,4},{5,6,7,8},{9,10,11,12},{13,14,15,16}};

    int rank = 4;

    rotate(&x[0][0], rank);

    for(int i=0; i<rank; i++)

    {

        for(int j=0; j<rank; j++)

        {

            printf("%4d", x[i][j]);

        }

        printf("\n");

    }

    system("pause");

    return 0;

}

#include<stdio.h>
#include<string.h>
#include<algorithm>
#define INF 0x3f3f3f3f
#define ll long long
#define N 1010
using namespace std;
void rotate(int *x,int rank)
{
	int *y=(int*)malloc(rank*rank*sizeof(int));
	for(int i=0;i<rank*rank;i++)
		y[(i%rank)*rank+rank-i/rank-1]=x[i];
	for(int i=0;i<rank*rank;i++)
		x[i]=y[i];
	free(y);
}
int main()
{
	int x[4][4]={{1,2,3,4},{5,6,7,8},{9,10,11,12},{13,14,15,16}};
	int rank=4;
	rotate(&x[0][0],rank);
	for(int i=0;i<rank;i++)
	{
		for(int j=0;j<rank;j++)
		{
			printf("%4d",x[i][j]);
		}
		printf("\n");
	}
	return 0;
}


 

六、大数乘法

对于32位字长的机器，大约超过20亿，用int类型就无法表示了，我们可以选择int64类型，但无论怎样扩展，固定的整数类型总是有表达的极限！如果对超级大整数进行精确运算呢？一个简单的办法是：仅仅使用现有类型，但是把大整数的运算化解为若干小整数的运算，即所谓：“分块法”。

如图【1.jpg】表示了分块乘法的原理。可以把大数分成多段（此处为2段）小数，然后用小数的多次运算组合表示一个大数。可以根据int的承载能力规定小块的大小，比如要把int分成2段，则小块可取10000为上限值。注意，小块在进行纵向累加后，需要进行进位校正。

以下代码示意了分块乘法的原理（乘数、被乘数都分为2段）。

 

#include <stdio.h>

#include <iostream>

using namespace std;

 

void bigmul(int x, int y, int r[])

{

    int base = 10000;

    int x2 = x / base;

    int x1 = x % base;

    int y2 = y / base;

    int y1 = y % base;

 

    int n1 = x1 * y1;

    int n2 = x1 * y2;

    int n3 = x2 * y1;

    int n4 = x2 * y2;

 

    r[3] = n1 % base;

    r[2] = n1 / base + n2 % base + n3 % base;

    r[3]=n4%base+n3/base+n2/base;// 填空

    r[0] = n4 / base;

 

    r[1]+=r[2]/base; // 填空

    r[2] = r[2] % base;

    r[0] += r[1] / base;

    r[1] = r[1] % base;

}

int main(int argc, char* argv[])

{

    int x[] = {0,0,0,0};

    bigmul(87654321, 12345678, x);

    printf("%d%d%d%d\n", x[0],x[1],x[2],x[3]);

    system("pause");

    return 0;

}

#include <stdio.h>
#include <iostream>
using namespace std;

void bigmul(int x, int y, int r[])
{
    int base = 10000;
    int x2 = x / base;
    int x1 = x % base;
    int y2 = y / base;
    int y1 = y % base;

    int n1 = x1 * y1;
    int n2 = x1 * y2;
    int n3 = x2 * y1;
    int n4 = x2 * y2;

    r[3] = n1 % base;
    r[2] = n1 / base + n2 % base + n3 % base;
    r[1]=n4%base+n3/base+n2/base;// 填空
    r[0] = n4 / base;

    r[1]+=r[2]/base; // 填空
    r[2] = r[2] % base;
    r[0] += r[1] / base;
    r[1] = r[1] % base;
}
int main(int argc, char* argv[])
{
    int x[] = {0,0,0,0};
    bigmul(10011001,10011001, x);
    printf("%d%d%d%d\n", x[0],x[1],x[2],x[3]);
    system("pause");
    return 0;
}


 

七、放棋子

今有 6 x 6 的棋盘格。其中某些格子已经预先放好了棋子。现在要再放上去一些，使得：每行每列都正好有3颗棋子。我们希望推算出所有可能的放法。下面的代码就实现了这个功能。

初始数组中，“1”表示放有棋子，“0”表示空白。

#include <cstdio>

#include <iostream>

 

using namespace std;

 

int N = 0;

bool CheckStoneNum(int x[][6])

{

    for(int k=0; k<6; k++)

    {

        int NumRow = 0;

        int NumCol = 0;

        for(int i=0; i<6; i++)

        {

            if(x[k][i]) NumRow++;

            if(x[i][k]) NumCol++;

        }

        if(--------------)// 填空

            return false;

    }

    return true;

}

int GetRowStoneNum(int x[][6], int r)

{

    int sum = 0;

    for(int i=0; i<6; i++)     if(x[r][i]) sum++;

    return sum;

}

int GetColStoneNum(int x[][6], int c)

{

    int sum = 0;

    for(int i=0; i<6; i++)     if(x[i][c]) sum++;

    return sum;

}

void show(int x[][6])

{

    for(int i=0; i<6; i++)

    {

        for(int j=0; j<6; j++) printf("%2d", x[i][j]);

        printf("\n");

    }

    printf("\n");

}

void f(int x[][6], int r, int c);

void GoNext(int x[][6],  int r,  int c)

{

    if(c<6)

       -----------;   // 填空

    else

        f(x, r+1, 0);

}

void f(int x[][6], int r, int c)

{

    if(r==6)

    {

        if(CheckStoneNum(x))

        {

            N++;

            show(x);

        }

        return;

    }

    if(-------) //填空------已经放有了棋子

    {

        GoNext(x,r,c);

        return;

    }

    int rr = GetRowStoneNum(x,r);

    int cc = GetColStoneNum(x,c);

    if(cc>=3)  // 本列已满

        GoNext(x,r,c);

    else if(rr>=3)  // 本行已满

        f(x, r+1, 0);

    else

    {

        x[r][c] = 1;

        GoNext(x,r,c);

        x[r][c] = 0;

        if(!(3-rr >= 6-c || 3-cc >= 6-r))  // 本行或本列严重缺子，则本格不能空着！

            GoNext(x,r,c);

    }

}

int main(int argc, char* argv[])

{

    int x[6][6] = {

        {1,0,0,0,0,0},

        {0,0,1,0,1,0},

        {0,0,1,1,0,1},

        {0,1,0,0,1,0},

        {0,0,0,1,0,0},

        {1,0,1,0,0,1}

    };

    f(x, 0, 0);

    printf("%d\n", N);

    system("pause");

    return 0;

}

#include <cstdio>
#include <iostream>

using namespace std;

int N = 0;
bool CheckStoneNum(int x[][6])
{
    for(int k=0; k<6; k++)
    {
        int NumRow = 0;
        int NumCol = 0;
        for(int i=0; i<6; i++)
        {
            if(x[k][i]) NumRow++;
            if(x[i][k]) NumCol++;
        }
        if(NumRow!=3||NumCol!=3)// 填空
            return false;
    }
    return true;
}
int GetRowStoneNum(int x[][6], int r)
{
    int sum = 0;
    for(int i=0; i<6; i++)     if(x[r][i]) sum++;
    return sum;
}
int GetColStoneNum(int x[][6], int c)
{
    int sum = 0;
    for(int i=0; i<6; i++)     if(x[i][c]) sum++;
    return sum;
}
void show(int x[][6])
{
    for(int i=0; i<6; i++)
    {
        for(int j=0; j<6; j++) printf("%2d", x[i][j]);
        printf("\n");
    }
    printf("\n");
}
void f(int x[][6], int r, int c);
void GoNext(int x[][6],  int r,  int c)
{
    if(c<6)
       f(x,r,c+1);   // 填空
    else
        f(x, r+1, 0);
}
void f(int x[][6], int r, int c)
{
    if(r==6)
    {
        if(CheckStoneNum(x))
        {
            N++;
            show(x);
        }
        return;
    }
    if(x[r][c]) //填空------已经放有了棋子
    {
        GoNext(x,r,c);
        return;
    }
    int rr = GetRowStoneNum(x,r);
    int cc = GetColStoneNum(x,c);
    if(cc>=3)  // 本列已满
        GoNext(x,r,c);
    else if(rr>=3)  // 本行已满
        f(x, r+1, 0);
    else
    {
        x[r][c] = 1;
        GoNext(x,r,c);
        x[r][c] = 0;
        if(!(3-rr >= 6-c || 3-cc >= 6-r))  // 本行或本列严重缺子，则本格不能空着！
            GoNext(x,r,c);
    }
}
int main(int argc, char* argv[])
{
    int x[6][6] = 
	{
        {1,0,0,0,0,0},
        {0,0,1,0,1,0},
        {0,0,1,1,0,1},
        {0,1,0,0,1,0},
        {0,0,0,1,0,0},
        {1,0,1,0,0,1}
    };
    f(x, 0, 0);
    printf("%d\n", N);
    system("pause");
    return 0;
}


 

八、密码发生器

在对银行账户等重要权限设置密码的时候，我们常常遇到这样的烦恼：如果为了好记用生日吧，容易被破解，不安全；如果设置不好记的密码，又担心自己也会忘记；如果写在纸上，担心纸张被别人发现或弄丢了...

这个程序的任务就是把一串拼音字母转换为6位数字（密码）。我们可以使用任何好记的拼音串(比如名字，王喜明，就写：wangximing)作为输入，程序输出6位数字。

变换的过程如下：

第一步. 把字符串6个一组折叠起来，比如wangximing则变为：

wangxi

ming

第二步. 把所有垂直在同一个位置的字符的ascii码值相加，得出6个数字，如上面的例子，则得出：

228 202 220 206 120 105

第三步. 再把每个数字“缩位”处理：就是把每个位的数字相加，得出的数字如果不是一位数字，就再缩位，直到变成一位数字为止。例如: 228 => 2+2+8=12 => 1+2=3

上面的数字缩位后变为：344836, 这就是程序最终的输出结果！

要求程序从标准输入接收数据，在标准输出上输出结果。

输入格式为：第一行是一个整数n（<100），表示下边有多少输入行，接下来是n行字符串，就是等待变换的字符串。

输出格式为：n行变换后的6位密码。

例如，输入：

5

zhangfeng

wangximing

jiujingfazi

woaibeijingtiananmen

haohaoxuexi

则输出：

772243

344836

297332

716652

875843

注意：

请仔细调试！您的程序只有能运行出正确结果的时候才有机会得分！

在评卷时使用的输入数据与试卷中给出的实例数据可能是不同的。

请把所有函数写在同一个文件中，调试好后，存入与【考生文件夹】下对应题号的“解答.txt”中即可。

相关的工程文件不要拷入。

源代码中不能能使用诸如绘图、Win32API、中断调用、硬件操作或与操作系统相关的API。

允许使用STL类库，但不能使用MFC或ATL等非ANSI c++标准的类库。例如，不能使用CString类型（属于MFC类库）。

#include<stdio.h>
#include<string.h>
#include<algorithm>
#define N 1010
using namespace std;
char s[N];
char dp[N][7];
int a[N];
int f(int x)
{
	while(x>9)
	{
		int m=x;
		int k=0;
		while(m)
		{
			k+=(m%10);
			m/=10;
		}
		x=k;
	}
	return x;
}
int main()
{
	int t;
	int i,j,k;
	scanf("%d",&t);
	getchar();
	while(t--)
	{
		memset(dp,'\0',sizeof(dp));
		memset(a,0,sizeof(a));
		scanf("%s",s);
		getchar();
		int l=strlen(s);
		for(i=0;i<l;i++)
			dp[i/6][i%6]=s[i];
		for(j=0;j<6;j++)
		{
			for(i=0;i<=l/6;i++)
			{
				a[j]+=dp[i][j];
			}
		}
		for(i=0;i<6;i++)
		{
			printf("%d",f(a[i]));
		}
		printf("\n");
	}
	return 0;
}


 

九、夺冠概率

足球比赛具有一定程度的偶然性，弱队也有战胜强队的可能。

假设有甲、乙、丙、丁四个球队。根据他们过去比赛的成绩，得出每个队与另一个队对阵时取胜的概率表:

甲 乙 丙 丁

甲 - 0.1 0.3 0.5

乙 0.9 - 0.7 0.4

丙 0.7 0.3 - 0.2

丁 0.5 0.6 0.8 -

数据含义：甲对乙的取胜概率为0.1，丙对乙的胜率为0.3，...

现在要举行一次锦标赛。双方抽签，分两个组比，获胜的两个队再争夺冠军。（参见【1.jpg】）

请你进行10万次模拟，计算出甲队夺冠的概率。

注意：

请仔细调试！您的程序只有能运行出正确结果的时候才有机会得分！

在评卷时使用的输入数据与试卷中给出的实例数据可能是不同的。

请把所有函数写在同一个文件中，调试好后，存入与【考生文件夹】下对应题号的“解答.txt”中即可。

相关的工程文件不要拷入。

源代码中不能能使用诸如绘图、Win32API、中断调用、硬件操作或与操作系统相关的API。

允许使用STL类库，但不能使用MFC或ATL等非ANSI c++标准的类库。例如，不能使用CString类型（属于MFC类库）。

#include<stdio.h>
#include<string.h>
#include<time.h>
#include<algorithm>
using namespace std;
double dp[4][4];
int main()
{
	int i,j,k;
	memset(dp,0,sizeof(dp));
	for(i=0;i<4;i++)
	{
		for(j=0;j<4;j++)
		{
			if(i==j)
				dp[i][j]=1.0;
			else
				scanf("%lf",&dp[i][j]);
		}
	}
	double x1=dp[0][1]*(dp[2][3]*dp[0][2]+dp[3][2]*dp[0][3]);
	double x2=dp[0][2]*(dp[1][3]*dp[0][1]+dp[3][1]*dp[0][3]);
	double x3=dp[0][3]*(dp[1][2]*dp[0][1]+dp[2][1]*dp[0][2]);
	double sum=0;
	srand((int)time(NULL));//c语言中语句srand( (time(NULL) ) ; 表示设置一个随机种子，每次运行都能保证随机种子不同
	for(i=0;i<100000;i++)
	{
		k=rand()%3;//在C语言中,rand()函数可以用来产生随机数，但是这不是真正意义上的随机数，是一个伪随机数，它是根据一个数
		if(k==0)
			sum+=x1;
		else if(k==1)
			sum+=x2;
		else
			sum+=x3;
	}
	printf("%.4lf\n",sum/100000);
	return 0;
}
/*
测试数据 
0.1 0.3 0.5
0.9 0.7 0.4
0.7 0.3 0.2
0.5 0.6 0.8
*/


 

十、取球游戏

今盒子里有n个小球，A、B两人轮流从盒中取球，每个人都可以看到另一个人取了多少个，也可以看到盒中还剩下多少个，并且两人都很聪明，不会做出错误的判断。

我们约定：

每个人从盒子中取出的球的数目必须是：1，3，7或者8个。

轮到某一方取球时不能弃权！

A先取球，然后双方交替取球，直到取完。

被迫拿到最后一个球的一方为负方（输方）

请编程确定出在双方都不判断失误的情况下，对于特定的初始球数，A是否能赢？

程序运行时，从标准输入获得数据，其格式如下：

先是一个整数n(n<100)，表示接下来有n个整数。然后是n个整数，每个占一行（整数<10000），表示初始球数。

程序则输出n行，表示A的输赢情况（输为0，赢为1）。

例如，用户输入：

４

１

２

10

18

则程序应该输出：

0

1

1

0

注意：

请仔细调试！您的程序只有能运行出正确结果的时候才有机会得分！

在评卷时使用的输入数据与试卷中给出的实例数据可能是不同的。

请把所有函数写在同一个文件中，调试好后，存入与【考生文件夹】下对应题号的“解答.txt”中即可。

相关的工程文件不要拷入。

源代码中不能能使用诸如绘图、Win32API、中断调用、硬件操作或与操作系统相关的API。

允许使用STL类库，但不能使用MFC或ATL等非ANSI c++标准的类库。例如，不能使用CString类型（属于MFC类库）。


#include<stdio.h>
#include<string.h>
#include<algorithm>
#include<math.h>
#define INF 0x3f3f3f3f
#define ll long long
#define N 10010
#define M 1000000007
using namespace std;
int b[]={1,3,7,8};
int a[N];
int main()
{
	int t,i,j,k;
	memset(a,0,sizeof(a));
	for(i=1;i<=10000;i++)
	{
		if(!a[i])
		{
			for(j=0;j<4&&i+b[j]<=10000;j++)
			{
				a[i+b[j]]=1;
			}
		}
	}
	scanf("%d",&t);
	while(t--)
	{
		scanf("%d",&k);
		printf("%d\n",a[k]);
	}
	return 0;
}


 

没有能与不能只有想与不想
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
2012年第三届蓝桥杯C/C++程序设计本科B组省赛
A place to record sth.
01-26 1万+
1.微生物增殖 2.古堡算式 3.海盗比酒量 4.方阵旋转 5.大数乘法 6.放棋子 7.密码发生器
蓝桥杯嵌入式设计开发——（一）利用官方函数库建立工程
qq_43572364的博客
02-20 1017
大学的时光里没什么喜欢的课程，也就稍稍觉得嵌入式的设计很酷，很有趣。就报名参加了蓝桥杯嵌入式的比赛。不过本人很菜，很多地方都不是特别理解，不过好在不完全理解并不代表不会用。下面将贴出利用stm官方提供的库 ...
2012第三届--2017第八届 蓝桥杯省赛-C/C++真题汇总
cr496352127的博客
11-18 1484
2012第三届--2017第八届 蓝桥杯省赛-C/C++真题汇总链接：2012第三届                            本科组               高职组 2013第四届                            A组         B组         C组    2014第五届                            A组        ...
C语言第13周作业（malloc函数，动态分配数组）
Cachel Wood的博客
12-03 1726
1. 1. 2. #include <stdio.h> #include <stdlib.h> #include <string.h> char *duplicate(const char*); int main(){ printf("enter a string:"); char s[100]; gets(s); puts(duplicate(s)); return 0; } char *duplicate(const ch
每位选手需要回答10个问题（其编号为1到10），越后面越有难度。答对的，当前分数翻倍；答错了则扣掉与题号相同的分数
CTLLIN的专栏
03-26 3556
package Java2012大赛; /* * /* * 某电视台举办了低碳生活大奖赛。题目的计分规则相当奇怪： * 每位选手需要回答10个问题（其编号为1到10），越后面越有难度。答对的，当前分数翻倍；答错了则扣掉与题号相同的分数（选手必须回答问题，不回答按错误处理 * 每位选手都有一个起步的分数为10分。 * 某获胜选手最终得分刚好是100分，如果不让你看比赛过程，你能推
蓝桥杯12届省赛题
Lust_zyf的博客
04-02 593
蓝桥杯单片机赛道第十二届省赛题解析
蓝桥杯省一之路04——第十届省赛真题
weixin_58931449的博客
04-17 336
一，代码部分 1.smgshow #include "reg52.h" void Delay(int t) { while(t--); } void HC573(unsigned char channel, unsigned char dat) { P0=dat; switch(channel) { case 4: P2=(P2 & 0x1f) | 0x80;//选通Y4C,LED break; case 5: P2=(P2 & 0x1f) | 0.
第14届蓝桥杯Python省赛真题-大学B组
12-28
第14届蓝桥杯Python省赛真题-大学B组 第14届蓝桥杯Python省赛真题-大学B组 第14届蓝桥杯Python省赛真题-大学B组 第14届蓝桥杯Python省赛真题-大学B组 第14届蓝桥杯Python省赛真题-大学B组 第14届蓝桥杯Python省赛...
第14届蓝桥杯Python省赛真题-大学C组
12-28
第14届蓝桥杯Python省赛真题-大学C组 第14届蓝桥杯Python省赛真题-大学C组 第14届蓝桥杯Python省赛真题-大学C组 第14届蓝桥杯Python省赛真题-大学C组 第14届蓝桥杯Python省赛真题-大学C组 第14届蓝桥杯Python省赛...
第14届蓝桥杯Python省赛真题-大学A组
12-28
第14届蓝桥杯Python省赛真题-大学A组 第14届蓝桥杯Python省赛真题-大学A组 第14届蓝桥杯Python省赛真题-大学A组 第14届蓝桥杯Python省赛真题-大学A组 第14届蓝桥杯Python省赛真题-大学A组 第14届蓝桥杯Python省赛...
第14届蓝桥杯Python省赛真题-研究生组
01-05
第14届蓝桥杯Python省赛真题-研究生组 第14届蓝桥杯Python省赛真题-研究生组 第14届蓝桥杯Python省赛真题-研究生组 第14届蓝桥杯Python省赛真题-研究生组 第14届蓝桥杯Python省赛真题-研究生组 第14届蓝桥杯Python省...
第十五届蓝桥杯大赛软件赛决赛-CB
最新发布
06-03
### 第十五届蓝桥杯大赛软件赛决赛-C/C++B组真题解析 #### 概述 第十五届蓝桥杯大赛软件赛决赛是面向全国大学生的一项高水平编程竞赛，旨在检验参赛者的算法设计与实现能力。本次比赛针对C/C++语言的大学B组选手...
（2012蓝桥杯） 奇怪的比赛 某电视台举办了低碳生活大奖赛。题目的计分规则相当奇怪： 每位选手需要回答10个问题（其编号为1到10），越后面越有难度。
Ontheroad_的博客
11-28 3455
（校内2017java程序设计大赛、2012蓝桥杯） 某电视台举办了低碳生活大奖赛。题目的计分规则相当奇怪： 每位选手需要回答10个问题（其编号为1到10），越后面越有难度。 答对的，当前分数翻倍；答错了则扣掉与题号相同的分数（选手必须回答问题，不回答按错误处理）。 每位选手都有一个起步的分数为10分。 某获胜选手最终得分刚好是100分，如果不让你看比赛过程， 你能推断出他（她）哪个题
放旗子
shuaiby的专栏
12-08 812
原题     今有 6 x 6 的棋盘格。其中某些格子已经预先放好了棋子。现在要再放上去一些，使得：每行每列都正好有3颗棋子。我们希望推算出所有可能的放法。下面的代码就实现了这个功能。     初始数组中，“1”表示放有棋子，“0”表示空白。    int N = 0; bool CheckStoneNum(int x[][6]) {  for(int k=0; k  {
低碳生活大奖赛
LIS606的博客
09-12 406
问题描述：某电视台举办了低碳生活大奖赛。题目的计分规则相当奇怪： （1）每位选手需要回答10个问题（其编号为1到10），越后面越有难度。答对的，当前分数翻倍；答错了则扣掉与题号相同的分数（选手必须回答问题，不回答按错误处理）。  （2）每位选手都有一个起步的分数为10分。 某获胜选手最终得分刚好是100分，如果不让你看比赛过程，你能推断出他（她）哪个题目答对了，哪个题目答错了吗？
奇怪的比赛
shuaiby的专栏
12-01 861
原题  某电视台举办了低碳生活大奖赛。题目的计分规则相当奇怪：     每位选手需要回答10个问题（其编号为1到10），越后面越有难度。答对的，当前分数翻倍；答错了则扣掉与题号相同的分数（选手必须回答问题，不回答按错误处理）。     每位选手都有一个起步的分数为10分。     某获胜选手最终得分刚好是100分，如果不让你看比赛过程，你能推断出他（她）哪个题目答对了，哪个题目答错了吗？
奇怪的比赛 某电视台举办了低碳生活大奖赛。题目的计分规则相当奇怪： 每位选手需要回答10个问题（其编号为1到10），越后面越有难度。
韩世雷 程序员专栏
03-25 9560
/* 某电视台举办了低碳生活大奖赛。题目的计分规则相当奇怪： 每位选手需要回答10个问题（其编号为1到10），越后面越有难度。 答对的，当前分数翻倍；答错了则扣掉与题号相同的分数（选手必须回答问题，不回答按错误处理）。 每位选手都有一个起步的分数为10分。 某获胜选手最终得分刚好是100分，如果不让你看比赛过程， 你能推断出他（她）哪个题目答对了，哪
奇怪的比赛|2012年蓝桥杯B组题解析第四题-fishers
weixin_30600197的博客
01-30 627
(8‘)奇怪的比赛 某电视台举办了低碳生活大奖赛。题目的计分规则相当奇怪： 每位选手需要回答10个问题（其编号为1到10），越后面越有难度。答对的，当前分数翻倍；答错了则扣掉与题号相同的分数（选手必须回答问题，不回答按错误处理）。 每位选手都有一个起步的分数为10分。 某获胜选手最终得分刚好是100分，如果不让你看比赛过程，你能推断出他（她）哪个题目答对了，哪个题目答错了吗？ 如果把答对的记为1...
蓝桥杯 波动数列 （DP&滚动数组 好题）
yanghui07216的博客
03-18 2771
历届试题 波动数列   时间限制：1.0s   内存限制：256.0MB      问题描述 　　观察这个数列： 　　1 3 0 2 -1 1 -2 ... 　　这个数列中后一项总是比前一项增加2或者减少3。 　　栋栋对这种数列很好奇，他想知道长度为 n 和为 s 而且后一项总是比前一项增加a或者减少b的整数数列可能有多少种呢？ 输入格式
蓝桥杯省赛真题：程序设计与结果填空
"蓝桥杯省赛真题包括Java大学B组的竞赛题目，主要涉及程序设计和结果填空两类题型。考生需通过浏览器提交答案，程序设计题要求程序能处理不同输入数据并得到正确输出，源码主类名为Main。试题包括组队问题、不同子串...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值