HNU面向对象与程序设计 Java程序设计基础

1.DNA序列

【问题描述】 

一个DNA序列由A/C/G/T四个字母的排列组合组成。G和C的比例（定义为GC-Ratio）是序列中G和C两个字母的总的出现次数除以总的字母数目（也就是序列长度）。在基因工程中，这个比例非常重要。因为高的GC-Ratio可能是基因的起始点。

给定一个很长的DNA序列，以及要求的最小子序列长度，研究人员经常会需要在其中找出GC-Ratio最高的子序列。

【输入形式】输入一个string型基因序列，和int型子串的长度

【输出形式】找出GC比例最高的子串,如果有多个输出第一个的子串

【样例输入】AACTGTGCACGACCTGA 5

【样例输出】GCACG

import java.util.Scanner;
//DNA序列
// 一个DNA序列由A/C/G/T四个字母的排列组合组成。G和C的比例（定义为GC-Ratio）
// 是序列中G和C两个字母的总的出现次数除以总的字母数目（也就是序列长度）。
// 在基因工程中，这个比例非常重要。因为高的GC-Ratio可能是基因的起始点。
//给定一个很长的DNA序列，以及要求的最小子序列长度，研究人员经常会需要在其中找出GC-Ratio最高的子序列。
public class DNA {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        String s=sc.next();  //输入基因序列
        int n=sc.nextInt();  //输入长度
        int left=0;
        int res=0;  //结果计数
        int ind=0;  //记录开始的下标
        for(int right=n-1;rightres){
                ind=left; //下标更新
                res=tem;
            }
            left+=1; //窗口移动
        }
        System.out.println(s.substring(ind,ind+n)); //substring截取字符串
    }
}

2.求近似数 

【问题描述】

写出一个程序，接受一个正浮点数值，输出该数值的近似整数值。如果小数点后数值大于等于5,向上取整；小于5，则向下取整。

【输入形式】

输入一个正浮点数值

【输出形式】

输出该数值的近似整数值

【样例输入】

5.5

【样例输出】

6

import java.util.Scanner;

//求近似数
//写出一个程序，接受一个正浮点数值，
// 输出该数值的近似整数值。如果小数点后数值大于等于5,向上取整；小于5，则向下取整。
public class approximate {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        double n=sc.nextDouble(); //输入浮点数
        double tem=n-(int) n; //拿到小数部分 //强制类型转换,获取整数部分
        if(tem>=0.5){
            System.out.println((int) n +1); //判断范围
        }else{
            System.out.println((int) n);
        }
    }
}

3.密码检查

【问题描述】

开发一个密码检查软件，密码要求:

1. 长度超过8位

2. 包括大小写字母.数字.其它符号,以上四种至少三种

3. 不能有相同长度大于或等于2的子串重复

【输入形式】

一组或多组长度超过2的子符串。每组占一行

【输出形式】

如果符合要求输出：OK，否则输出NG

【样例输入】

021Abc9000

021Abc9Abc1

021ABC9000

021$bc9000

【样例输出】

OK

NG

NG

OK

import java.util.Scanner;
//密码检查
//开发一个密码检查软件，密码要求:
//
//长度超过8位
//
//包括大小写字母.数字.其它符号,以上四种至少三种
//
//不能有相同长度大于或等于2的子串重复
public class checkPassword {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        while(sc.hasNext()){
            String s=sc.next();
            boolean flag=false; //标记是否有子串重复
            if(s.length()<=8){ //长度判断
                System.out.println("NG");
                continue;
            }
            int[] arr={0,0,0,0};
            for(int i=0;i='a' && s.charAt(i)<='z'){
                    arr[0]=1; //小写字母
                }else if(s.charAt(i)>='A' && s.charAt(i)<='Z'){
                    arr[1]=1; //大写字母
                }else if(s.charAt(i)>='0' && s.charAt(i)<='9'){
                    arr[2]=1; //数字
                }else{
                    arr[3]=1; //其他符号
                }
                if(i=0){
                        flag=true; //含有重复子串
                        break;
                    }
                }
            }
            if((arr[0]+arr[1]+arr[2]+arr[3])<3){ //判断种类数目是否不超过三种
                System.out.println("NG");
                continue;
            }
            if(flag){
                System.out.println("NG");
                continue;
            }
            System.out.println("OK");
        }
    }
}

