ACM（OJ）模式下对于各种输入输出情况的总结（JAVA）

已于 2022-09-14 10:00:30 修改
阅读量1.2w 收藏 212
点赞数 45
分类专栏： 算法分析 华为机试 文章标签： java 算法 OJ模式 输入输出
于 2021-09-05 17:27:28 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44052055/article/details/120117628
版权

在刷牛客网时，遇到一类机试（华为机试）是采用ACM模式下的算法，这样针对不同的输入输出就需要有一个大致的了解。

牛客网题目链接：https://ac.nowcoder.com/acm/contest/5657#question

首先对与Java的输入，要用Scanner：

Scanner in = new Scanner(System.in);

读取字符或行：

in.hasNext()
in.hasNextLine()

使用的方法总结：

采用has xxxx的话，后面也要用next xxxx。比如前面用hasNextLine，那么后面要用 nextLine 来处理输入。

具体区别参考：笔试在线判题系统输入输出（剑指Offer类和传统ACM的OJ模式）

以下是针对各种输入输出条件下举例实现的Java代码：

1. 多组空格分割的两个整数 （无行数，结束字符限制）

题目描述：

输入包括两个正整数a,b(1 <= a, b <= 10^9),输入数据包括多组。
输出a+b的结果

输入示例：

1 5
10 20

输出示例

6
30

import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        while (in.hasNext()) { 
            int a = in.nextInt();
            int b = in.nextInt();
            System.out.println(a + b);
        }
    }
}

2. 第一行组数接空格分割的两个正整数 （行数限制）

题目描述：

输入第一行包括一个数据组数t(1 <= t <= 100)
接下来每行包括两个正整数a,b(1 <= a, b <= 10^9)
输出a+b的结果

输入示例：

2
1 5
10 20

输出示例：

6
30

import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int num = in.nextInt();
        for(int i = 0; i < num; i++) { // 注意 while 处理多个 case
            int a = in.nextInt();
            int b = in.nextInt();
            System.out.println(a + b);
        }
    }
}

3. 空行分割的两个正整数，0 0 结束 （结束符限制）

题目描述：

输入包括两个正整数a,b(1 <= a, b <= 10^9),输入数据有多组, 如果输入为0 0则结束输入
输出a+b的结果

输入示例：

1 5
10 20
0 0

输出示例：

6
30

import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        
        while (in.hasNext()) { 
            int a = in.nextInt();
            int b = in.nextInt();
            if(a ==0 && b == 0) break;
            System.out.println(a + b);
        }
    }
}

4. 每行第一个为个数后带空格分割整数，0结束 （结束符限制,每行有个数限制）

题目描述：

输入数据包括多组。
每组数据一行,每行的第一个整数为整数的个数n(1 <= n <= 100), n为0的时候结束输入。
接下来n个正整数,即需要求和的每个正整数。

每组数据输出求和的结果

输入示例：

4 1 2 3 4
5 1 2 3 4 5
0

输出示例：

10
15

import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        
        while (in.hasNext()) { 
            int n = in.nextInt();
            if(n == 0) break;
            int sum = 0;
            for (int i = 0; i < n; i++) {
                sum += in.nextInt();
            }
            System.out.println(sum);
        }
    }
}

5. 第一行组数接第一个个数接空格分开的整数 （行数限制,每行有个数限制）

题目描述：

输入的第一行包括一个正整数t(1 <= t <= 100), 表示数据组数。
接下来t行, 每行一组数据。
每行的第一个整数为整数的个数n(1 <= n <= 100)。
接下来n个正整数, 即需要求和的每个正整数。

每组数据输出求和的结果

输入示例：

2
4 1 2 3 4
5 1 2 3 4 5

输出示例：

10
15

import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
    
        Scanner in = new Scanner(System.in);
        
        int num = in.nextInt();
        for (int i = 0; i < num; i++){
            int n = in.nextInt();
            int sum = 0;
            for(int j = 0; j < n; j++){
                sum += in.nextInt();
            }
            System.out.println(sum);
        }
    }
}

6. 每行第一个为个数后带空格分割整数 (无结束限制,每行有个数限制)

题目描述：

输入数据有多组, 每行表示一组输入数据。
每行的第一个整数为整数的个数n(1 <= n <= 100)。
接下来n个正整数, 即需要求和的每个正整数。

每组数据输出求和的结果

输入示例：

4 1 2 3 4
5 1 2 3 4 5

输出示例：

10
15

