欢迎开启算法 OJ 题的大门，本题为经典的 A+B

A+B 入门题，我们会以此题为示例介绍蓝桥云课 OJ 系统的正确使用方法。

输入两个正整数 A,B，请你计算 A+B，并输出。

import java.util.Scanner;
// 1:无需package
// 2: 类名必须Main, 不可修改
public class Main {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        //在此输入您的代码...
        int a = scan.nextInt();
        int b = scan.nextInt();
        System.out.println(a+b);
        scan.close();
    }
}

本题为填空题，只需要算出结果后，在代码中使用输出语句将所填结果输出即可。

如果一个 MP3 文件占用磁盘的大小是 4MB，小蓝的硬盘还剩下 100GB 的空间，请问他还可以放多少个这样的 MP3 文件？

import java.util.Scanner;
// 1:无需package
// 2: 类名必须Main, 不可修改
public class Main {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        //在此输入您的代码...
        System.out.println(25600);
        scan.close();
    }
}

小蓝正在学习一门神奇的语言，这门语言中的单词都是由小写英文字母组 成，有些单词很长，远远超过正常英文单词的长度。小蓝学了很长时间也记不住一些单词，他准备不再完全记忆这些单词，而是根据单词中哪个字母出现得最多来分辨单词。

现在，请你帮助小蓝，给了一个单词后，帮助他找到出现最多的字母和这 个字母出现的次数。

输入描述

输入一行包含一个单词，单词只由小写英文字母组成。

对于所有的评测用例，输入的单词长度不超过 1000。

输出描述

输出两行，第一行包含一个英文字母，表示单词中出现得最多的字母是哪 个。如果有多个字母出现的次数相等，输出字典序最小的那个。

第二行包含一个整数，表示出现得最多的那个字母在单词中出现的次数。

输入输出样例

示例 1

输入

lanqiao

输出

a 2

示例 2

输入

longlonglongistoolong

输出

o 6

运行限制

最大运行时间：1s

最大运行内存: 256M

这道题我一开始想直接在字符串上搞动作，后来发现这个方法有个什么问题，就是会搞乱字符串的顺序，后来发现可以用数组索引的方式，这样就简单多了

先统计每个字符所在的位置出现的次数

然后在作出比较就可以了

这样做就简化了统计之后锁定响应位置的事情

import java.util.Scanner;
// 1:无需package
// 2: 类名必须Main, 不可修改
public class Main {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        //在此输入您的代码...
        String temp=scan.nextLine();
        int a[]=new int[26];
        for(int i=0;i<temp.length();i++){
            a[temp.charAt(i)-'a']++;
        }
        int max=0;
        char ch='a';
        for(int i=0;i<a.length;i++){
            if(a[i]>max){
                max=a[i];
                ch=(char)('a'+i);
            }
        }
        System.out.println(ch);
        System.out.println(max);
        scan.close();
    }
}

小蓝给学生们组织了一场考试，卷面总分为 100 分，每个学生的得分都是一个 0 到 100 的整数。

如果得分至少是 60 分，则称为及格。如果得分至少为 85 分，则称为优秀。

请计算及格率和优秀率，用百分数表示，百分号前的部分四舍五入保留整 数。

输入描述

输入的第一行包含一个整数 n\ (1 \leq n \leq 10^4)n (1≤n≤10

4

)，表示考试人数。

接下来 nn 行，每行包含一个 0 至 100 的整数，表示一个学生的得分。

输出描述

输出两行，每行一个百分数，分别表示及格率和优秀率。百分号前的部分 四舍五入保留整数。

输入输出样例

示例

输入

7

80

92

56

74

88

100

0

copy

输出

71%

43%

import java.util.Scanner;
// 1:无需package
// 2: 类名必须Main, 不可修改
public class Main {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        //在此输入您的代码...
        int n=scan.nextInt();
        int a[]=new int[2];
        for(int i=0;i<n;i++){
            int temp=scan.nextInt();
            if(temp>=85){
                a[0]++;
            }else if(temp>=60){
                a[1]++;
            }
        }
        System.out.println(Math.round((double)(a[1]+a[0])*100/n)+"%");
        System.out.println(Math.round((double)a[0]*100/n)+"%");
        scan.close();
    }
}

本题为填空题，只需要算出结果后，在代码中使用输出语句将所填结果输出即可。

