蓝桥杯练习题-基础题

2023-12-03数据结构与算法12 分钟109 次阅读
AI 摘要鱼粮不足,AI 今天先歇着 · 正文在下面

1、A+B问题

【资源限制】
内存限制:256.0MB C/C++时间限制:1.0s Java时间限制:3.0s Python时间限制:5.0s

【问题描述】
输入A、B,输出A+B。

【输入格式】
输入的第一行包括两个整数,由空格分隔,分别表示A、B。

【输出格式】
输出一行,包括一个整数,表示A+B的值。

【样例输入】
12 45

【样例输出】
57

【数据规模与约定】
-10000 <= A, B <= 10000。

解法

java 复制代码
import java.util.*;
 
public class Main {
    public static void main(String args[]) {
        Scanner sc = new Scanner(System.in);
        Integer a = sc.nextInt();
        Integer b = sc.nextInt();
        System.out.println(a + b);
    }
}

2、01字串

【资源限制】
内存限制:256.0MB C/C++时间限制:1.0s Java时间限制:3.0s Python时间限制:5.0s

【问题描述】
对于长度为5位的一个01串,每一位都可能是0或1,一共有32种可能。它们的前几个是:
00000
00001
00010
00011
00100
请按从小到大的顺序输出这32种01串。

【输入格式】
本试题没有输入。

【输出格式】
输出32行,按从小到大的顺序每行一个长度为5的01串。

【样例输出】
00000
00001
00010
00011
<以下部分省略>

解法

java 复制代码
public class Main {
    public static void main(String[] args) {
        for (int i = 0; i < 32; i++) {
            String string = Integer.toBinaryString(i);
            System.out.printf("%05d\n", Integer.parseInt(string));
        }
    }
}

3、字母图形

【资源限制】
内存限制:256.0MB C/C++时间限制:1.0s Java时间限制:3.0s Python时间限制:5.0s

【问题描述】
利用字母可以组成一些美丽的图形,下面给出了一个例子:
ABCDEFG
BABCDEF
CBABCDE
DCBABCD
EDCBABC
这是一个5行7列的图形,请找出这个图形的规律,并输出一个n行m列的图形。

【输入格式】
输入一行,包含两个整数n和m,分别表示你要输出的图形的行数的列数。

【输出格式】
输出n行,每个m个字符,为你的图形。

【样例输入】
5 7

【样例输出】
ABCDEFG
BABCDEF
CBABCDE
DCBABCD
EDCBABC

【数据规模与约定】
1 <= n, m <= 26。

解法

java 复制代码
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int m = sc.nextInt();
        for (int i = 0; i < n; ++i) {
            for (int j = 0; j < m; ++j) {
                System.out.print((char) (Math.abs(i - j) + 'A'));
            }
            System.out.println();
        }
    }
}

4、数列特征

【资源限制】
内存限制:256.0MB C/C++时间限制:1.0s Java时间限制:3.0s Python时间限制:5.0s

【问题描述】
给出n个数,找出这n个数的最大值,最小值,和。

【输入格式】
第一行为整数n,表示数的个数。
第二行有n个数,为给定的n个数,每个数的绝对值都小于10000。

【输出格式】
输出三行,每行一个整数。第一行表示这些数中的最大值,第二行表示这些数中的最小值,第三行表示这些数的和。

【样例输入】
5
1 3 -2 4 5

【样例输出】
5
-2
11

【数据规模和约定】
1 <= n <= 10000。

解法

java 复制代码
import java.util.*;

public class Main {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int num = sc.nextInt();
        int[] arr = new int[num];
        int sum = 0;
        for (int i = 0; i < num; i++) {
            int temp = sc.nextInt();
            arr[i] = temp;
            sum += temp;
        }
        Arrays.sort(arr);
        System.out.println(arr[num - 1]);
        System.out.println(arr[0]);
        System.out.println(sum);
    }

}

5、查找整数

【资源限制】
内存限制:256.0MB C/C++时间限制:1.0s Java时间限制:3.0s Python时间限制:5.0s

