2015年第六届蓝桥杯省赛AB组全部编程题和部分填空题AC代码（仅不包含A组第十题灾后重建）

最新推荐文章于 2022-01-03 15:58:08 发布
最新推荐文章于 2022-01-03 15:58:08 发布
阅读量1.4k 收藏 7
点赞数 4
分类专栏： 蓝桥杯 文章标签： 算法 动态规划 DFS 图论
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/GD_ONE/article/details/108951613
版权

文章目录

方程整数解

import java.io.*;
import java.util.*;
  
public class Main
{
    private static final Class<int[]> Comparator = null;
  
    public static void main(String args[])
    {
        int res = 0;
        Scanner in = new Scanner(System.in);
        int n;
          
        
        while(in.hasNext())
        {
            int[][] arr = new int[100][3];
              
            n = in.nextInt();   
            int f = 0, cnt = 0;
            for(int c = 1; c <= n/c; c++)
            {
                for(int b = 1; b <= c; b++)
                {
                    int a = n - c*c - b*b;
                    int t = (int) Math.sqrt(a);
                    if(a >= 1 && t*t == a && a <= b*b && a <= c*c)
                    {
                        f = 1;
                        arr[cnt][0] = t;
                        arr[cnt][1] = b;
                        arr[cnt][2] = c;        
                        cnt ++;
                    }
                }
            }
            if(f != 1)
            {
                System.out.print("No Solution\n");
                continue;
            }
              
            Arrays.sort(arr, 0, cnt, new Comparator<int[]>() { // 排序
                public int compare(int[] a, int[] b) {  
                    if(a[0] != b[0])
                        return a[0] - b[0]; 
                    else if(a[1] != b[1])
                        return a[1] -b[1];
                    else if(a[2] != b[2])
                        return a[2] - b[2];
                    return 0;
                }
            });
              
            for(int i = 0; i < cnt; i++)
            {
                for(int j = 0; j < 3; j++)
                    System.out.print(arr[i][j] + " ");
                System.out.println();
            }
        }
    }
}

星系炸弹

import java.io.*;
 
public class Main{
    static BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
    static BufferedWriter out = new BufferedWriter(new OutputStreamWriter(System.out));
     
    static int[] arr = {31,28,31,30,31,30,31,31,30,31,30,31};
     
    public static int Int(String s)
    {
        return Integer.parseInt(s);
    }
    public static boolean IsLeapYear(int n)
    {
        if(n % 4 == 0 && n % 100 != 0 || n % 400 == 0)
            return true;
        else return false;
    }
     
    public static void main(String[] args) throws IOException
    {
        while(in.ready())
        {
            String[] s = in.readLine().split(" ");
            int y, m, d, t;
            y = Int(s[0]);
            m = Int(s[1]);
            d = Int(s[2]);
            t = Int(s[3]);
            if(IsLeapYear(y)) arr[1] = 29;
            while(t != 0)
            {
                 
                if(IsLeapYear(y)) arr[1] = 29;
                else arr[1] = 28;
                 
                if(t + d <= arr[m-1])
                {
                    d += t;
                    t = 0;
                }
                else
                {
                    t -= arr[m-1] - d + 1;
                    if(m < 12) m++;
                    else{
                        m = 1;
                        y ++;
                    }
                    d = 1;
                }
                //out.write(y + " " + m + " " + d + " " + t +  "\n");
            }
             
            String M = null,D = null;
            if(m <= 9)
                M = "0" + Integer.toString(m);
            else
                M = Integer.toString(m);
            if(d <= 9)
                D = "0" + Integer.toString(d);
            else
                D = Integer.toString(d);
                 
            out.write(y + "-" + M + "-" + D + "\n");
            out.flush();
        }
             
    }
}

牌型总数

import java.io.*;
import java.util.*;

public class Main
{
    static int[] arr = new int[14];
    static int ans = 0;
   
    public static void dfs(int n, int m) // 枚举每一种牌可以选择几张
    {
        if(n == 13 && m <= 13)
        {
            ans ++;
            return ;
        }	
        if(m > 13) return;
        
        for(int i = 1; i <= 4; i++)
        {
            dfs(n+i, m+1);
        }
        dfs(n, m+1);
    }
    