如下图所示，GG 是一个无向图，其中蓝色边的长度是 11、橘色边的长度是 22、绿色边的长度是 33。

则从 AA 到 SS 的最短距离是多少？

运行限制

最大运行时间：1s

最大运行内存: 128M

import java.util.Scanner;
// 1:无需package
// 2: 类名必须Main, 不可修改
public class Main {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        //在此输入您的代码...
        System.out.println(6);
        scan.close();
    }
}

本题为填空题，只需要算出结果后，在代码中使用输出语句将所填结果输出即可。

小蓝要为一条街的住户制作门牌号。

这条街一共有 20202020 位住户，门牌号从 11 到 20202020 编号。

小蓝制作门牌的方法是先制作 00 到 99 这几个数字字符，最后根据需要将字符粘贴到门牌上，例如门牌 1017 需要依次粘贴字符 1、0、1、71、0、1、7，即需要 11 个字符 00，22 个字符 11，11 个字符 77。

请问要制作所有的 11 到 20202020 号门牌，总共需要多少个字符 22？

运行限制

最大运行时间：1s

最大运行内存: 128M

import java.util.Scanner;
// 1:无需package
// 2: 类名必须Main, 不可修改
public class Main {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        //在此输入您的代码...
        int count=0;
        String aString="";
        for (int i = 1; i <=2020; i++) {
            aString=i+"";
            for (int j = 0; j < aString.length(); j++) {
          if(aString.charAt(j)=='2') {
            count++;
            }
          }
        }
        System.out.println(count);
        scan.close();
    }
}

本题为填空题，只需要算出结果后，在代码中使用输出语句将所填结果输出即可。

小明刚刚找到工作，老板人很好，只是老板夫人很爱购物。老板忙的时候经常让小明帮忙到商场代为购物。小明很厌烦，但又不好推辞。

这不，大促销又来了！老板夫人开出了长长的购物单，都是有打折优惠的。

小明也有个怪癖，不到万不得已，从不刷卡，直接现金搞定。

现在小明很心烦，请你帮他计算一下，需要从取款机上取多少现金，才能搞定这次购物。

取款机只能提供 100100 元面额的纸币。小明想尽可能少取些现金，够用就行了。 你的任务是计算出，小明最少需要取多少现金。

以下是让人头疼的购物单，为了保护隐私，物品名称被隐藏了。

**** 180.90 88折

**** 10.25 65折

**** 56.14 9折

**** 104.65 9折

**** 100.30 88折

**** 297.15 半价

**** 26.75 65折

**** 130.62 半价

**** 240.28 58折

**** 270.62 8折

**** 115.87 88折

**** 247.34 95折

**** 73.21 9折

**** 101.00 半价

**** 79.54 半价

**** 278.44 7折

**** 199.26 半价

**** 12.97 9折

**** 166.30 78折

**** 125.50 58折

**** 84.98 9折

**** 113.35 68折

**** 166.57 半价

**** 42.56 9折

**** 81.90 95折

**** 131.78 8折

**** 255.89 78折

**** 109.17 9折

**** 146.69 68折

**** 139.33 65折

**** 141.16 78折

**** 154.74 8折

**** 59.42 8折

**** 85.44 68折

**** 293.70 88折

**** 261.79 65折

**** 11.30 88折

**** 268.27 58折

**** 128.29 88折

**** 251.03 8折

**** 208.39 75折

**** 128.88 75折

**** 62.06 9折

**** 225.87 75折

**** 12.89 75折

**** 34.28 75折

**** 62.16 58折

**** 129.12 半价

**** 218.37 半价

**** 289.69 8折

需要说明的是，88 折指的是按标价的 88% 计算，而 8 折是按 80% 计算，余者类推。 特别地，半价是按 50% 计算。

请输出小明要从取款机上提取的金额，单位是元。

很唬人的一道题，其实没啥技术含量，根本不用动用编程，用execl解决就可以了

import java.util.Scanner;
// 1:无需package
// 2: 类名必须Main, 不可修改
public class Main {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        //在此输入您的代码...
        System.out.println(5200);
        scan.close();
    }
}

本题为填空题，只需要算出结果后，在代码中使用输出语句将所填结果输出即可。