【问题描述】
给出一个包含n个整数的数列,问整数a在数列中的第一次出现是第几个。

【输入格式】
第一行包含一个整数n。
第二行包含n个非负整数,为给定的数列,数列中的每个数都不大于10000。
第三行包含一个整数a,为待查找的数。

【输出格式】
如果a在数列中出现了,输出它第一次出现的位置(位置从1开始编号),否则输出-1。

【样例输入】
6
1 9 4 8 3 9
9

【样例输出】
2

【数据规模与约定】
1 <= n <= 1000。

解法

java 复制代码
import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        List<Integer> list = new ArrayList<>(n);
        for (int i = 0; i < n; i++) {
            list.add(sc.nextInt());
        }
        int tar = sc.nextInt();
        int res = list.indexOf(tar);
        if (res != -1) {
            res += 1;
        }
        System.out.println(res);
    }
}

6、杨辉三角形

【资源限制】
内存限制:256.0MB C/C++时间限制:1.0s Java时间限制:3.0s Python时间限制:5.0s

【问题描述】
杨辉三角形又称Pascal三角形,它的第i+1行是(a+b)i的展开式的系数。

它的一个重要性质是:三角形中的每个数字等于它两肩上的数字相加。

下面给出了杨辉三角形的前4行:
   1 
   1  1
 1 2 1  
1 3 3 1

给出n,输出它的前n行。

【输入格式】
输入包含一个数n。

【输出格式】
输出杨辉三角形的前n行。每一行从这一行的第一个数开始依次输出,中间使用一个空格分隔。请不要在前面输出多余的空格。

【样例输入】
4

【样例输出】
1
1 1
1 2 1
1 3 3 1

【数据规模与约定】
1 <= n <= 34。

解法

java 复制代码
import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        // 创建二维数组
        int[][] arr = new int[n][];
        // 固定二维数组列数
        for (int i = 0; i < n; i++) {
            arr[i] = new int[i + 1];
        }
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                // 每行头尾都是 1
                if (j == 0 || j == i) {
                    arr[i][j] = 1;
                } else {
                    // 等于它上面一行的第 j-1 与 j 位置的数字和
                    arr[i][j] = arr[i - 1][j - 1] + arr[i - 1][j];
                }
                System.out.print(arr[i][j] + " ");
            }
            System.out.println();
        }
    }
}

7、特殊的数字

【资源限制】
内存限制:512.0MB C/C++时间限制:1.0s Java时间限制:3.0s Python时间限制:5.0s

【问题描述】
  153是一个非常特殊的数,它等于它的每位数字的立方和,即153=1*1*1+5*5*5+3*3*3。编程求所有满足这种条件的三位十进制数。

【输出格式】
  按从小到大的顺序输出满足条件的三位十进制数,每个数占一行。

解法

java 复制代码
public class Main {
    public static void main(String[] args) {
        for (int i = 100; i < 1000; i++) {
            int bai = i / 100;
            int shi = i / 10 % 10;
            int ge = i % 10;
            if (i == bai * bai * bai + shi * shi * shi + ge * ge * ge) {
                System.out.println(i);
            }
        }
    }
}

8、回文数

【资源限制】
内存限制:512.0MB C/C++时间限制:1.0s Java时间限制:3.0s Python时间限制:5.0s

【问题描述】
  1221是一个非常特殊的数,它从左边读和从右边读是一样的,编程求所有这样的四位十进制数。

【输出格式】
  按从小到大的顺序输出满足条件的四位十进制数。

解法

java 复制代码
public class Main {
    public static void main(String[] args) {
        for (int i = 1000; i < 10000; i++) {
            String s = Integer.toString(i);
            boolean flag = true;
            for (int j = 0; j < s.length() / 2; j++) {
                if (s.charAt(j) != s.charAt(s.length() - 1 - j)) {
                    flag = false;
                    break;
                }
            }
            if (flag) {
                System.out.println(s);
            }
        }
    }
}

9、特殊回文数

【资源限制】
内存限制:512.0MB C/C++时间限制:1.0s Java时间限制:3.0s Python时间限制:5.0s

