记录一下我的刷题实录

先说一下刷题的初衷----->>

刷题这个就跟做数学题一样,一是为了查漏补缺,另一个是为了…没错就是money (俗,俗不可耐,但…华为机考肝了)

开始—>>

1,

import java.util.Scanner;

public class Main{
    public static void main(String []args){
       
        Scanner sc= new Scanner(System.in);

        String str=sc.nextLine();

        System.out.println(SplitStr(str));
        sc.close();
        
    }
    public static int SplitStr(String string){
        String[] str=string.split(" ");

        return str[str.length-1].toCharArray().length;
    }
}

import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String str = scanner.nextLine();
        String next = scanner.next();
        char[] chars = next.toCharArray();
        char ch = chars[0];

        System.out.println(AppearTime(str, ch));
    }

    public static int AppearTime(String str, char ch) {
        char[] chars = str.toCharArray();
        int result = 0;
        for (int i = 0; i < chars.length; i++) {
            if (String.valueOf(chars[i]).equalsIgnoreCase(String.valueOf(ch))) {
                result += 1;
            }

        }


        return result;
    }
}

import java.util.HashSet;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        int num = scanner.nextInt();
        HashSet<Integer> hashSet = new HashSet<>();
        for (int i = 0; i < num; i++) {
            int number = scanner.nextInt();
            hashSet.add(number);
        }
        scanner.close();
       hashSet.forEach(System.out::println);

    }
}

import java.util.Scanner;

public class Main{
    public static void  main(String []args){
        Scanner sc = new Scanner(System.in);
        String next=sc.next();
        if (next.contains("0x")||next.contains("0X")){
            String str= next.substring(2);
            Integer integer = Integer.parseInt(str, 16);
            System.out.println(integer);
        }else{
            Integer integer = Integer.parseInt(next, 16);
            System.out.println(integer);
        }

        sc.close();
    }
}

public class Test4 {

    public static void main(String[] args) {

        Scanner scanner= new Scanner(System.in);
        long l = scanner.nextLong();
        Demo(l);
//        System.out.println(l>>1);能用位操作实现吗?-
        scanner.close();
    }

    public static void Demo(long l){

        for (int i = 2; i <=l ; i++) {
            //都除一遍,挨个查找
            if (l%i==0){
                System.out.println(i+" ");
                Demo(l/i);
                break;
            }
//            最后收个尾巴
            if(i==l){
                System.out.println(i+" ");
            }
        }
    }
}

import java.util.Scanner;
public class Main{

public static void main(String args[]){
Scanner sc = new Scanner(System.in); 
    double num=sc.nextDouble();
    int x=NumDemo(num);
    sc.close();
    System.out.print(x);
}
    public static int NumDemo(double num){
    double n=num-(int)num;
    if(n>=0.5){
    int m=(int)num+1;
    return m;
    }
    int m=(int)num;
    
    return m;
    }

}

主要是 map.merge(m, n, Integer::sum)方法

指定的 key 是否存在，如果不存在，则添加键值对到 hashMap 中。

如果 key 对应的 value 不存在，则返回该 value 值，如果存在，则返回通过 remappingFunction 重新计算后的值。

import java.util.*;

public class Main {

    public static void main(String args[]) {
        Show();
    }

    public static void Show() {
        Map<Integer, Integer> map = new HashMap<>();
        Scanner sc = new Scanner(System.in);
        int num = sc.nextInt();

        for (int i = 0; i < num; i++) {
            int m = sc.nextInt();
            int n = sc.nextInt();
            map.merge(m, n, Integer::sum);
            
        }
        map.keySet().stream().sorted().forEach(k -> System.out.println(k + " " + map.get(k)));
        sc.close();

    }
}

import java.util.*;

public class Test6 {
    public static void main(String[] args) throws Exception {
        Scanner sc = new Scanner(System.in);

        String s = sc.nextLine();

        char[] chars = s.toCharArray();
        //Set中的LinkedHashSet就是有序的
        LinkedHashSet<Character> set = new LinkedHashSet<>();
        for (int i = chars.length - 1; i >= 0; i--) {
            set.add(chars[i]);

        }


        Iterator<Character> it = set.iterator();
        while (it.hasNext()) {
            System.out.print(it.next());
        }
    }
}

import java.util.HashSet;
import java.util.Scanner;
public class Main{
    
