1.多行输入,每次输入两个整数
import java.lang.*;
import java.util.*;
public class Main{
public static void main(String[] args){
Scanner in = new Scanner(System.in);
while(in.hasNextInt()){
int a = in.nextInt();
int b = in.nextInt();
System.out.println(a+b);
}
}
}
2.多组数据,每组第一行为n, 之后输入n行两个整数
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
while (scanner.hasNext()) {
int n = scanner.nextInt();
while (n-- > 0) {
int a = scanner.nextInt();
int b = scanner.nextInt();
System.out.println(a + b);
}
}
}
}
3.若干行输入,每行输入两个整数,遇到特定条件终止
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
while (scanner.hasNext()) {
int a = scanner.nextInt();
int b = scanner.nextInt();
if (a == 0 && b == 0) {
break;
}
System.out.println(a + b);
}
}
}
4.若干行输入,遇到0终止,每行第⼀个数为N,表示本行后面有N个数
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
while (scanner.hasNext()) {
int n = scanner.nextInt();
if (n == 0) {
break;
}
int sum = 0;
for (int i = 0; i < n; i++) {
sum += scanner.nextInt();
}
System.out.println(sum);
}
}
}
5.若干行输入,每行包括两个整数a和b,由空格分隔,每行输出 后接⼀个空行。
import java.util.Scanner;
public class Main{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
while(sc.hasNextLine()){
int a = sc.nextInt();
int b = sc.nextInt();
System.out.println(a + b);
System.out.println();
}
}
}
6.多组n行数据,每行先输入一个整数N,然后在同一行内输入M个整数,每组输出之间输出一个空行。
import java.util.Scanner;
public class Main{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
while(sc.hasNextLine()){
int N = sc.nextInt();
// 每组有n⾏数据
while(N-- > 0){
int M = sc.nextInt();
int sum = 0;
// 每⾏有m个数据
while(M-- > 0){
sum += sc.nextInt();
}
System.out.println(sum);
if(N > 0) System.out.println();
}
}
}
}
7.多组测试样例,每组输⼊数据为字符串,字符用空格分隔,输出 为小数点后两位
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
while (in.hasNextLine()) {
String line = in.nextLine(); // 接收⼀整⾏字符串作为输⼊
String[] items = line.split(" "); // 字符串分割成数组
for (String item : items) { // 遍历数组
}
}
}
}
8.多组测试用例,第一行为正整数n, 第二行为n个正整数,n=0 时,结束输入,每组输出结果的下面都输出⼀个空行
import java.util.ArrayList;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
while (scanner.hasNext()) {
Integer size = scanner.nextInt();
if (size == 0) {
break;
}
// 创建list
ArrayList<Integer> list = new ArrayList<>();
// 添加⼀组数据到list中
for (int i = 0; i < size; i++) {
int num = scanner.nextInt();
list.add(num);
}
// 遍历
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}
System.out.println(res);
System.out.println();
}
}
}
9. 多组测试数据,每组数据只有一个整数,对于每组输入数据, 输出一行,每组数据下方有⼀个空行。
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
while (in.hasNextInt()) {
int n = in.nextInt();
while (n > 0) {
int tmp = n % 10; // 获取各位数据
n /= 10;
}
System.out.println(res);
System.out.println();
}
}
}
10.多组测试数据,每个测试实例包括2个整数M,K (2<=k<=M<=1000)。M=0,K=0代表输入结束。
import java.util.*;
public class Main{
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
while (sc.hasNextInt()) {
int m = sc.nextInt();
int k = sc.nextInt();
if (m == 0 && k == 0) break;
int sum = 0;
System.out.println(sum);
}
}
}
11.多组测试数据,首先输入⼀个整数N,接下来N行每行输入两个整数a和b, 读取输入数据到Map
import java.util.*;
public class Main{
static Map<Integer, Integer> map = new HashMap();
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
while (sc.hasNextInt()) {
int n = sc.nextInt();
for (int i = 0; i < n; i++) {
int a = sc.nextInt();
int b = sc.nextInt();
map.put(a, b);
}
}
}
}
12.多组测试数据。每组输入⼀个整数n,输出特定的数字图形
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
while (scanner.hasNext()) {
int n = scanner.nextInt();
for (int i = 1; i <= n; i++) {
print(n - i, i);
}
for (int i = n - 1; i >= 1; i--) {
print(n - i, i);
}
}
}
public static void print(int blank, int n) {
// 前⾯需要补⻬空格
for (int i = 0; i < blank; i++) {
System.out.print(" ");
}
for (int i = 1; i <= n; i++) {
System.out.print(i);
}
for (int i = n - 1; i > 0; i--) {
System.out.print(i);
}
System.out.println();
}
}
13.多行输入,每行输入为⼀个字符和⼀个整数,遇到特殊字符结束
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
while (sc.hasNext()) {
String line = sc.nextLine();
if (line.equals("@"))
break;
String[] inputs = line.split(" ");
char ch = inputs[0].charAt(0);
int n = Integer.parseInt(inputs[1]);
}
sc.close();
}
}
14.第一行是⼀个整数n,表示⼀共有n组测试数据, 之后输入n行字符串
import java.util.*;
public class Main{
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
while (sc.hasNextInt()) {
int n = sc.nextInt();
sc.nextLine();
for (int i = 0; i < n; i++) {
String line = sc.nextLine().trim();
StringBuilder sb = new StringBuilder();
System.out.println(sb.toString());
}
}
}
}
15.第⼀行是⼀个整数n,然后是n组数据,每组数据2行,每行为⼀个字符串,为每组数据输出⼀个字符串,每组输出占⼀行
import java.util.Scanner;
public class Main{
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int n = in.nextInt();
for (int i = 0; i < n; i++) {
String a = in.next();
String b = in.next();
StringBuilder sb = new StringBuilder(a);
System.out.println(sb.toString());
}
}
}
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
public class Main {
public static void main(String[] args) throws IOException {
BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
String str = null;
while((str = reader.readLine())!= null){
StringTokenizer tokenizer = new StringTokenizer(str);
int n = Integer.parseInt(tokenizer.nextToken());
for(int i = 0; i < n; i++){
String a = reader.readLine();
String b = reader.readLine();
StringBuilder sb = new StringBuilder();
System.out.println(sb.toString());
}
}
}
}
16.多组测试数据,第⼀行是⼀个整数n,接下来是n组字符串, 输出字符串
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
public class Main {
public static void main(String[] args) throws IOException {
BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
String str = null;
while((str = reader.readLine())!= null){
StringTokenizer tokenizer = new StringTokenizer(str);
int n = Integer.parseInt(tokenizer.nextToken());
for(int i = 0; i < n; i++){
String s = reader.readLine();
StringBuilder sb = new StringBuilder();
System.out.println(sb.toString());
}
}
}
}
// ⽅法⼆:原地交换
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
sc.nextLine();
for (int i = 0; i < n; i++) {
String s1 = sc.nextLine();
int len = s1.length();
char[] chs = s1.toCharArray();
System.out.println(new String(chs));
}
sc.close();
}
}
17.多组测试数据,每组测试数据的第⼀行为整数N (1<=N<=100),当N=0时,输⼊结束,第二行为N个正整数, 以空格隔开,输出结果为字符串
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
public class Main {
public static void main(String[] args) throws IOException {
BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
String str = null;
while((str = reader.readLine())!= null){
StringTokenizer tokenizer = new StringTokenizer(str);
// 读取n
int n = Integer.parseInt(tokenizer.nextToken());
if(n == 0){
break;
}
int[] arr = new int[n];
tokenizer = new StringTokenizer(reader.readLine());
// 读取n个正整数
for(int i = 0; i < n; i++){
arr[i] = Integer.parseInt(tokenizer.nextToken());
}
if(check(arr)){
System.out.println("Yes");
}else{
System.out.println("No");
}
}
}
}
// ⽅法⼆:使⽤栈模拟
import java.util.Scanner;
import java.util.Stack;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
while (true) {
int n = sc.nextInt();
if (n == 0)
break;
Stack<Integer> stack = new Stack<>();
for (int i = 0; i < n; i++)
stack.push(sc.nextInt())
}
if (isValidPopSequence(n, poppedSequence))
System.out.println("Yes");
else
System.out.println("No");
}
sc.close();
}
}
18.⼀组输⼊数据,第⼀行为n+1个整数,逆序插⼊n个整数,第二行为⼀个整数m, 接下来有m行字符串,并根据字符串内容输 ⼊不同个数的数据
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
// 输⼊n
int n = sc.nextInt();
// 输⼊n个整数
for (int i = 0; i < n; i++) {
int num = sc.nextInt();
linkedList.addFirst(num);
}
// 输⼊m
int m = sc.nextInt();
// 输⼊m个字符串
for (int i = 0; i < m; i++) {
// 获取输⼊的字符串
String operation = sc.next();
// 根据输⼊内容,给出不同输出结果
if ("get".equals(operation)) {
int a = sc.nextInt();
int result = linkedList.get(a - 1);
if (result != -1) {
System.out.println(result);
} else {
System.out.println("get fail");
}
} else if ("delete".equals(operation)) {
int a = sc.nextInt();
boolean deleteResult = linkedList.delete(a - 1);
if (deleteResult) {
System.out.println("delete OK");
} else {
System.out.println("delete fail");
}
} else if ("insert".equals(operation)) {
int a = sc.nextInt();
int e = sc.nextInt();
boolean insertResult = linkedList.insert(a - 1, e);
if (insertResult) {
System.out.println("insert OK");
} else {
System.out.println("insert fail");
}
} else if ("show".equals(operation)) {
linkedList.show();
}
}
sc.close();
}
19.多组测试数据,每行为n+1个数字, 输出链表或对应的字符串
import java.util.Scanner;
public class Main{
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
while (sc.hasNextLine()) {
String[] str = sc.nextLine().split(" ");
if (Integer.parseInt(str[0]) == 0) {
System.out.println("list is empty");
}
ListNode dummyhead = new ListNode(-1);
ListNode cur = dummyhead;
//构造链表
for (int i = 1; i < str.length; i++) {
ListNode temp = new ListNode(Integer.parseInt(str[i]));
cur.next = temp;
cur = cur.next;
if (i == str.length - 1) cur.next = null;
}
//输出原链表
ListNode pointer = dummyhead.next;
while (pointer != null) {
System.out.print(pointer.val + " ");
pointer = pointer.next;
}
System.out.println();
}
}
}
20.多组输入,每组输入包含两个字符串,输出字符串
public class Main{
public static Map<Character, Integer> map = new HashMap();
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
while (sc.hasNextLine()) {
String s = sc.nextLine();
String[] ss = s.split(" ");
String pre = ss[0];
String in = ss[1];
// 构建⼆叉树
TreeNode res = afterHelper(pre.toCharArray(), in.toCharArray());
//打印⼆叉树
printTree(res);
System.out.println();
}
}
public static void printTree(TreeNode root) {
if (root == null) return;
printTree(root.left);
printTree(root.right);
System.out.print(root.val);
}
}
21.⼀组多行数据,第⼀行为数字n, 表示后面有n行,后面每行 为1个字符加2个整数,输出树节点的后序遍历字符串
import java.util.*;
class TreeNode {
char val;
TreeNode left;
TreeNode right;
public TreeNode(char val) {
this.val = val;
}
}
public class Main{
static TreeNode[] nodes = new TreeNode[30];
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
while (sc.hasNextInt()) {
int len = sc.nextInt();
for (int i = 0; i < len; i++) {
// 获取字符和左右⼦节点
char val = sc.next().charAt(0);
int left = sc.nextInt();
int right = sc.nextInt();
}
preorder(nodes[1]);
System.out.println();
inorder(nodes[1]);
System.out.println();
postorder(nodes[1]);
System.out.println();
}
}
public static void preorder(TreeNode root) {
if (root == null) return;
System.out.print(root.val);
preorder(root.left);
preorder(root.right);
}
public static void inorder(TreeNode root) {
if (root == null) return;
inorder(root.left);
System.out.print(root.val);
inorder(root.right);
}
public static void postorder(TreeNode root) {
if (root == null) return;
postorder(root.left);
postorder(root.right);
System.out.print(root.val);
}
}
// ⽅法⼆:使⽤索引,简化构建树的过程
import java.util.Scanner;
public class Main {
static class TreeNode {
char val;
int left;
int right;
public TreeNode(char val, int left, int right) {
this.val = val;
this.left = left;
this.right = right;
}
}
static TreeNode[] nodes;
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
nodes = new TreeNode[n + 1];
for (int i = 0; i < n; i++) {
char val = sc.next().charAt(0);
int left = sc.nextInt();
int right = sc.nextInt();
nodes[i + 1] = new TreeNode(val, left, right);
}
preOrderTraversal(1);
System.out.println();
inOrderTraversal(1);
System.out.println();
postOrderTraversal(1);
System.out.println();
sc.close();
}
private static void postOrderTraversal(int root) {
if (root == 0)
return;
postOrderTraversal(nodes[root].left);
postOrderTraversal(nodes[root].right);
System.out.print(nodes[root].val);
}
private static void inOrderTraversal(int root) {
if (root == 0)
return;
inOrderTraversal(nodes[root].left);
System.out.print(nodes[root].val);
inOrderTraversal(nodes[root].right);
}
private static void preOrderTraversal(int root) {
if (root == 0)
return;
System.out.print(nodes[root].val);
preOrderTraversal(nodes[root].left);
preOrderTraversal(nodes[root].right);
}
}
22.多组测试数据,首先给出正整数N,接着输入两行字符串, 字符串⻓度为N
// ⽅法⼀:递归
import java.util.Scanner;
public class Main {
static class TreeNode {
char val;
TreeNode left;
TreeNode right;
TreeNode(char val) {
this.val = val;
this.left = null;
this.right = null;
}
}
private static int getHeight(TreeNode root) {
if (root == null)
return 0;
int leftHeight = getHeight(root.left);
int rightHeight = getHeight(root.right);
return Math.max(leftHeight, rightHeight) + 1;
}
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
while (sc.hasNext()) {
sc.nextInt();
String preOrder = sc.next();
String inOrder = sc.next();
TreeNode root = buildTree(preOrder, inOrder);
int height = getHeight(root);
System.out.println(height);
}
sc.close();
}
}
// ⽅法⼆:递归(使⽤哈希表来优化中序遍历中查找根节点位置的过程)
import java.util.HashMap;
import java.util.Scanner;
public class Main {
static class TreeNode {
char val;
TreeNode left;
TreeNode right;
TreeNode(char val) {
this.val = val;
this.left = null;
this.right = null;
}
}
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
while (sc.hasNext()) {
int N = sc.nextInt();
String preOrder = sc.next();
String inOrder = sc.next();
HashMap<Character, Integer> inOrderMap = new HashMap<>();
for (int i = 0; i < N; i++) {
inOrderMap.put(inOrder.charAt(i), i);
}
TreeNode root = buildTree(preOrder, 0, N - 1, 0, N - 1, inOrderMap);
int height = getHeight(root);
System.out.println(height);
}
sc.close();
}
private static int getHeight(TreeNode root) {
if (root == null) {
return 0;
}
int leftHeight = getHeight(root.left);
int rightHeight = getHeight(root.right);
return Math.max(leftHeight, rightHeight) + 1;
}
}
23.多组测试数据。每组输入占一行,为两个字符串,由若干个 空格分隔
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
while (scanner.hasNextLine()) {
String line = scanner.nextLine();
String[] s = line.split(" ");
String x = s[0];
String y = s[1];
int m = x.length();
int n = y.length();
// 初始化dp数组
int[][] dp = new int[m + 1][n + 1];
// 输出
int max = dp[m][n];
System.out.println(max);
}
}
}
24.多组测试数据,每组第一行为两个正整数n和m,接下来m行,每行3个整数, 最后⼀⾏两个整数
import java.util.Arrays;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
while (scanner.hasNext()) {
// 处理输⼊
int n = scanner.nextInt();
int m = scanner.nextInt();
for (int i = 0; i < m; i++) {
int a = scanner.nextInt();
int b = scanner.nextInt();
int l = scanner.nextInt();
}
int x = scanner.nextInt();
int y = scanner.nextInt();
// 处理输出
int res = dfs(graph, x, y, isVisit, sum);
if (res != Integer.MAX_VALUE) {
System.out.println(res);
} else {
System.out.println("No path");
}
}
}
private static int dfs(int[][] graph, int start, int end, int[] isVisit, int sum) {
if (end == start) {
return sum;
}
return min;
}
}