4.选美比赛

【问题描述】

在选美大奖赛的半决赛现场，有n名选手(2

选手数量： 7 选手得分： 5，3，4，7，3，5，6宣布名次： 3，5，4，1，5，3，2 请编程帮助大奖赛组委会完成半决赛的评分排名工作。

【输入形式】选手数量：7 选手得分：5;3;4;7;3;5;6

【输出形式】选手的排名：3 5 4 1 5 3 2

【样例输入】7 5 3 4 7 3 5 6

【样例输出】3 5 4 1 5 3 2 

import java.util.*;

//选美比赛
//在选美大奖赛的半决赛现场，有n名选手(2 

// 选手数量： 7 选手得分： 5，3，4，7，3，5，6宣布名次： 3，5，4，1，5，3，2
// 请编程帮助大奖赛组委会完成半决赛的评分排名工作。
public class chooseGame {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
        int[] arr=new int[n];
        int[] copy=new int[n]; //去重数组
        for(int i=0;i

5.情报加密

【问题描述】

在情报传递过程中，为了防止情报被截获，往往需要对情报用一定的方式加密，简单的加密算法虽然不足以完全避免情报被破译，但仍然能防止情报被轻易的识别。我们给出一种最简的的加密方法，对给定的一个字符串，把其中从a-y,A-Y的字母用其后继字母替代，把z和Z用a和A替代，则可得到一个简单的加密字符串。

【输入形式】

可能有多组测试数据。每组测试数据的第一行是字符串的数目n，其余n行每行一个字符串,每个字符串长度小于80个字符。

【输出形式】

对于每组数据，输出每行字符串的加密字符串。

【样例输入】

1

Hello! How are you!

【样例输出】

Ifmmp! Ipx bsf zpv!

import java.util.Scanner;
//情报加密
//在情报传递过程中，为了防止情报被截获，往往需要对情报用一定的方式加密，
// 简单的加密算法虽然不足以完全避免情报被破译，但仍然能防止情报被轻易的识别。
// 我们给出一种最简的的加密方法，对给定的一个字符串，把其中从a-y,
// A-Y的字母用其后继字母替代，把z和Z用a和A替代，则可得到一个简单的加密字符串。
public class encryption {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
        sc.nextLine(); //换行接收
        //nextLine()的使用
        //(1)读取Enter键出现之前的所有字符，包括带空格的字符。
        //(2)只能以Enter键作为结束符。
        for(int i=0;i='a' && arr[j]<='z')||(arr[j]>='A' && arr[j]<='Z')){
                    arr[j]+=1; //确保是字母，然后后移 //字符与数字相加，会先将字符转换成ASCII然后相加
                }
            }
            System.out.println(arr);
        }
    }
}

6.骰子问题旋转

【问题描述】 

骰子是个立方体每个面一个数字，初始为左1，右2，前3（观察者方向），后4，上5，下6，用123456表示这个状态。放置在平面上，用L表示向左翻转一次，用R表示向右翻转一次，用F表示向前翻转一次，用B表示向后翻转一次，用A表示逆时针旋转90度，用C表示顺时针旋转90度，现从初始状态开始，根据输入的动作序列，计算得到最终的状态。

【输入形式】输入只包含LRFBAC的字母序列，最大长度为50，可重复

【输出形式】输出经过一系列操作后的序列  注：按左右前后上下顺序输出

【样例输入】LB

【样例输出】5 6 1 2 3 4

import java.util.Scanner;

