蓝桥杯第七届B.C组C

最新推荐文章于 2024-08-14 10:38:11 发布
最新推荐文章于 2024-08-14 10:38:11 发布
阅读量1.1k 收藏 6
点赞数 1
分类专栏： 题解 文章标签： 7.C.b.c
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/duchenlong/article/details/102859393
版权

1.煤球数目

有一堆煤球，堆成三角棱锥形。具体：
第一层放1个，
第二层3个（排列成三角形），
第三层6个（排列成三角形），
第四层10个（排列成三角形），
....
如果一共有100层，共有多少个煤球？请填表示煤球总数目的数字。
注意：你提交的应该是一个整数，不要填写任何多余的内容或说明性文字。

这个题的思路就是，煤球堆是一个三棱锥，他从第二层开始，每一层都会比上一层多当前层数个，然后累加就好了。

#include<stdio.h>

int main()
{
    int i = 0;
    int num = 0;
    int a[101] = { 0 };
    for (i = 1; i < 101; i++)
    {
        a[i] = a[i - 1] + i;
        num += a[i];
    }
    printf("%d", num);

    return 0;
}


3.凑算式

     B      DEF
A + --- + ------- = 10
     C      GHI
     
（如果显示有问题，可以参见【图1.jpg】）
     
     
这个算式中A~I代表1~9的数字，不同的字母代表不同的数字。

比如：
6+8/3+952/714 就是一种解法，
5+3/1+972/486 是另一种解法。

这个算式一共有多少种解法？注意：你提交应该是个整数，不要填写任何多余的内容或说明性文字。

凑算式，感觉这个题难点就在于，这九个数字怎样分配的问题，有两种写法，一种是递推，一种是递归。重点就是这个题要用到回溯的思想，每一次退出当前循环的话，就要把计数器回到上一循环的状态中。

递推：（感觉递推的代码有点长，就是9个for循环嵌套，而且中间还很容易出错，表示写的时候就吃过这种亏，之后百度的时候，发现有递归的代码，就是dfs）

#include<stdio.h>
#include<string.h>

int  arr[10] = { 0 };
int ans = 0;
int visit[10] = { 0 };


int judge(int* arr)
{
    double x = arr[1] + (double)arr[2] / arr[3] + (double)(arr[4] * 100 + arr[5] * 10 + arr[6]) / (arr[7] * 100 + arr[8] * 10 + arr[9]);
    if (x == 10)
    {
        return 1;
    }
    return 0;
}

