zoukankan      html  css  js  c++  java
  • java-CCF+杂七杂八

    1. 关于for的过程: ![](https://img2020.cnblogs.com/blog/1595358/202103/1595358-20210304161203022-1088744843.png) 必须满足条件后才能进去循环

    2. 遇到的一个形式的++i: https://blog.csdn.net/qq_42933123/article/details/100105858 还挺有意思的。

     

     


     

     

    CCF-CSP考试   全用Java写的

    要着重锻炼设计测试样例的能力,我们在考试的使用代码提交上去后当时是没有分数的,得第二天才有,所以我们并不知道我们提交的代码是否能拿满分,这就要我们自己测试好再提交代码。

    机器判断输出和正确输出不一样就是0分。

    https://blog.csdn.net/wl16wzl/article/details/79344292

    https://blog.csdn.net/tigerisland45/article/details/78420636

    java输入

    Scanner  scan_input = new Scanner(System.in);
    //接收类型为int整型数字nextInt,并赋值给id,如果小数可以nextDouble/nextFloat、nextLong
    int  id = scan_input.nextInt();
     1 import java.util.Scanner;
     2  3 public class Main {
     4     
     5     public static void main(String[] args) {
     6         new Main().run();
     7     }
     8     
     9     public void run() {
    10         Scanner sc = new Scanner(System.in);
    11         
    12         int n = sc.nextInt();
    13         int[] people = new int[4];
    14         
    15         for(int i = 0; i < n; i++) {
    16             if((i+1) % 7 == 0 || String.valueOf(i+1).contains("7")) {
    17                 people[i%4] ++;
    18                 n++;
    19             }
    20         }
    21         
    22         for(int i = 0; i < 4; i++) {
    23             System.out.println(people[i]);
    24         }
    25     }
    26 27 }
     1 import java.util.*;
     2 public class Main{
     3     public static void main(String[] args){
     4         new Main().run();
     5     }
     6     public void run(){
     7      int n;//多少个数后游戏结束
     8      int num=1;
     9      int count=1;
    10      int[] people = new int[4];
    11      Scanner input1 = new Scanner(System.in);
    12      int in = input1.nextInt();
    13      while(count<=in){
    14         if(num%7==0 || String.valueOf(num).contains("7")){
    15             people[(num-1)%4]++;//数组是从0开始算的 如果是的话 该计数不动
    16         }else{
    17             count++;
    18         }
    19         num++;//不管是不是 都要++
    20      }
    21        for(int i=0;i<4;i++){
    22           System.out.println(people[i]);
    23        }
    24     }
    25 }
    26 //String.valueOf(int i) : 将 int 变量 i 转换成字符串 
    27 //String.contains()方法用法实例教程, 返回true,当且仅当此字符串包含指定的char值序列
    
    
    //垃圾场选址

    java Scanner中的hasNext()方法--判断输入(文件、字符串、键盘等输入流)是否还有下一个输入项,若有,返回true,反之false。

    Scanner sc = new Scanner(new  File("test.txt"``));
    System.out.println(sc.hasNext());

    若test.txt为空(空格、tab、回车),则输出结果为false;若该文件不为空输出true。

    当输入为键盘时,该方法出现阻塞(block),也即等待键盘输入。输入源没有结束,又读不到更多输入项。

    Scanner sc = new Scanner(System.in);
    System.out.println(sc.hasNext());

    运行上面的程序,控制台等待键盘输入,输入信息后输出结果为true。

    输入:Hello
    true

    由上面的知识,则如下代码则不难理解:

    Scanner sc = new Scanner(System.in);
    while(sc.hasNext()) {
    System.out.println("Input from keyboard:"+ sc.next());
    }

    sc.hasNext()始终等待键盘输入,输入信息后,sc.next()打印出该信息。


    Scanner sc = new Scanner(System.in);

    此句 表示从控制台获取数据, sc.hasNext() 表示你是否有输入数据, while语句块 表示当你输入数据的时候,就执行输出sc.next()(输出内容) 所以只要你输入数据了,它就可以执行,

    所以后台只是开了一块内存,一直未关闭,不算死循环

    2hasNext()这个方法是如果此扫描器的输入中有另一个标记,则返回 true。在等待要扫描的输入时,此方法可能阻塞。扫描器将不执行任何输入。所以循环会一直下去。 你可以设置一个终止符,调用hasNext()的重载方法hasNext(String patten):如果下一个标记与从指定字符串构造的模式匹配,则返回 true。扫描器不执行任何输入。 例:以输入"0",结束输出 Scanner sc = new Scanner(System.in); while (!sc.hasNext("0")) { System.out.println(sc.next()); }


    Java中关于nextInt()、next()和nextLine()的理解

    先看解释:

    nextInt(): it only reads the int value, nextInt() places the cursor in the same line after reading the input.

    next(): read the input only till the space. It can't read two words separated by space. Also, next() places the cursor in the same line after reading the input.

    nextLine(): reads input including space between the words (that is, it reads till the end of line ). Once the input is read, nextLine() positions the cursor in the next line.

    next方法不能得到带空格的字符串而nextLine()方法的结束符只是Enter键

    import java.util.Scanner;
    ​
    public class MaxMap {
        public static void main(String[] args){
            Scanner cin = new Scanner(System.in);
            String n = cin.next();
            //cin.nextLine();
            String str = cin.nextLine();
            System.out.println("END");
            System.out.println("next()read:"+n);
            System.out.println("nextLine()read:"+str);
        }
    }

    img

    img

    next()只读空格之前的数据,并且cursor指向本行,后面的nextLine()会继续读取前面留下的数据。

    想要读取整行,就是用nextLine()。

    读取数字也可以使用nextLine(),不过需要转换:Integer.parseInt(cin.nextLine())。

    //回收站选址
    package epistatic;
    import java.util.*;

    class points{
    int x;
    int y;
    public points(int x,int y) {
    this.x = x;
    this.y = y;
    }
    }

    public class Main {

    //static:Cannot make a static reference to the non-static method solve(points[]) from the type Main
    public static int[] solve(points[] p) { //传递过来的是整个points的数组 就是所有的垃圾点
    int[] score = new int[5];
    int returnscore = 0;
    for(int i = 0;i<p.length;i++) {//上下左右都有垃圾
    int count = 0;
    returnscore = 0;//!!
    for(int j = 0;j<p.length;j++) {//跟其他垃圾点挨个比对一下
    if(i!=j) { //别是同一个垃圾点
    if(p[i].x==p[j].x && (p[i].y-1)==p[j].y) {
    count++;
    }if(p[i].x==p[j].x && (p[i].y+1)==p[j].y) {
    count++;
    }if((p[i].x+1)==p[j].x && p[i].y==p[j].y) {
    count++;
    }if((p[i].x-1)==p[j].x && p[i].y==p[j].y) {
    count++;
    }

    }//if
    }
    //System.out.println(p[i].x+" "+p[i].y);
    //p[i]和其他点比对完了
    if(count==4) {//判断对角线
    for(int j = 0;j<p.length;j++) {//跟其他垃圾点挨个比对一下
    if(i!=j) { //别是同一个垃圾点
    if((p[i].x+1)==p[j].x && (p[i].y+1)==p[j].y) {
    returnscore++;
    }if((p[i].x-1)==p[j].x && (p[i].y-1)==p[j].y) {
    returnscore++;
    }if((p[i].x+1)==p[j].x && (p[i].y-1)==p[j].y) {
    returnscore++;
    }if((p[i].x-1)==p[j].x && (p[i].y+1)==p[j].y) {
    returnscore++;
    }

    }//if
    }//for 对角线比对完了
    score[returnscore]++;
    //System.out.println("p[i].score"+i +" "+ score[returnscore]);
      }


    }
    return score;

    }


    public static void main(String[] args) {

    Scanner in = new Scanner(System.in);
    while(in.hasNext()) {
    int n = in.nextInt();//共有多少个垃圾点
    points[] p = new points[n];
    for(int i=0;i<n;i++) {
    int x = in.nextInt();
    int y = in.nextInt();
    p[i] = new points(x,y);
    }//输入完毕
    int[] a = solve(p);
    for(int i= 0;i<a.length;i++) {
    System.out.println(a[i]);
    }
    }
    //关闭输入流
    in.close();
    }

    }

    几个输入方式:

    Scanner sc = new Scanner(System.in);
    int n = sc.nextInt();//鼠标还在这行
    int[][] point = new int[n][2];
    int[] count = new int[5];
    sc.nextLine();//读整行 读取了
    for(int i = 0; i < n; i++) {
     String[] s = sc.nextLine().split(" ");//读整行 按“ ”分开
     point[i][0] = Integer.valueOf(s[0]);
     point[i][1] = Integer.valueOf(s[1]);
    }
    //看他们的代码 有个地方 是会有个排序函数sort 是为了让整个p的坐标由小到大 这样比对的时候j直接=i+1 而不用像我j=0并且i!=j 以及所有的函数都是static的
    import java.util.Scanner;
     
    public class Main {
        
        private static int[][] point;  //垃圾点集合
        private static int result[]=new int[5];
        
        public static void main(String args[])
        {
            
            Scanner scan=new Scanner(System.in);
            int n=scan.nextInt();//
            point=new int[n][2];
            for(int i=0;i<n;i++)
            {
                point[i][0]=scan.nextInt();//
                point[i][1]=scan.nextInt();//
            }
            Sort(n);
            run(n);
            
        }
        
        public static void Sort(int n) 
        {//排序函数
            int tmp[]=new int[2];
            for(int i=0;i<n;i++)
            {
                for(int j=i+1;j<n;j++)
                {
                    if(point[i][0]>point[j][0])
                    {
                        tmp=point[i];
                        point[i]=point[j];
                        point[j]=tmp;
                    }
                    else if(point[i][0]==point[j][0]&&point[i][1]>point[j][1])
                    {
                        tmp=point[i];
                        point[i]=point[j];
                        point[j]=tmp;
                    }
                }
            }
            
        }
        
        public static void run(int n)
        {
            for(int i=0;i<n;i++)
            {
                int num=0;
                int key=0;
                for(int j=0;j<n;j++)
                {
                    if(point[i][0]-1==point[j][0]&&point[i][1]==point[j][1])
                    {
                        num++;
                    }
                    if(point[i][0]==point[j][0]&&point[i][1]+1==point[j][1])
                    {
                        num++;
                    }
                    if(point[i][0]+1==point[j][0]&&point[i][1]==point[j][1])
                    {
                        num++;
                    }
                    if(point[i][0]==point[j][0]&&point[i][1]-1==point[j][1])
         {
    num++;
        }
        }
    
    if(num==4)
        {
    for(int j=0;j<n;j++)
        {
    if(point[i][0]-1==point[j][0]&&point[i][1]+1==point[j][1])
        {
    key++;
        }
    if(point[i][0]-1==point[j][0]&&point[i][1]-1==point[j][1])
        {
    key++;
        }
    if(point[i][0]+1==point[j][0]&&point[i][1]+1==point[j][1])
        {
    key++;
        }
    if(point[i][0]+1==point[j][0]&&point[i][1]-1==point[j][1])
        {
    key++;
        }
        }
    result[key]++;
        }
        }
    
    for(int i=0;i<5;i++)
        {
    System.out.println(result[i]);
        }
        }
    }

    好乱 自己看markdown把

    化学方程式

    String.toCharArray() 方法将字符串转换为字符数组。

    nextint()之后使用nextline

    https://blog.csdn.net/guanghuichenshao/article/details/81545450

    https://blog.csdn.net/zxr0130/article/details/107634973

    https://blog.csdn.net/qq_43489379/article/details/88263684

    Map<String,Integer> answer1 = new HashMap<String,Integer>(); 用于存储元素对(称作“键”和“值”),其中每个键映射到一个值

    https://www.cnblogs.com/lzq198754/p/5780165.html

    HashMap<K,V>:存储数据采用的哈希表结构,元素的存取顺序不能保证一致。由于要保证键的唯一、不重复,需要重写键的hashCode()方法、equals()方法。

    for( Map.Entry<String,Integer>e : answer1.entrySet() ) {} 遍历

    我们总说键值对键值对, 每一个键值对也就是一个Entry

    Map是java中的接口,Map.Entry是Map的一个内部接口。

    Map.Entry里面包含getKey()和getValue()方法

    Map提供了一些常用方法,如keySet()、entrySet()等方法。

    keySet()方法返回值是Map中key值的集合;entrySet()的返回值也是返回一个Set集合,此集合的类型为Map.Entry。

    Map的四种遍历方法:https://blog.csdn.net/tjcyjd/article/details/11111401

    package epistatic;
    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(n-->0) {//if n> 0 n--
                Map<String,Integer> answer1 = new HashMap<String,Integer>();//容器
                Map<String,Integer> answer2 = new HashMap<String,Integer>();//容器
                String s = in.nextLine();//一整行拿下
                String[] split = s.split("=");//等式左右【0】 【1】
                String[] sleft = split[0].split("\+");//去掉+号
                String[] sright = split[1].split("\+");//去掉+号  剩 几个数字和化学式 所以也是数组啊
                for(String a: sleft) {//左边数组 一堆数和元素
                    resolvenum(answer1,a);
                }
                for(String a:sright) {//右边数组
                    resolvenum(answer2,a);
                }
                //等式左右都将元素值和系数各自存起来了 
                for(Map.Entry<String,Integer>e : answer1.entrySet()) {//等式左右两边对比 
                    int v = e.getValue();//得到元素的系数
                    String k = e.getKey();//得到元素名
                    int vv = answer2.containsKey(k)?answer2.get(k):-1;
                    //Map.containsKey方法——判断Map集合对象中是否包含指定的键名:return:true/false  Map.get(key)返回指定键所映射的值:null
                    if(!answer2.containsKey(k)||v!=vv) {//右边没有这个元素或者左右该元素系数不等
                        break;//跳出该for循环 直接到下面的if语句
                    }else {
                        answer2.remove(e.getKey());//HashMap.remove(Object key) 删去该映射(键值对都删)
                    }
                }
                if(answer2.size()==0) {//HashMap.size()返回映射中存在的键值对的数量。
                    System.out.println("Y");
                }else {
                    System.out.println("N");
                }
                    
            }
            in.close();
        }
        //----------------
        
        public static void resolvenum(Map<String,Integer>answer,String s) {//按+号分开后的s 系数为负呢?
            char[] a = s.toCharArray();//字符串转为字符数组
            int left = 0;
            int right = a.length-1;
            int index = 0;//数字系数
            while(a[left]<='9' && a[left]>='0') {//该字母是不是数字 这是个循环,因为可能 系数比较大30/45 那么*10就是:十位百位啥的
                index = index*10 + a[left++] -'0';//left++ 先运算回来再加
            }//系数处理完毕 再处理化学式     [会有些H20 CH4 这类的 这都属于化学式啊一旦出现非数字就知道系数结束了]
            resolveitem(a,left,right,answer,index==0?1:index);//后面那个三元表达式 当index还是==0,证明没变,证明系数为1(化学中省略不写)
         }
        //这 得到的是元素们整体的系数 比如:2H3PO4 的 2
        
       public static void resolveitem(char[] a,int left,int right,Map<String,Integer>map,int index) {//过来的都是元素: O/H/CaCl2/CH4/Ba(OH)2
           String e = "";
           int num = 0;
           while(left <= right && a[left] != ')') { //???Ba(OH)2咋办
               if(a[left] >= 'a' && a[left] <='z') {//小写字母
                   e = e + a[left++];
               }else if(a[left] >='A'&& a[left]<='Z') {//大写字母 证明上一个元素结束Ca钙 Cl氯 Na:钠  OH:是要分开看的,H20也是分开看:对 这都拆开了
                   add(map,e,index,num);//不用传什么left和right啊 e和两个系数
                   e = ""+a[left++];//回来了之后自然是要重新初始化
                   num = 0;//
               }else if(a[left] >= '0' && a[left] <='9') {//数字
                   num = num*10+a[left++]-'0';
               }else {//左括号  上一个元素结束
                 add(map,e,index,num);
                 e = "";
                 num = 0;//左括号结束
                 int b[] = getnx(a,++left,right);//getnx:去判断括号后面有没有跟系数
                 resolveitem(a,left,b[0],map,index*b[1]);//判断括号内的情况
                 left = b[2];//括号结束后回来
               }
           }//while结束 把最后这个元素加到map里
           add(map,e,index,num);
       }//这个整体式子 系数带元素 结束
       
       public static void add(Map<String,Integer>map,String e,int index,int num) {//把该元素连带他的系数 加入到map
         
           if(e.equals("")) return; //index是该元素系数 num是该元素中的数字  5Cl2   e就是元素表达式
           map.put(e,map.getOrDefault(e, 0)+(num==0?1:num)*index);
           //Map.getOrDefault(Object key, V defaultValue)方法的作用是: 当Map集合中有这个key时,就使用这个value值;如果没有就使用默认值defaultValue。
           //(num==0?1:num)*index:一部分   map.getOrDefault(e, 0)一部分 为啥+:就是万一有元素重复了 系数直接累加就行:4Au+8NaCN+2H2O+O2:O
           
       }
       
       /**
                *  找到匹配表达式的系数和右边界,
        * b0是表达式右边界(包含越界),b1是括号外数字(越界置1)
        * b2是下次要开始的位置
        */
       public static int[] getnx(char[] a,int left,int right) { //left:(后第一个
           int count = 1,index = 0,rl = 0;
           while(count != 0) {
               if(a[left] == '(') {
                   count++;
               }
               if(a[left]==')') {
                   count--;
               }
               left++;
           }
           rl = left-2;// rl:)的前一个 left:)后一个
           while(left <= right && a[left]<='9' &&a[left]>='0') { //括号结束后会不会跟着数字(OH)2
               index = index*10 + a[left++] -'0';
           }
           
           return new int[] {rl,index==0?1:index,left};//3个元素
       }
        
                
    }

     我不要粘贴了 我的天

    化学方程式

    String.toCharArray() 方法将字符串转换为字符数组。

    nextint()之后使用nextline:nextLine()自动读取了被next()去掉的Enter作为他的结束符

    https://blog.csdn.net/qq_43489379/article/details/88263684

    Scanner in = new Scanner(System.in); int n = in.nextInt(); //有几个方程式
    System.out.println("n: "+n);
    System.out.println("in.nextLine(): "+in.nextLine()+"!!");
    //in.nextLine()吸收的是enter
    in.close();

    例子:
    Scanner input = new Scanner(System.in); while(true) {
    System.out.println("进行学号/工号账号的登录--:"); String name=input.nextLine();
    System.out.println("进行学号/工号密码的登录--:"); String password=input.nextLine();
    System.out.println("进行身份的登录(辅导员/负责人/学生,分别为数字1,2,3):");
    int bank=input.nextInt();}
    //改法1:就是在int bank=input.nextInt();后面加上一行input.nextLine();把你的回车获取到后,就不会影响后面的代码了。
    //改法2:nextLine()都改成String name=input.next();这样也不会出错

    Map<String,Integer> answer1 = new HashMap<String,Integer>(); 用于存储元素对(称作“键”和“值”),其中每个键映射到一个值

    https://www.cnblogs.com/lzq198754/p/5780165.html

    HashMap<K,V>:存储数据采用的哈希表结构,元素的存取顺序不能保证一致。由于要保证键的唯一、不重复,需要重写键的hashCode()方法、equals()方法。

    for( Map.Entry<String,Integer>e : answer1.entrySet() ) {} 遍历

    我们总说键值对键值对, 每一个键值对也就是一个Entry

    Map是java中的接口,Map.Entry是Map的一个内部接口。

    Map.Entry里面包含getKey()和getValue()方法

    Map提供了一些常用方法,如keySet()、entrySet()等方法。

    keySet()方法返回值是Map中key值的集合;entrySet()的返回值也是返回一个Set集合,此集合的类型为Map.Entry。

    Map的四种遍历方法:https://blog.csdn.net/tjcyjd/article/details/11111401

      1 package epistatic;
      2 import java.util.*;
      3 
      4 public class Main{
      5     
      6     public static void main(String[] args) {
      7         Scanner in = new Scanner(System.in);
      8         int n = in.nextInt(); //有几个方程式
      9         in.nextLine();
     10         while(n-->0) {//if n> 0 n--
     11             Map<String,Integer> answer1 = new HashMap<String,Integer>();//容器
     12             Map<String,Integer> answer2 = new HashMap<String,Integer>();//容器
     13             String s = in.nextLine();//一整行拿下
     14             String[] split = s.split("=");//等式左右【0】 【1】
     15             String[] sleft = split[0].split("\+");//去掉+号
     16             String[] sright = split[1].split("\+");//去掉+号  剩 几个数字和化学式 所以也是数组啊
     17             for(String a: sleft) {//左边数组 一堆数和元素
     18                 resolvenum(answer1,a);
     19             }
     20             for(String a:sright) {//右边数组
     21                 resolvenum(answer2,a);
     22             }
     23             //等式左右都将元素值和系数各自存起来了 
     24             for(Map.Entry<String,Integer>e : answer1.entrySet()) {//等式左右两边对比 
     25                 int v = e.getValue();//得到元素的系数
     26                 String k = e.getKey();//得到元素名
     27                 int vv = answer2.containsKey(k)?answer2.get(k):-1;
     28                 //Map.containsKey方法——判断Map集合对象中是否包含指定的键名:return:true/false  Map.get(key)返回指定键所映射的值:null
     29                 if(!answer2.containsKey(k)||v!=vv) {//右边没有这个元素或者左右该元素系数不等
     30                     break;//跳出该for循环 直接到下面的if语句
     31                 }else {
     32                     answer2.remove(e.getKey());//HashMap.remove(Object key) 删去该映射(键值对都删)
     33                 }
     34             }
     35             if(answer2.size()==0) {//HashMap.size()返回映射中存在的键值对的数量。
     36                 System.out.println("Y");
     37             }else {
     38                 System.out.println("N");
     39             }
     40                 
     41         }
     42         in.close();
     43     }
     44     //----------------
     45     
     46     
     47     
     48     public static void resolvenum(Map<String,Integer>answer,String s) {//按+号分开后的s 系数为负呢?
     49         char[] a = s.toCharArray();//字符串转为字符数组
     50         int left = 0;
     51         int right = a.length-1;
     52         int index = 0;//数字系数
     53         while(a[left]<='9' && a[left]>='0') {//该字母是不是数字 这是个循环,因为可能 系数比较大30/45 那么*10就是:十位百位啥的
     54             index = index*10 + a[left++] -'0';//left++ 先运算回来再加
     55         }//系数处理完毕 再处理化学式     [会有些H20 CH4 这类的 这都属于化学式啊一旦出现非数字就知道系数结束了]
     56         resolveitem(a,left,right,answer,index==0?1:index);//后面那个三元表达式 当index还是==0,证明没变,证明系数为1(化学中省略不写)
     57      }
     58     //这 得到的是元素们整体的系数 比如:2H3PO4 的 2
     59     
     60    public static void resolveitem(char[] a,int left,int right,Map<String,Integer>map,int index) {//过来的都是元素: O/H/CaCl2/CH4/Ba(OH)2
     61        String e = "";
     62        int num = 0;
     63        while(left <= right && a[left] != ')') { //???Ba(OH)2咋办
     64            if(a[left] >= 'a' && a[left] <='z') {//小写字母
     65                e = e + a[left++];
     66            }else if(a[left] >='A'&& a[left]<='Z') {//大写字母 证明上一个元素结束Ca钙 Cl氯 Na:钠  OH:是要分开看的,H20也是分开看:对 这都拆开了
     67                add(map,e,index,num);//不用传什么left和right啊 e和两个系数
     68                e = ""+a[left++];//回来了之后自然是要重新初始化
     69                num = 0;//
     70            }else if(a[left] >= '0' && a[left] <='9') {//数字
     71                num = num*10+a[left++]-'0';
     72            }else {//左括号  上一个元素结束
     73              add(map,e,index,num);
     74              e = "";
     75              num = 0;//左括号结束
     76              int b[] = getnx(a,++left,right);//getnx:去判断括号后面有没有跟系数
     77              resolveitem(a,left,b[0],map,index*b[1]);//判断括号内的情况
     78              left = b[2];//括号结束后回来
     79            }
     80        }//while结束 把最后这个元素加到map里
     81        add(map,e,index,num);
     82    }//这个整体式子 系数带元素 结束
     83    
     84    public static void add(Map<String,Integer>map,String e,int index,int num) {//把该元素连带他的系数 加入到map
     85      
     86        if(e.equals("")) return; //index是该元素系数 num是该元素中的数字  5Cl2   e就是元素表达式
     87        map.put(e,map.getOrDefault(e, 0)+(num==0?1:num)*index);
     88        //Map.getOrDefault(Object key, V defaultValue)方法的作用是: 当Map集合中有这个key时,就使用这个value值;如果没有就使用默认值defaultValue。
     89        //(num==0?1:num)*index:一部分   map.getOrDefault(e, 0)一部分 为啥+:就是万一有元素重复了 系数直接累加就行:4Au+8NaCN+2H2O+O2:O
     90        
     91    }
     92    
     93    /**
     94             *  找到匹配表达式的系数和右边界,
     95     * b0是表达式右边界(包含越界),b1是括号外数字(越界置1)
     96     * b2是下次要开始的位置
     97     */
     98    public static int[] getnx(char[] a,int left,int right) { //left:(后第一个
     99        int count = 1,index = 0,rl = 0;
    100        while(count != 0) {
    101            if(a[left] == '(') {
    102                count++;
    103            }
    104            if(a[left]==')') {
    105                count--;
    106            }
    107            left++;
    108        }
    109        rl = left-2;// rl:)的前一个 left:)后一个
    110        while(left <= right && a[left]<='9' &&a[left]>='0') { //括号结束后会不会跟着数字(OH)2
    111            index = index*10 + a[left++] -'0';
    112        }
    113        
    114        return new int[] {rl,index==0?1:index,left};//3个元素
    115    }
    116     
    117             
    118 }
     1 //小明种苹果:绝对值Math.abs()
     2 package epistatic;
     3 
     4 import java.util.*;
     5 
     6 public class Main {
     7     
     8     public static void main(String[] args) {
     9         Scanner in = new Scanner(System.in);
    10         int t = 0;
    11         int dropsum = 0;
    12         int maxtree = 0;
    13         int maxsum = 0;
    14         int treesum = in.nextInt();//棵树
    15         int drop = in.nextInt();//蔬果次数
    16         
    17         int[][] sum = new int[treesum][drop+1];
    18         for(int i=0;i<treesum;i++) {
    19             for(int j=0;j<(drop+1);j++) {
    20                     sum[i][j] = in.nextInt();
    21                      t += sum[i][j];
    22             }
    23         }//这得到的t就是剩下的苹果总数
    24         
    25         //计算最大蔬果
    26         for(int i=0;i<treesum;i++) {
    27             dropsum = 0;
    28             for(int j=1;j<drop+1;j++) {
    29                 dropsum+=sum[i][j];//该树的蔬果个数
    30             }
    31             if(Math.abs(dropsum)>maxsum) { //这里有个坑点 dropsum是负数
    32                 maxtree = i;
    33                 maxsum = Math.abs(dropsum);
    34             }
    35             
    36         }
    37         System.out.println(t+" "+(maxtree+1)+" "+maxsum);//棵树这也是 题意可没第0颗
    38         
    39         in.close();
    40     }
    41 }

    java 初始化

    https://blog.csdn.net/Zhangguohao666/article/details/88570426

    https://blog.csdn.net/weixin_41809435/article/details/82814208

    在java中初始化布尔数组?

    要么使用boolean[],使所有值默认为false:

    boolean[] array = new boolean[size];

    使用Arrays#fill()来填充整个数组Boolean.FALSE:

    Boolean[] array = new Boolean[size];
    Arrays.fill(array, Boolean.FALSE);

    //小明种苹果 续 
    import java.util.*;
    
    public class Main {
        
        public static void main(String[] args) {
            
            Scanner in = new Scanner(System.in);
            int treenum = in.nextInt();//棵树
            int[][] giftsum = new int[treenum][];
            int t = 0;//还剩多少苹果
            int selfnum = 0;//掉落苹果的树的颗数
            int circle = 0;//掉落组数
            int[] flag = new int[treenum];//局部变量 必须先初始化
            for(int x:flag) {
                x = 0;
            }
            
            for(int i=0;i<treenum;i++) {
                int  self = in.nextInt();//本行操作次数
                int  selfapple = in.nextInt();//本行最初的苹果个数
                giftsum[i] = new int[self+1];//!!!!!!!!!!!!!!!!!上面申请的时候列没初始化 这里必须
                giftsum[i][0] = self;
                giftsum[i][1] = selfapple;
                int nowapple = selfapple;
                for(int j=2;j<self+1;j++) {
                    giftsum[i][j] = in.nextInt();//都输进去了
                    if(giftsum[i][j]<=0) {
                        nowapple += giftsum[i][j];
                    }else {
                        if(giftsum[i][j] < nowapple) {
                            nowapple = giftsum[i][j];
                            //selfnum++;!!!!!卧槽 这个地方 我找了好久 为啥不能在这算 是万一这颗树掉了好几次 在这的话不都++了嘛 就多算了啊
                            flag[i] = 1;
                        }
                    }
                }
                t += nowapple;
                
            }
            
            
            for(int i=0;i<treenum;i++) {
                if(flag[i]==1) {
                    selfnum++;
                    if(flag[(i+treenum-1)%treenum]==1 && flag[(i+treenum+1)%treenum]==1 ) { //!!!!计算圆方式
                        circle++;
                    }
                }
            }
            
            System.out.println(t+" "+selfnum+" "+circle);
            in.close();
        }
    }

    字符画

    https://www.cnblogs.com/shenben/p/11783987.html

    https://blog.csdn.net/weixin_43662429/article/details/105498562?utm_medium=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-2.channel_param&depth_1-utm_source=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-2.channel_param

     

    题意:

    • 将n * m的RGB图片压缩成q * p的块,每块为该原像素的平均值,我们暂且称之为像素块(代码注释为字符块) 。

    • 输入n行m列的RGB图片:

    • 第一行:图片的宽m高n

    • 第二行:要压缩的单位宽p高q,即对原图片的每q*p个像素取平均值得到像素块,保证输入得到整数个像素块。

    • 接下来n*m行,自上到下,自左往右输入图片的HTML格式的像素:

    • #a 表示RGB(0xaa,0xaa,0xaa)

    • #abc 表示RGB(0xaa,0xbb,0xcc)

    • #abcdef 表示RGB(0xab,0xcd,0xef)

    • 输出压缩后的图片的背景色

    • 像素块行处理:

    • 若背景色与该行的像素块的前一块(第一块与默认值比较)颜色相同,则不处理;否则若与默认值相同则输出 ESC[0m 的格式化表示,不相同则输出 ESC[48;2;R;G;Bm 的格式化表示(此处RGB指代像素块的RGB)。

      (解释:就是这个块如果跟前一个块背景一样,就不改,如果跟默认背景颜色一样,就直接重置终端,都不相同,就直接输出自己的背景色)

    • 每一个像素块 后必须紧跟一个格式化的空格: x20 (块与块分开)

    • 像素块行尾处理:

    • 若该行的最后一个像素块颜色不是默认值则输出 ESC[0m (重置)的格式化表示。

    • 始终在像素块行尾 追加一个格式化的回车: x0A

    ESC是一个字符,表示转义的开始,ascii为27:33(8进制),x1b(16进制)

    • ESC[38;2;R;G;Bm:改前景色

    • ESC[48;2;R;G;Bm:改背景色

    • ESC[0m:重置终端 (默认背景色为0,0,0)

    空格mn/pq个:一个像素块一个 换行符n/q个:一行一个


    前景色的知识并没有用到,"空格用于 转义用于"在胡扯,上面给的那个hello world是误例,他的输出还有hello world,可是我们的要求根本不用,就只看颜色,划分块,模糊字母的关注点


    *输出格式* 为依次输出小块的平均像素,按从左到右,从上到下的顺序输出为一行,每次到行尾时输出/x0A表示换行。并按照题目要求在相应位置加入转义序列ESC[48;2;...m(x1Bx5Bx34x38x3Bx32x3B...x6D)或ESC[0m(即x1Bx5Bx30x6D)。

    *输出格式要注意以下几点:*

    1. 初始时终端的背景色都为默认值(背景黑色);

    2. 如果下一个字符的颜色刚好与默认值完全相同,应当直接使用重置转义序列ESC[0m(即x1Bx5Bx30x6D),而非手动更改颜色;

    3. 如果某个字符的背景色与其前一个字符相同,则直接在前一个字符后输入“空格”(x20);

    4. 在每行(遇到/x0A几位换行)结尾处,如果终端颜色不是默认值,应该重置终端的颜色状态。

    关于输出的解释:ESC[0m(即x1Bx5Bx30x6D):ESC的ascii是1b;[的ascii是5b;0是30;m是6d,均为16进制,所以前面要加上x,表明是16进制http://c.biancheng.net/c/ascii/;空格是x20;回车是x0a

    卧槽我就纳闷了,你提这回事了????????????

    例一的输出:esc [ 4 8 ; 2 ; 1 ; 2 ; 3 m 空格 esc [ 0 m 换行

    ESC[48;2;R;G;Bm:改背景色 / 空格 / 重置 / 换行

    例二的输出:esc [ 4 8 ; 2 ; 8 ; 8 ; 8 m 空格 空格 esc [ 0 m 换行


    BufferReader的作用是为其它Reader提供缓冲功能。创建BufferReader时,我们会通过它的构造函数指定某个Reader为参数。BufferReader会将该Reader中的数据分批读取,每次读取一部分到缓冲中;操作完缓冲中的这部分数据之后,再从Reader中读取下一部分的数据。

    BufferedReader in = new BufferedReader(new FileReader(“foo.in”));

    Java 中我们可以使用 StringTokennizer 设置不同分隔符来分隔字符串,默认的分隔符是:空格、制表符( )、换行符( )、回车符( )。

    https://www.runoob.com/w3cnote/java-stringtokenizer-intro.html

    public class Main {
        public static void main(String[] args) {
     
            String str = "This is String , split by StringTokenizer";
            StringTokenizer st = new StringTokenizer(str);
     
            System.out.println("----- 通过空格分隔 ------");
            while (st.hasMoreElements()) {
                System.out.println(st.nextElement());
            }
     
            System.out.println("----- 通过逗号分隔 ------");
            StringTokenizer st2 = new StringTokenizer(str, ",");
     
            while (st2.hasMoreElements()) {
                System.out.println(st2.nextElement());
            }
        }
    }

    ----- 通过空格分隔 ------
    This
    is
    String
    ,
    split
    by
    StringTokenizer,
    ----- 通过逗号分隔 ------
    This is String
    split by StringTokenizer

    当对字符串进行修改的时候,需要使用 StringBuffer 和 StringBuilder 类。

    和 String 类不同的是,StringBuffer 和 StringBuilder 类的对象能够被多次的修改,并且不产生新的未使用对象。

    StringBuilder 类在 Java 5 中被提出,它和 StringBuffer 之间的最大不同在于 StringBuilder 的方法不是线程安全的(不能同步访问)。

    由于 StringBuilder 相较于 StringBuffer 有速度优势,所以多数情况下建议使用 StringBuilder 类。然而在应用程序要求线程安全的情况下,则必须使用 StringBuffer 类。

    public StringBuffer append(String s) 将指定的字符串追加到此字符序列。

      1 //后来 把大神的改了改 就是输入那块 还是拿scanner做的  过程都一样 就是输入没这么麻烦
      2 
      3 //代价是时间空间都大了
      4 
      5 //java
      6 import java.io.*;
      7 import java.util.*;
      8 
      9 public class Main{
     10     
     11     static int R,G,B;//实例变量不用初始化
     12     static String reset = "\x1B\x5B\x30\x6D"; //重置 ESC[0m
     13     
     14     public static void main(String[] args) {
     15         
     16         run();
     17         
     18     }
     19     
     20     public static void run() {
     21         Scanner in = new Scanner(System.in);
     22         int width = in.nextInt(),height = in.nextInt();
     23         int pwidth = in.nextInt(),qheight = in.nextInt();
     24         
     25         int[][][] image = new int[height][width][3];//这张图片
     26         for(int i = 0;i<height;i++) {
     27             for(int j=0;j<width;j++) {            
     28                 hextoRGB(in.next());//输入一块的像素,转为一块rgb形式    
     29                 image[i][j][0] = R;
     30                 image[i][j][1] = G;
     31                 image[i][j][2] = B;//这一块的image
     32             }
     33         }//---
     34         int  countpix = pwidth*qheight;
     35         int ravg = 0,gavg = 0,bavg = 0;//像素均值
     36         int rpre = 0,gpre = 0,bpre = 0;//前一个像素块的像素值
     37         StringBuilder result = new StringBuilder();//对字符串进行修改
     38         boolean first = true;
     39         for(int i=0;i<height;i+=qheight) { //计算划分后的像素块的像素均值
     40             for(int j=0;j<width;j+=pwidth) {
     41                 int rsum = 0,gsum = 0, bsum = 0;
     42                 for(int y=i;y<i+qheight;y++) {//这个块内的东西
     43                     for(int x=j;x<j+pwidth;x++) {
     44                         rsum += image[y][x][0];
     45                         gsum += image[y][x][1];
     46                         bsum += image[y][x][2];
     47                     }
     48                 }
     49                 ravg = rsum / countpix;
     50                 gavg = gsum / countpix;
     51                 bavg = bsum / countpix;//这块的均值像素出来了
     52                      //这一行内的像素块
     53                 //开始拿这个像素块 判断像素块之间的背景色
     54                 if(first) {//如果他是第一行的第一块
     55                     if(!(ravg==0 && gavg==0 && bavg==0)) {//第一块的颜色不等于默认色的话 输出默认色 
     56                         changebackground(ravg,gavg,bavg,result);//result = new StringBuilder();?????????????
     57                     }
     58                     //等于默认色的话 什么也不做  跟一个空格就行(下面有)
     59                     first = false;//first 是否是某行的第一块
     60                 }else if(!(ravg==rpre && gavg==gpre && bavg==bpre)) {//如果该块颜色不等于上一块
     61                     if(ravg==0 && gavg==0 && bavg==0) {//但是等于默认色  直接重置
     62                         result.append(reset);
     63                     }else { //都不等 改变背景色成为自己的
     64                         changebackground(ravg,gavg,bavg,result);
     65                     }
     66                 }//---if elseif 一块结束
     67                result.append("\x20");//空格
     68                rpre = ravg;
     69                gpre = gavg;
     70                bpre = bavg;
     71             }//---int j 一行结束
     72             if(!(ravg == 0 && gavg == 0 && bavg == 0)) {//如果该行结束后时的背景色不等于默认色,则输出要重置
     73                 result.append(reset);
     74             }
     75             result.append("\x0A");//添加换行符
     76             first = true;
     77         }
     78         
     79          //只在最后输出结果,而不是每一行就输出一次,这样可以减少IO次数,节约用时
     80         System.out.print(result.toString());//返回此对象表示的这组字符的字符串表示形式
     81        in.close();
     82     }
     83     
     84     
     85     //以html形式表示的颜色转为RGB形式  #abcdef-- 0xab 0xcd 0xef:16进制
     86     public static void hextoRGB(String hex) {//io.next()得到的是string
     87         if(hex.length() == 4) {//#abc
     88             R = Integer.parseInt(hex.substring(1,2) + hex.substring(1,2),16);//substring() 方法返回字符串的子字符串。[) 将字符串aa转为16进制的整数
     89             G = Integer.parseInt(hex.substring(2,3) + hex.substring(2,3),16);
     90             B = Integer.parseInt(hex.substring(3,4) + hex.substring(3,4),16);
     91         }else if(hex.length() == 2) {//#a
     92             R = Integer.parseInt(hex.substring(1,2) + hex.substring(1,2),16);
     93             G = R;
     94             B = R; 
     95         }else {
     96             R = Integer.parseInt(hex.substring(1,3),16);
     97             G = Integer.parseInt(hex.substring(3,5),16);
     98             B = Integer.parseInt(hex.substring(5,7),16);
     99         }
    100     }
    101     
    102     //更改背景色
    103     public static void changebackground(int R,int G,int B, StringBuilder hexout) {
    104         hexout.append("\x1B\x5B\x34\x38\x3B\x32\x3B");//==ESC[48;2;    ESC[48;2;R;G;Bm将背景色改为默认值
    105         //3B对应字符
    106         gethexorder(R,hexout);
    107         hexout.append("\x3B");//;
    108         gethexorder(G,hexout);
    109         hexout.append("\x3B");//;
    110         gethexorder(B,hexout);
    111         hexout.append("\x6D");//m   R;G;Bm
    112     }
    113     
    114     //对于命令行中的RGB值,要先将10进制的RGB值转换成字符串,再按16进制数形式逐个字符地输出。
    115     //例如一个RGB的一个颜色分量值为128,需要按16进制数的形式分别输出1、2、8这3个字符,而不是直接按16进制数形式输出128这个10进制数。
    116     public static void gethexorder(int a,StringBuilder hexout) {
    117          if (a >= 100) {
    118                 //该颜色分量有3位
    119                 hexout.append("\x");
    120                 // 48对应ACSII字符表中的'0' 字符,因为我们最终的输出时一个字符对应的转义序列,而不是10进制的int值的16进制,所以需要加上48
    121                 //Integer.toHexString()用于将十进制转成十六进制输出
    122                 hexout.append(Integer.toHexString(a / 100+48));//百位
    123                 hexout.append("\x");
    124                 hexout.append(Integer.toHexString(a / 10 % 10+48));//十位
    125                 hexout.append("\x");
    126                 hexout.append(Integer.toHexString(a % 10+48));//个位
    127             } else if (a >= 10) {
    128                 //颜色分量有2位
    129                 hexout.append("\x");
    130                 hexout.append(Integer.toHexString(a / 10+48));
    131                 hexout.append("\x");
    132                 hexout.append(Integer.toHexString(a % 10+48));
    133             }else {
    134                 //颜色分量只有一位
    135                 hexout.append("\x");
    136                 hexout.append(Integer.toHexString(48 + a));
    137             }
    138     }
    139 
    140     
    141 }
    142 
    1. 本题只涉及到了更改背景色,并没有涉及到前景色的更改。

    2. 对于每一个命令行中的字符,均需按16进制数输出其ASCII码,且输出的16进制数要有2位,不足两位在高位补0。

    3. RGB颜色分量值在0~255之间,不能用char存储(char存储范围是-128~127),最好用int存储。(c++)

    4. 对于命令行中的RGB值,要先将10进制的RGB值转换成字符串,再按16进制数形式逐个字符地输出。例如一个RGB的一个颜色分量值为128,需要按16进制数的形式分别输出128这3个字符,而不是直接按16进制数形式输出128这个10进制数。

    5. 计算RGB颜色分量平均值要向0取整,所以直接使用C++中的除法运算就可以了。

    6. 输出每一个块之后都要按16进制数形式输出一个空格,输出每一行字符串后都要按16进制数形式输出一个换行符。

    7. 输出每一行字符之后,输出换行符之前,要检查当前RGB值是否是默认状态,如果不是,要置为默认状态,且要更新代码中的上一个状态为默认状态

    8. 如果某个状态的RGB值与其前一个状态相同,那么什么也不要做,直接输出一个空格即可。

    9. 如果一个状态的RGB值刚好与默认状态完全相同,要使用重置转义序列。

    10. 先检查一个状态是否与上一个状态相同,再检查是否与默认状态相同。也就是说,假如上一个状态就是默认状态,当前状态也是默认状态,那么无需输出重置转义序列,直接输出一个空格即可。

    package epistatic;
    
    import java.io.*;
    import java.util.*;
    
    public class Main{
        
        static int R,G,B;//实例变量不用初始化
        static String reset = "\x1B\x5B\x30\x6D"; //重置 ESC[0m
        
        public static void main(String[] args) {
            
              run();
            
        }
        
        public static void run() {
            fastio io = new fastio();
            io.init(System.in);
            int width = io.nextint(),height = io.nextint();
            int pwidth = io.nextint(),qheight = io.nextint();
            int[][][] image = new int[height][width][3];//这张图片
            for(int i = 0;i<height;i++) {
                for(int j=0;j<width;j++) {
                    //输入height*width行像素
                    hextoRGB(io.next());//像素转为rgb形式了
                    image[i][j][0] = R;
                    image[i][j][1] = G;
                    image[i][j][2] = B;
                }
            }//---
            int  countpix = pwidth*qheight;
            int ravg = 0,gavg = 0,bavg = 0;//像素均值
            int rpre = 0,gpre = 0,bpre = 0;//前一个像素块的像素值
            StringBuilder result = new StringBuilder();
            boolean first = true;
            for(int i=0;i<height;i+=qheight) { //计算像素块像素均值
                for(int j=0;j<width;j+=pwidth) {
                    int rsum = 0,gsum = 0, bsum = 0;
                    for(int y=i;y<i+qheight;y++) {
                        for(int x=j;x<j+pwidth;x++) {
                            rsum += image[y][x][0];
                            gsum += image[y][x][1];
                            bsum += image[y][x][2];
                        }
                    }
                    ravg = rsum / countpix;
                    gavg = gsum / countpix;
                    bavg = bsum / countpix;
                    //开始判断像素块之间的背景色
                    if(first) {//一行的开始,此时背景色已经是默认色
                        if(!(ravg==0 && gavg==0 && bavg==0)) {//第一块的颜色不等于默认色 输出默认色 
                            changebackground(ravg,gavg,bavg,result);//result = new StringBuilder();????????
                        }
                        //等于默认色的话 什么也不做
                        first = false;//first 是否是某行的第一块
                    }else if(!(ravg==rpre && gavg==gpre && bavg==bpre)) {//如果该块颜色不等于上一块
                        if(ravg==0 && gavg==0 && bavg==0) {//但是等于默认色  直接重置
                            result.append(reset);
                        }else { //都不等 改变背景色成为自己的
                            changebackground(ravg,gavg,bavg,result);
                        }
                    }//---if elseif 一块结束
                   result.append("\x20");//空格
                   rpre = ravg;
                   gpre = gavg;
                   bpre = bavg;
                }//---int j 一行结束
                if(!(ravg == 0 && gavg == 0 && bavg == 0)) {//如果该行结束后时的背景色不等于默认色,则输出要重置
                    result.append(reset);
                }
                result.append("\x0A");//添加换行符
                first = true;
            }
            
             //只在最后输出结果,而不是每一行就输出一次,这样可以减少IO次数,节约用时
            System.out.print(result.toString());//返回此对象表示的这组字符的字符串表示形式
        }
        
        
        //以html形式表示的颜色转为RGB形式  #abcdef-- 0xab 0xcd 0xef:16进制
        public static void hextoRGB(String hex) {
            if(hex.length() == 4) {//#abc
                R = Integer.parseInt(hex.substring(1,2) + hex.substring(1,2),16);//substring() 方法返回字符串的子字符串。[) 将字符串aa转为16进制的整数
                G = Integer.parseInt(hex.substring(2,3) + hex.substring(2,3),16);
                B = Integer.parseInt(hex.substring(3,4) + hex.substring(3,4),16);
            }else if(hex.length() == 2) {//#a
                R = Integer.parseInt(hex.substring(1,2) + hex.substring(1,2),16);
                G = R;
                B = R; 
            }else {
                R = Integer.parseInt(hex.substring(1,3),16);
                G = Integer.parseInt(hex.substring(3,5),16);
                B = Integer.parseInt(hex.substring(5,7),16);
            }
        }
        
        //将背景色改为默认
        public static void changebackground(int R,int G,int B, StringBuilder hexout) {
            hexout.append("\x1B\x5B\x34\x38\x3B\x32\x3B");//==ESC[48;2;    ESC[48;2;R;G;Bm将背景色改为默认值
            //3B对应字符
            gethexorder(R,hexout);
            hexout.append("\x3B");//;
            gethexorder(G,hexout);
            hexout.append("\x3B");//;
            gethexorder(B,hexout);
            hexout.append("\x6D");//m   R;G;Bm
        }
        
        //对于命令行中的RGB值,要先将10进制的RGB值转换成字符串,再按16进制数形式逐个字符地输出。
        //例如一个RGB的一个颜色分量值为128,需要按16进制数的形式分别输出1、2、8这3个字符,而不是直接按16进制数形式输出128这个10进制数。
        public static void gethexorder(int a,StringBuilder hexout) {
             if (a >= 100) {
                    //该颜色分量有3位
                    hexout.append("\x");
                    // 48对应ACSII字符表中的'0' 字符,因为我们最终的输出时一个字符对应的转义序列,而不是10进制的int值的16进制,所以需要加上48
                    //Integer.toHexString()用于将十进制转成十六进制输出
                    hexout.append(Integer.toHexString(a / 100+48));//百位
                    hexout.append("\x");
                    hexout.append(Integer.toHexString(a / 10 % 10+48));//十位
                    hexout.append("\x");
                    hexout.append(Integer.toHexString(a % 10+48));//个位
                } else if (a >= 10) {
                    //颜色分量有2位
                    hexout.append("\x");
                    hexout.append(Integer.toHexString(a / 10+48));
                    hexout.append("\x");
                    hexout.append(Integer.toHexString(a % 10+48));
                }else {
                    //颜色分量只有一位
                    hexout.append("\x");
                    hexout.append(Integer.toHexString(48 + a));
                }
        }
        
        static class fastio{
            BufferedReader reader;
            StringTokenizer tokenizer;
            
            void init(InputStream inputstream) {
                reader = new BufferedReader(new InputStreamReader(inputstream));
                tokenizer = new StringTokenizer("");
            }
            //读入一个字符串
            String next() {
                while(!tokenizer.hasMoreTokens()) { //hasMoreTokens(): 返回当前字符串是否还有分隔符  有的话true
                    try {
                        tokenizer = new StringTokenizer(reader.readLine());//方法读取一行文本。一行被认为是由一个换行符(' n'),回车符(' r')或回车符中的任何一个被终止紧跟一个换行符
                    }catch(IOException e){
                        e.printStackTrace();
                    }
                }
                return tokenizer.nextToken();//返回从当前位置到下一个分隔符的字符串
            }
            //读入一整行
            String nextline() {
                while(!tokenizer.hasMoreElements()) {
                    try {
                        tokenizer = new StringTokenizer(reader.readLine());
                    }catch(IOException e) {
                        e.printStackTrace();
                    }
                }
                return tokenizer.nextToken("
    ");//返回从当前位置到指定的分隔符的字符串
            }
            //读int
            int nextint() {
                return Integer.parseInt(next());//将字符串参数分析为一个带符号的整数,(第二个参数是指指定的基数)
            }
            //读double
            double nextdouble() {
                return Double.parseDouble(next());
            }
            
            
        }
        
    }
    View Code

    大神的代码 https://www.cnblogs.com/godlovesme/p/11919032.html

  • 相关阅读:
    黑马程序员面向对象09天1
    一键安装LNMP
    多屏互动技术
    阿里云CentOS 64位解决kernel2.6.32220.13.1.el6.x86_64 has missing requires错误
    listview的onItemClickListener失效
    在阿里云主机上基于CentOS用vsftpd搭建FTP服务器(赚)
    asp.net关于在线支付的实现过程
    C#关闭登录窗体,显示主窗体
    winform 刷新父窗体(转)
    用代码生成器生成的DAL数据访问操作类 基本满足需求了
  • 原文地址:https://www.cnblogs.com/yundong333/p/13468210.html
Copyright © 2011-2022 走看看