题库练习7（最小公倍数、求立方根、字符串逆序、记负均正、字符串分割）

1. 求最小公倍数

import java.util.*;

public class Main{
    public static void main(String[] args){
        Scanner sc=new Scanner(System.in);
        
        int a=sc.nextInt();
        int b=sc.nextInt();
        
        System.out.println(getMin(a,b));
    }
    
    public static int getMin(int a,int b){
        int max=a>b?a:b;
        int min=max==a?b:a;
        
        while(max%min!=0){
            int temp=max%min;
            max=min;
            min=temp;
        }
        return a*b/min;
    }
}

2. 求立方根

计算一个数字的立方根，不使用库函数

详细描述：

• 接口说明
  • 原型：
  • public static double getCubeRoot(double input)
  • 输入:double 待求解参数
  • 返回值:double  输入参数的立方根，保留一位小数

2.1 分析

Java中求立方根需要了解牛顿迭代法。

牛顿迭代法。设, 求f(x)=0时的解x，即为y的立方根。

根据牛顿迭代思想，即。

import java.util.*;
import java.text.DecimalFormat;

public class Main{
    public static void main(String[] args){
        Scanner sc=new Scanner(System.in);
        
        double d=sc.nextDouble();
        DecimalFormat df = new DecimalFormat(".0");
        System.out.println(df.format(getCubeRoot(d)));
    }
    
   public static double getCubeRoot(double input){
        double a=input;
        double b=(2*a+input/a/a)/3;
        while(Math.abs(b-a)>0.000001){
            a=b;
            b=(2*a+input/a/a)/3;
        }
        return b;
    }
}

注：

1. 输出格式的设置（保留两位小数）

public class Test {
    public static void main(String[] args) {
        double d = 756.2345566;

        //方法一：最简便的方法，调用DecimalFormat类
        DecimalFormat df = new DecimalFormat(".00");
        System.out.println(df.format(d));

        //方法二：直接通过String类的format函数实现
        System.out.println(String.format("%.2f", d));

        //方法三：通过BigDecimal类实现
        BigDecimal bg = new BigDecimal(d);
        double d3 = bg.setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();
        System.out.println(d3);

        //方法四：通过NumberFormat类实现
        NumberFormat nf = NumberFormat.getNumberInstance();
        nf.setMaximumFractionDigits(2);
        System.out.println(nf.format(d));

    }
}

3. 字符串逆序

将一个字符串str的内容颠倒过来，并输出。str的长度不超过100个字符。 如：输入“I am a student”，输出“tneduts a ma I”。

import java.util.*;

public class Main{
    public static void main(String[] args){
        Scanner sc=new Scanner(System.in);
        
        String str=sc.nextLine();
        
        System.out.println(reverse(str));
    }
    
    public static String reverse(String str){
        Stack<Character> stack=new Stack<>();
        
        char[] chs=str.toCharArray();
        for(int i=0;i<chs.length;i++)
            stack.push(chs[i]);
        String result="";
        while(!stack.isEmpty())
            result+=stack.pop();
        return result;
    }
}

4. 记负均正

从输入任意个整型数，统计其中的负数个数并求所有非负数的平均值

import java.util.*;
import java.text.DecimalFormat;

public class Main{
    public static void main(String[] args){
        Scanner sc=new Scanner(System.in);
        ArrayList<Integer> list=new ArrayList<>();
        while(sc.hasNext()){
            list.add(sc.nextInt());
        }
        
        getResult(list);
    }
    
    public static void getResult(ArrayList<Integer> list){
        if(list==null){
            System.out.println(0);
            System.out.println(0);
            return;
        }
        int count=0;
        double sum=0.0;
        for(int i=0;i<list.size();i++){
            if(list.get(i)<0)
                count++;
            else
                sum+=list.get(i);
        }
        System.out.println(count);
        if(count==list.size())
            System.out.println(0.0);
        else{
            sum/=(list.size()-count);
            DecimalFormat df = new DecimalFormat(".0");
            System.out.println(df.format(sum));
        }

        return;
    }
}

5. 字符串分割

连续输入字符串(输出次数为N,字符串长度小于100)，请按长度为8拆分每个字符串后输出到新的字符串数组，

长度不是8整数倍的字符串请在后面补数字0，空字符串不处理。

输入描述：首先输入数字n，表示要输入多少个字符串。连续输入字符串(输出次数为N,字符串长度小于100)

输出描述：按长度为8拆分每个字符串后输出到新的字符串数组，长度不是8整数倍的字符串请在后面补数字0，空字符串不处理。

import java.util.Scanner;
import java.util.ArrayList;

public class Main{
    public static void main(String[] args){
        Scanner sc=new Scanner(System.in);
        while(sc.hasNext()){
            int n=sc.nextInt();
            sc.nextLine();
            ArrayList<String> list=new ArrayList<>();
            int i=0;
            while(i<n){
                list.add(sc.nextLine());
                i++;
            }
            list=getResult(list);
            for(int j=0;j<list.size();j++)
                System.out.println(list.get(j));
        }
    }
    
    public static ArrayList<String> getResult(ArrayList<String> list){
        if(list==null)
            return null;
        ArrayList<String> res=new ArrayList<>();
        
        for(int i=0;i<list.size();i++){
            String str=list.get(i);
            while(str.length()>=8){
                res.add(str.substring(0,8));
                str=str.substring(8);
            }
            if(str.length()<8&&str.length()>0){
                str+="00000000";
                res.add(str.substring(0,8));
            }
        }
        return res;
    }
}