【问题描述】
  123321是一个非常特殊的数,它从左边读和从右边读是一样的。
  输入一个正整数n, 编程求所有这样的五位和六位十进制数,满足各位数字之和等于n 。

【输入格式】
  输入一行,包含一个正整数n。

【输出格式】
  按从小到大的顺序输出满足条件的整数,每个整数占一行。

【样例输入】
52

【样例输出】
899998
989989
998899

【数据规模和约定】
  1<=n<=54。

解法

java 复制代码
import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int num = sc.nextInt();
        for (int i = 10000; i < 999999; i++) {
            String s = Integer.toString(i);
            boolean flag = true;
            int sum = 0;
            for (int j = 0; j < s.length() / 2; j++) {
                if (s.charAt(j) != s.charAt(s.length() - 1 - j)) {
                    flag = false;
                    break;
                } else {
                    sum += Integer.parseInt(s.charAt(j) + "") * 2;
                }
            }
            if (s.length() % 2 == 1) {
                sum += Integer.parseInt(s.charAt(s.length() / 2) + "");
            }
            if (flag && sum == num) {
                System.out.println(s);
            }
        }
    }
}

10、十进制转十六进制

【资源限制】
内存限制:512.0MB C/C++时间限制:1.0s Java时间限制:3.0s Python时间限制:5.0s

【问题描述】
  十六进制数是在程序设计时经常要使用到的一种整数的表示方式。它有0,1,2,3,4,5,6,7,8,9,A,B,C,D,E,F共16个符号,分别表示十进制数的0至15。十六进制的计数方法是满16进1,所以十进制数16在十六进制中是10,而十进制的17在十六进制中是11,以此类推,十进制的30在十六进制中是1E。
  给出一个非负整数,将它表示成十六进制的形式。

【输入格式】
  输入包含一个非负整数a,表示要转换的数。0<=a<=2147483647

【输出格式】
  输出这个整数的16进制表示

【样例输入】
30

【样例输出】
1E

解法

直接 api

java 复制代码
import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int num = sc.nextInt();
        System.out.println(Integer.toHexString(num).toUpperCase());
    }
}

自己计算

java 复制代码

11、十六进制转十进制

【资源限制】
内存限制:512.0MB C/C++时间限制:1.0s Java时间限制:3.0s Python时间限制:5.0s

【问题描述】
  从键盘输入一个不超过8位的正的十六进制数字符串,将它转换为正的十进制数后输出。
  注:十六进制数中的10~15分别用大写的英文字母A、B、C、D、E、F表示。

【样例输入】
FFFF

【样例输出】
65535

解法

直接 api

java 复制代码
import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String hex = sc.next();
        System.out.println(Long.value(hex, 16));
    }
}

做运算

java 复制代码
import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String hex = sc.next();
        char[] arr = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
        Map<Character, Integer> map = new HashMap<>();
        for (int i = 0; i < arr.length; i++) {
            map.put(arr[i], i);
        }
        long sum = 0;
        for (int i = hex.length() - 1; i >= 0; i--) {
            sum += (long) (map.get(hex.charAt(i)) * Math.pow(16, hex.length() - i - 1));
        }
        System.out.println(sum);
    }
}

或者这样

java 复制代码
import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String hex = sc.nextLine();
        char[] chars = hex.toCharArray();
        int len = chars.length;
        long sum = 0;
        for (int i = 0; i < len; i++) {
            if ((int) chars[i] - 48 > 9) {
                if (chars[i] == 'A') {
                    sum += (long) (10 * Math.pow(16, len - i - 1));
                } else if (chars[i] == 'B') {
                    sum += (long) (11 * Math.pow(16, len - i - 1));
                } else if (chars[i] == 'C') {
                    sum += (long) (12 * Math.pow(16, len - i - 1));
                } else if (chars[i] == 'D') {
                    sum += (long) (13 * Math.pow(16, len - i - 1));
                } else if (chars[i] == 'E') {
                    sum += (long) (14 * Math.pow(16, len - i - 1));
                } else if (chars[i] == 'F') {
                    sum += (long) (15 * Math.pow(16, len - i - 1));
                }
            } else {
                sum += (long) (((int) chars[i] - 48) * Math.pow(16, len - i - 1));
            }
        }
        System.out.println(sum);
    }
}