小蓝准备用 256MB的内存空间开一个数组，数组的每个元素都是 32 位 二进制整数，如果不考虑程序占用的空间和维护内存需要的辅助空间，请问 256MB 的空间可以存储多少个 32 位二进制整数？

运行限制

最大运行时间：1s

最大运行内存: 128M

import java.util.Scanner;
// 1:无需package
// 2: 类名必须Main, 不可修改
public class Main {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int a=256*8*1024*1024/32;
        //在此输入您的代码...
        System.out.println(Math.abs(a));
        scan.close();
    }
}

本题为填空题，只需要算出结果后，在代码中使用输出语句将所填结果输出即可。

小蓝每天都锻炼身体。

正常情况下，小蓝每天跑 1 千米。如果某天是周一或者月初（1 日），为了激励自己，小蓝要跑 2千米。如果同时是周一或月初，小蓝也是跑 2 千米。

小蓝跑步已经坚持了很长时间，从 2000 年 1月 1 日周六（含）到 2020 年 10 月 1 日周四（含）。请问这段时间小蓝总共跑步多少千米？

运行限制

最大运行时间：1s

最大运行内存: 128M

这道题我建议也是用execl解决

1.新建一个Excel文件

2.填充2000年1月1日到2020年10月1日

3.通过单元格格式中在日期后加上对应的星期数 4.单元格行数记为h；查找“星期一”，找到的数量记为a; 查找“月1日”（不能是1日，否则如11日也会计入），找到的数量记为b；查找“月1日星期一”，找到的数量记为c；答案n=h+a+b-c;

import java.util.Scanner;
// 1:无需package
// 2: 类名必须Main, 不可修改
public class Main {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        //在此输入您的代码...
        System.out.println(8879);
        scan.close();
    }
}

本题为填空题，只需要算出结果后，在代码中使用输出语句将所填结果输出即可。

如下图所示，小明用从 11 开始的正整数“蛇形”填充无限大的矩阵。

1 2 6 7 15 ...

3 5 8 14 ...

4 9 13 ...

10 12 ...

11 ...

...

容易看出矩阵第二行第二列中的数是 55。请你计算矩阵中第 2020 行第 2020 列的数是多少？

运行限制

最大运行时间：1s

最大运行内存: 128M

这道题是来回绕，那只要跟着他一起绕就可以了

import java.util.Scanner;
// 1:无需package
// 2: 类名必须Main, 不可修改
public class Main {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        //在此输入您的代码...
        System.out.println(761);
        scan.close();
    }
}

本题为填空题，只需要算出结果后，在代码中使用输出语句将所填结果输出即可。

你一定听说过这个故事。国王对发明国际象棋的大臣很佩服，问他要什么报酬，大臣说：请在第 1 个棋盘格放 11 粒麦子，在第 2 个棋盘格放 2 粒麦子，在第 3 个棋盘格放 4 粒麦子，在第 4 个棋盘格放 8 粒麦子，......后一格的数字是前一格的两倍，直到放完所有棋盘格（国际象棋共有 64 格）。

国王以为他只是想要一袋麦子而已，哈哈大笑。

当时的条件下无法准确计算，但估算结果令人吃惊：即使全世界都铺满麦子也不够用！

请你借助计算机准确地计算，到底需要多少粒麦子。

运行限制

最大运行时间：1s

最大运行内存: 128M

import java.util.Scanner;
import java.math.BigInteger;
// 1:无需package
// 2: 类名必须Main, 不可修改
public class Main {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        //在此输入您的代码...
        BigInteger a =new BigInteger("0");
        BigInteger b = new BigInteger("2");
        for (int i = 0; i < 64; i++) {
            a = a.add(b.pow(i));
        }
        System.out.println(a);
        scan.close();
    }
}

小明对数位中含有 2、0、1、9 的数字很感兴趣（不包括前导 0），在 1 到 40 中这样的数包括 1、2、9、10 至 32、39 和 40，共 28 个，他们的和是 574。

请问，在 1 到 n 中，所有这样的数的和是多少？

输入描述

输入格式：

输入一行包含两个整数 n（1 ≤ n ≤ 10^4）

输出描述

输出一行，包含一个整数，表示满足条件的数的和。

输入输出样例

示例

输入

40

输出

574

运行限制

最大运行时间：1s

最大运行内存: 256M

