第三届蓝桥杯C++B组国(决)赛真题

解题代码部分来自网友,如果有不对的地方,欢迎各位大佬评论

题目1、星期几

1949年的国庆节(10月1日)是星期六。

今年(2012)的国庆节是星期一。
那么,从建国到现在,有几次国庆节正好是星期日呢?

只要答案,不限手段!
可以用windows日历,windows计算器,Excel公式,。。。。。
当然,也可以编程!
不要求写出具体是哪些年,只要一个数目!
千万不要提交源代码!

答案不要写在这里,写在“解答.txt”中

9

public class Main {

    public static void main(String[] args) {
        int count = 0;
        int day = 0;
        for(int i = 1950;i <= 2012;i++) {
            if(i % 400 == 0 || (i % 4 == 0 && i % 100 != 0))
                day += 366;
            else 
                day += 365;
            if(day % 7 == 1)
                count++;
        }
        System.out.println(count);
    }
}
题目2、数据压缩
某工业监控设备不断发回采样数据。每个数据是一个整数(0到1000之间)。各个数据间用空白字符(空格,TAB或回车换行)分隔。这些数据以文本形式被存储在文件中。

    因为大多数时候,相邻的采样间隔数据是相同的,可以利用这个特征做数据的压缩存储。其方法是:对n(n>1)个连续相同的数字只记录n和该数字本身;对m(m>0)个连续不重复的数字,则记录 m*-1 和这些数字本身(之所以用负数,是为了与第一种情况区分,便于解压缩)。

    例如:采样数字:
34 34 25 25 25 25 11 15 17 28 14 22 22 22 13
    则根据上述规则变化后:
    -1 12 2 34 4 25 -5 11 15 17 28 14 3 22 -1 13

    下面的程序实现了这个功能。请仔细阅读分析代码,填写空白的部分。

void pop(int s, int* buf, int c, FILE* fp)
{
    int i;
    if(s)
    {
        fprintf(fp, "%d %d ", c, *buf);
    }
    else
    {
        fprintf(fp, "%d ", -c);
        for(i=0; i<c; i++)
        {
            fprintf(fp, "%d ", buf[i]);
        }
    }
}

void dopack(FILE* r, FILE* w)
{
    int buf[BUF_N];

    int pos = 0;  // 下一个数字在buf中将要存放的位置
    int c = 0;    // 当前段已读入的整数个数
    int pst; 
    int cst;

    while(fscanf(r, "%d", buf+pos)==1)
    {
        if(c==0)
        {
            c = pos = 1;
            continue;
        }

        if(c==1)
        {
            pst = buf[0] == buf[1];
            pos = pos + 1 - pst;
            c = 2;
            continue;
        }
        
        cst = buf[pos-1] == buf[pos];
        if(pst && !cst)
        {
            pop(pst, buf, c, w);
            buf[0] = buf[1];
            c = pos = 1;
            pst = cst;
        }
        else if(!pst && cst || pos == BUF_N-1)
        {
            pop(pst, buf, c-1, w);
            buf[0] = buf[pos-1];
            c = 2;

            if(!cst)
            {
                buf[1] = buf[pos];
                pos = 2;
            }
            else
            {
                pos = 1;
                pst = ______________;  // 填空1
            }
        }
        else
        {
            c++;
            if(!pst) pos++;
        }
    } // while

    if(c>0) _____________________________;   // 填空2
}

void main()
{
    FILE* rfp;
    FILE* wfp;

    if((rfp=fopen(RFILE, "r")) == NULL)
    {
        printf("can not open %s!\n", RFILE);
        exit(1);
    }

    if((wfp=fopen(WFILE, "w")) == NULL)
    {
        printf("can not open %s!\n", WFILE);
        fclose(rfp);
        exit(2);
    }

    dopack(rfp, wfp);

    fclose(wfp);
    fclose(rfp);
}


【注意】
    只填写缺少的部分,不要抄写已有的代码。
    所填写代码不超过1条语句(句中不会含有分号)
    所填代码长度不超过256个字符。
    答案写在“解答.txt”中,不要写在这里!
pop(pst, buf, c, w)
题目3、拼音字母 在很多软件中,输入拼音的首写字母就可以快速定位到某个词条。比如,在铁路售票软件中,输入: “bj”就可以定位到“北京”。怎样在自己的软件中实现这个功能呢?问题的关键在于:对每个汉字必须能计算出它的拼音首字母。
GB2312汉字编码方式中,一级汉字的3755个是按照拼音顺序排列的。我们可以利用这个特征,对常用汉字求拼音首字母。

