作业1003

package org.westos_Homework01;
/*1.考试成绩已经保存在数组scores中，依次为 89,23,64,91,119,52,73,-23

要求根据通过自定义方法来找出其中前三名，将数组成绩作为参数传入
要求判断成绩的有效性(0-100),如果成绩无效，则忽略此成绩.
*/
public class Homework01 {
    //主函数
    public static void main(String[] args) {
        int [] scores = new int [] {89,23,64,91,119,52,73,-23};
        findScores(scores);

    }
    //寻找成绩的函数
    public static void findScores(int [] scores) {
        int temp=0;
        //给成绩按从大到小排序
        for(int i=0; i<scores.length; i++) {
            for(int j=i; j<scores.length-1; j++){
                if(scores[i]<scores[j+1]) {
                    temp = scores[i];
                    scores[i] = scores[j+1];
                    scores[j+1]=temp;
                }
            }
        }
        //前三名就是 下标位 0 1 2的 数
        int First = scores[0];
        int Second = scores[1];
        int Third = scores[2];
        //输出
        if(First<=100 && First>=0) {
            System.out.println("第一名的分数是"+First);
        }else {
            System.out.println("第一名的分数不符合要求");
        }
        if(Second<=100 && Second>=0) {
            System.out.println("第二名的分数是"+Second);
        }else {
            System.out.println("第二名的分数不符合要求");
        }
        if(Third<=100 && Third>=0) {
            System.out.println("第三名的分数是"+Third);
        }else {
            System.out.println("第三名的分数不符合要求");
        }
    }
}

package org.westos_Homework02;
/*2. 用数组来实现， 定义并初始化一个（1--100）保存100个数的数组，从第一个元素开始，依次数(1,2,3 循环往复),
 * 每次数到到3的元素淘汰掉.当到达数组
    末尾的时候再从头开始，直到最后剩余一个元素，
    写出算法，并输出最后保留的元素所在的最初的位置.*/
public class Homework02 {
    static final int ALL_NUMBERS = 100; // 定义数组的总数
    static final int ERE_NUMBERS= 3;   // 循环到几
    public static void main(String[] args) {
        myAri(1);
    }
    public static void myAri(int site) {    //该题的算法
        int cir = -1;   //总循环
        int count = -1;   // 被淘汰的数的次序
        int [] arr = new int [ALL_NUMBERS];  // 定义并初始化一个（1--100）保存100个数的数组
        for(int i=0; i<arr.length; i++) {
            arr[i]=i+1;
        }
        int j =0;
        while(-count<=ALL_NUMBERS) {       
            do {
                cir = (cir+1) % ALL_NUMBERS; 
                if(arr[cir]>=0) {     //开始数数
                    j++;
                }if(j==3){  //数到3重置
                    j=0;
                    break; //跳出循环
                }
            }while(true);
            arr[cir]=count;  //给被选中的数组的值赋值   第一个被选出来的赋值-1 第二是 -2 依次循环 最后一个出来的是-100
            count--;
        }
        site=-count-site;   // 从第一个数开始数 所以减去 site
        for(int i=0; i<arr.length; i++) {
            if(-site==arr[i]) {
                System.out.println("最后保留的元素的最初位置是"+(i+1)); // 找出-100所对应的数组的下标
                break;
            }
        }
    }
} 