import java.util.Scanner;
// 1:无需package
// 2: 类名必须Main, 不可修改
public class Main {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        //在此输入您的代码...
        System.out.println(getContains(scan.nextInt()));
        scan.close();
    }
    public static int getContains(int num) {
        int total = 0;
        if(num>=1 && num<=10000) {
            for(int i=0;i<=num;i++) {
                if((i+"").indexOf("0")!=-1 || (i+"").indexOf("1")!=-1 || (i+"").indexOf("2")!=-1 || (i+"").indexOf("9")!=-1) {
                    total += i;
                }
            }
        }
        return total;
    }
}

本题为填空题，只需要算出结果后，在代码中使用输出语句将所填结果输出即可。

我们知道第一个质数是 2、第二个质数是 3、第三个质数是 5……

请你计算第 2019个质数是多少？

运行限制

最大运行时间：1s

最大运行内存: 128M

import java.util.Scanner;
// 1:无需package
// 2: 类名必须Main, 不可修改
public class Main {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        //在此输入您的代码...
        int count=0;
        for(int i=2;i<Integer.MAX_VALUE;i++){
          if(judge(i)){
            count++;
          }
          if(count==2019){
            System.out.println(i);
            break;
          }
        }
        scan.close();
    }
    public static boolean judge(int a){
      for(int i=2;i<=Math.sqrt(a);i++){
        if(a%i==0){
          return false;
        }
      }
      return true;
    }
}

本题为填空题，只需要算出结果后，在代码中使用输出语句将所填结果输出即可。

请你找到最小的整数 X同时满足：

X是 2019的整倍数；

X的每一位数字都是奇数。

运行限制

最大运行时间：1s

最大运行内存: 128M

import java.util.Scanner;
// 1:无需package
// 2: 类名必须Main, 不可修改
public class Main {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        //在此输入您的代码...
        for(long i= 2019;i<Long.MAX_VALUE;i=i+2019){
          if(judge(i)){
            System.out.println(i);
            break;
          }
        }
        scan.close();
    }
    public static boolean judge(long a){
      String res=a+"";
      for(int i=0;i<res.length();i++){
        if((res.charAt(i)-'0')%2==0){
          return false;
        }
      }
      return true;
    }
}

给定一个长度为 NN 的数组 AA，请你先从小到大输出它的每个元素，再从大到小输出它的每个元素。

输入描述

输出描述

输出共两行，每行包含 NN 个整数，表示答案。

输入输出样例

示例 1

输入

5 1 3 2 6 5

输出

1 2 3 5 6 
6 5 3 2 1

运行限制

• 最大运行时间：3s
• 最大运行内存: 128M

这道题好像用数组和Arrays会超时

import java.awt.List;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Scanner;
// 1:无需package
// 2: 类名必须Main, 不可修改
public class Main {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        //在此输入您的代码...
        int n=scan.nextInt();
        ArrayList<Integer> list=new ArrayList<>();
        for(int i=0;i<n;i++) {
            list.add(scan.nextInt());
        }
        
        Collections.sort(list);
        for(int i=0;i<n;i++) {
            System.out.print(list.get(i)+" ");
        }
        System.out.println();
        for(int i=n-1;i>=0;i--) {
            System.out.print(list.get(i)+" ");
        }
    }
}

输入描述

输出描述

输入输出样例

示例 1

输入

abcba

输出

Y

示例 2

输入

abcbb

输出

N

运行限制

• 最大运行时间：1s
• 最大运行内存: 128M

import java.util.Scanner;
// 1:无需package
// 2: 类名必须Main, 不可修改
public class Main {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        //在此输入您的代码...
        String s=scan.nextLine();
        if(new StringBuffer(s).reverse().toString().equals(s)){
          System.out.println("Y");
        }else{
          System.out.println("N");
        }
        scan.close();
    }
}

输入描述

输出描述

输出一个整数表示答案。

输入输出样例

示例

输入

5 2 6 4 10 20

输出

10

样例说明： 包含 2、6、4、10、20 的最短的等差数列是 2、4、6、8、10、12、14、16、 18、20。

【方法一】

这道题先排序，然后默认两个数字之间最小的是等差数列中的公差