import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        while (in.hasNextInt()) { 
            int n = in.nextInt();
            int sum = 0;
            while (n > 0) {
                sum += in.nextInt();
                n--;
            }
            System.out.println(sum);
        }
    }
}

7. 多组空格分隔的正整数 (无结束限制,每行无个数限制,需要当作字符串处理)

题目描述：

输入数据有多组, 每行表示一组输入数据。
每行不定有n个整数，空格隔开。(1 <= n <= 100)。

每组数据输出求和的结果

输入示例：

1 2 3
4 5
0 0 0 0 0

输出示例：

6
9
0

import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        while (in.hasNextLine()) { 
            String[] s = in.nextLine().split(" ");
            int sum = 0;
            for (int i = 0; i < s.length; i++) {
                sum += Integer.parseInt(s[i]);
            }
            System.out.println(sum);
        }
    }
}

// 扩展：第一行组数接空格分开的多个整数 (有行数限制,每行无个数限制,需要当作字符串处理)
// 需要注意的是：读取行数后，要加一行in.nextLine();再读下面的行。
// eg: 每组数据输出求和的结果
// 3
// 1 2 3
// 4 5
// 0 0 0 0 0

import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int num = in.nextInt();
        in.nextLine();  // 注意：跳过行数所在行
        for (int i = 0; i < num; i++ ){
            String[] s = in.nextLine().split(" ");
            int sum = 0;
            for(int j = 0; j < s.length; j++){
                sum += Integer.parseInt(s[j]);  // 将字符转成整数类型
            }
            System.out.println(sum);
        }
    }
}

8. 第一行个数第二行字符串

题目描述：

输入有两行，第一行n
第二行是n个空格隔开的字符串

输出一行排序后的字符串，空格隔开，无结尾空格

输入示例：

5
c d a bb e

输出示例：

a bb c d e

import java.util.*;
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        in.nextLine();
        while (in.hasNext()) { 
            String[] s = in.nextLine().split(" ");
            Arrays.sort(s);
            for (int i = 0; i < s.length; i++) {
                System.out.print(s[i] + " ");
            }
            
        }
    }
}

9. 多行空格分开的字符串

题目描述：

多个测试用例，每个测试用例一行。
每行通过空格隔开，有n个字符，n＜100

对于每组测试用例，输出一行排序过的字符串，每个字符串通过空格隔开

输入示例：

a c bb
f dddd
nowcoder

输出示例：

a bb c
dddd f
nowcoder

import java.util.*;
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        while (in.hasNextLine()) { 
            String[] s = in.nextLine().split(" ");
            Arrays.sort(s);
            for (String c:s) {
                System.out.print(c + " ");
            }
            System.out.println();
        }
    }
}

10. 多行逗号分开的字符串 （逗号和空格的区别就是最后一个字符输完的时候",“还是” " ）

题目描述：

多个测试用例，每个测试用例一行。
每行通过,隔开，有n个字符，n＜100

对于每组用例输出一行排序后的字符串，用','隔开，无结尾空格

输入示例：

a,c,bb
f,dddd
nowcoder

输出示例：

a,bb,c
dddd,f
nowcoder

import java.util.*;
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        while (in.hasNextLine()) { 
            String[] s = in.nextLine().split(",");
            Arrays.sort(s);
            int l = s.length;
            for (int i = 0; i < l - 1; i++) {
                System.out.print(s[i] + ",");
            }
            System.out.println(s[l-1]);
        }
    }
}

以上就是遇到的各种输入输出的一个总结，后面再遇到新的情况会及时更新。

一个整体的代码如下：

import java.util.Arrays;
import java.util.Scanner;