12、十六进制转八进制

【资源限制】
内存限制:512.0MB C/C++时间限制:1.0s Java时间限制:3.0s Python时间限制:5.0s

【问题描述】
  给定n个十六进制正整数,输出它们对应的八进制数。

【输入格式】
  输入的第一行为一个正整数n (1<=n<=10)。
  接下来n行,每行一个由09、大写字母AF组成的字符串,表示要转换的十六进制正整数,每个十六进制数长度不超过100000。

【输出格式】
  输出n行,每行为输入对应的八进制正整数。

  【注意】
  输入的十六进制数不会有前导0,比如012A。
  输出的八进制数也不能有前导0。

【样例输入】
  2
  39
  123ABC

【样例输出】
  71
  4435274

  【提示】
  先将十六进制数转换成某进制数,再由某进制数转换成八进制。

注意:
题目中每个十六进制数长度不超过100000,这个哪怕是 Long 也装不下。
image.png

解法

java 复制代码
import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int num = sc.nextInt();
        String[] strs = new String[num];
        for (int i = 0; i < num; i++) {
            strs[i] = sc.next();
        }
        for (int i = 0; i < strs.length; i++) {
            // 转 2进制 字符串
            String binary = hexToBin(strs[i]);
            // 转 8进制 字符串
            System.out.println(binaryToOct(binary));
        }
    }

    /**
     * 2进制 转 8进制
     *
     * @param binary 2进制字符串
     * @return 8进制字符串
     */
    private static String binaryToOct(String binary) {
        // 二进制数字不是 3 的倍速时,需要补零
        if (binary.length() % 3 == 1) {
            binary = "00" + binary;
        }
        if (binary.length() % 3 == 2) {
            binary = "0" + binary;
        }
        StringBuilder sb = new StringBuilder();
        int len = binary.length();
        int k = 0;
        // 看看前三位是不是0,是零就从第四位开始截取,因为题目说输入的十六进制数不会有前导0,比如012A
        if ("000".equals(binary.substring(0, 3))) {
            k = 3;
        }
        for (int i = k; i < len - 2; i += 3) {
            //抽取三个二进制字符
            String subStr = binary.substring(i, i + 3);
            // 将抽取的二进制字符串转换成八进制字符
            switch (subStr) {
                case "000":
                    sb.append("0");
                    break;
                case "001":
                    sb.append("1");
                    break;
                case "010":
                    sb.append("2");
                    break;
                case "011":
                    sb.append("3");
                    break;
                case "100":
                    sb.append("4");
                    break;
                case "101":
                    sb.append("5");
                    break;
                case "110":
                    sb.append("6");
                    break;
                case "111":
                    sb.append("7");
                    break;
                default:
            }
        }
        return sb.toString();
    }

    /**
     * 16进制 转 2进制
     *
     * @param hex 16进制字符串
     * @return 2进制字符串
     */
    private static String hexToBin(String hex) {
        char[] chars = hex.toCharArray();
        int len = chars.length;
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < len; i++) {
            switch (chars[i]) {
                case '0':
                    sb.append("0000");
                    break;
                case '1':
                    sb.append("0001");
                    break;
                case '2':
                    sb.append("0010");
                    break;
                case '3':
                    sb.append("0011");
                    break;
                case '4':
                    sb.append("0100");
                    break;
                case '5':
                    sb.append("0101");
                    break;
                case '6':
                    sb.append("0110");
                    break;
                case '7':
                    sb.append("0111");
                    break;
                case '8':
                    sb.append("1000");
                    break;
                case '9':
                    sb.append("1001");
                    break;
                case 'A':
                    sb.append("1010");
                    break;
                case 'B':
                    sb.append("1011");
                    break;
                case 'C':
                    sb.append("1100");
                    break;
                case 'D':
                    sb.append("1101");
                    break;
                case 'E':
                    sb.append("1110");
                    break;
                case 'F':
                    sb.append("1111");
                    break;
                default:
            }
        }
        return sb.toString();
    }
}