int main()
{
    int a, b, c, d, e, f, g, h, i;
    for (a = 1; a <= 9; a++)
    {
        memset(arr, 0, sizeof(arr));
        arr[a] = 1;
        for (b = 1; b <= 9; b++)
        {
            memset(arr, 0, sizeof(arr));
            arr[a] = 1;
            if (arr[b] == 1)
            {
                continue;
            }
            arr[b] = 1;
            for (c = 1; c <= 9; c++)
            {
                memset(arr, 0, sizeof(arr));
                arr[a] = 1;
                arr[b] = 1;
                if (arr[c] == 1)
                {
                    continue;
                }
                arr[c] = 1;
                for (d = 1; d <= 9; d++)
                {
                    memset(arr, 0, sizeof(arr));
                    arr[a] = 1;
                    arr[b] = 1;
                    arr[c] = 1;
                    if (arr[d] == 1)
                    {
                        continue;
                    }
                    arr[d] = 1;
                    for (e = 1; e <= 9; e++)
                    {
                        memset(arr, 0, sizeof(arr));
                        arr[a] = 1;
                        arr[b] = 1;
                        arr[c] = 1;
                        arr[d] = 1;
                        if (arr[e] == 1)
                        {
                            continue;
                        }
                        arr[e] = 1;
                        for (f = 1; f <= 9; f++)
                        {
                            memset(arr, 0, sizeof(arr));
                            arr[a] = 1;
                            arr[b] = 1;
                            arr[c] = 1;
                            arr[d] = 1;
                            arr[e] = 1;
                            if (arr[f] == 1)
                            {
                                continue;
                            }
                            arr[f] = 1;
                            for (g = 1; g <= 9; g++)
                            {
                                memset(arr, 0, sizeof(arr));
                                arr[a] = 1;
                                arr[b] = 1;
                                arr[c] = 1;
                                arr[d] = 1;
                                arr[e] = 1;
                                arr[f] = 1;
                                if (arr[g] == 1)
                                {
                                    continue;
                                }
                                arr[g] = 1;
                                for (h = 1; h <= 9; h++)
                                {
                                    memset(arr, 0, sizeof(arr));
                                    arr[a] = 1;
                                    arr[b] = 1;
                                    arr[c] = 1;
                                    arr[d] = 1;
                                    arr[e] = 1;
                                    arr[f] = 1;
                                    arr[g] = 1;
                                    if (arr[h] == 1)
                                    {
                                        continue;
                                    }
                                    arr[h] = 1;
                                    for (i = 1; i <= 9; i++)
                                    {
                                        memset(arr, 0, sizeof(arr));
                                        arr[a] = 1;
                                        arr[b] = 1;
                                        arr[c] = 1;
                                        arr[d] = 1;
                                        arr[e] = 1;
                                        arr[f] = 1;
                                        arr[g] = 1;
                                        arr[h] = 1;
                                        if (arr[i] == 1)
                                        {
                                            continue;
                                        }
                                        arr[i] = 1;
                                        visit[1] = a;
                                        visit[2] = b;
                                        visit[3] = c;
                                        visit[4] = d;
                                        visit[5] = e;
                                        visit[6] = f;
                                        visit[7] = g;
                                        visit[8] = h;
                                        visit[9] = i;
                                        if (judge(visit))
                                        {
                                            ans++;
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
    printf("%d", ans);
    return 0;
}

递归：

#include<stdio.h>
#include<string.h>

int arr[10] = { 0 };
int ans = 0;
int my_arr[10] = { 0 };

void slove()
{
    double x = arr[1] + (double)arr[2] / arr[3] + (double)(arr[4] * 100 + arr[5] * 10 + arr[6]) / (arr[7] * 100 + arr[8] * 10 + arr[9]);
    if (x == 10)
    {
        ans++;
    }
}

void dfs(int index)
{
    if (index == 10)
    {
        slove();
        return;
    }
    int i = 0;
    for (i = 1; i < 10; i++)
    {
        if (!my_arr[i])
        {
            my_arr[i] = 1;
            arr[index] = i;
            dfs(index + 1);
            my_arr[i] = 0;
        }
    }
}

int main()
{
    dfs(1);
    printf("%d", ans);
    return 0;
}


5.
抽签

X星球要派出一个5人组成的观察团前往W星。
其中：
A国最多可以派出4人。
B国最多可以派出2人。
C国最多可以派出2人。
....

那么最终派往W星的观察团会有多少种国别的不同组合呢？

下面的程序解决了这个问题。
数组a[] 中既是每个国家可以派出的最多的名额。
程序执行结果为：
DEFFF
CEFFF
CDFFF
CDEFF
CCFFF
CCEFF
CCDFF
CCDEF
BEFFF
BDFFF
BDEFF
BCFFF
BCEFF
BCDFF
BCDEF
....
(以下省略，总共101行)

#include <stdio.h>
#define N 6
#define M 5
#define BUF 1024

void f(int a[], int k, int m, char b[])
{
    int i,j;
    
    if(k==N){ 
        b[M] = 0;
        if(m==0) printf("%s\n",b);
        return;
    }
    
    for(i=0; i<=a[k]; i++){
        for(j=0; j<i; j++) b[M-m+j] = k+'A';
        //______________________;  //填空位置
        f(a, k + 1, m-i, b);
    }
}
int main()
{    
    int  a[N] = {4,2,2,1,1,3};
    char b[BUF];
    f(a,0,M,b);
    return 0;
}

仔细阅读代码，填写划线部分缺少的内容。注意：不要填写任何已有内容或说明性文字。


9.交换瓶子

有N个瓶子，编号 1 ~ N，放在架子上。

比如有5个瓶子：
2 1 3 5 4

要求每次拿起2个瓶子，交换它们的位置。
经过若干次后，使得瓶子的序号为：
1 2 3 4 5

对于这么简单的情况，显然，至少需要交换2次就可以复位。

如果瓶子更多呢？你可以通过编程来解决。

输入格式为两行：
第一行: 一个正整数N（N<10000）, 表示瓶子的数目
第二行：N个正整数，用空格分开，表示瓶子目前的排列情况。

输出数据为一行一个正整数，表示至少交换多少次，才能完成排序。

例如，输入：
5
3 1 2 5 4

程序应该输出：
3

再例如，输入：
5
5 4 3 2 1

程序应该输出：
2资源约定：
峰值内存消耗 < 256M
CPU消耗  < 1000ms

     一开始看到这个题，就想的是就是给这几个瓶子排个顺序就好了，但是写完之后发现时间太长了，再读一遍题才发现，瓶子标号是1-N，。。。。。这样用一个数组进行计数，然后一个遍历，for循环每循环一次，当前位置的瓶子就是正确的标号。这里感觉还有一个要注意的点就是交换的时候，如果新建一个变量进行交换的时候，会有一点点的慢，用异或的方式，以二进制的形式进行交换好一点。

#include<stdio.h>

int ans = 0;
int arr[10010] = { 0 };
int N = 0;
int i = 0;

void Exchange(int* a, int* b)
{
    *a = *a^*b;
    *b = *a^*b;
    *a = *a^*b;
    ans++;
}

int main()
{
    scanf("%d", &N);
    for (i = 1; i <= N; i++)
    {
        scanf("%d", &arr[i]);
    }
    for (i = 1; i <= N; i++)
    {
        while (arr[i] != i)
        {
            Exchange(&arr[i], &arr[arr[i]]);
        }
    }
    printf("%d", ans);
    return 0;
}


C
1.报纸页数

X星球日报和我们地球的城市早报是一样的，
都是一些单独的纸张叠在一起而已。每张纸印有4版。

比如，某张报纸包含的4页是：5,6,11,12，
可以确定它应该是最上边的第2张报纸。

我们在太空中捡到了一张X星球的报纸，4个页码分别是：
1125,1126,1727,1728

请你计算这份报纸一共多少页（也就是最大页码,并不是用了几张纸哦）？请填写表示总页数的数字。
注意：你提交的应该是一个整数，不要填写任何多余的内容或说明性文字。

看到这个题，我蒙了，百度之后才想起来，报纸的排版就时中间四页的顺序是连起来的，然后逐渐向两边递减和递增。。。。。

#include<stdio.h>

int main()
{
    int a[4] = { 1125, 1126, 1727, 1728 };
    int page = a[3] + a[0] + 1;
    printf("%d", page);
    return 0;
}


3.平方怪圈

如果把一个正整数的每一位都平方后再求和，得到一个新的正整数。
对新产生的正整数再做同样的处理。

如此一来，你会发现，不管开始取的是什么数字，
最终如果不是落入1，就是落入同一个循环圈。

请写出这个循环圈中最大的那个数字。

请填写该最大数字。
注意：你提交的应该是一个整数，不要填写任何多余的内容或说明性文字。

一开始我就是求一个数字在循环过程中的最大数，结果突然发现数字越来越大。。。。。然后更改了一下思路，把数字没一次得到的数字都打印出来，然后暴力观察。。。。

#include<stdio.h>

int main()
{
    int i = 0;
    int a[1000] = { 0 };
    int b[1000] = { 0 };
    int n = 0;
    scanf("%d", &n);
    while (a[n] == 0 )
    {
        int sum = 0;
        int num = n;
        a[n] = 1;
        while (num)
        {
            sum += (num % 10)*(num % 10);
            num /= 10;
        }
        b[i] = sum;
        i++;
        n = sum;
    }
    int j = 0;
    for (j = 0; j < i; j++)
    {
        printf("%d ", b[j]);
    }
    printf("%d", n);
    return 0;
}


冰雹数

任意给定一个正整数N，
如果是偶数，执行： N / 2
如果是奇数，执行： N * 3 + 1

生成的新的数字再执行同样的动作，循环往复。

通过观察发现，这个数字会一会儿上升到很高，
一会儿又降落下来。
就这样起起落落的，但最终必会落到“1”
这有点像小冰雹粒子在冰雹云中翻滚增长的样子。

比如N=9
9,28,14,7,22,11,34,17,52,26,13,40,20,10,5,16,8,4,2,1
可以看到，N=9的时候，这个“小冰雹”最高冲到了52这个高度。

输入格式：
一个正整数N（N<1000000）
输出格式：
一个正整数，表示不大于N的数字，经过冰雹数变换过程中，最高冲到了多少。

例如，输入：
10
程序应该输出：
52

再例如，输入：
100
程序应该输出：
9232资源约定：
峰值内存消耗 < 256M
CPU消耗  < 1000ms

这个题有坑。。。N的意思就是从1到N，没一次冰雹变化的过程中，总体的最大值，而不是N的变化过程中的最大值。。

#include<stdio.h>
#include<string.h>

long long operation(long long number)
{
    if (number % 2 == 0)
    {
        return number / 2;
    }
    return number * 3 + 1;
}

int main()
{
        long long j = 0;
        long long max = 0;
        long N=0;
        scanf("%ld", &N);
        for (j = 1; j <= N; j++)
        {
            long long num = j;
            while (num != 1)
            {                
                num = operation(num);
                if (num > max)
                {
                    max = num;
                }
            }
        }
        printf("%lld\n", max);
    return 0;
}

 

_ 菜 -∞
关注
专栏目录
蓝桥杯单片机第7届省赛_模拟风扇控制系统
k7780的博客
08-01 1169
题目 代码 timer.c #include <timer.h> void Timer0Init(void) //1毫秒@11.0592MHz { AUXR |= 0x80; //定时器时钟1T模式 TMOD &= 0xF0; //设置定时器模式 TL0 = 0xCD; //设置定时初值 TH0 = 0xD4; //设置定时初值 TF0 = 0; //清除TF0标志 TR0 = 1; //定时器0开始计时 EA=ET0=1; } void Time
第七届蓝桥杯省赛
qiulianshaonv_wjm的博客
03-11 598
1.煤球数目：求和循环。 2.生日蜡烛：求和循环，也可以用递归。 3.凑算式：认真读题，从原始数据出发解法最简单。 4.快速排序：模板题 5.抽签：读题写答案 6.方格填数：按说应该用搜索，但是next_permutation更简单 7.剪格子：搜索 8.四平方和：思维题 9.换瓶子： 思维题 10 直接弃掉了。 1.煤球数目 有一堆煤球，堆成三角棱锥形。具体： 第一...
【蓝桥杯】第七届蓝桥杯大赛个人赛省赛（软件类）Java 大学C组 真题
最新发布
qq_46132558的博客
08-14 1082
第七届蓝桥杯大赛个人赛省赛（软件类）Java 大学C组 真题及部分解析。小明很喜欢猜谜语。最近，他被邀请参加了X星球的猜谜活动。每位选手开始的时候都被发给777个电子币。规则是：猜对了，手里的电子币数目翻倍，猜错了，扣除555个电子币, 扣完为止。小明一共猜了15条谜语。战果为：vxvxvxvxvxvxvvx其中v表示猜对了，x表示猜错了。请你计算一下，小明最后手里的电子币数目是多少。请填写表示最后电子币数目的数字。
蓝桥杯2016年第7届省赛
Zoctan's Blog
03-12 1188
结果填空 煤球数目 有一堆煤球，堆成三角棱锥形。具体： 第一层放1个， 第二层3个（排列成三角形）， 第三层6个（排列成三角形）， 第四层10个（排列成三角形）， …. 如果一共有100层，共有多少个煤球？ 171700 public class Main { public static void main(String[] args) { int...
【蓝桥杯第七届赛试题-模拟风扇控制系统】
boybs的博客
01-17 1384
【蓝桥杯第七届赛试题-模拟风扇控制系统】 内部基础学习来自小蜜蜂老师 在编程过程中看了一位大佬对逻辑的处理，记不得博主名称了 只能说yyds 有很多值得学习的地方譬如说一开始我没有想到用数组来存储三种不同的工作模式占空比和定时的时间 这样应用的真的很巧妙 至少我一开始写没有想到直接先用数组来存储 可能我就会分别赋值了。 总的来说 如果前面的基础外设写熟悉了对这个题目的编程可能不是太难，难的还是逻辑处理 慢慢来吧不断想大佬学习 学习他们巧妙的思路 然后转换成自己的，当然自己对每一套真题也要多练习几遍 掌
第十二届蓝桥杯Python组国赛试题.pdf
01-31
在Python中，字符串切片的语法是`str[start:end]`，这里的`s[-7:]`表示从倒数第七个字符开始到字符串末尾，因此正确答案是A。选项B和C会截取不完整的子串，D则是重复了B的错误。 2. Python格式化输出： 第二题涉及...
第三届蓝桥杯cc++真题.pdf
05-09
### 第三届蓝桥杯CC++真题解析 #### 知识点概述 根据提供的文件信息，第三届蓝桥杯CC++真题主要涉及以下几个方面的知识点： 1. **基础语法**：包括C/C++的基本语法、数据类型、流程控制（如循环、分支）、函数等...
第十一届蓝桥杯省赛C语言B组.docx
03-12
"蓝桥杯省赛 C 语言 B 组知识点总结" 本文总结了蓝桥杯省赛 C 语言 B 组的知识点，涵盖了程序设计、结果填空、数据结构、算法设计等方面。 一、程序设计 * 程序设计题目要求选手设计的程序对于给定的输入能给出...
第十五届蓝桥杯大赛软件赛省赛C++B组题目
04-13
### 第十五届蓝桥杯大赛软件赛省赛C++B组题目分析 #### 一、握手问题 **知识点概述：** 握手问题是典型的组合数学问题，主要涉及到组合计数原理的应用。此类问题通常需要理解基本的排列组合公式以及如何在特定条件...
2018省赛第九届蓝桥杯真题C(B组)
04-01
【标题】"2018省赛第九届蓝桥杯真题C(B组)"涉及到的是一个编程竞赛的真题集，主要针对C语言参赛者。蓝桥杯是全国知名的编程比赛，旨在提升大学生的计算机软件设计能力和创新思维，对参赛者的C语言基础和算法理解有较...
蓝桥杯2012~2018 省赛 国赛 A B C 组
05-29
蓝桥杯2012~2018 省赛 国赛 A B C 组 标题：乘积最大 给定N个整数A1, A2, ... AN。请你从中选出K个数，使其乘积最大。 请你求出最大的乘积，由于乘积可能超出整型范围，你只需输出乘积除以1000000009的余数。 注意，如果X<0， 我们定义X除以1000000009的余数是负(-X)除以1000000009的余数。 即：0-((0-x) % 1000000009)
2018年第九届蓝桥杯省赛C++B组和javaB组题目
04-05
2018年第九届蓝桥杯省赛C++B组和javaB组题目，c++B组的部分题解可以看我的博客：https://blog.csdn.net/zuzhiang/article/details/79825178
第七届蓝桥杯参赛经历回顾
beyond_zl的博客
05-27 3825
现在是2017年5月26日 14:14 上不了电脑，用手机写的草稿。明天是第八届蓝桥杯决赛的日子，蓝桥杯似乎越办越好了，看着广大童鞋说这一届试题比往届更暴力，有种莫名的愉悦。 去年刚刚参加了蓝桥杯，报了JavaB组，成功避开了A组和C语言组的大神们，水了个国三。。。考完就懈怠了准备期末考试去了，也没研究试题。 觉得Java组真心好办事，自带很多方便的api,如Calendar类解决了大多简单日
蓝桥杯第七届 省赛C++ B组 答案
qq_45260619的博客
01-31 233
文章目录第一题第二题第三题第四题第五题第六题第七题第八题 第一题 ans：171700（粗心，每一项应该是前缀和，算成了1~100的前缀和） 前缀和 #include <iostream> using namespace std; int main() { int s = 0; for(int i = 1; i <= 100; i++) { s += i; } cout << s; } 第二题 ans：26 一段区间的前缀和 #include <ios
蓝桥杯--2016第七届C/C++C组省赛
小胡同的诗
03-20 444
报纸页数 X星球日报和我们地球的城市早报是一样的， 都是一些单独的纸张叠在一起而已。每张纸印有4版。 比如，某张报纸包含的4页是：5,6,11,12， 可以确定它应该是最上边的第2张报纸。 我们在太空中捡到了一张X星球的报纸，4个页码分别是： 1125,1126,1727,1728 请你计算这份报纸一共多少页（也就是最大页码,并不是用了几张纸哦）？ 请填写表示总页数的数字。 注意：你提交...
2016第七届蓝桥杯省赛c/c++本科B组试题总结及解题答案
Sinhaeng_Hhjian
03-28 1177
2016第七届蓝桥杯省赛c/c++本科B组试题总结及解题答案第一题：煤球数目第i层的煤球数组为(1+n)*n/2，答案：171700第二题：生日蜡烛思路：1 2 3 4 5 6……这一个等差数列的前n项和为(1+n)*n/2设从a岁开始过生日，到了b岁一共吹熄了236根蜡烛。即为：(a+b)(b-a+1)/2=236，答案：26for(int i=1;i&lt;=100;i++)       f...
蓝桥杯第八届真题 ：兴趣小组
Xiong-er 的博客
02-12 892
点击查看：蓝桥杯历年真题 题解目录 兴趣小组 评测标准答案：20 方法： 1.开3个数组，将三个组的文件分别存储在数组中 2.以0开头的学号部分，用Crt+F 把 " 0"替换为" "; 3.嵌套for循环，得出A，B组相同的的学号个数，并将相同的学号存入数组D 4.比较C和D中相同部分，用A，B中的相同的个数减去A,B,C中相同的部分。 public cl...
蓝桥杯 第八届 Javac组第二题 兴趣小组
塑料码农的博客
02-22 613
标题：兴趣小组 为丰富同学们的业余文化生活，某高校学生会创办了3个兴趣小组 （以下称A组，B组，C组）。 每个小组的学生名单分别在【A.txt】,【B.txt】和【C.txt】中。 每个文件中存储的是学生的学号。 由于工作需要，我们现在想知道：     既参加了A组，又参加了B组，但是没有参加C组的同学一共有多少人？ 请你统计该数字并通过浏览器提交答案。 注意：答案是一个整数，不要提交任...
蓝桥杯省赛C/C++ B组：跑步训练题目详解
该资源是关于第十一届蓝桥杯软件类省赛C/C++大学B组的比赛题目，主要针对的是参赛选手在比赛中的规定和一个具体问题的实例。蓝桥杯是一项重要的大学生信息技术竞赛，C/C++大学B组的试题旨在考察选手的算法设计和编程...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值