public class InOutTest {
    public static void main(String[] args){
        // 1. 多组空格分割的两个整数
        // eg：每行输入两个数求和
        // 1 5
        // 10 20
//        Scanner in = new Scanner(System.in);
//        while (in.hasNext()){ // while处理多个case
//            int a = in.nextInt();
//            int b = in.nextInt();
//            System.out.println(a + b);
//        }

        // 2. 第一行组数接空格分割的两个正整数 （行数限制）
        // eg: 输出a+b的结果
        // 2
        // 1 5
        // 10 20
//        Scanner in = new Scanner(System.in);
//        int num = in.nextInt();
//        for (int i =0; i < num; i++){
//            int a = in.nextInt();
//            int b = in.nextInt();
//            System.out.println(a + b);
//        }

        // 3. 空行分割的两个正整数，0 0 结束 （结束符限制）
        // eg: 输出a+b的结果
        // 1 5
        // 10 20
        // 0 0
//        Scanner in = new Scanner(System.in);
//        while (in.hasNext()){
//            int a = in.nextInt();
//            int b = in.nextInt();
//            if(a == 0 && b == 0) break;
//            System.out.println(a + b);
//        }

        // 4. 每行第一个为个数后带空格分割整数，0结束 （结束符限制,每行有个数限制）
        // 输入数据包括多组。
        // 每组数据一行,每行的第一个整数为整数的个数n(1 <= n <= 100), n为0的时候结束输入。
        // 接下来n个正整数,即需要求和的每个正整数。
        // eg: 每组数据输出求和的结果
        // 4 1 2 3 4
        // 5 1 2 3 4 5
        // 0
//        Scanner in = new Scanner(System.in);
//        while (in.hasNext()){
//            int n = in.nextInt();
//            if (n == 0) break;
//            int sum = 0;
//            for (int i = 0; i < n; i++){
//                sum += in.nextInt();
//            }
//            System.out.println(sum);
//        }

        // 5. 第一行组数接第一个个数接空格分开的整数 （行数限制,每行有个数限制）
        // 输入的第一行包括一个正整数t(1 <= t <= 100), 表示数据组数。
        // 接下来t行, 每行一组数据。
        // 每行的第一个整数为整数的个数n(1 <= n <= 100)。
        // 接下来n个正整数, 即需要求和的每个正整数。
        // eg: 每组数据输出求和的结果
        // 2
        // 4 1 2 3 4
        // 5 1 2 3 4 5
//        Scanner in = new Scanner(System.in);
//        int num = in.nextInt();
//        for (int i = 0; i < num; i++){
//            int n = in.nextInt();
//            int sum = 0;
//            for(int j = 0; j < n; j++){
//                sum += in.nextInt();
//            }
//            System.out.println(sum);
//        }
        // 6. 每行第一个为个数后带空格分割整数 (无结束限制,每行有个数限制)
        // 输入数据有多组, 每行表示一组输入数据。
        // 每行的第一个整数为整数的个数n(1 <= n <= 100)。
        // 接下来n个正整数, 即需要求和的每个正整数。
        // eg: 每组数据输出求和的结果
        // 4 1 2 3 4
        // 5 1 2 3 4 5
//        Scanner in = new Scanner(System.in);
//        while (in.hasNextInt()){
//            int num = in.nextInt();
//            int sum = 0;
//            for(int i = 0; i < num; i++){
//                sum += in.nextInt();
//            }
//            System.out.println(sum);
//        }

        // 7. 多组空格分隔的正整数 (无结束限制,每行无个数限制,需要当作字符串处理)
        // 输入数据有多组, 每行表示一组输入数据。
        // 每行不定有n个整数，空格隔开。(1 <= n <= 100)。
        // eg: 每组数据输出求和的结果
        // 1 2 3
        // 4 5
        // 0 0 0 0 0 0
//        Scanner in = new Scanner(System.in);
//        while (in.hasNextLine()){   // 直接读一行字符串
//            String[] s = in.nextLine().split(" ");
//            int sum = 0;
//            for(int i = 0; i < s.length; i++){
//                sum += Integer.parseInt(s[i]);
//            }
//            System.out.println(sum);
//        }

        // 扩展：第一行组数接空格分开的多个整数 (有行数限制,每行无个数限制,需要当作字符串处理)
        // eg: 每组数据输出求和的结果
        // 3
        // 1 2 3
        // 4 5
        // 0 0 0 0 0
        Scanner in = new Scanner(System.in);
        int num = in.nextInt();
        in.nextLine();  // 跳过行数所在行
        for (int i = 0; i < num; i++ ){
            String[] s = in.nextLine().split(" ");
            int sum = 0;
            for(int j = 0; j < s.length; j++){
                sum += Integer.parseInt(s[j]);
            }
            System.out.println(sum);
        }


        // 8. 第一行个数第二行字符串
        // 输入有两行，第一行n
        // 第二行是n个空格隔开的字符串
        // eg: 输出一行排序后的字符串，空格隔开，无结尾空格
        // 5
        // c d a bb e
//        Scanner in = new Scanner(System.in);
//        int num = in.nextInt();
//        in.nextLine();
//        while (in.hasNext()){
//            String[] s = in.nextLine().split(" ");
//            Arrays.sort(s);
//            for (int i = 0; i < s.length; i++){
//                System.out.print(s[i] + " ");
//            }
//        }

        // 9. 多行空格分开的字符串
        // 多个测试用例，每个测试用例一行。
        // 每行通过空格隔开，有n个字符，n＜100
        // eg: 对于每组测试用例，输出一行排序过的字符串，每个字符串通过空格隔开
        // a c bb
        // f dddd
        // nowcoder
//        Scanner in = new Scanner(System.in);
//        while (in.hasNextLine()){
//            String[] s = in.nextLine().split(" ");
//            Arrays.sort(s);
//            for (String c:s){
//                System.out.print(c + " ");
//            }
//            System.out.println();
//        }

        // 10. 多行逗号分开的字符串 （逗号和空格的区别就是最后一个字符输完的时候","还是" " ）
        // 多个测试用例，每个测试用例一行。
        // 每行通过,隔开，有n个字符，n＜100
        // eg: 对于每组用例输出一行排序后的字符串，用','隔开，无结尾空格
        // a,c,bb
        // f,dddd
        // nowcoder
//        Scanner in = new Scanner(System.in);
//        while (in.hasNextLine()) {
//            String[] s = in.nextLine().split(",");
//            Arrays.sort(s);
//            int l = s.length;
//            for (int i = 0; i < l - 1; i++) {
//                System.out.print(s[i] + ",");
//            }
//            System.out.println(s[l-1]);
//        }

    }

}

