笔试（ACM）的输入输出常用案例

最新推荐文章于 2022-08-28 09:29:35 发布

码ming

最新推荐文章于 2022-08-28 09:29:35 发布

阅读量561

点赞数 1

分类专栏： # 算法过程笔记文章标签：算法线性代数 java

本文链接：https://blog.csdn.net/weixin_46168350/article/details/120181240

版权

算法过程笔记专栏收录该内容

4 篇文章 0 订阅

订阅专栏

案例

数组

1，输入一个整数，浮点数，输入一个数组；

package april;

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

public class Class_3 {
    public static void main(String[] args) {
        Scanner reader = new Scanner(System.in) ;
        while(reader.hasNext())
        {
            int m = reader.nextInt() ;
            int [] numbers = new int[m] ;
            for(int index=0;index<m;index++)
            {
                numbers[index] = reader.nextInt();
            }
            System.out.println(Arrays.toString(numbers));
        }
        reader.close() ;
    }
}

输入：
2
1 3
输出：
[1,3]

案例

package 内推笔试;
 
import java.util.Arrays;
import java.util.Scanner;
 
/**
 * Created by liuming on 2017/8/26.
 */
public class 滴滴 {
 
    /**
     * 给定整数序列求最大连续字串和
     * <p>
     * 问题描述：
     * 给定无序正数序列，求连续字串最大和，例如：{-23,17,-7,11,-2,1,34}，字串为{17,-7,11,}，最大和为21
     */
    public static int getTargetMax(int[] arr) {
        int max = arr[0];
        int tmpMax = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (tmpMax <= 0)
                tmpMax = arr[i];
            else
                tmpMax += arr[i];
            if (tmpMax > max) {
                max = tmpMax;
            }
        }
        return max;
    }
 
    public static void main1(String[] args) {
        Scanner sc = new Scanner(System.in);
        //获取输入的整数序列
        String str = sc.nextLine();
        String[] strings = str.split(" ");
        //转为整数数组
        int[] ints = new int[strings.length];
        for (int i = 0; i < strings.length; i++) {
            ints[i] = Integer.parseInt(strings[i]);
        }
        System.out.println(getTargetMax(ints));
    }
 
    /**
     * 整数无序数组求第K大数
     * <p>
     * 问题描述：
     * 给定无序整数序列，求其中第K大的数，例如{45，67，33，21}，第2大的数为45
     */
    public static int getTopK(int[] arr, int k) {
        Arrays.sort(arr);
        return arr[arr.length - k];
    }
 
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        //获取输入的整数序列
        String str = sc.nextLine();
        String[] strings = str.split(" ");
        //转为整数数组
        int[] ints = new int[strings.length];
        for (int i = 0; i < strings.length; i++) {
            ints[i] = Integer.parseInt(strings[i]);
        }
        int k = sc.nextInt();
        System.out.println(getTopK(ints, k));
    }
 
}

每行参数个数不确定（输入字符串分割为数组）

先用scanner.nextLine()读入字符串，再将字符串分割为字符数组或字符串数组。

import java.util.*;

public class MyScanner4 {
public static void main(String[] args) {
	
	Scanner sc = new Scanner(System.in);	
	System.out.println("输入字符串数组：");
	
	String str;
	str = sc.nextLine();
	
	char[] ch = new char[str.length()];
	for(int i=0; i<str.length(); i++) {
		//用charAt();进行定位分隔
		ch[i] = str.charAt(i);
		System.out.println(ch[i] + " ");
	}
	System.out.println("END");
	
	//读入字符串后,用空格分隔为数组
	String[] strs = str.split(" ");
	System.out.println(Arrays.toString(strs));
 
	}
}

每行参数个数确定

import java.util.Scanner;