    public static void main(String args[]){
        Scanner sc = new Scanner(System.in);
        String str=sc.nextLine();
        char[]ch=str.toCharArray();
        HashSet <Character> set= new HashSet();
     for(int i=0;i<ch.length;i++){
         set.add(ch[i]);
     }
        System.out.println(set.size());
        
        sc.close();
    }
    
}

发一个他人写的另一个解法---->>

import java.util.Scanner;
import java.util.BitSet;

public class Main {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String line = scanner.next();
        //总共有128个字符。字需要用128位
        BitSet bitSet = new BitSet(128);
        for (char c : line.toCharArray()) {
            //判断字符c是否已出现
            if (!bitSet.get(c)) {
                //未出现就设置为已出现
                bitSet.set(c);
            }
        }
        //统计有多少字符已出现过
        System.out.println(bitSet.cardinality());
    }
}

import java.util.Scanner;
public class Main{

public static  void main(String []args){
Scanner sc = new Scanner(System.in);
    int num=sc.nextInt();
reverseNum(num);
sc.close();
}
    
    public static void reverseNum(int num){
        
        String str=String.valueOf(num);
        char ch[]=str.toCharArray();
        for(int i=ch.length-1;i>=0;i--){
            System.out.print(ch[i]);
        }
        
    }

}

import java.util.Scanner;
public class Main{
    
    public static void main(String []args){
        Scanner sc = new Scanner(System.in);
         String str=sc.next();
        System.out.println(lowStr(str));
       
    }
    public static String lowStr(String str){
        String string=str.toLowerCase();
        StringBuilder sb= new StringBuilder(string);
        
        return sb.reverse().toString();
    }
    
}

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String str=sc.nextLine();
        Words(str);
        sc.close();
    }
    
    public static void Words(String str){
        String[]string=str.split(" ");
        for(int i=string.length-1;i>=0;i--){
            System.out.print(string[i]+" ");
        }
        
    }
}

import java.util.Scanner;

public class Main{
            public static void main(String []args){
                Scanner sc  = new Scanner(System.in);
                int num=sc.nextInt();
                
                char[] ch =Integer.toBinaryString(num).toCharArray();
                
                int count=0;
                for(int i =0;i<ch.length-1;i++){

                if(ch[i]=='1'){
}
                count+=1;
                }
                sc.close();
               System.out.print(count); 
                
            }
}

public class Test8{

    public static void main(String args[]){
        sortedStr();
    }
    public static void sortedStr(){

        Scanner sc= new Scanner(System.in);

        int count=sc.nextInt();

        if(count<=0){
            return;
        }
        String[]strings=new String[count];

        for(int i=0;i<strings.length;i++){
            strings[i]=sc.next();
        }
        sc.close();
        Arrays.sort(strings);

        for (String string : strings) {
            System.out.println(string);
        }
    }

}

import java.util.*;
import java.util.stream.Stream;

public class Main {
    public static void main(String args[]) {
//        System.out.println("A10".matches("^A\\d{1,2}"));
        ZB();
    }

    public static void ZB() {
        Scanner sc = new Scanner(System.in);
        String str = sc.nextLine();
        String strings[] = str.split(";");

        //处理数组去掉不符合的
//         含A的,D的
        HashMap<String, Integer> hashMap = new HashMap<>();
        for (int i = 0; i < strings.length; i++) {
            if (strings[i].matches("^A\\d{1,2}")) {
                String[] as = strings[i].split("A");
                hashMap.merge("A", Integer.valueOf(as[1]), Integer::sum);
            }
          else  if (strings[i].matches("^D\\d{1,2}")) {
                String[] as = strings[i].split("D");
                hashMap.merge("D", Integer.valueOf(as[1]), Integer::sum);
            }
           else if (strings[i].matches("^W\\d{1,2}")) {
                String[] as = strings[i].split("W");
                hashMap.merge("W", Integer.valueOf(as[1]), Integer::sum);
            }
        else    if (strings[i].matches("^S\\d{1,2}")) {
                String[] as = strings[i].split("S");
                hashMap.merge("S", Integer.valueOf(as[1]), Integer::sum);
            }else{
            continue;
            }
        }
        Integer a = hashMap.get("A");
        Integer d = hashMap.get("D");
        Integer s = hashMap.get("S");
        Integer w = hashMap.get("W");

        System.out.println((d-a) + "," + (w - s));
        sc.close();
    }
}