GB2312编码方案对每个汉字采用两个字节表示。第一个字节为区号,第二个字节为区中的偏移号。为了能与已有的ASCII编码兼容(中西文混排),区号和偏移编号都从0xA1开始。

我们只要找到拼音a,b,c,...x,y,z 每个字母所对应的GB2312编码的第一个汉字,就可以定位所有一级汉字的拼音首字母了(不考虑多音字的情况)。下面这个表给出了前述信息。请你利用该表编写程序,求出常用汉字的拼音首字母。

a 啊 B0A1
b 芭 B0C5
c 擦 B2C1
d 搭 B4EE
e 蛾 B6EA
f 发 B7A2
g 噶 B8C1
h 哈 B9FE
j 击 BBF7
k 喀 BFA6
l 垃 C0AC
m 妈 C2E8
n 拿 C4C3
o 哦 C5B6
p 啪 C5BE
q 期 C6DA
r 然 C8BB
s 撒 C8F6
t 塌 CBFA
w 挖 CDDA
x 昔 CEF4
y 压 D1B9
z 匝 D4D1

【输入、输出格式要求】
用户先输入一个整数n (n<100),表示接下来将有n行文本。接着输入n行中文串(每个串不超过50个汉字)。

程序则输出n行,每行内容为用户输入的对应行的汉字的拼音首字母。

字母间不留空格,全部使用大写字母。
例如:
用户输入:
3
大家爱科学
北京天安门广场
软件大赛

则程序输出:
DJAKX
BJTAMGC
RJDS

【注意】

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

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

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

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

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

允许使用STL类库,但不能使用MFC或ATL等非ANSI c++标准的类库。

例如,不能使用CString类型(属于MFC类库),不能使用randomize, random函数(不属于ANSI C++标准)

import java.util.Scanner;

public class Main {
    public static String word = "啊芭擦搭蛾发噶哈击喀垃妈拿哦啪期然撒塌挖昔压匝";
    public static int[] num = new int[24];
    public static char[] result = {'A','B','C','D','E','F','G','H','J','K',
        'L','M','N','O','P','Q','R','S','T','W','X','Y','Z'};
    
     // 将一个汉字(GB2312)转换为十进制表示  
    public static int getNum(char c){  
        byte[] b = null;  
        try {  
            b = (""+c).getBytes("GB2312");  
        } catch (Exception e) {  
            e.printStackTrace();  
        }   // 汉字变为十进制(核心)  
        return (b[0]<<8&0xff00) + (b[1]&0xff);  
    }  
    
    public void getResult(String[] A) {
        for(int i = 0;i < word.length();i++)
            num[i] = getNum(word.charAt(i));
        String[] result1 = new String[A.length];
        for(int i = 0;i < A.length;i++) {
            String temp1 = "";
            for(int j = 0;j < A[i].length();j++) {
                int a = getNum(A[i].charAt(j));
                int k = 0;
                for(;k < result.length - 1;k++) {
                    if(a >= num[k] && a < num[k + 1]) {
                        temp1 = temp1 + result[k];
                        break;
                    }
                }
                if(k == result.length - 1)
                    temp1 = temp1 + "Z";
            }
            result1[i] = temp1;
        }
        for(int i = 0;i < result1.length;i++)
            System.out.println(result1[i]);
    }
    
    public static void main(String[] args) {
        Main test = new Main();
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        String[] A = new String[n];
        in.nextLine();
        for(int i = 0;i < n;i++)
            A[i] = in.nextLine();
        test.getResult(A);
    }
}
题目4、DNA对比

脱氧核糖核酸即常说的DNA,是一类带有遗传信息的生物大分子。它由4种主要的脱氧核苷酸(dAMP、dGMP、dCMT和dTMP)通过磷酸二酯键连接而成。这4种核苷酸可以分别记为:A、G、C、T。
DNA携带的遗传信息可以用形如:AGGTCGACTCCA… 的串来表示。DNA在转录复制的过程中可能会发生随机的偏差,这才最终造就了生物的多样性。

为了简化问题,我们假设,DNA在复制的时候可能出现的偏差是(理论上,对每个碱基被复制时,都可能出现偏差):

1. 漏掉某个脱氧核苷酸。例如把 AGGT 复制成为:AGT

  1. 错码,例如把 AGGT 复制成了:AGCT

  2. 重码,例如把 AGGT 复制成了:AAGGT

如果某DNA串a,最少要经过 n 次出错,才能变为DNA串b,则称这两个DNA串的距离为 n。

