算法期末实验考核

1.用蛮力法计算1000以内符合条件的数，要求该数本身是质数，除此之外，它的每一个数位也是一个质数，输出符合要求的所有结果。要求自定义数据结构，并写出完整程序。

//用蛮力法计算1000以内符合条件的数，要求该数本身是质数，除此之外，它的每一个数位也是一个质数，输出符合要求的所有结果。
// 要求自定义数据结构，并写出完整程序。
public class is_prime {
    public static void main(String[] args) {
        for (int i = 2; i <= 1000; i++) {
            //首先判断i是否是质数，如果不是质数，直接跳过。
            if (is_prime(i) == false) {
                continue;
            } else {//说明i是质数，判断i的每一个数位是否是质数，如果是，输出i。
                int help = i;
                while (help > 0) {
                    int temp = help % 10;//用temp来表示i的每一位
                    if (is_prime(temp) == false) {//如果i不能保证其每一位都是质数，直接跳过。
                        break;
                    } else {
                        help = help / 10;
                    }
                }
                if (help == 0) {//说明i的每一位都是质数，输出i。
                    System.out.print(i + " ");
                }
            }
        }
    }
    public static Boolean is_prime(int n){
        for (int i = 2; i <= Math.sqrt(n); i++) {
            if (n % i == 0) {
                return false;
            }
        }
        return true;
    }
}

 2.用蛮力法编写一个程序，计算并按递增顺序输出1000以内符合条件的自然数，要求该数的各个数位均不同，例如1、12，123符合要求，但是122，22不行。自定义数据结构，并写出完整程序。

//用蛮力法编写一个程序，计算并按递增顺序输出1000以内符合条件的自然数，要求该数的各个数位均不同。
//例如1、12，123符合要求，但是122，22不行。自定义数据结构，并写出完整程序。
public class is_unique {
    public static void main(String[] args) {
        for(int i = 1; i<=1000; i++){
            if(is_unique(i)){
                System.out.print(i+" ");
            }
        }
    }
    public static Boolean is_unique(int n){
        String str = String.valueOf(n);
        for(int i = 0; i<str.length(); i++){//遍历str
            for(int j = i+1; j<str.length(); j++){//判断str[i]是否与str[j]相同，如果相同，返回false，否则返回true。
                if(str.charAt(i) == str.charAt(j)){
                    return false;
                }
            }
        }
        return true;
    }
}

 

 3.最大长度问题：有m根长短不一的棍子原料，现在需要对其进行处理，最终获得至少n根长度相同的棍子，给定m和n及m根棍子各自的长度，求棍子的最大长度。 

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

public class length_sticks {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        int m=sc.nextInt();//棍子的个数
        int n=sc.nextInt();//需要的棍子数
        int[] sticks=new int[m];
        for(int i=0;i<m;i++){
            sticks[i]=sc.nextInt();
        }
        System.out.println(max_length(sticks,n));//输出最大长度，这个长度一定能组成n个棍子。
    }

    /**
     * 求棍子数组中，按照给定的长度，最多能组成多少个棍子。
     * @param sticks  棍子的长度数组，数组中的棍子长度都是正整数。
     * @param length  棍子的长度。
     * @return        返回最多能组成多少个棍子。
     */
    public static int max_sticks(int[] sticks,double length){//按照给定的长度最多能组成多少个棍子
        if(length==0){
            return 0;
        }
        int  count=0;
        for(int i=0;i<sticks.length;i++){
            count+=sticks[i]/length;
        }
        return count;
    }

    /**
     * 二分查找，找到最大长度，这个长度一定能组成n个棍子。
     * @param sticks  棍子的长度数组，数组中的棍子长度都是正整数。
     * @param n       需要的棍子数。
     * @return        返回最大长度，-1表示找不到条件的长度
     */
    public static double max_length(int[] sticks,int n){
        Arrays.sort(sticks);
        double low=1;
        double high=sticks[sticks.length-1];
        double result=-1;
        while(low<=high){
            double mid=(low+high)/2.0;
            if(max_sticks(sticks,mid)>=n){//满足题意，长度增加，需要的棍子数减少。
                result=mid;
                low=mid+1;//1->0.1,每一的次改变量越小误差越小，所求得的最大长度也越精准
            }else{
                high=mid-1;
            }
        }
        return result;
    }
}

4. 游船安排问题：有n位同学想在公园划船玩，现有无限数量的游船，每条船最多能载两人，但是两人的总重量不能超出船的最大负载。现给出轮船的最大负载和全班每个人的重量，求最少需要多少条船。

import java.util.Scanner;

public class hcwt {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
        int weight[]=new int[n];
        int  max_weight=sc.nextInt();//一条船的最大载重
        for(int i=0;i<n;i++){
            weight[i]=sc.nextInt();
        }
        int count=0;
        int left=0;
        int right=n-1;
        while(left<right){
            if(weight[left]+weight[right]<=max_weight){
                left++;
                right--;
                count++;
            }else{
                right--;
                count++;
            }
        }
        System.out.println("至少需要"+count+"条船");
    }
}