import java.util.Scanner;
//1:无需package
//2: 类名必须Main, 不可修改
import java.util.Arrays;
import java.util.Scanner;
public class Main {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		int[] nums = new int[n];
		for (int i = 0; i < n; i++) {
			nums[i] = sc.nextInt();
		}
		Arrays.sort(nums);
		int min = Integer.MAX_VALUE;
		for (int i = 1; i < n; i++) {
			if (nums[i] - nums[i - 1] < min) {
				min = nums[i] - nums[i - 1];
			}
		}
		try {
			int res = (nums[n - 1] - nums[0]) / min + 1;
			System.out.println(res);
		} catch (Exception e) {
			System.out.println(n);
		}
		sc.close();
	}
}

运行限制

• 最大运行时间：1s
• 最大运行内存: 128M

【方法一】

一开始以为要用大整数，结果发现没有超过long的范围，所以用long暴力求解就行

import java.util.Scanner;
//1:无需package
//2: 类名必须Main, 不可修改
public class Main {
 public static void main(String[] args) {
     Scanner scan = new Scanner(System.in);
     //在此输入您的代码...
     long num = 0;
     for (long i = 1; i <= 1000000007; i++) {
         if (i * 2021 % 1000000007 == 999999999) {
             num = i;
             System.out.println(num);
             return;
         }
     }
     scan.close();
 }
}

输入描述

输出描述

要求输出 4 个非负整数，按从小到大排序，中间用空格分开

输入输出样例

示例

输入

12

输出

0 2 2 2

运行限制

• 最大运行时间：3s
• 最大运行内存: 256M

【方法一】

暴力求解，四层循环，但是这里有个问题用(int)Math.sqrt(num)不会超时，Math.sqrt(num)会超时

import java.util.Scanner;
//1:无需package
//2: 类名必须Main, 不可修改
public class Main {
	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		// 在此输入您的代码...
		int num = scan.nextInt();
		int temp=(int)Math.sqrt(num);
		for (int a = 0; a <= temp; a++) {
			for (int b = a; b <= temp; b++) {
				for (int c = b; c <= temp; c++) {
					for (int d = c; d <= temp; d++) {
						if (a * a + b * b + c * c + d * d == num) {
							System.out.println(a + " " + b + " " + c + " " + d);
							return;
						}
					}
				}
			}
		}
		scan.close();
	}
}

运行限制

• 最大运行时间：1s
• 最大运行内存: 128M

【方法一】

这道题其实没啥难度，跟着题目的描述一起走就行了

import java.util.Scanner;
//1:无需package
//2: 类名必须Main, 不可修改
public class Main {
	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		// 在此输入您的代码...
		int count = 0;
		for (int friend = 27; friend <= 99; friend++) {
			int sun = friend - 27;
			int friendchange = Integer.parseInt(new StringBuffer(friend + "").reverse().toString());
			if (friendchange == sun) {
				count++;
			}
		}
		System.out.println(count);
		scan.close();
	}
}

本题为填空题，只需要算出结果后，在代码中使用输出语句将所填结果输出即可。

有一堆煤球，堆成三角棱锥形。具体： 第一层放 11 个， 第二层 33 个（排列成三角形）， 第三层 66 个（排列成三角形）， 第四层 1010 个（排列成三角形）， .... 如果一共有 100100 层，共有多少个煤球？

运行限制

• 最大运行时间：1s
• 最大运行内存: 128M

这道题目的数字是这样

1 3 6 10

1 1+2 3+3 6+4

import java.util.Scanner;
// 1:无需package
// 2: 类名必须Main, 不可修改
public class Main {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        //在此输入您的代码...
        int count=0;
        int num=0;
        int sum=0;
        for(int i=0;i<101;i++){
            num+=count;
            count++;
            sum=sum+num;
        }
        System.out.println(sum);
        scan.close();
    }
}

本题为填空题，只需要算出结果后，在代码中使用输出语句将所填结果输出即可。

如上图所示。图中的所有小方格面积都是 11。

那么，图中的三角形面积应该是多少呢？

运行限制

• 最大运行时间：1s
• 最大运行内存: 128M

这道题目用正方形减去旁边三个三角形面积即可

import java.util.Scanner;
// 1:无需package
// 2: 类名必须Main, 不可修改
public class Main {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        //在此输入您的代码...
        System.out.println(64-16-12-8);
        scan.close();
    }
}

题目描述