例如:AGGTCATATTCC 与 CGGTCATATTC 的距离为 2

你的任务是:编写程序,找到两个DNA串的距离。

【输入、输出格式要求】

用户先输入整数n(n<100),表示接下来有2n行数据。

接下来输入的2n行每2行表示一组要比对的DNA。(每行数据长度<10000)

程序则输出n行,表示这n组DNA的距离。

例如:用户输入:
3
AGCTAAGGCCTT
AGCTAAGGCCT
AGCTAAGGCCTT
AGGCTAAGGCCTT
AGCTAAGGCCTT
AGCTTAAGGCTT

则程序应输出:
1
1
2

【注意】

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

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

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

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

允许使用STL类库,但不能使用MFC或ATL等非ANSI c++标准的类库。
例如,不能使用CString类型(属于MFC类库),不能使用randomize, random函数(不属于ANSI C++标准)

import java.util.Scanner;

public class Main {
    public static int n;
    public static String[] arrayA;
    
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        n = in.nextInt();
        arrayA = new String[2 * n + 1];
        in.nextLine();
        for(int i = 1;i <= n;i++) {
            arrayA[2 * i - 1] = in.nextLine();
            arrayA[2 * i] = in.nextLine();
        }
        int[] result = new int[n + 1];
        for(int i = 1;i <= n;i++) {
            String A = arrayA[2 * i - 1];
            String B = arrayA[2 * i];
            int lenA = A.length();
            int lenB = B.length();
            int[][] dp = new int[lenA + 1][lenB + 1];
            for(int k = 0;k < lenA;k++)
                dp[k][0] = k;
            for(int k = 0;k < lenB;k++)
                dp[0][k] = k;
            for(int a = 1;a <= lenA;a++) {
                for(int b = 1;b <= lenB;b++) {
                    if(A.charAt(a - 1) == B.charAt(b - 1))
                        dp[a][b] = dp[a - 1][b - 1];
                    else {
                        dp[a][b] = Math.min(dp[a - 1][b]+1, Math.min(dp[a][b-1]+1, dp[a-1][b-1]+1));
                    }
                }
            }
            result[i] = dp[lenA][lenB];
        }
        for(int i = 1;i <= n;i++)
            System.out.println(result[i]);
    }
}
题目5、方块填数 “数独”是当下炙手可热的智力游戏。一般认为它的起源是“拉丁方块”,是大数学家欧拉于1783年发明的。

如图[1.jpg]所示:6x6的小格被分为6个部分(图中用不同的颜色区分),每个部分含有6个小格(以下也称为分组)。

开始的时候,某些小格中已经填写了字母(ABCDEF之一)。需要在所有剩下的小格中补填字母。

全部填好后,必须满足如下约束:

  1. 所填字母只允许是A,B,C,D,E,F 中的某一个。

  2. 每行的6个小格中,所填写的字母不能重复。

  3. 每列的6个小格中,所填写的字母不能重复。

  4. 每个分组(参见图中不同颜色表示)包含的6个小格中,所填写的字母不能重复。
    为了表示上的方便,我们用下面的6阶方阵来表示图[1.jpg]对应的分组情况(组号为0~5):
    000011
    022013
    221113
    243333
    244455
    445555

用下面的数据表示其已有字母的填写情况:
02C
03B
05A
20D
35E
53F

很明显,第一列表示行号,第二列表示列号,第三列表示填写的字母。行号、列号都从0开始计算。

一种可行的填写方案(此题刚好答案唯一)为:

E F C B D A
A C E D F B
D A B E C F
F B D C A E
B D F A E C
C E A F B D

你的任务是:编写程序,对一般的拉丁方块问题求解,如果多解,要求找到所有解。

【输入、输出格式要求】
用户首先输入6行数据,表示拉丁方块的分组情况。
接着用户输入一个整数n (n<36), 表示接下来的数据行数

接着输入n行数据,每行表示一个预先填写的字母。

程序则输出所有可能的解(各个解间的顺序不重要)。

每个解占用7行。

即,先输出一个整数,表示该解的序号(从1开始),接着输出一个6x6的字母方阵,表示该解。

解的字母之间用空格分开。

如果找不到任何满足条件的解,则输出“无解”

例如:用户输入:
000011
022013
221113
243333
244455
445555
6
02C
03B
05A
20D
35E
53F

则程序输出:
1
E F C B D A
A C E D F B
D A B E C F
F B D C A E
B D F A E C
C E A F B D

