记录一下自己的洛谷的题解

不出意外应该都是很基础的练习题，最近在学java，刷洛谷的简单题，熟悉熟悉语法

P5727

/*
 * 给出一个正整数 n (n<=100)，然后对这个数字一直进行下面的操作：
 * 如果这个数字是奇数，那么将其乘 3 再加 1，否则除以 2。
 * 经过若干次循环后，最终都会回到 1。经过验证很大的数字(7e11)
 * 都可以按照这样的方式比变成 1，所以被称为“冰雹猜想”。
 * 例如当 n 是 20，变化的过程是 [20, 10, 5, 16, 8, 4, 2, 1]。
 *
 * 根据给定的数字，验证这个猜想，并从最后的 1 开始，倒序输出整个变化序列。
 * */
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        List<Integer> list = new ArrayList<>();
        while (n > 1) {
            list.add(n);
            if (n % 2 == 1) {
                n = n * 3 + 1;
            } else {
                n = n / 2;
            }
        }
        list.add(1);
    
        for (int i = list.size()-1; i >=0; i--) {
            System.out.print(list.get(i)+" ");
        }
    }
}

P5719

/*
 * 给定 n(n≤10000) 和 k(k≤100)，
 * 将从 1 到 n 之间的所有正整数可以分为两类：
 * A 类数可以被 k 整除（也就是说是 k 的倍数），
 * 而 B 类数不能。请输出这两类数的平均数，
 * 精确到小数点后 1 位，用空格隔开。
 * 数据保证两类数的个数都不会是 0。
 * */

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt(),
            k = sc.nextInt();
        
        double sumA = 0, sumB = 0,
            countA = 0, countB = 0;
        
        for (int i = 1; i <= n; i++) {
            if (i % k == 0) {
                sumA += i;
                countA++;
            } else {
                sumB += i;
                countB++;
            }
        }
        
        System.out.printf("%.1f %.1f",sumA / countA , sumB / countB);
    }
}

P5717

/*
 * 给出三条线段 a,b,c 的长度，均是不大于 10000 的整数。
 * 打算把这三条线段拼成一个三角形，它可以是什么三角形呢？
 *
 * 如果三条线段不能组成一个三角形，输出Not triangle；
 * 如果是直角三角形，输出Right triangle；
 * 如果是锐角三角形，输出Acute triangle；
 * 如果是钝角三角形，输出Obtuse triangle；
 * 如果是等腰三角形，输出Isosceles triangle；
 * 如果是等边三角形，输出Equilateral triangle。
 * 如果这个三角形符合以上多个条件，请分别输出，并用换行符隔开。
 *
 * a+b>c构成三角形
 *
 * 当两短边的平方和大于一长边的平方，说明是锐角三角形。
 * 当两短边的平方和等于一长边的平方，说明是直角三角形。
 * 当两短边的平方和小于一长边的平方，说明是钝角三角形。
 * */

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

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int[] arr = new int[3];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = sc.nextInt();
        }
        Arrays.sort(arr); // 升序 (0<=1<=2)
        
        // 三角形判断
        if (arr[0] + arr[1] <= arr[2]) {
            System.out.println("Not triangle");
            return;
        }
        // 角类型判断
        int a = arr[0]*arr[0]+arr[1] * arr[1]; // 两短边平方和
        int b = arr[2]*arr[2]; // 长边的平方
        if (a>b) {
            System.out.println("Acute triangle");
        }else if (a < b) {
            System.out.println("Obtuse triangle");
        }else {
            System.out.println("Right triangle");
        }
        // 等腰判断 (由于数组已排序,所以条件可以适当省去)
        if (arr[0] == arr[1] || arr[1] == arr[2]) {
            System.out.println("Isosceles triangle");
            if (arr[0] == arr[2]) {
                System.out.println("Equilateral triangle");
            }
        }
    }
}

P5716