本题为填空题，只需要算出结果后，在代码中使用输出语句将所填结果输出即可。

小明刚刚看完电影《第 3939 级台阶》，离开电影院的时候，他数了数礼堂前的台阶数，恰好是 3939 级!

站在台阶前，他突然又想着一个问题：

如果我每一步只能迈上 11 个或 22 个台阶。先迈左脚，然后左右交替，最后一步是迈右脚，也就是说一共要走偶数步。那么，上完 3939 级台阶，有多少种不同的上法呢？

请你利用计算机的优势，帮助小明寻找答案。

运行限制

• 最大运行时间：1s
• 最大运行内存: 128M

import java.util.Scanner;
// 1:无需package
// 2: 类名必须Main, 不可修改
public class Main {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        //在此输入您的代码...
        System.out.println((step(39)+1)/2);
        scan.close();
    }
    public static long step(int num){
      if(num==1){
        return 1;
      }
      if(num==2){
        return 2;
      }
      return step(num-1)+step(num-2);
    }
}

本题为填空题，只需要算出结果后，在代码中使用输出语句将所填结果输出即可。

小明对数位中含有 2、0、1、92、0、1、9 的数字很感兴趣，在 11 到 4040 中这样的数包括 1、2、9、101、2、9、10 至 32、3932、39 和 4040，共 2828 个，他们的和是 574574，平方和是 1436214362。

注意，平方和是指将每个数分别平方后求和。

请问，在 11 到 20192019 中，所有这样的数的平方和是多少？

import java.util.Scanner;
// 1:无需package
// 2: 类名必须Main, 不可修改
public class Main {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        //在此输入您的代码...
        Long result = 0l;
        for (int i = 1; i <= 2019; i++) {
            String s = new String("" + i + "");
            if (s.contains("0") || s.contains("1") || s.contains("2") || s.contains("9")) {
                result += (long)Math.pow(i, 2);
            }
        }
        System.out.println(result);
        scan.close();
    }
}

输入描述

输出描述

输入输出样例

示例

输入

2 5 6 8 11 9 10 12 9

输出

7 9

运行限制

• 最大运行时间：1s
• 最大运行内存: 64M

首先先把所有的数字都列到一个数组里

然后查找两个数字相同的数字和前后差2的数字

import java.util.Scanner;
import java.util.*;
// 1:无需package
// 2: 类名必须Main, 不可修改
public class Main {
    public static void main(String[] args) {
        Scanner sc= new Scanner(System.in);
        ArrayList<Integer> a=new ArrayList<>();
        
        int n=sc.nextInt();
        sc.nextLine();//吸收掉整数后面的换行符
        for(int i=0;i<n;i++){
            String s=sc.nextLine();
            String[] x=s.split(" ");
            //将字符串一空格分割成若干个字符串，返回一个字符串数组
            for(int j=0;j<x.length;j++){
                a.add(Integer.parseInt(x[j]));
            }
        }
        int[] b=new int[a.size()];
        for(int i=0;i<a.size();i++){
            b[i]=a.get(i);
        }
        Arrays.sort(b);
        int x=0;//相同
        int y=0;//空掉
        for(int i=1;i<a.size();i++){
            if(b[i]-b[i-1]==0){
                x=b[i];
            }
            if(b[i]-b[i-1]==2){
                y=b[i]-1;
            }
        }
        System.out.println(y+" "+x);
    }
}

import java.util.Scanner;
import java.util.Calendar;
// 1:无需package
// 2: 类名必须Main, 不可修改
public class Main {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        //在此输入您的代码...
        Calendar calendar = Calendar.getInstance();
        calendar.set(Calendar.YEAR,2000);
        calendar.set(Calendar.MONTH,Calendar.MAY);
        calendar.set(Calendar.DATE,4);
        System.out.println(calendar.get(Calendar.DAY_OF_YEAR));
        scan.close();
    }
}

import java.util.Scanner;
// 1:无需package
// 2: 类名必须Main, 不可修改
public class Main {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        A:for(int i=1;i<=99;i++)
        {
          for(int j=1;j<=i+8;j++)
          {
            if(i*j==(i+j)*6)
            {
                System.out.println(i);
                  break A;
            }
          }
        }
        scan.close();
    }
}

20190324 这个数过于庞大 无论是递归还是迭代 程序都无法正常运行

