2023/08/06

洛希极限（Roche limit）是一个天体自身的引力与第二个天体造成的潮汐力相等时的距离。当两个天体的距离少于洛希极限，天体就会倾向碎散，继而成为第二个天体的环。它以首位计算这个极限的人爱德华·洛希命名。（摘自百度百科）

大天体密度与小天体的密度的比值开 3 次方后，再乘以大天体的半径以及一个倍数（流体对应的倍数是 2.455，刚体对应的倍数是 1.26），就是洛希极限的值。例如木星与地球的密度比值开 3 次方是 0.622，如果假设地球是流体，那么洛希极限就是 0.622×2.455=1.52701 倍木星半径；但地球是刚体，对应的洛希极限是 0.622×1.26=0.78372 倍木星半径，这个距离比木星半径小，即只有当地球位于木星内部的时候才会被撕碎，换言之，就是地球不可能被撕碎。

本题就请你判断一个小天体会不会被一个大天体撕碎。

输入格式：
输入在一行中给出 3 个数字，依次为：大天体密度与小天体的密度的比值开 3 次方后计算出的值（≤1）、小天体的属性（0 表示流体、1 表示刚体）、两个天体的距离与大天体半径的比值（>1 但不超过 10）。

输出格式：
在一行中首先输出小天体的洛希极限与大天体半径的比值（输出小数点后2位）；随后空一格；最后输出 ^_^ 如果小天体不会被撕碎，否则输出 T_T。

输入样例 1：
0.622 0 1.4
输出样例 1：
1.53 T_T
输入样例 2：
0.622 1 1.4
输出样例 2：
0.78 ^_^

import java.util.Scanner;
public class Main
{
    public static void main(String[] args)
    {
        Scanner sc=new Scanner(System.in);
        double midubi=sc.nextDouble();
        int x=sc.nextInt();
        double rbi=sc.nextDouble();
        if(x==0)
        {
            double r=midubi*2.455;
            System.out.printf("%.2f ",r);
            if(r<rbi)
            {
                System.out.println("^_^");
            }
            else
            {
                System.out.println("T_T");
            }
        }
        else if(x==1)
        {
            double r=midubi*1.26;
            System.out.printf("%.2f ",r);
            if(r<rbi)
            {
                System.out.println("^_^");
            }
            else
            {
                System.out.println("T_T");
            }
        }
    }
}

让我们把四个车轮 —— 左前轮、右前轮、右后轮、左后轮 —— 顺次编号为 1、2、3、4。本题就请你编写一个监测程序，随时监测四轮的胎压，并给出正确的报警信息。报警规则如下：

如果所有轮胎的压力值与它们中的最大值误差在一个给定阈值内，并且都不低于系统设定的最低报警胎压，则说明情况正常，不报警；
如果存在一个轮胎的压力值与它们中的最大值误差超过了阈值，或者低于系统设定的最低报警胎压，则不仅要报警，而且要给出可能漏气的轮胎的准确位置；
如果存在两个或两个以上轮胎的压力值与它们中的最大值误差超过了阈值，或者低于系统设定的最低报警胎压，则报警要求检查所有轮胎。
输入格式：
输入在一行中给出 6 个 [0, 400] 范围内的整数，依次为 1~4 号轮胎的胎压、最低报警胎压、以及胎压差的阈值。

输出格式：
根据输入的胎压值给出对应信息：

如果不用报警，输出 Normal；
如果有一个轮胎需要报警，输出 Warning: please check #X!，其中 X 是出问题的轮胎的编号；
如果需要检查所有轮胎，输出 Warning: please check all the tires!。
输入样例 1：
242 251 231 248 230 20
输出样例 1：
Normal
输入样例 2：
242 251 232 248 230 10
输出样例 2：
Warning: please check #3!
输入样例 3：
240 251 232 248 240 10
输出样例 3：
Warning: please check all the tires!