/*
 * 输入年份和月份，输出这一年的这一月有多少天。需要考虑闰年。
 * */

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class Main {
    public static void main(String[] args) throws Exception {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(br.readLine());
        
        int year = Integer.parseInt(st.nextToken()),
            month = Integer.parseInt(st.nextToken()),
            days = 0;
        //是否是闰年
        boolean isLeapYear = ((year % 4 == 0) && (year % 100 != 0))
                             || (year % 400 == 0);
        switch (month) {
            case 1:
            case 3:
            case 5:
            case 7:
            case 8:
            case 10:
            case 12:
                days = 31;
                break;
            case 2:
                days = 28;
                break;
            default:
                days = 30;
                break;
        }
        if (isLeapYear && month == 2) {
            days++;
        }
        
        System.out.println(days);
    }
}

P1914

/*
 * 密码是由一个字符串组成。
 * 密码是由原文字符串（由不超过 50 个小写字母组成）中
 * 每个字母向后移动 n 位形成的。
 * z 的下一个字母是 a，如此循环。
 * 现在找到了移动前的原文字符串及 n，请你求出密码。
 * */

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        String oldStr = sc.next();
        char[] oldChars = oldStr.toCharArray();
        for (int i = 0; i < oldChars.length; i++) {
            oldChars[i] += n % 26;
            if (oldChars[i] > 'z') {
                oldChars[i] = (char) (oldChars[i] - 'z' - 1 + 'a');
            }
        }
    
        for (char oldChar : oldChars) {
            System.out.print(oldChar);
        }
    }
}

P1909

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt(); // 需要的铅笔数量
        int[][] arr = new int[3][2];
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                arr[i][j] = sc.nextInt();
            }
        }
        
        int min;
        
        if (n % arr[0][0] != 0) {
            min = arr[0][1] * (n / arr[0][0] + 1);
        } else {
            min = arr[0][1] * (n / arr[0][0]);
        }
        
        if (n % arr[1][0] != 0) {
            min = Math.min(min, arr[1][1] * (n / arr[1][0] + 1));
        } else {
            min = Math.min(min, arr[1][1] * (n / arr[1][0]));
        }
        if (n % arr[2][0] != 0) {
            min = Math.min(min, arr[2][1] * (n / arr[2][0] + 1));
        } else {
            min = Math.min(min, arr[2][1] * (n / arr[2][0]));
        }
        
        System.out.println(min);
    }
}

P1085

/*
 * 津津如果一天上课超过八个小时就会不高兴，而且上得越久就会越不高兴。
 * 假设津津不会因为其它事不高兴，并且她的不高兴不会持续到第二天。
 * 请你帮忙检查一下津津下周的日程安排，
 * 看看下周她会不会不高兴；如果会的话，哪天最不高兴。
 *
 * 输入格式
 * 输入包括7行数据，分别表示周一到周日的日程安排。
 * 每行包括两个小于10的非负整数，用空格隔开，
 * 分别表示津津在学校上课的时间和妈妈安排她上课的时间。
 *
 * 输出格式
 * 一个数字。如果不会不高兴则输出00，如果会则输出最不高兴的是周几（用1, 2, 3, 4, 5, 6, 7
 * 分别表示周一，周二，周三，周四，周五，周六，周日）。
 * 如果有两天或两天以上不高兴的程度相当，则输出时间最靠前的一天。
 * */


import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int[] a = new int[7];
        int[] b = new int[7];
        int[] notHappy = new int[7];
        for (int i = 0; i < notHappy.length; i++) {
            a[i] = sc.nextInt();
            b[i] = sc.nextInt();
            notHappy[i] = a[i] + b[i] - 8;
        }
        int maxIndex = 0;
        for (int i = 1; i < notHappy.length; i++) {
            maxIndex = notHappy[i] > notHappy[maxIndex] ? i : maxIndex;
        }
        System.out.println(maxIndex+1);
    }
}

P1055

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String s = sc.nextLine();
        String str= s.replace("-", "");
        int sum = 0;
        for (int i = 0; i < str.length()-1; i++) {
            int a = Character.getNumericValue(str.charAt(i));
            sum+=a*(i+1);
        }
        int code = sum%11;
        String s1 = str.substring(str.length() - 1);
        String s2;
        if (code == 10) {
            s2="X";
        }else {
            s2 = String.valueOf(code);
        }
        if (s.substring(s.length() - 1).equals(s2)) {
            System.out.println("Right");
        }else {
            System.out.println(s.substring(0,s.length() - 1)+s2);
        }
        
    }
}