//骰子问题旋转
//骰子是个立方体每个面一个数字，初始为左1，右2，前3（观察者方向），后4，上5，下6，
//用123456表示这个状态。放置在平面上，用L表示向左翻转一次，用R表示向右翻转一次，
//用F表示向前翻转一次，用B表示向后翻转一次，用A表示逆时针旋转90度，
//用C表示顺时针旋转90度，现从初始状态开始，根据输入的动作序列，计算得到最终的状态。
public class diceProblem {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        char[] arr = sc.nextLine().toCharArray(); //字符数组
        int[] now = {1, 2, 3, 4, 5, 6};  // 当前状态数组
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == 'C') {
                int t1=now[0];  //列出所有情况
                now[0]=now[2];
                now[2]=now[1];
                now[1]=now[3];
                now[3]=t1;
            }else if(arr[i]=='A'){
                int t1=now[0];
                now[0]=now[3];
                now[3]=now[1];
                now[1]=now[2];
                now[2]=t1;
            }else if(arr[i]=='F'){
                int t1=now[2];
                now[2]=now[4];
                now[4]=now[3];
                now[3]=now[5];
                now[5]=t1;
            }else if(arr[i]=='B'){
                int t1=now[2];
                now[2]=now[5];
                now[5]=now[3];
                now[3]=now[4];
                now[4]=t1;
            }else if(arr[i]=='L'){
                int t1=now[4];
                now[4]=now[1];
                now[1]=now[5];
                now[5]=now[0];
                now[0]=t1;
            }else if(arr[i]=='R'){
                int t1=now[4];
                now[4]=now[0];
                now[0]=now[5];
                now[5]=now[1];
                now[1]=t1;
            }
        }
        for(int i=0;i<6;i++){
            System.out.print(now[i]+" "); //输出状态
        }
    }
}

7.供应商问题

【问题描述】

有n个某种商品供应商，某地有m个商店，商店需要从供应商那里进货该商品，每个供应商的供应能力有上限，每个商店都有自己的商品需求量（need[i]:表示第i个商店的需求），每个供应商运送单位商品到商店需要一个运费。

【输入形式】

输入说明：第一行包含两个整数N，M

接下来N行包含三个整数，第一个数表示供应商编号，第二数表示供应能力上限，表示该供应商的供应量不能超过这个上限，第三个数表示运送单位商品到商店的运费。

接下来M行包含两个整数，第一个数表示商店编号，第二个数表示某种商品的需求量。

【输出形式】

输出说明：若可以满足所有商店需求，则输出格式如下：每行第一个数表示供应商编号，第二个数为商店编号，第三个数为供应量。

如：1 2 20

表示第1个供应商给第2个商店供应20个单位量的商品

按商店编号顺序，输出所有供应路径（最后一行无换行符）。

若不满足，输出-1

【样例输入】

4 4

0 20 8

1 15 3

2 55 6

3 40 10

0 28

1 36

2 49

3 12

【样例输出】

1 0 15

2 0 13

2 1 36

2 2 6

0 2 20

3 2 23

3 3 12

import java.util.Scanner;

//供应商问题
//有n个某种商品供应商，某地有m个商店，商店需要从供应商那里进货该商品，
// 每个供应商的供应能力有上限，每个商店都有自己的商品需求量
// （need[i]:表示第i个商店的需求），每个供应商运送单位商品到商店需要一个运费。
public class supplyProblem {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
        int m=sc.nextInt();
        int[][] supply=new int[n][3]; //记录供应方
        int[][] need=new int[m][2];//记录商家
        int s1=0;
        int s2=0;
        for(int i=0;i supply[j][2]) {
                    int[] temp = supply[i];
                    supply[i] = supply[j];
                    supply[j] = temp;
                }
            }//利用冒泡排序进行运费的排序
        }
        for(int i=0;i=need[i][1]){
                    System.out.println(""+supply[j][0]+" "+i+" "+need[i][1]);
                    supply[j][1]-=need[i][1]; //供应方多了，直接满足
                    need[i][1]=0;//需求量清零
                }else if(supply[j][1]>0){
                    System.out.println(""+supply[j][0]+" "+i+" "+supply[j][1]);
                    need[i][1]-=supply[j][1];//要继续寻找供应方
                    supply[j][1]=0;//供应方提供量清零

                }
            }
        }
    }
}