package com.gavin.shuati;

import java.util.Scanner;

public class Test12 {


    public static void main(String []args) {
Scanner sc = new Scanner(System.in);
        String s = sc.nextLine();
        System.out.println(ChangePwd(s));
        sc.close();
    }


    public static String ChangePwd(String str) {

        str = str.replaceAll("[a-c]", "2");
        str = str.replaceAll("[d-f]", "3");
        str = str.replaceAll("[g-i]", "4");
        str = str.replaceAll("[k-l]", "5");

        str = str.replaceAll("[m-o]", "6");
        str = str.replaceAll("[p-s]", "7");

        str = str.replaceAll("[t-v]", "8");
        str = str.replaceAll("[w-z]", "9");
        //转为字节数组
        char[] ch = str.toLowerCase().toCharArray();
        for (int i = 0; i < ch.length; i++) {
            if ((int) ch[i] > 96 && (int) ch[i] < 123) {
                ch[i] = (char) ((int) ch[i] + 1);
                if ((int) ch[i] == 123) {
                    ch[i] = 'a';
               }
            }
        }
        return new String(ch);

    }
}

import java.util.*;

public class Main{
    static   boolean flag= true;//做一个标记
    public static void main(String args[]){
        
        Scanner sc= new Scanner(System.in);
  ArrayList<Integer> list= new ArrayList<>();
            //判断如果不是 int,则重新输入,异常先不管他吧
    
        int count=0;//计数用的
        while(flag){
            int num=sc.nextInt();
            list.add(num);
            count++;
            
            if(count>10||num==0){
                flag=false;
               break;
                             
            }
        }
       for(int i=0;i<list.size();i++){
           if(list.get(i)==0){
               continue;
           }
           int m=(int)(list.get(i)/2);
           
         System.out.println(m);
}
        sc.close();
    }
}

但总感觉怪怪的

import java.util.*;

public class Main {

    public static void main(String args[]) {

        Scanner sc = new Scanner(System.in);
        String str = sc.next();
        ArrayList <Character>list  = DelStr(str);
        for (int i = 0; i < list.size(); i++) {
            str=str.replace(list.get(i).toString(),"");
        }

        System.out.println(str);
        sc.close();


    }

    public static ArrayList DelStr(String str) {
        HashSet<Character> set = new HashSet<>();

        char[] ch = str.toCharArray();
        for (int i = 0; i < ch.length; i++) {
            //目的就是为了去重
            set.add(ch[i]);
        }

        HashMap<Character, Integer> hashMap = new HashMap<>();
        //字符串原长度
        int strength = str.length();
        for (Character character : set) {
            //替换之后的字符串
            String str1 = str.replace(String.valueOf(character), "");

            //字母出现的次数
            int num = strength - str1.length();
            //存起来
            hashMap.put(character, num);

        }
//        Set<Map.Entry<Character, Integer>> entries = hashMap.entrySet();
//找到num最小值,遍历比较找到最小值同时也要得到该key,如果最小值不止一个,那么应该得到一个集合
        Collection<Integer> values = hashMap.values();
        Object[] objects = values.toArray();
        //拍一下序
        Arrays.sort(objects);
//        得到最小值
        int min =(int)objects[0];
//然后去map里面去除value对应的key
//遍历map
        ArrayList<Character> list = new ArrayList<>();
        for (Map.Entry<Character, Integer> characterIntegerEntry : hashMap.entrySet()) {
            if (characterIntegerEntry.getValue() != min) {
                continue;
            }
            list.add(characterIntegerEntry.getKey());
        }

        return list;
    }
}

import java.util.*;

public class Main {
    static int asc = 0;

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int num = sc.nextInt();
        asc = sc.nextInt();
SortedSet<Person>set= new TreeSet<>();
//        LinkedHashMap<String, Integer> map = new LinkedHashMap<>();