import java.util.Scanner;
public class Main{
    public static void main(String[] args)
    {
        Scanner sc=new Scanner(System.in);
        int[] wheel=new int[4];
        for(int i=0;i<4;i++)
        {
            wheel[i]=sc.nextInt();
        }
        int min=sc.nextInt();
        int n=sc.nextInt();
        int max=0;
        for(int i=0;i<4;i++)//找最大胎压
        {
            if(wheel[i]>max)
            {
                max=wheel[i];
            }
        }
        int m=-1;
        int num=0;
        for(int i=0;i<4;i++)
        {
            int dis=0;
            dis=Math.abs(wheel[i]-max);
            if(dis>n||wheel[i]<min)
            {
                num++;
                m=i;
            }
        }
        if(num==1)
        {
            System.out.println("Warning: please check #"+(m+1)+"!");
        }
        else if(num>1)
        {
            System.out.println("Warning: please check all the tires!");
        }
        else if(num==0)
        {
            System.out.println("Normal");
        }
    }
}

本题要求你实现一个程序，自动检查你朋友给你发来的信息里有没有 chi1 huo3 guo1。

输入格式：
输入每行给出一句不超过 80 个字符的、以回车结尾的朋友信息，信息为非空字符串，仅包括字母、数字、空格、可见的半角标点符号。当读到某一行只有一个英文句点 . 时，输入结束，此行不算在朋友信息里。

输出格式：
首先在一行中输出朋友信息的总条数。然后对朋友的每一行信息，检查其中是否包含 chi1 huo3 guo1，并且统计这样厉害的信息有多少条。在第二行中首先输出第一次出现 chi1 huo3 guo1 的信息是第几条（从 1 开始计数），然后输出这类信息的总条数，其间以一个空格分隔。题目保证输出的所有数字不超过 100。

如果朋友从头到尾都没提 chi1 huo3 guo1 这个关键词，则在第二行输出一个表情 -_-#。

输入样例 1：
Hello!
are you there?
wantta chi1 huo3 guo1?
that's so li hai le
our story begins from chi1 huo3 guo1 le
.
输出样例 1：
5
3 2
输入样例 2：
Hello!
are you there?
wantta qi huo3 guo1 chi1huo3guo1?
that's so li hai le
our story begins from ci1 huo4 guo2 le
.
输出样例 2：
5
-_-#

import java.util.Scanner;
public class Main{
    public static void main(String[] args)
    {
        Scanner sc=new Scanner(System.in);
        int i=0,sum=0,index=-1;
        for(i=0;;i++)
        {
            String sentence=sc.nextLine();
            if(sentence.indexOf("chi1 huo3 guo1")!=-1)
            {
                sum++;//出现次数
                if(index<0)//前面没出现过时就记录出现位置
                {
                    index=i+1;
                }
            }
            if(sentence.indexOf(".")!=-1)
                break;
        }
        System.out.println(i);
        if(sum!=0)
        {
            System.out.println(index+" "+sum);
        }
        else
        {
            System.out.println("-_-#");
        }
    }
}

网络世界中时常会遇到这类滑稽的算命小程序，实现原理很简单，随便设计几个问题，根据玩家对每个问题的回答选择一条判断树中的路径（如下图所示），结论就是路径终点对应的那个结点。

现在我们把结论从左到右顺序编号，编号从 1 开始。这里假设回答都是简单的“是”或“否”，又假设回答“是”对应向左的路径，回答“否”对应向右的路径。给定玩家的一系列回答，请你返回其得到的结论的编号。

输入格式：
输入第一行给出两个正整数：N（≤30）为玩家做一次测试要回答的问题数量；M（≤100）为玩家人数。

随后 M 行，每行顺次给出玩家的 N 个回答。这里用 y 代表“是”，用 n 代表“否”。

输出格式：
对每个玩家，在一行中输出其对应的结论的编号。

输入样例：
3 4
yny
nyy
nyn
yyn
输出样例：
3
5
6
2

import java.util.Scanner;
public class Main{
    public static void main(String[] args)
    {
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
        int m=sc.nextInt();
        int num=(int)Math.pow(2,n)-1;//总节点数
        for(int i=0;i<m;i++)
        {
            String ans=sc.next();
            int k=1;//开始的节点为1
            for(int j=0;j<n;j++)//节点加叶的数量
            {
                if(ans.charAt(j)=='y')
                {
                    k*=2;
                }
                else if(ans.charAt(j)=='n')
                {
                    k=2*k+1;
                }
            }
            System.out.println(k-num);//
        }
    }
}