8.反转字符串 

【问题描述】

写出一个程序，接受一个字符串，然后输出该字符串反转后的字符串。

【输入形式】输入N个字符
【输出形式】输出该字符串反转后的字符串

【样例输入】

 abcd
【样例输出】

  dcba 

import java.util.Scanner;

//反转字符串
//写出一个程序，接受一个字符串，然后输出该字符串反转后的字符串。
public class strReverse {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        char[] s=sc.next().toCharArray();//字符数组 ，将左右两边进行交换从而达到反转字符串目的
        int left=0; //左指针
        for(int right=s.length-1;right>left;right--){
            char temp=s[right]; //左右交换
            s[right]=s[left];
            s[left]=temp;
            left+=1; //左指针移动
        }
        System.out.println(s);
    }
}

9. 找朋友

【问题描述】

两个人是朋友通常意味着他们存在着许多共同的兴趣。然而作为一个宅男，你发现自己与他人相互了解的机会并不太多。幸运的是，你意外得到了一份湖大图书馆的图书借阅记录，于是你挑灯熬夜地编程，想从中发现潜在的朋友。

首先你对借阅记录进行了一番整理，把N个读者依次编号为1,2,…,N，把M本书依次编号为1,2,…,M。同时，按照“臭味相投”的原则，和你喜欢读同一本书的人，就是你的潜在朋友。你现在的任务是从这份借阅记录中计算出每个人有几个潜在朋友。

【输入形式】

每个案例第一行两个整数N,M。接下来有N行，第i(i = 1,2,…,N)行每一行有一个数，表示读者i-1最喜欢的图书的编号P(1<=P<=M)

【输出形式】

每个案例包括N行，每行一个数，第i行的数表示读者i有几个潜在朋友。如果i和任何人都没有共同喜欢的书，则输出“BeiJu”（即悲剧，^ ^）

【样例输入】

4  5

2

3

2

1

【样例输出】

1

BeiJu

1

BeiJu

import java.util.Scanner;

//找朋友
//两个人是朋友通常意味着他们存在着许多共同的兴趣。然而作为一个宅男，
// 你发现自己与他人相互了解的机会并不太多。幸运的是，
// 你意外得到了一份湖大图书馆的图书借阅记录，于是你挑灯熬夜地编程，想从中发现潜在的朋友。
//
//首先你对借阅记录进行了一番整理，把N个读者依次编号为1,2,…,N，
// 把M本书依次编号为1,2,…,M。同时，按照“臭味相投”的原则，
// 和你喜欢读同一本书的人，就是你的潜在朋友。
// 你现在的任务是从这份借阅记录中计算出每个人有几个潜在朋友。
public class findFriend {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
        int m=sc.nextInt();
        int[] read=new int[n];
        for(int i=0;i0){  //排除自身，所以-1
                System.out.println(res-1);
            }else{
                System.out.println("BeiJu");
            }

        }
    }
}

10. 进制转化

【问题描述】

写出一个程序，接受一个十六进制的数值字符串，输出该数值的十进制字符串。(多组同时输入)

【输入形式】输入一个十六进制的数值字符串。

【输出形式】输出该数值的十进制字符串。

【样例输入】0xA

【样例输出】10

import java.util.Scanner;

//进制转换
//写出一个程序，接受一个十六进制的数值字符串，输出该数值的十进制字符串。(多组同时输入
public class hexadecimalConversion {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        char[] arr=sc.next().toCharArray();//字符数组
        int res=0;