        for (int i = 0; i < num; i++) {
            String name = sc.next();
            int grade = sc.nextInt();
            set.add(new Person(name,grade));
        }
        set.forEach(System.out::println);
    }


    /**
     * 整一个内部类
     */

   static class Person implements Comparable {
        String name;
        int grade;

        public Person(String name, int grade) {
            this.name = name;
            this.grade = grade;

        }

        @Override
        public String toString() {

            return this.name + " " + this.grade;
        }

        @Override
        public boolean equals(Object o) {
            if (this == o) {
                return true;
            }
            if (o == null || getClass() != o.getClass()) {
                return false;
            }
            Person person = (Person) o;
            return grade == person.grade &&
                    Objects.equals(name, person.name);
        }

        @Override
        public int hashCode() {
            return Objects.hash(name, grade);
        }


        @Override
        public int compareTo(Object o) {
            Person per = (Person) o;
            if (asc == 1) {
                return this.grade - per.grade;
            }
            return per.grade - this.grade;

        }
    }

}

描述 正整数A和正整数B 的最小公倍数是指 能被A和B整除的最小的正整数值，设计一个算法，求输入A和B的最小公倍数。

数据范围：1 \le a,b \le 100000 \1≤a,b≤100000 输入描述： 输入两个正整数A和B。

输出描述： 输出A和B的最小公倍数。

import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
    
     System.out.println(GetGm());
    }
    
  
    public static int GetGm() {
        Scanner sc = new Scanner(System.in);
        int a = sc.nextInt();
        int b = sc.nextInt();
        //a被b除
        //b被a除
        for (int i = (a > b ? a : b); i < a * b; i++) {
            if (i % a == 0 && i % b == 0) {
                return i;
            }

        }
        return a * b;
    }
}

解题思路就是:
两个数最新小公倍数,他的范围在较大那个数到两数之乘积那个数之间,然后通过循环开始找呗;

如果你有其他合适的算法,欢迎在评论区提出,谢谢!

描述 将一个字符串str的内容颠倒过来，并输出。

数据范围：1 \le len(str) \le 10000\1≤len(str)≤10000 输入描述： 输入一个字符串，可以有空格

输出描述： 输出逆序的字符串

import java.io.IOException;
import java.util.Scanner;
public class Main {
    public static void main(String[] args) throws IOException {
System.out.println(ReverseStr());
    }
    
    public static String ReverseStr(){
        Scanner sc= new Scanner(System.in);
         String str = sc.nextLine();
       char[]ch= str.toCharArray();
        StringBuilder st= new StringBuilder();
        for(int i=ch.length-1;i>=0;i--){
           st.append(ch[i]);
        }
        sc.close();
        return st.toString();
        
        
    }
}

描述 输入 n 个整型数，统计其中的负数个数并求所有非负数的平均值，结果保留一位小数，如果没有非负数，则平均值为0
本题有多组输入数据，输入到文件末尾。

数据范围：1 \le n \le 50000 \1≤n≤50000 ，其中每个数都满足 |val| \le 10^{6}
\∣val∣≤10 6 输入描述： 输入任意个整数，每行输入一个。

输出描述： 输出负数个数以及所有非负数的平均值

先给出网站给出的运行成功的代码:

public static void De() {
            Scanner sc = new Scanner(System.in);
            int positiveCnt = 0;
            int negativeCnt = 0;
            int sum = 0;
            while (sc.hasNext()) {
                int n = sc.nextInt();
                if (n > 0) {
                    sum += n;
                    positiveCnt++;
                } else {
                    negativeCnt++;
                }
            }
            double res = positiveCnt == 0 ? 0.0 : sum * 1.0 / positiveCnt;
            System.out.println(negativeCnt + "\n" + String.format("%.1f", res));
        }

但是我有疑问的是,这个什么时候算作输入结束?timu后台测试时不明确,如果换成本地ide运行,测试是不通过的;
于是我写了下面的 方式:

public static void test() {

        Scanner sc = new Scanner(System.in);
        ArrayList<Integer> list = new ArrayList<>();
        int count = 0;

        int sum = 0;
        double avg = 0;
        String s = sc.nextLine();
        String[] split = s.split(" ");

        for (int i = 0; i < split.length; i++) {
            int num = Integer.valueOf((split[i]));
            if (num < 0) {
                ++count;
                continue;
            }
            list.add(num);
        }
        System.out.println(count);
        if (list.size() > 0) {
            for (int i = 0; i < list.size(); i++) {
                sum += list.get(i);
            }
            avg = (double) sum / (list.size());
            System.out.printf("%.1f", avg);

        } else {
            System.out.println(0.0);
        }
        sc.close();
    }

欢迎大家讨论;