在做笔试题的时候，遇到了一道输入一个Java代码，输出for循环的嵌套层数问题，这种需要循环读入字符串，直到遇到"}"。
在这里插入图片描述

String[] codes = new String[10000];
int index = 0;
String s = null;
while (!(s = in.nextLine()).equals("}")) {
    codes[index++] = s;
}

定义了一个数组，把每行字符串存到数组里面，这里也可以用动态数组。

注意的是，这里只需要定义字符串s，判断s = in.nextLine()).equals("}")即可。同理，遇到空行结束什么的也可以这样处理。

小朱小朱绝不服输
关注
  • 45
    点赞
  • 踩
  • 212
    收藏
    觉得还不错? 一键收藏
  • 5
    评论
专栏目录
nextline函数_JAVA中hashNextLine的用法。
weixin_42168830的博客
12-29 836
java语言中hasNextLine用于控制台输入或者读取文本文件时的输入扫描器(java.util.Scanner类)扫描,当扫描到存在下一行时,hasNextLine返回true,没有下一行输入或者文本文件没有下一行时,返回false.一般用于读取文本文件或控制台输入的数据时,while循环的判断条件,比如 while(in.hasNextLine()),如果有下一行就执行while循环,没有...
java进行ACM读入输出
12-08
详细讲述了用java进行ACM刷题的方法，包括输入输出等，总之对刚入门的用java进行amc的朋友很有帮助。
ACM之java速成
12-22
这里指的java速成，只限于java语法，包括输入输出，运算处理，字符串和高精度的处理，进制之间的转换等，能解决OJ上的一些高精度题目。 　　1. 输入： 　　格式为：Scanner cin = new Scanner (new BufferedInputStream(System.in)); 　　例程：   import java.io.*; import java.math.*; import java.util.*; import java.text.*; public class Main { pu
ACM入门之基本输入输出
06-16
ACM入门必看 的 OJ系统基本输入输出格式
Java链表oj题（快慢指针）
最新发布
qq_62771564的博客
03-19 1560
这几道oj题运用了快慢指针、双指针等思想，重点是一定要画图理解，然后慢慢整理思路，考虑各种情况，最后调试t=N7T8t=N7T8t=N7T8t=N7T8t=N7T8876. 链表的中间结点 - 力扣（LeetCode）https://leetcode.cn/problems/middle-of-the-linked-list/description/链表中倒数最后k个结点_牛客题霸_牛客网输入一个长度为 n 的链表，设链表中的元素的值为 ai ，返回该链表中倒数第k个节点。。
牛客网输入输出问题，java输入hasNext和hasNextLine区别
qq_42070000的博客
07-13 1379
比如一道牛客网题目的输入是这样的 7 15 9 5 采用java语言的话，有的同学这样处理输入输出复制代码12345 牛客网的系统会提示错误，但是如果把hasNextLine改成hasNext或者hasNextInt的话，就会提示正确复制代码1234 这里要说明一下java中，hasNextLine和hasNext的区别。先说结论：采用has xxxx的话，后面也要用next xxxx。比如前面用hasNextLine，那么后面要用 nextLine 来处理输入。---------------分割线
JAVA——ACM模式下输入输出总结
m0_50916733的博客
03-01 755
1. JAVA输入需要用到Scanner类导入类 import java.util.Scanner;
【ACM模式】牛客网ACM机试模式Python&Java&C++主流语言OJ输入输出案例代码总结
热门推荐
苏柒的博客
05-14 2万+
前言 前天做最后一批华为软件机试时，因为完全不清楚这种所谓的ACM模式，刚看到的时候就傻眼了，即使已经看到了这种区别，但是也没有充分的提前准备好应对，因此光输入输出都卡了好久，最后也有自己的原因基本等于交了白卷。 看网上评论说大家都会有这个问题，因此也算是正常。自己也要从哪里跌倒就从哪里爬起来，把这个难点给克服了，不然以后遇到同样的机试还是干瞪眼。 学习的过程顺便留下记录，以便日后翻阅。 题目链接：OJ在线编程常见输入输出练习场 提交记录 ：ACM/NOI/CSP/CCPC/ICPC算法编程高难度练习赛 分
JAVA基础：Scanner类中next(),nextline(),hasnext(),hasnextline()浅析
LZKKJD的博客
08-01 2308
在JAVA的初阶段学习中，经常会把这几个函数搞混，或者对他们的用法模糊不清。 下面将对这四个函数进行理论和举例分析，以及少许用法。 先给理论： next():只读取输入直到空格。它不能读两个由空格或符号隔开的单词。此外，next()在读取输入后将光标放在同一行中。next()只读空格之前的数据,并且光标指向本行。 nextLine():读取输入，包括单词之间的空格和除回车以外的所有符号(即它读到行尾)。读取输入后，nextLine()将光标定位在下一行。 可能...
牛客网ACM模式 JsV8和Java输入输出练习
好好学习天天向上
04-17 7367
文章目录牛客网ACM模式 JsV8和Java输入输出练习背景输入输出语法JS V8JAVAVS Code配置Java运行环境题目1 多行输入多行输出 行数列数确定JS题目2 由第一行输入确定行数 行数不确定列数确定JS题目3 由特定的输入表示输入结束 行数不确定列数确定js题目4 特定的输入结束符 列数不确定JS题目5 行数列数都不确定JS题目6 字符串排序JS题目7 字符串排序 多行输入 牛客网ACM模式 JsV8和Java输入输出练习 背景 事情是这个样子，第一次笔试时发现笔试题是ACM模式，要自己写
hasNext() hasNextLine() next() nextLine() 详解
tay1213wwb的博客
05-18 851
java的hasNext()、hasNextLine()、next()、nextLine()函数详解
Java ACM模式 处理输入输出
weixin_43916896的博客
12-04 3087
牛客网算法题的acm模式需要自己处理输入和输出，在此记录一下一些值得注意的细节 1、基本答题框架： import java.util.*; public class Main{ public static void main(String[] args){ Scanner sc = new Scanner(System.in); } } 2、next() 和 nextLine()的区别： 　1、next（）会自动消去有效字符前的空格，只返
ACM基本输入输出
01-24
详细的各种情况的ACM基本输入输出和练习，附有完整的代码
ACM中使用java
10-08
ACM中使用java时输入输出重定向的方法，自己总结的，绝对使用！
oj1199.java
07-26
在一个N*N的方阵中，填入1，2，……N 共N个数，并要求构成如下的格式：N<=10, 例： N=4 10 11 12 1 9 16 13 2 8 15 14 3 7 6 5 4 输入 多组数据，每行读入一个N. 输出 对应输出N*N的蛇形矩阵，每个数字占3格子, 每个蛇形矩阵之间用空行分割. 每个测试案例之间有一个空行
ACM模式输入输出攻略 - C++篇.pdf
02-22
ACM模式输入输出攻略 _ C++篇
Java实现OJ多组测试数据的输入方法
08-27
今天小编就为大家分享一篇Java实现OJ多组测试数据的输入方法，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
ACM简介与OJ输入输出
05-14
ACM/ICPC的全称为ACM国际大学生程序设计竞赛（ACM－International Collegiate Programming Contest），是世界上规模最大、水平最高的国际大学生程序竞赛。
java acm输入输出
09-22
引用是一个用Java编写的程序，它通过Scanner类从标准输入读取有限个整数，并将每对整数相加后输出。该程序使用了循环来处理多组输入数据。 引用讲述了使用Java进行ACM刷题的方法，包括输入输出。在ACM竞赛中，输入通常通过标准输入流进行读取，而输出则通过标准输出流进行输出。可以使用Scanner类来读取输入，通过System.out.println()方法将结果输出到控制台。 引用是另一个例子，它演示了如何按行读取空格隔开的整数，并将每行的整数求和后输出。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值