Java语言的ACM输入输出模版

batcat560

于 2024-05-27 17:02:56 发布

阅读量532

点赞数 10

分类专栏：力扣刷题记录文章标签： java 开发语言

本文链接：https://blog.csdn.net/batcat560/article/details/139239311

版权

力扣刷题记录专栏收录该内容

3 篇文章 0 订阅

订阅专栏

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;
 }
}