public class ChooseSeat {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        while(in.hasNext()) {
            int n = in.nextInt();   // 读第一行的参数
            int[] nums = new int[n];  // 创建数组
            for(int i = 0; i < n; i++) {
                nums[i] = in.nextInt();  // 不停的读入元素
            }
        }
        in.close();
    }
}

矩阵

数组大小确定

package april;
import java.util.Scanner;
public class Class_4 {
    public static void main(String[] args) {
        Scanner reader = new Scanner(System.in);
        int m = reader.nextInt();
        int n = reader.nextInt() ;
        int [][] array = new int[m][n] ;
        for (int i=0 ; i<m ; i++)
            for(int j=0 ;j<n ;j++)
            {
                array[i][j]=reader.nextInt();
            }
        reader.close() ;
        /**
         * 对矩阵按行打出
         */
        for (int i=0 ; i<m ; i++)
        {
            for(int j=0 ;j<n ;j++)
            {
                System.out.print(array[i][j]+" ");
            }
            System.out.println( );
        }
    }
}

大小不确定

//输入一个整数矩阵，矩阵的长度和宽度不确定，可以用于输入n*n的矩阵
public void aMatrix(){
		Scanner sc = new Scanner(System.in);
		ArrayList matrix=new ArrayList();//整个矩阵
		ArrayList alinelist;//每一列
		int length=0;//一列的长度
		System.out.println("请输入一个矩阵：");
	//获得下一行
	while (sc.hasNextLine()) {
		String str = sc.nextLine();
		if (str.equals(""))//输入空行则完成输入，退出循环
			break;
		
		alinelist=new ArrayList();
		
		int pre=0;//扫描指针
		int i=0;
		int temp=0;
		for (i = 0; i < str.length(); i++) {
			if (str.charAt(i) == ' ') {
				temp = Integer.parseInt(str.substring(pre, i));
				alinelist.add(temp);
				pre = i + 1;
			}
		}
		temp = Integer.parseInt(str.substring(pre, i));
		alinelist.add(temp);
		matrix.add(alinelist);
		
		if(length<alinelist.size())
			length=alinelist.size();
	}
	//复制到数组中
	int array [] []=new int [matrix.size()][length];
	//调用函数计算数量
	
	for(int i=0;i<matrix.size();i++){
		alinelist=(ArrayList) matrix.get(i);
		for(int j=0;j<alinelist.size();j++){
			array[i][j]=(int)alinelist.get(j);
			System.out.print(array[i][j]+" ");
		}
		System.out.println();
	}
}

输入为一个链表

这里选用最经典的反转链表题目作为例子。

package learnACM;

import java.util.Scanner;
import java.util.Stack;

public class LinkListInput {
    //题目描述
    //对于一个链表 L: L0→L1→…→Ln-1→Ln,
    //将其翻转成 L0→Ln→L1→Ln-1→L2→Ln-2→…

    //先构建一个节点类，用于链表构建
    static class LinkNode {
        int val;
        LinkNode next;
        public LinkNode(int val){
            this.val = val;
        }
    }

    public static void main(String[] args){
        //输入是一串数字，请将其转换成单链表格式之后，再进行操作
        //输入描述:
        //一串数字，用逗号分隔
        //输入
        //1,2,3,4,5
        Scanner scanner = new Scanner(System.in);
        //以字符串形式作为输入
        String str = scanner.next().toString();
        //通过分隔符将其转为字符串数组
        String[] arr  = str.split(",");
        //初始化一个整数数组
        int[] ints = new int[arr.length];
        //给整数数组赋值
        for(int j = 0; j<ints.length;j++) {
            ints[j] = Integer.parseInt(arr[j]);
        }
        Stack<LinkNode> stack = new Stack<>();
        LinkNode head = new LinkNode(0);
        LinkNode p = head;
        //链表初始化并放入stack中
        for(int i = 0; i < ints.length; i++){
            p.next = new LinkNode(ints[i]);
            p = p.next;
            stack.add(p);
        }
        head = head.next;
        //开始链表转换
        p = head;
        LinkNode q = stack.peek();
        while ((!p.equals(q)) && (!p.next.equals(q))) {
            q = stack.pop();
            q.next = p.next;
            p.next = q;
            p = p.next.next;
            q = stack.peek();
        }
        q.next = null;
        //输出
        //1,5,2,4,3
        //打印
        while (head != null) {
            if(head.next == null){
                System.out.print(head.val);
            }else{
                System.out.print(head.val + ",");
            }
            head = head.next;
        }
    }
}