        for(int i=2;i='0' && arr[i]<='9'){ //一种情况<10，那么直接进行加和
                res*=16;
                res=res+(arr[i]-'0');
            }else{
                res*=16;  //是字母的情况
                res=res+((arr[i]-'A')+10); //拿到对应的十进制数
            }
        }
        System.out.println(res);
    }
}

11. ip地址判定

【问题描述】

现在IPV4下用一个32位无符号整数来表示，一般用点分方式来显示，点将IP地址分成4个部分，每个部分为8位，表示成一个无符号整数（因此不需要用正号出现），如10.137.17.1，是我们非常熟悉的IP地址，一个地址串中没有空格出现（因为要表示成一个32数字）。>现在需要你用程序来判断IP是否合法。

【输入形式】输入一个ip地址

【输出形式】返回判断的结果YES or NO

【样例输入】

  10.138.15.1

【样例输出】

YES

import java.util.Scanner;

// ip地址判定
//现在IPV4下用一个32位无符号整数来表示，一般用点分方式来显示，
// 点将IP地址分成4个部分，每个部分为8位，表示成一个无符号整数
// （因此不需要用正号出现），如10.137.17.1，是我们非常熟悉的IP地址，
// 一个地址串中没有空格出现（因为要表示成一个32数字）。>
// 现在需要你用程序来判断IP是否合法。
public class checkIP {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        String s=sc.next();
        String[] arr=s.split("\\."); //拆分字符串,注意进行转义
        if(arr.length!=4){
            System.out.println("NO");
            return;   //无法分成四个部分，直接返回no
        }
        for(int i=0;i<4;i++){
            int tem=Integer.parseInt(arr[i]); //拿到对应的数字
            if(tem>255){
                System.out.println("NO");//四位数字，最大就是1111即255
                return;
            }
        }
        System.out.println("YES"); //验证完毕，符合题意


    }
}

  12. 计算日期

【问题描述】

给出年分m和一年中的第n天，算出第n天是几月几号。

【输入形式】

输入包括两个整数y，n

【输出形式】

可能有多组测试数据，对于每组数据，按yyyy-mm-dd的格式将输入中对应的日期打印出来。

【样例输入】

2000 3

2000 31

2000 40

2000 60

【样例输出】

2000-01-03

2000-01-31

2000-02-09

2000-02-29

import java.util.Scanner;

//计算日期
//给出年分m和一年中的第n天，算出第n天是几月几号。
public class calculateDate {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while (sc.hasNext()) {
            int year = sc.nextInt();
            int day = sc.nextInt();
            int month = 1; //初始化月份
            int leap = 0; //闰年标记
            int temp = 31; //初始化天数
            if ((year % 4 == 0 && year % 400 != 0) || (year % 100 == 0)) {
                leap = 1;  //判断是否是闰年
            }
            while ((day - temp) > 0) {
                month += 1;  //满足一个月的天数，月份+1
                day -= temp;
                if (month == 1 || month == 3 || month == 5 || month == 7 || month == 8 || month == 10 || month == 12) {
                    temp = 31; //记录当前月份的天数
                } else if (month == 2) {
                    temp = 28 + leap;
                } else {
                    temp = 30;
                }

            }
            if (month < 10) {
                if (day < 10) {
                    System.out.println(year + "-0" + month + "-0" + day);//注意格式输出的分类讨论
                } else {
                    System.out.println(year + "-0" + month + "-"+day);
                }
            } else {
                System.out.println(year + "-" + month + "-" + day);
            }


        }
    }
}

13. 去重与排序

【问题描述】

明明想在学校中请一些同学一起做一项问卷调查，为了实验的客观性，他先用计算机生成了N个1到1000之间的随机整数（N≤1000），对于其中重复的数字，只保留一个，把其余相同的数去掉，不同的数对应着不同的学生的学号。然后再把这些数从小到大排序，按照排好的顺序去找同学做调查。请你协助明明完成“去重”与“排序”的工作。Input Param n 输入随机数的个数 inputArray n 个随机整数组成的数组 Return Value OutputArray 输出处理后的随机整数