    public static void dfs1(int n, int m)// 枚举1~13中的组合  
    {
        if(n == 13)
        {
        	ans ++;
        	//System.out.print("\n");
//        	if(ans == 20)
//        		System.exit(0);
        	
            return ;
        }
        
        for(int i = m; i < 13; i++)
        {
        	if(arr[i] < 4)
        	{
        	//	System.out.print(i + " ");
        		arr[i] ++;
        		dfs1(n+1, i);
        		arr[i] --;
        	}
        }
    }
    
    public static void main(String args[])
    {
    	dfs(0, 0);
    	//dfs1(0, 0);
        System.out.println(ans);
    }
}

手链样式

package 蓝桥杯2015初赛;

import java.io.*;
import java.util.*;

public class T_手链样式
{
    static TreeSet<String> set = new TreeSet<String>(); 
    static char[] arr = {'a', 'b', 'c'};
    static int[] st = new int[3];
    static int res = 0;
    public static void dfs(int n, String s)
    {
        if(n == 12)
        {
             Iterator it = set.iterator();
             int f = 0;
             while(it.hasNext())
             {
                 String t = (String)it.next();
                 if(t.indexOf(s) != -1)
                 {
                     f = 1;
                     break;
                 }
             }
            
            if(f == 1) return; // 已经有存在的
            
             String ans = s + s;
             set.add(ans);
             set.add(new StringBuilder(ans).reverse().toString());  // 为了去重后面出现反转的情况 123  321
             res ++;
             return ;
        }
        
        for(int i = 0; i < 3 ; i++)
        {
            if(st[i] < i + 3)
            {
            	st[i] ++;
            	dfs(n+1, s + arr[i]);
            	st[i] --;
            }
        }
    }
    
    public static void main(String args[])
    {
       dfs(0, "");
       System.out.print(res);
    }
}

饮料换购

import java.io.*;
import java.util.Scanner;
 
public class Main {
//  static BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
    static BufferedWriter out = new BufferedWriter(new OutputStreamWriter(System.out));
    static Scanner input = new Scanner(System.in);;
    public static void main(String[] args) throws IOException
    {
        int n;
        while(input.hasNext())
        {
            n = input.nextInt();
            int res = n, num = 0;
            while(n >= 3)
            {
                res += n / 3;
                num += n % 3;
                n = n/3 + num;
                num = 0;
            }
            out.write(res + "\n");
            out.flush();
        }
    }
}

##　垒骰子

import java.util.Arrays;
import java.util.Scanner;
 
   
public class Main{
    static final int mod = 1000000000 + 7;
    public static void Int(long[][] a, long[][] b)
    {
        for(int i = 0; i < 6; i++)
        {
            Arrays.fill(b[i], 1);
            a[0][i] = 1;
        }
    }
       
    public static void mut_mul(long[][] a, long[][] b, long[][] c) // c = a*b
    {
        long[][] t = new long[6][6];
        for(int i = 0; i < 6; i++)
        {
            Arrays.fill(t[i], 0);
        }
         
        for(int i = 0; i < 6; i++)
        {
            for(int j = 0; j < 6; j++)
            {
                for(int k = 0; k < 6; k++)
                {
                    t[i][j] = (t[i][j] + (a[i][k] * b[k][j])%mod)%mod;
                }
            }
        }
         
        for(int i = 0; i < 6; i++)
        {
            c[i] = Arrays.copyOf(t[i], 6);
        }
    }
       
    public static void mut_qmi(long[][] a, long b, long[][] c) // a = a * c^b 
    {
        while(b != 0)
        {
            if((b&1) == 1)
            {
                mut_mul(a, c, a);
            }
            mut_mul(c, c, c);
            b >>= 1;
        }
 
    }
       
    public static long qmi(long a, long b) // return a^b
    {
        long res = 1;
        while(b != 0)
        {
            if((b&1) == 1)
            {
                res = (res * a) % mod;
            }
            a = (a * a) % mod;
            b >>= 1;
        }
        return res;
    }
       