先创建一个stack，把数组遍历放入stack。
创建头结点head，头结点指针p，查看的栈顶元素q，while循环

while ((!p.equals(q)) && (!p.next.equals(q))) {
    q = stack.pop();
    q.next = p.next;
    p.next = q;
    p = p.next.next;
    q = stack.peek();
}

把q的next指向空，q.next = null;

输入为一个链表（第二种方法）

 public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        while(in.hasNext()){
            String str = in.nextLine();
            int k = in.nextInt();
            ListNode head = new ListNode(-1);
            ListNode p = head;
            String[] strArray = str.split(" ");
            for(int i = 0; i < strArray.length - 1; i++){
                p.next = new ListNode(Integer.parseInt(strArray[i]));
                p = p.next;
            }
            head = reverseK(head.next, k);
            printList(head);
        }
    }
        // 输出处理
    private static void printList(ListNode head) {
        while(head != null){
            System.out.print(head.val);
            if(head.next != null){
                System.out.print("->");
            }
            head = head.next;
        }
    }

List转Int数组（逐个复制）*

Scanner sc = new Scanner(System.in);
ArrayList arrayList = new ArrayList<>();
while (sc.hasNext()){

arrayList.add(sc.next());//nextLine()/next()看情况使用

}

List<Integer> list = new ArrayList<Integer>();
//LinkedList<Integer> list = new LinkedList<Integer>();
 list.add(1);
 list.add(2);
 int count = list.size();
        int[] aux = new int[count];
        for(int i = 0; i < count; i++){
            aux[i] = list.poll();
        }
        return aux;

数组变树

这里

易错

问题：Java中nextInt()后接nextLine()读取不到数据

愿意：nextInt()函数在缓冲区中遇到“空格”、“回车符”等空白字符时会将空白字符前的数据读取走，但空白字符不会被处理掉，而nextLine()函数是在缓冲区中读取一行数据，这行数据以“回车符”为结束标志，nextLine()会把包括回车符在内的数据提走。所以nextInt()后的nextLine()函数并非读取不到数据，因为nextInt()将“回车符”留在了缓冲区，nextLine()读取时遇到的第一个字符便是“回车符”，所以直接结束了。

解决：
1.在要使用nextLine()前先调用一次nextLine()，这样留在缓冲区的“回车符”就会被处理掉，这时第二个nextLine()函数可以正常读取到数据

sc.nextline() 相当于光标换到下一行
在这里插入图片描述

避免在nextLine()之前调用nextInt()等函数，可以统一使用nextLine()来读取数据，之后再进行类型转换。

总结：
nextInt()或者next()读取完毕并回车之后其后紧跟nextLine()，就会导致nextLine()读取到空值，因为nextLine()自动读取到’\n'，意味着遇到结束符；

有时候将字符串转为整数时，代码没问题却提示数组越界，往往是因为字符串代表的整数超过了int的最值，需要改用long。

总结

不确定数组大小可以用list再转数组

码ming

关注

1
点赞
踩
7

收藏

觉得还不错? 一键收藏
0
评论
笔试（ACM）的输入输出常用案例

案例数组1，输入一个整数，浮点数，输入一个数组；package april;import java.util.Arrays;import java.util.Scanner;public class Class_3 { public static void main(String[] args) { Scanner reader = new Scanner(System.in) ; while(reader.hasNext()) {
复制链接

扫一扫