【输入形式】输入多行，先输入随机整数的个数n，再输入相应个数的整数

【输出形式】输出一行，处理后的结果

【样例输入】 11 

             10 20 40 32 67 40 20 89 300 400 15 

【样例输出】10 15 20 32 40 67 89 300 400 

import java.util.Scanner;

//去重与排序
//明明想在学校中请一些同学一起做一项问卷调查，为了实验的客观性，
// 他先用计算机生成了N个1到1000之间的随机整数（N≤1000），
// 对于其中重复的数字，只保留一个，把其余相同的数去掉，不同的数对应着不同的学生的学号。
// 然后再把这些数从小到大排序，按照排好的顺序去找同学做调查。
// 请你协助明明完成“去重”与“排序”的工作。Input Param n 
// 输入随机数的个数 inputArray n 个随机整数组成的数组 
// Return Value OutputArray 输出处理后的随机整数
public class uniqueSort {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
        int[] nums=new int[n];
        for(int i=0;inums[j]){ //冒泡排序
                    int temp=nums[i];
                    nums[i]=nums[j];
                    nums[j]=temp;
                }
            }
        }
        for(int i=0;i

14. 跳跃最大长度 

【问题描述】

给一个非负整数数组。假设你最初的位置为0，数组中每一个元素的值代表你能跳跃最大的长度，判断是否能达到数组的最后一个位置

【输入形式】第一行数组长度

            第二行输入一个非负整数数组

【输出形式】布尔类型的值

【样例输入】

   5 

 1 2 3 1 4

【样例输出】

    true 

import java.util.Scanner;

//跳跃最大长度
//给一个非负整数数组。假设你最初的位置为0，
// 数组中每一个元素的值代表你能跳跃最大的长度，判断是否能达到数组的最后一个位置
public class maxJump {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
        int[] arr=new int[n];
        boolean flag=true;
        int m=0;
        for(int i=0;i=n-1){
                break;
            }
            if(m==i && i!=n-1){ //此时最远位置对应的值为0,且还没有到终点，没办法继续跳
                flag=false;
            }
        }
        if(flag){
            System.out.println("true");
        }else{
            System.out.println("false");
        }
    }
}

15. 输出较小数

【问题描述】

输入n个整数，输出其中最小的k个。

【输入形式】输入说明 1输入两个整数（n k） 2输入一个整数数组

【输出形式】输出一个整数数组

【样例输入】

   5 2 

 1 3 5 7 2 

【样例输出】

 1 2

import java.util.Scanner;

//输出较小数
//输入n个整数，输出其中最小的k个。
public class minNum {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
        int k=sc.nextInt();
        int nums[]=new int[n];
        for(int i=0;inums[j]){
                    int temp=nums[i];
                    nums[i]=nums[j];
                    nums[j]=temp;  //冒泡排序
                }
            }
        }
        for(int i=0;i

16.计算int型二进制1的个数

【问题描述】

输入一个int型的正整数，计算出该int型数据在内存中存储时1的个数。

【输入形式】

输入一个整数int类型

【输出形式】

这个数转换成2进制后，输出1的个数

【样例输入】

5

【样例输出】

2

import java.util.Scanner;

//计算int型二进制1的个数
//输入一个int型的正整数，计算出该int型数据在内存中存储时1的个数。
public class countNum1 {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
        int count=0;  //记录1的个数
        while(n>0){
            int y=n%2;
            n=n/2;
            if(y==1){
                count+=1;
            }
        }
        System.out.println(count);
    }
}

17. 水瓶换水

【问题描述】

有这样一道智力题：“某商店规定：三个空汽水瓶可以换一瓶汽水。小张手上有十个空汽水瓶，她最多可以换多少瓶汽水喝？”答案是5瓶，方法如下：先用9个空瓶子换3瓶汽水，喝掉3瓶满的，喝完以后4个空瓶子，用3个再换一瓶，喝掉这瓶满的，这时候剩2个空瓶子。然后你让老板先借给你一瓶汽水，喝掉这瓶满的，喝完以后用3个空瓶子换一瓶满的还给老板。如果小张手上有n个空汽水瓶，最多可以换多少瓶汽水喝？