再如,用户输入:
001111
002113
022243
022443
544433
555553
7
04B
05A
13D
14C
24E
50C
51A
则程序输出:
1
D C E F B A
E F A D C B
A B F C E D
B E D A F C
F D C B A E
C A B E D F
2
D C E F B A
E F A D C B
A D F B E C
B E C A F D
F B D C A E
C A B E D F
3
D C F E B A
A E B D C F
F D A C E B
B F E A D C
E B C F A D
C A D B F E
4
D C F E B A
B E A D C F
A D C F E B
F B E A D C
E F B C A D
C A D B F E
5
D C F E B A
E F A D C B
A B C F E D
B E D A F C
F D B C A E
C A E B D F
6
D C F E B A
E F A D C B
A B D F E C
B E C A F D
F D B C A E
C A E B D F
7
D C F E B A
E F A D C B
A D B F E C
B E C A F D
F B D C A E
C A E B D F
8
D C F E B A
F E A D C B
A D B C E F
B F E A D C
E B C F A D
C A D B F E
9
D C F E B A
F E A D C B
A F C B E D
B D E A F C
E B D C A F
C A B F D E

【注意】

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

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

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

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

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

允许使用STL类库,但不能使用MFC或ATL等非ANSI c++标准的类库。

例如,不能使用CString类型(属于MFC类库);例如,不能使用randomize, random函数(不属于ANSI C++标准)

在这里插入图片描述

import java.util.ArrayList;
import java.util.Scanner;

public class Main {
    public static int[][] map = new int[6][6];
    public static char[][] value = new char[6][6];
    public static int[][] group = new int[6][6];
    public static int[][] ring = new int[6][6];
    public static int[][] row = new int[6][6];
    public static ArrayList<String> list = new ArrayList<String>();
    
    public void init() {
        for(int i = 0;i < 6;i++) {
            for(int j = 0;j < 6;j++) {
                value[i][j] = '-';
                group[i][j] = -1;
                ring[i][j] = -1;
                row[i][j] = -1;
            }
        }
    }
    
    public boolean check(int step, int i) {
        int x = step / 6;
        int y = step % 6;
        if(group[map[x][y]][i] == -1 && ring[x][i] == -1 && row[y][i] == -1 
                && value[x][y] == '-')
            return true;
        return false;
    }
    
    public void dfs(int step) {
        if(step == 36) {
            StringBuilder temp = new StringBuilder("");
            for(int i = 0;i < 6;i++) {
                for(int j = 0;j < 6;j++) {
                    temp.append(value[i][j]);
                    if(j != 5)
                        temp.append(" ");
                }
                if(i != 5)
                    temp.append("\n");
            }
            if(!list.contains(temp.toString()))
                list.add(temp.toString());
            return;
        } else {
            
            for(int i = 0;i < 6;i++) {
                int x = step / 6;
                int y = step % 6;
                if(check(step, i)) {
                    group[map[x][y]][i] = 1;
                    ring[x][i] = 1;
                    row[y][i] = 1;
                    value[x][y] = (char) ('A' + i);
                    dfs(step + 1);
                    group[map[x][y]][i] = -1;
                    ring[x][i] = -1;
                    row[y][i] = -1;
                    value[x][y] = '-';
                } 
                if(value[x][y] != '-')
                    dfs(step + 1);
            }
        }
    }
    
    public void getResult(String[] M, String[] P) {
        init();
        for(int i = 0;i < M.length;i++)
            for(int j = 0;j < M[i].length();j++)
                map[i][j] = M[i].charAt(j) - '0';
        for(int i = 0;i < P.length;i++) {
            int x = P[i].charAt(0) - '0';
            int y = P[i].charAt(1) - '0';
            int z = P[i].charAt(2) - 'A';
            ring[x][z] = 1;
            row[y][z] = 1;
            group[map[x][y]][z] = 1;
            value[x][y] = P[i].charAt(2);
        }
        dfs(0);
        if(list.size() == 0) {
            System.out.println("无解");
            return;
        }
        for(int i = 0;i < list.size();i++) {
            System.out.println((i + 1));
            System.out.println(list.get(i));
        }
    }
    
    public static void main(String[] args) {
        Main test = new Main();
        Scanner in = new Scanner(System.in);
        String[] M = new String[6];
        for(int i = 0;i < 6;i++)
            M[i] = in.nextLine();
        int n = in.nextInt();
        in.nextLine();
        String[] P = new String[n];
        for(int i = 0;i < n;i++)
            P[i] = in.nextLine();
        test.getResult(M, P);
    }
}
posted @ 2019-07-16 21:10  南墙1  阅读(26)  评论(0编辑  收藏  举报