    public static void main(String[] args)
    {
        long[][] a = new long[6][6];
        long[][] b = new long[6][6];
        int[] op = {0,4,5,6,1,2,3};
        Scanner in = new Scanner(System.in);
        int n, m;
        while(in.hasNext())
        {
            Int(a, b);
            n = in.nextInt();
            m = in.nextInt();
               
            while(m --> 0)
            {
                int m1,m2;
                m1 = in.nextInt();
                m2 = in.nextInt();
                // 不能直接用冲突面处理关系矩阵， 不能让第一个骰子确定朝上面， 然后让第二个骰子确定朝下面
                // 因为当骰子数大于3时， 第三个骰子势必要落在第二个骰子的上面，所以如果不确定第二个骰子朝上的面有几种可能，算出的答案就是错的
          
                b[op[m1]-1][m2-1] = 0; // 4 2        
                b[op[m2]-1][m1-1] = 0; // 5 1   
            }
 
            mut_qmi(a, n-1, b);
                  
            long res = 0;
             
            for(int i = 0; i < 6; i++) res = (res + a[0][i])%mod;
             
            res = res * qmi(4, n) % mod;
            System.out.println(res);
        }
           
    }
}

奖券数目

public class Main{
    public static void main(String args[])
    {
        int res = 0;
        for(int i = 10000; i <= 99999; i++)
        {
            int t = i, f = 0;
            while(t != 0)
            {
                int r = t%10;
                t /= 10;
                if(r == 4)
                {
                    f = 1;
                    break;
                }
            }
            if(f == 0) res ++;
        }
        System.out.print(res);
    }
}

加法变乘法

public class Main {
    public static void main(String args[]) {
        int t = 1225;
        for(int i = 1; i <= 48; i++)
        {
            for(int j = i+2; j <= 48; j++)
            {
                int n = t - (i+i+1) - (j+j+1);
                n += i*(i+1) + j*(j+1);
                if(n == 2015 && i != 10)
                    System.out.print(i+"\n");
            }
        }
    }
}

移动距离

import java.util.Scanner;
 
public class Main{
    public static int gety(int n, int w)
    {
        int y1 = 0;
        if(((n-1)/w)%2 != 0)
        {
            y1 = w - ((n-1)%w+1);
        }
        else
        {
            y1 = (n-1)%w;
        }
        return y1;
    }
     
    public static void main(String args[]) {
        Scanner in = new Scanner(System.in);
        int w, n, m;
     
        while(in.hasNext())
        {
            w = in.nextInt();
            n = in.nextInt();
            m = in.nextInt();
             
            int x1, y1, x2, y2;
            x1 = (n-1)/w;
            x2 = (m-1)/w;
            y1 = gety(n, w);
            y2 = gety(m, w);
         
             
            System.out.print(Math.abs(x1 - x2) + Math.abs(y1-y2) + "\n");
        }
         
    } 
}

生命之树

注意

  • 递归问题：”本题用java写DFS解法则会运行错误，原因是栈溢出，java中递归函数最多递归10000层 而本题中结点数最大为100000，会爆栈 C/C++用此方法则无问题
  • 数据问题：本题题干中所描述的是查找最大非空节点集S中所有点的对应整数的最大和，所以对于全为负数的数据结果不应该为0， 但是只有输出0的时候才可以过测试点。

JAVA解法：拓扑序
将DFS转化为BFS，从叶结点开始遍历，以拓扑序的方式搜索整棵树，期间不断更新最大值

import java.io.*;
import java.util.*;

class DFS  
{
    static final int N = 100005, M = N*2;
     
    int[] e = new int[M], ne = new int[M], h = new int[N], w = new int[N];
    int idx = 1;
    long res;
     
    public void add(int a, int b)
    {
        e[idx] = b; ne[idx] = h[a]; h[a] = idx++;
    }
     
    public long dfs(int u, int f)
    {
        long sum = w[u];
        for(int i = h[u]; i != 0; i = ne[i])
        {
            int j = e[i];
            if(j == f) continue;
             
            long d = dfs(j, u);
            if(d > 0)
            {
                sum += d;
            }
        }
        res = Math.max(res, sum);
        return sum;
    }
     