【输入形式】输入文件最多包含10组测试数据，每个数据占一行，仅包含一个正整数n（1<=n<=100），表示小张手上的空汽水瓶数。n=0表示输入结束，你的程序不应当处理这一行。

【输出形式】对于每组测试数据，输出一行，表示最多可以喝的汽水瓶数。如果一瓶也喝不到，输出0。

【样例输入】 3 10 81 0 

【样例输出】   1 5 40

import java.util.Scanner;
import java.util.concurrent.TransferQueue;

//水瓶换水
//有这样一道智力题：“某商店规定：三个空汽水瓶可以换一瓶汽水。
// 小张手上有十个空汽水瓶，她最多可以换多少瓶汽水喝？”答案是5瓶，
// 方法如下：先用9个空瓶子换3瓶汽水，喝掉3瓶满的，喝完以后4个空瓶子，
// 用3个再换一瓶，喝掉这瓶满的，这时候剩2个空瓶子。然后你让老板先借给你一瓶汽水
// ，喝掉这瓶满的，喝完以后用3个空瓶子换一瓶满的还给老板。
// 如果小张手上有n个空汽水瓶，最多可以换多少瓶汽水喝？
public class changeWater {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        while(true){
            int n=sc.nextInt();
            if(n==0){
                break;
            }
            int res=0;
            while(n>=3){
                res+=1;
                n-=2;  //由于换的水所以多了一个瓶子
            }
            if(n==2){
                res+=1;  //特殊情况判断，如果还有2个，那么可以借一个换水
                n=0;
            }
            System.out.print(res+" ");
        }
    }
}

18. 导弹防御系统

【问题描述】

某国为了防御敌国的导弹袭击，开发出一种导弹拦截系统。但是这种导弹拦截系统有一个缺陷：虽然它的第一发炮弹能够到达任意的高度，但是以后每一发炮弹都不能高于前一发的高度。某天，雷达捕捉到敌国的导弹来袭，并观测到导弹依次飞来的高度，请计算这套系统最多能拦截多少导弹。拦截来袭导弹时，必须按来袭导弹袭击的时间顺序，不允许先拦截后面的导弹，再拦截前面的导弹。

【输入形式】每组输入有两行，第一行，输入雷达捕捉到的敌国导弹的数量k（k<=25），第二行，输入k个正整数，表示k枚导弹的高度，按来袭导弹的袭击时间顺序给出，以空格分隔。

【输出形式】每组输出只有一行，包含一个整数，表示最多能拦截多少枚导弹。

【样例输入】

8 

300 207 155 300 299 170 158 65

【样例输出】 6

import java.util.Scanner;

//导弹防御系统
//某国为了防御敌国的导弹袭击，开发出一种导弹拦截系统。
// 但是这种导弹拦截系统有一个缺陷：虽然它的第一发炮弹能够到达任意的高度，
// 但是以后每一发炮弹都不能高于前一发的高度。某天，雷达捕捉到敌国的导弹来袭，
// 并观测到导弹依次飞来的高度，请计算这套系统最多能拦截多少导弹。拦截来袭导弹时，
// 必须按来袭导弹袭击的时间顺序，不允许先拦截后面的导弹，再拦截前面的导弹。
public class defenseSystem {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        int k=sc.nextInt();
        int res=1; //记录最长值
        int[] height=new int[k];
        for(int i=0;i=height[i]){
                    dp[i]=Math.max(dp[j]+1,dp[i]);  //往前遍历，找到比当前值大的，状态转移方程
                }
            }
            res=Math.max(res,dp[i]); //更新最大值
        }
        System.out.println(res);
    }
}