二进制转八进制的算法也可以稍微调整下,改成下边这样,其实逻辑是一样的。

java 复制代码
/**
 * 2进制 转 8进制
 *
 * @param binary 2进制字符串
 * @return 8进制字符串
 */
private static String binaryToOct1(String binary) {
    // 二进制数字不是 3 的倍速时,需要补零
    if (binary.length() % 3 == 1) {
        binary = "00" + binary;
    }
    if (binary.length() % 3 == 2) {
        binary = "0" + binary;
    }
    StringBuilder sb = new StringBuilder();
    int len = binary.length() / 3;
    int start = 0;
    // 看看前三位是不是0,是零就从第四位开始截取,因为题目说输入的十六进制数不会有前导0,比如012A
    if ("000".equals(binary.substring(0, 3))) {
        start = 3;
        len--;
    }
    for (int i = 0; i < len; i++) {
        //抽取三个二进制字符
        String subStr = binary.substring(start, start + 3);
        start += 3;
        // 将抽取的二进制字符串转换成八进制字符
        switch (subStr) {
            case "000":
                sb.append("0");
                break;
            case "001":
                sb.append("1");
                break;
            case "010":
                sb.append("2");
                break;
            case "011":
                sb.append("3");
                break;
            case "100":
                sb.append("4");
                break;
            case "101":
                sb.append("5");
                break;
            case "110":
                sb.append("6");
                break;
            case "111":
                sb.append("7");
                break;
            default:
        }
    }
    return sb.toString();
}

13、数列排序

【资源限制】
内存限制:512.0MB C/C++时间限制:1.0s Java时间限制:3.0s Python时间限制:5.0s

【问题描述】
  给定一个长度为n的数列,将这个数列按从小到大的顺序排列。1<=n<=200

【输入格式】
  第一行为一个整数n。
  第二行包含n个整数,为待排序的数,每个整数的绝对值小于10000。

【输出格式】
  输出一行,按从小到大的顺序输出排序后的数列。

【样例输入】
5
8 3 6 4 9

【样例输出】
3 4 6 8 9

解法

java 复制代码
import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int num = sc.nextInt();
        int[] arr = new int[num];
        for (int i = 0; i < num; i++) {
            arr[i] = sc.nextInt();
        }
        Arrays.sort(arr);
        for (int i = 0; i < num; i++) {
            System.out.print(arr[i] + " ");
        }
    }
}

14、Fibonacci数列

【资源限制】
内存限制:256.0MB C/C++时间限制:1.0s Java时间限制:3.0s Python时间限制:5.0s

【问题描述】
Fibonacci数列的递推公式为:Fn=Fn-1+Fn-2,其中F1=F2=1。
当n比较大时,Fn也非常大,现在我们想知道,Fn除以10007的余数是多少。

【输入格式】
输入包含一个整数n。

【输出格式】
输出一行,包含一个整数,表示Fn除以10007的余数。

说明:在本题中,答案是要求Fn除以10007的余数,因此我们只要能算出这个余数即可,而不需要先计算出Fn的准确值,再将计算的结果除以10007取余数,直接计算余数往往比先算出原数再取余简单。

【样例输入】
10

【样例输出】
55

【样例输入】
22

【样例输出】
7704

【数据规模与约定】
1 <= n <= 1,000,000。

解法

递归法,直接求和后取余数,但由于数字大,栈太深,运行超时。

java 复制代码
import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        long add = add(n);
        System.out.println(add % 10007);
    }

    private static long add(int n) {
        if (n == 1 || n == 2) {
            return 1;
        }
        return add(n - 1) + add(n - 2);
    }
}

直接每个数字求余数,在刘汝佳老师的《算法竞赛入门经典》也提到了:要计算只包含加法、减法和乘法的整数表达式除以正整数n的余数,可以在每步计算之后对n取余,结果不变。