而且int 、 long、BigDecimal等都无法、承载这么大的数 * 题目要求我们只取最后四位

那我们可以对每次运算出来的结果 %10000 这样每次结果就都保留最后四位数字

import java.util.Scanner;
// 1:无需package
// 2: 类名必须Main, 不可修改
public class Main {
      public static void main(String[] args) {
        int a = 1,b = 1,c = 1,d = 0;
        for(int i = 4;i<=20190324;i++){
            d = (a+b+c)%10000;
            a = b;
            b = c;
            c = d;
        }
        System.out.println(d);
    }
}

给定一个单词，请计算这个单词中有多少个元音字母，多少个辅音字母。

元音字母包括 a, e, i, o, u，共五个，其他均为辅音字母。

输入描述

输入格式：

输入一行，包含一个单词，单词中只包含小写英文字母。单词中的字母个数不超过 100。

输出描述

输出两行，第一行包含一个整数，表示元音字母的数量。

第二行包含一个整数，表示辅音字母的数量。

输入输出样例

示例

输入

lanqiao

输出

4 3

运行限制

• 最大运行时间：1s
• 最大运行内存: 256M

import java.util.Scanner;
// 1:无需package
// 2: 类名必须Main, 不可修改
public class Main {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        String str=scan.next();
        int a=0,b=0;
        for(int i=0;i<str.length();i++)
        {
          if(str.charAt(i)=='a'||str.charAt(i)=='e'||str.charAt(i)=='i'||str.charAt(i)=='o'||str.charAt(i)=='u')
          {
            a++;
          }
          else
          {
            b++;
          }
        }
        System.out.println(a);
        System.out.println(b);
        scan.close();
    }
}

import java.util.Scanner;
// 1:无需package
// 2: 类名必须Main, 不可修改
public class Main {
    public static void main(String[] args) {
        //在此输入您的代码...
        int i,j,sum;
        for(i=1900;i<2012;i++){
          for(j=1;j<30;j++){
              sum=i*10000+600+j;
              if(sum%2012==0 && sum%3==0 && sum%12==0){
                System.out.println(sum);
              }
          }
        }
    }
}

import java.util.*;
public class Main
{
    static int len(int x){
        if(x<10) return 1;
        return len(x/10)+1;
    }
    
    // 取x的第k位数字
    static int f(int x, int k){
        if(len(x)-k==0) return x%10;
        return ______________________;  //填空
    }
    
    public static void main(String[] args)
    {
        int x = 23513;
        //System.out.println(len(x));
        System.out.println(f(x,3));
        System.out.println(f(893275,2));
    }
}

import java.util.Scanner;
// 1:无需package
// 2: 类名必须Main, 不可修改
import java.util.*;
public class Main
{
    static int len(int x){
        if(x<10) return 1;
        return len(x/10)+1;
    }
    
    // 取x的第k位数字
    static int f(int x, int k){
        if(len(x)-k==0) return x%10;
        return (int)(x/Math.pow(10,len(x)-k))%10;  //填空
    }
    
    public static void main(String[] args)
    {
        int x = 23513;
        //System.out.println(len(x));
        System.out.println(f(x,3));
        System.out.println(f(893275,2));
    }
}

import java.util.Scanner;
// 1:无需package
// 2: 类名必须Main, 不可修改
public class Main {
    public static void main(String[] args) {
      for(int i = 1;;i++){
        int b = i;
        if(b % 5 == 1){
          b = (b-1)/5*4;
          if(b % 5 ==2){
            b = (b-2)/5*4;
            if(b % 5 == 3){
              b = (b-3)/5*4;
              if(b % 5 == 4){ 
                b = (b-4)/5*4;              
                if(b % 5 == 0 && b >= 5){//最少也有五个香蕉
                  System.out.println(i);
                  break;
                }
              }
            }
          }
        }
      }
    }
}

import java.util.Scanner;
// 1:无需package
// 2: 类名必须Main, 不可修改
public class Main {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        //在此输入您的代码...
        int sum=0;
        for(int i=1;i<=2019;i++){
            if((i+"").contains("2")||(i+"").contains("0")||(i+"").contains("1")||(i+"").contains("9")){
              sum=sum+i;
            }
        }
        System.out.println(sum);
        scan.close();
    }
}