package org.westos_Homewor03;
//用数组来实现对于一个整形数组， 分别通过冒泡排序和 快速排序，实现对于任意一个数组进行由小到大的排列。
public class Homework03{
    public static void main(String[] args) {
        int [] arr = new int[] {49,8,26,44,69,54,88,76,34};

        bubSort(arr);   //冒泡排序
        quickSort(arr); //快速排序
    }
    public static void bubSort(int [] arr){           //冒泡排序
        for(int i=0; i<arr.length; i++){                
            int flag=0;                               //定义一个标记
            for(int j=arr.length-1; j>i; j--) {       //从末尾开始数 
                if(arr[j]<arr[j-1]) {                 //如果后面的数小于前面的数就调换位置 
                    int temp=arr[j];          
                    arr[j]=arr[j-1];
                    arr[j-1]=temp; 
                    flag=1;                           //调换成功之后让标记flag=1
                }
            }
            if(flag==0) {                             //当内存循环完毕之后   =>  j<=i之后跳出循环
                break;
            }
        }
        System.out.println("冒泡排序:");                //输出排序的结果
        for(int i=0; i<arr.length; i++){
            System.out.print(arr[i]+" ");
        }
    }
    public static int partSort(int [] arr,int low, int high) {   //快速排序
        int key=arr[low];                                        //定义一个基数  该基数为数组的第一个数 
        while(high>low) {                                        //当low<high时执行循环
            while(arr[high]>=key && high>low) {                  //如果high大于等于基数     让high--
                high--;
            }
            int temp=arr[low];                                   //直到high<基数   调换low和high中元素的位置                      
            arr[low]=arr[high];
            arr[high]=temp;
            while(arr[low]<=key && high>low) {                   //如果low小于等于基数       low++           
                low++;
            }
            int temp2=arr[low];                                  //直到low>基数时  调换low和high的位置
            arr[low]=arr[high];
            arr[high]=temp2;
        }
        arr[high]=key;                                           //把基数的值赋值给high    返回一个high
        return high;
    }
    public static int[] sort(int [] arr,int low,int high) {      
          if(low>=high){
                return arr;
            }
            int index=partSort(arr,low,high);                    //定义一个下标赋值为high
            sort(arr,low,index-1);                               // 运用递归的方法把前后分成的小数组继续按照上面的方法排序
            sort(arr,index+1,high);                              //直到high与low重合   然后返回数组的首地址
            return arr;
    }
    public static void quickSort(int [] arr) {                   //写一个打印这个数组的函数
        int low=0;
        int high= arr.length-1;
        int [] arr1=sort(arr,low,high);
        System.out.println();
        System.out.println("快速排序:");
        for(int i=0; i<arr1.length; i++){
            System.out.print(arr1[i]+" ");
        }
    }
}

package org.westos_Homework04;
//判断101-200之间有多少个素数，并输出所有素数。
public class Homework04 {
    public static void main(String[] args) {
            //判断是否是质数的函数
            ifPrime();
    }     //判断是否是质数的函数
    public static void ifPrime() {
        //定义一个100个数的数组  初始化他们的变量为 101-200
            int [] arr= new int[100];
            int temp=0;
            int index=0;
            for(int i=0; i<arr.length; i++){
                arr[i]= 101+i;
            }
            //寻找出非质数的数  
            for(int i=0; i<arr.length; i++){
                for(int j=2; j<arr[i]; j++) {
                    temp=arr[i]%j;
                    if(temp==0 && arr[i]!=0 ) {
                        // 让非质数的数的值为0
                        arr[i]=0;
                        break;
                    }
                }
            }
            //找出这个数组中非0的数 这些数为质数 
            for(int i=0; i<arr.length; i++) {
                if(arr[i]!=0) {
                    index++;
                    System.out.print(arr[i]+" ");
                }
            }
            // 一共有多少个质数
            System.out.println();
            System.out.println("101-200之间的素数有"+index+"个");
    }   
}

package org.westos_Homework05;
import  java.util.Scanner;  
//输入一行字符，分别统计出其中英文字母、空格、数字和其它字符的个数。
public class Homework05 {
    public static void main(String[] args) {
        stri();      
    }  
    public static void stri() {
        int num=0,chartra=0,blak=0,other=0;  
        Scanner  s=new Scanner(System.in);  
        System.out.println("请输入字符串");
        //定义一个字符串类型的reslut  从键盘录入字符串
        String  result=s.nextLine();  
        //定义一个字符串数组来储存 键盘录入的串
        char x[]=result.toCharArray(); 
        //遍历数组
        for(int i=0;i<x.length;i++){  
           if(Character.isDigit(x[i])){  
               num++;  
           }else if(Character.isLetter(x[i])){  
               chartra++;  
           }else if(Character.isSpace(x[i])){  
               blak++;  
           }  
           else{  
               other++;  
           }  
        }  
        //输出结果
        System.out.println("数字的个数是"+num);  
        System.out.println("字符的个数是"+chartra);  
        System.out.println("空值的个数是"+blak);  
        System.out.println("其他的个数是"+other); 
    }
}  