    public void slove()
    {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        for(int i = 1; i <= n; i++)
        {
            w[i] = in.nextInt();
        }
         
        for(int i = 0; i < n-1; i++)
        {
            int a, b;
            a = in.nextInt();
            b = in.nextInt();
            add(a, b);
            add(b, a);
        }
         
        dfs(1,-1);
         
        System.out.print(res + "\n");
    }
}
 
 
class BFS
{
    static final int N = 100005, M = N*2;
     
    int[] e = new int[M], ne = new int[M], h = new int[N], r = new int[N], st = new int[N];
    long[] w = new long[N];
    int idx = 1;
    long res = 0;
     
    Queue<Integer> q = new LinkedList<Integer>();
     
    public void add(int a, int b)
    {
        e[idx] = b; ne[idx] = h[a]; h[a] = idx++;
        r[b]++; //入度加 1
    }
     
    public void bfs()
    {
        while(!q.isEmpty())
        {
            int f = q.poll();
            st[f] = 1;
            for(int i = h[f]; i != 0; i = ne[i])
            {
                int j = e[i];
                if(st[j] == 0)
                {
                    if(w[f] > 0)
                        w[j] += w[f];
                    r[j] --;
                    if(r[j] == 0)
                    {
                        q.add(j);
                    }
                }
            }
            res = Math.max(res, w[f]);
        }
    }
     
    public void slove()
    {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
         
        for(int i = 1; i <= n; i++)
        {
            w[i] = in.nextLong();
        }
         
     
        for(int i = 0; i < n-1; i++)
        {
            int a, b;
            a = in.nextInt();
            b = in.nextInt();
         
            if(a > b)
                add(a, b);
            else
                add(b, a);
        }
         
        for(int i = 1; i <= n; i++)
        {
            if(r[i] == 0)
            {
                q.add(i);
            }
        }
         
        bfs();
        System.out.print(res + "\n");
    }
}
 
 
public class Main {
     
    public static void main(String args[]) throws Exception
    {
//      DFS dfs1 = new DFS();
//      dfs1.slove();
        BFS bfs1 = new BFS();
        bfs1.slove();
    }
}

打印大X

import java.util.Scanner;
 