java 复制代码
import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int[] arr = new int[10000001];
        arr[1] = 1;
        arr[2] = 1;
        for (int i = 3; i <= n; i++) {
            arr[i] = (arr[i - 1] + arr[i - 2]) % 10007;
        }
        System.out.println(arr[n]);
    }
}

15、圆的面积

【资源限制】
内存限制:256.0MB C/C++时间限制:1.0s Java时间限制:3.0s Python时间限制:5.0s

【问题描述】
给定圆的半径r,求圆的面积。

【输入格式】
输入包含一个整数r,表示圆的半径。

【输出格式】
输出一行,包含一个实数,四舍五入保留小数点后7位,表示圆的面积。

说明:在本题中,输入是一个整数,但是输出是一个实数。
对于实数输出的问题,请一定看清楚实数输出的要求,比如本题中要求保留小数点后7位,则你的程序必须严格的输出7位小数,输出过多或者过少的小数位数都是不行的,都会被认为错误。
实数输出的问题如果没有特别说明,舍入都是按四舍五入进行。

【样例输入】
4

【样例输出】
50.2654825

【数据规模与约定】
1 <= r <= 10000。

解法

java 复制代码
import java.util.*;

public class Main {
    public static void main(String[] args) {
        double pi = Math.PI;
        Scanner sc = new Scanner(System.in);
        int r = sc.nextInt();
        double s = r * r * pi;
        System.out.printf("%.7f", s);
    }
}

16、闰年判断

【资源限制】
内存限制:256.0MB C/C++时间限制:1.0s Java时间限制:3.0s Python时间限制:5.0s

【问题描述】
给定一个年份,判断这一年是不是闰年。
当以下情况之一满足时,这一年是闰年:
1. 年份是4的倍数而不是100的倍数;
2. 年份是400的倍数。
其他的年份都不是闰年。

【输入格式】
输入包含一个整数y,表示当前的年份。

【输出格式】
输出一行,如果给定的年份是闰年,则输出yes,否则输出no。
说明:当试题指定你输出一个字符串作为结果(比如本题的yes或者no,你需要严格按照试题中给定的大小写,写错大小写将不得分。

【样例输入】
2013

【样例输出】
no

【样例输入】
2016

【样例输出】
yes

【数据规模与约定】
1990 <= y <= 2050。

解法

java 复制代码
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int year = sc.nextInt();
        if (year % 400 == 0 || (year % 4 == 0 && year % 100 != 0)) {
            System.out.println("yes");
        } else {
            System.out.println("no");
        }
    }
}

17、序列求和

【资源限制】
内存限制:256.0MB C/C++时间限制:1.0s Java时间限制:3.0s Python时间限制:5.0s

【问题描述】
求1+2+3+...+n的值。

【输入格式】
输入包括一个整数n。

【输出格式】
输出一行,包括一个整数,表示1+2+3+...+n的值。

【样例输入】
4

【样例输出】
10

【样例输入】
100

说明:有一些试题会给出多组样例输入输出以帮助你更好的做题。

一般在提交之前所有这些样例都需要测试通过才行,但这不代表这几组样例数据都正确了你的程序就是完全正确的,潜在的错误可能仍然导致你的得分较低。

【样例输出】
5050

【数据规模与约定】
1 <= n <= 1,000,000,000。

说明:请注意这里的数据规模。

本题直接的想法是直接使用一个循环来累加,然而,当数据规模很大时,这种“暴力”的方法往往会导致超时。此时你需要想想其他方法。你可以试一试,如果使用1000000000作为你的程序的输入,你的程序是不是能在规定的上面规定的时限内运行出来。

本题另一个要值得注意的地方是答案的大小不在你的语言默认的整型(int)范围内,如果使用整型来保存结果,会导致结果错误。

如果你使用C++或C语言而且准备使用printf输出结果,则你的格式字符串应该写成%I64d以输出long long类型的整数。

解法

java 复制代码
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        long n = sc.nextLong();
        System.out.println((1 + n) * n / 2);
    }
}
觉得有用就点个赞,不用登录也能读

评论

0 条
登录 之后才能评论
—
还没有评论,来说第一句