package org.westos_Homework06;
/*6.题目：企业发放的奖金根据利润提成。利润(I)低于或等于10万元时，奖金可提10%；利润高于10万元，低于20万元时，低于10万元的部分按10%提成，
高于10万元的部分，可可提成7.5%；20万到40万之间时，高于20万元的部分，可提成5%；40万到60万之间时高于40万元的部分，可提成3%；60万到100万之间时，
高于60万元的部分，可提成1.5%，高于100万元时，超过100万元的部分按1%提成，从键盘输入当月利润，求应发放奖金总数？
*/
import java.util.Scanner;
public class Homework06 {
    public static void main(String[] args) {
        calculateBonus();
    }
    //这感觉没啥要注释的....
    public static void calculateBonus() {
        Scanner sr = new Scanner(System.in);
        System.err.println("请输入当月的利润");
        int profit = sr.nextInt();
        double bonus=0;
        if(profit<=100000) {
            bonus=profit*0.1;
        }else if(profit>100000 && profit<=200000) {
            bonus=(profit-100000)*0.075+100000*0.1;
        }else if(profit>200000 && profit<=400000) {
            bonus=(profit-200000)*0.05+100000*0.075+100000*0.1;
        }else if(profit>400000 && profit<=600000) {
            bonus=(profit-400000)*0.03+200000*0.05+100000*0.075+100000*0.1;
        }else if(profit>600000 && profit<=1000000) {
            bonus=(profit-600000)*0.015+200000*0.03+200000*0.05+100000*0.075+100000*0.1;
        }else if(profit>1000000) {
            bonus=(profit-1000000)*0.01+400000*0.015+200000*0.03+200000*0.05+100000*0.075+100000*0.1;
        }//限制一下用户输入
            else if(profit<=0) {
                System.out.println("亏成一个大xx啊");
            }
        System.err.println("应当发放的奖金总数为"+bonus);
    }
}

package org.westos_Homework07;
/*
 * 分别定义用户类，订单类，产品类，其中订单类至少要具有下订单的行为(入参为一个产品名称)，
产品类中至少有一个成员变量为产品名称，至少有一个方法用来获取产品的名称。
用户类中持有一个产品类型的成员变量。
用户类中持有一个订单类型的成员变量。

在我们的用户类中定义main函数，当执行的时候，构造一个用户类的对象，
并且通过手段可以拿到产品成员变量中的产品名称，并且调用成员变量订单的对象，进行下单。
最后输出下单成功。
*/
//导包
import java.util.Scanner;
public class User extends Product{
    //定义一个产品类型和订单类型
     int productType=0;
     int orderType=0;
     Scanner sr = new Scanner(System.in);
    public static void main(String[] args) {
        //定义一个用于循环的 i
        int i =-1;
        // 构造一个用户类
        User uu = new User();
        while(i==-1) {
            //输入产品类型
            uu.getProductType();
            uu.productType= uu.sr.nextInt();
            //判断产品为什么类型
            if(uu.productType==1) {
                System.out.println("您确定购买"+uu.getFruitName()+"吗");
            }else if(uu.productType==2) {
                System.out.println("您确定购买"+uu.getSnacksName()+"吗");
            }
            //判断是否继续购买
            System.out.println("输入1确认购买,输入其他数字返回主菜单");
            int affirm = uu.sr.nextInt();
            if(affirm==1) {
                uu.getorderType();
                uu.orderType=uu.sr.nextInt();
                System.out.println(uu.orders(uu.orderType));
                //如果继续购买就让i=0; 结束次循环  并且输出订单成功
                i=0;
            }
        }   
    }
}
class Order{
    // 订单类
    //判断是否订单成功的函数
    public String orders(int ifSucc) {
        String condition = "没有下单";
        if(ifSucc==1 || ifSucc==2) {
            condition="下单成功";
            //return condition;
        }else{
            condition="下单失败";
        }return condition;
    }
}
//产品类
class Product extends Order{
     Scanner sr = new Scanner(System.in);
     //产品封装
     private String pr01="苹果";
     private String pr02="香蕉";
     private String pr03="橘子";
     private String pr04="饼干";
     private String pr05="可乐";
     private String pr06="薯片";
     //得到产品类型的函数
    public void getProductType() {
        System.out.println("输入您想购买的类型");
        System.out.println("1:水果类");
        System.out.println("2:零食类");
    }
    //得到支付类型的函数
    public void getorderType() {
        System.out.println("请输入支付方式");
        System.out.println("1:自己支付");
        System.out.println("2:朋友支付");
    }
    //得到商品名字
    public String getFruitName() {
        String name;
        System.out.println("-------------------");
        System.out.println("请选择你要购买的商品");
        System.out.println("1:"+pr01);
        System.out.println("2:"+pr02);
        System.out.println("3:"+pr03);
        int result = sr.nextInt();
        switch(result) {
            case 1:
                name =pr01;
                break;
            case 2:
                name =pr02;
                break;
            case 3:
                name =pr03;
                break;
            default :
                name="没有此商品";
                break;
        }
        return name;
}
    public String getSnacksName() {
        String name;
        System.out.println("-------------------");
        System.out.println("请选择你要购买的商品");
        System.out.println("1:"+pr04);
        System.out.println("2:"+pr05);
        System.out.println("3:"+pr06);
        int result = sr.nextInt();
        switch(result) {
            case 1:
                name =pr04;
                break;
            case 2:
                name =pr05;
                break;
            case 3:
                name =pr06;
                break;
            default :
                name="没有此商品";
                break;
        }
        return name;
    }
}