public class Main{
    public static void main(String args[]) {
        Scanner in = new Scanner(System.in);
         
        while(in.hasNext())
        {
            int m = in.nextInt(); // 笔的宽度
            int n = in.nextInt(); // X的高度
            int[][] arr = new int[1005][1005];
            for(int i = 0; i < n; i++)
            {
                for(int j = i; j < i + m; j++)
                {
                    arr[i][j] = 1;
                    arr[i][n+m-j-2] = 1;
                }
            }
             
            for(int i = 0; i < n; i++)
            {
                for(int j = 0; j < n + m-1; j++)
                {
                    if(arr[i][j] == 1)
                        System.out.print("*");
                    else
                        System.out.print(".");
                }
                System.out.print("\n");
            }
        }
 
    }
}
Androids_lost_Sheep
关注
  • 4
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
2018年第九届蓝桥杯省赛C++B组和javaB组题目
04-05
2018年第九届蓝桥杯省赛C++B组和javaB组题目，c++B组的部分题解可以看我的博客：https://blog.csdn.net/zuzhiang/article/details/79825178
第四届蓝桥杯本科A组解题报告(和B组相同的题目详见B组解题报告)
focus-unchanged-thing
05-21 3344
排他平方数 639172 package JiaNan; import java.math.BigInteger; public class PaiTaPingFangShu { static int c[] = new int[7]; //存储这个六位数 static boolean vis[] = new boolean[11]; //记录0-9这10个数字是否
蓝桥杯2018初赛AB组决赛部分题目(持续更新中...)
qq_44678216的博客
10-16 375
蓝桥杯2018初赛AB组决赛部分题目(持续更新中…) 按照New Online Judge的题目先后顺序 下次一定边敲边写博客，敲完再回去找太慢了 文章目录蓝桥杯2018初赛AB组决赛部分题目(持续更新中...)[蓝桥杯2018初赛]分数题解：[蓝桥杯2018初赛]星期一题解：[蓝桥杯2018初赛]乘积尾零题解：[蓝桥杯2018初赛]第几个幸运数题解：[蓝桥杯2018初赛]航班时间题解： [蓝桥杯2018初赛]分数 1/1 + 1/2 + 1/4 + 1/8 + 1/16 + … 每项是前一项的一半，如果一
2015年第六届蓝桥杯省赛 C/C++真题混搭题解
Star's blogs
02-12 599
小鱼鸡汤时刻：点墨（老爸）曰：养精蓄锐，厚积薄发。 墨点儿（我）曰：老爸说的对哈哈！ 1.隔行变色 Excel表的格子很多，为了避免把某行的数据和相邻行混淆，可以采用隔行变色的样式。 小明设计的样式为：第1行蓝色，第2行白色，第3行蓝色，第4行白色，.... 现在小明想知道，从第21行到第50行一共包含了多少个蓝色的行。 请你直接提交这个...
2015年第六届蓝桥杯省赛试题及详解（Java本科A组）
一叶之修的博客
02-28 2674
蓝桥杯历年真题题目及题解目录汇总 结果填空 (满分3分) 结果填空 (满分5分) 结果填空 (满分9分) 代码填空 (满分11分) 代码填空 (满分13分) 结果填空 (满分17分) 结果填空 (满分21分) 程序设计（满分15分） 程序设计（满分25分） 程序设计（满分31分） 1.熊怪吃核桃 森林里有一只熊怪，很爱吃核桃。不过它有个习惯，每次都把找到的核桃分成...
2020年第十一届蓝桥杯省赛C++大学A组真题（第二场）
10-17
【标题】2020年第十一届蓝桥杯省赛C++大学A组真题（第二场）揭示了这是一场面向大学学生的编程竞赛，主要考察参赛者的C++编程技能和算法理解。蓝桥杯是知名的全国性编程比赛，旨在促进计算机科学与信息技术教育的...
蓝桥杯AB组2014-2019省赛试题.zip
07-23
这份“蓝桥杯AB组2014-2019省赛试题.zip”文件，收录了从2014年至2019年间蓝桥杯C++ AB组的省级比赛试题，以及2020年的两次模拟赛试题，是参赛者宝贵的参考资料。 一、试题概述 蓝桥杯的试题涵盖了数据结构、算法...
第四届 蓝桥杯 竞赛试题题目 C/C++高职高专组
05-05
第四届“蓝桥杯”全国软件专业人才设计与创业大赛选拔赛 C/C++高职高专组 1、题目标题: 猜年龄 美国数学家维纳(N.Wiener)智力早熟，11岁就上了大学。他曾在1935~1936年应邀来中国清华大学讲学。 一次，他参加...
Acwing蓝桥杯C++AB组辅导课例题及习题
最新发布
04-30
在IT领域，特别是编程竞赛和算法训练中，"Acwing蓝桥杯C++ AB组辅导课例题及习题"是一份重要的学习资源。蓝桥杯是一项针对C/C++编程语言的竞赛，旨在提升参赛者的算法设计和实现能力。这份资料集合了多种经典算法...
2015第六届蓝桥杯省赛JAVA C组真题解析（带源码及解析）
王跃坤的博客
03-31 1125
蓝桥杯历年真题及解析. 目录：蓝桥杯历年真题及解析.A：隔行变色（难度：★★★★★）题目：分析：代码：B：立方尾不变（难度：★★★★★）题目：分析：代码：C：无穷分数（难度：★★★★★）题目：分析：代码：D：循环节长度（难度：★★★★★）题目：分析：代码：E：格子中输出（难度：★★★★★）题目：分析：代码：F：奇妙的数字（难度：★★★★★）题目：分析：代码：G：加法变乘法（难度：★★★★★）题目：分析：代码：H：移动距离（难度：★★★★★）题目：分析：代码：I：（难度：★★★★★）题目：分析：代码：J：垒骰
【蓝桥杯】2015初赛 灾后重建
YFR718的博客
08-10 580
题目描述 Pear市一共有N（<=50000）个居民点，居民点之间有M（<=200000）条双向道路相连。 这些居民点两两之间都可以通过双向道路到达。 这种情况一直持续到最近，一次严重的地震毁坏了全部M条道路。 震后，Pear打算修复其中一些道路，修理第i条道路需要Pi的时间。 不过，Pear并不打算让全部的点连通，而是选择一些标号特殊的点让他们连通。 Pear有Q（<=50000）次询问，每次询问，他会选择所有编号在[l,r]之间，并且 编号 mod K = C 的点，修理一些路使得它
[蓝桥杯2015初赛]手链样式-JAVA
m0_55762164的博客
01-03 3725
题目描述 小明有3颗红珊瑚，4颗白珊瑚，5颗黄玛瑙。 他想用它们串成一圈作为手链，送给女朋友。 现在小明想知道：如果考虑手链可以随意转动或翻转，一共有多少不同的组合样式？ 输出格式 请你输出该整数。不要输出任何多余的内容或说明性的文字。 代码 public class Main { public static void main(String[] args) { //C12 3*C9 4 int s1=1; for(int i=1;i<=12;i++){ s1=s1*i; }
求出0～100000之间的所有“水仙花数”并输出
zihaia的博客
12-21 1651
思路： “水仙花数”是指一个n位数，其各位数字的n次方之和确好等于该数本身，如:153＝1^3＋5^3＋3^3，则153是一个“水仙花数 1.给定一个数据data,求取data是几位数 2.获取data中每个位置上的数据 3.利用pow函数进行次方运算，并求和 4.若求和结果与data元素本身相等，则为水仙花数，否则，不是。 #include <stdio.h> #include <math.h> int main() { int i=0; for(..
算法笔记简单模拟练习
qq_30983445的博客
02-27 401
codeup墓地简单模拟练习 练习地址 问题 A: 剩下的树 题目描述 有一个长度为整数L(1&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;lt;=L&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;lt;=10000)的马路，可以想象成数轴上长度为L的一个线段，起点是坐标原点，在每个整数坐标点有一棵树，即在0,1,2，…，L共L+1个位置上有L+1棵树。 现在要移走一些树，移走的树的区间用一对数字
手链样式
xuzhuang1996的博客
03-30 598
手链样式 小明有3颗红珊瑚，4颗白珊瑚，5颗黄玛瑙。他想用它们串成一圈作为手链，送给女朋友。 现在小明想知道：如果考虑手链可以随意转动或翻转，一共可以有多少不同的组合样式呢？ 请你提交该整数。不要填写任何多余的内容或说明性的文字。 主要受这篇文章的启发，可以说重要思维都是从这里面得到的 http://blog.csdn.net/u013619254/article/detai
2015年第六届蓝桥杯C/C++程序设计本科B组省赛 垒骰子(编程大题)
A place to record sth.
01-24 5665
垒骰子 赌圣atm晚年迷恋上了垒骰子，就是把骰子一个垒在另一个上边，不能歪歪扭扭，要垒成方柱体。 经过长期观察，atm 发现了稳定骰子的奥秘：有些数字的面贴着会互相排斥！ 我们先来规范一下骰子：1 的对面是 4，2 的对面是 5，3 的对面是 6。 假设有 m 组互斥现象，每组中的那两个数字的面紧贴在一起，骰子就不能稳定的垒起来。 atm想计算一下有多少种不同的可能的垒骰子方式。
2019蓝桥杯B组C++省赛题目及感受
热门推荐
子衿
03-28 1万+
2019年第十届蓝桥杯大赛软件类省赛C/C++大学B组 试题 A:组队 本题总分：5分 【问题描述】 作为篮球队教练，你需要从以下名单中选出 1号位至 5号位各一名球员， 组成球队的首发阵容。 每位球员担任 1号位至 5号位时的评分如下表所示。请你计算首发阵容 1 号位至5号位的评分之和最大可能是多少？ 试题 B:年号字串 本题总分：5分 【问题描述】 小明用字母 A对应数字 1，B对...
Python编程总结（1）
weixin_41440032的博客
01-14 801
Python总结 Python语言开发复习总结 第一章，字符串相关 一，查看在一段字符串中是否出现一个字符 a,str =input().split() #拆开成两个字符串，用空格隔开 str.strip() #除去多余的空格 if str.find(a) == -1: #直接用find方法 print(“false”) else: print(“true”) 二，活用字符串的内嵌方法： 用字符串...
2015年计算机统考试题及答案.doc
06-19
2015年计算机统考试题及答案.doc

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值