好多鱼！

牛牛有一个鱼缸。鱼缸里面已经有n条鱼，每条鱼的大小为fishSize[i] (1 ≤ i ≤ n,均为正整数)，牛牛现在想把新捕捉的鱼放入鱼缸。鱼缸内存在着大鱼吃小鱼的定律。经过观察，牛牛发现一条鱼A的大小为另外一条鱼B大小的2倍到10倍(包括2倍大小和10倍大小)，鱼A会吃掉鱼B。考虑到这个，牛牛要放入的鱼就需要保证：
1、放进去的鱼是安全的，不会被其他鱼吃掉
2、这条鱼放进去也不能吃掉其他鱼
鱼缸里面已经存在的鱼已经相处了很久，不考虑他们互相捕食。现在知道新放入鱼的大小范围minSize,maxSize,牛牛想知道有多少种大小的鱼可以放入这个鱼缸。

输入描述:
输入数据包括3行.
第一行为新放入鱼的尺寸范围minSize,maxSize(1 ≤ minSize,maxSize ≤ 1000)，以空格分隔。
第二行为鱼缸里面已经有鱼的数量n(1 ≤ n ≤ 50)
第三行为已经有的鱼的大小fishSize[i](1 ≤ fishSize[i] ≤ 1000)，以空格分隔。

输出描述:
输出有多少种大小的鱼可以放入这个鱼缸。考虑鱼的大小都是整数表示
示例1
输入

1 12
1
1

输出

import java.util.Random;
import java.util.Scanner;

public class Main{
    public static void main(String[] args){
        Scanner scanner = new Scanner(System.in);
        System.out.println("minSize :");
        int minSize = scanner.nextInt();
        System.out.println("maxSize :");
        int maxSize = scanner.nextInt();
        System.out.println("inNumber :");
        int inNumber = scanner.nextInt();

        System.out.println("inFishSize[ ] :");
        int [] inFishSize = new int[inNumber];
       for(int i=0;i<inNumber;i++) {
           inFishSize[i]=scanner.nextInt();
       }
       int count =0;
       for(int i=minSize;i<=maxSize ;i++){
           boolean flag=false;
           for(int j=0;j<inNumber ;j++){
               if(( i*2<=inFishSize[j]&&inFishSize[j]<=i*10 )||( inFishSize[j]*2<=i && inFishSize[j]*10>=i )){
                   flag=true;
                   break;
               }
           }
           if(!flag){
               count++;
           }
       }
      System.out.println(count);
    }
}

DNA合成

DNA分子是以4种脱氧核苷酸为单位连接而成的长链，这4种脱氧核苷酸分别含有A,T,C,G四种碱基。碱基互补配对原则：A和T是配对的，C和G是配对的。如果两条碱基链长度是相同的并且每个位置的碱基是配对的，那么他们就可以配对合成为DNA的双螺旋结构。现在给出两条碱基链，允许在其中一条上做替换操作：把序列上的某个位置的碱基更换为另外一种碱基。问最少需要多少次让两条碱基链配对成功
输入描述:
输入包括一行：
包括两个字符串,分别表示两条链,两个字符串长度相同且长度均小于等于50。
输出描述:
输出一个整数，即最少需要多少次让两条碱基链配对成功
示例1
输入

ACGT
TGCA

输出

import java.util.Scanner;

public class Main{
    public static void main(String[] args){
        Scanner scanner = new Scanner(System.in);
        System.out.println("输入碱基s1 :");
        String s1=scanner.nextLine();
        System.out.println("输入碱基s2 :");
        String s2= scanner.nextLine();

    if(s1.length()!=s2.length()||s1.isEmpty()||s2.isEmpty()){
    return;
    }
    int count =0;
    for(int i=0;i<s1.length();i++){
        if(!( (s1.charAt(i)=='A' && s2.charAt(i)=='T') ||
            (s2.charAt(i)=='A' && s1.charAt(i)=='T') ||
            (s1.charAt(i)=='C' && s2.charAt(i)=='G') ||
            (s2.charAt(i)=='C' && s1.charAt(i)=='G') )){
            count++;
        }
    }
    System.out.println(count);
    }
}

连续整数

牛牛的好朋友羊羊在纸上写了n+1个整数，羊羊接着抹除掉了一个整数，给牛牛猜他抹除掉的数字是什么。牛牛知道羊羊写的整数神排序之后是一串连续的正整数，牛牛现在要猜出所有可能是抹除掉的整数。例如：
10 7 12 8 11 那么抹除掉的整数只可能是9
5 6 7 8 那么抹除掉的整数可能是4也可能是9
输入描述:
输入包括2行：
第一行为整数n(1 <= n <= 50)，即抹除一个数之后剩下的数字个数
第二行为n个整数num[i] (1 <= num[i] <= 1000000000)
输出描述:
在一行中输出所有可能是抹除掉的数,从小到大输出,用空格分割,行末无空格。如果没有可能的数，则输出mistake
示例1
输入

2
3 6

输出

mistake

import java.util.Scanner;

public class Main{
    public static void main(String[] args){
       Scanner scanner=new Scanner(System.in);
       System.out.println("剩下数字个数 ：");
       int n=scanner.nextInt();
       int [] num=new int[n];
       System.out.println("输入剩下数字 :");
       int max=Integer.MIN_VALUE;
       int min=Integer.MAX_VALUE;
       int s=0;
       for(int i=0;i<n;i++){
       num[i]=scanner.nextInt();
       s+=num[i];
       if(num[i]<min) min=num[i];
       if(num[i]>max) max=num[i];
       }

       if(max-min+1 == n){
           if(s==(max+min)*n/2){
               if(min>1){
                   System.out.println((min-1)+" "+ (max+1));
               }else {
                   System.out.println(max+1);
               }
           }else {
               System.out.println("mistake!");
           }
       }else {
           if(max-min==n){
           for(int j=1;j<n;j++){
               if(num[j]==num[j-1]){
                   System.out.println("mistake!");
               }else if (num[j]==num[j-1]+2){
                   System.out.println(num[j]-1);
               }
           }
       }else {
           System.out.println("mistake!");
           }
       }
    }
}

序列和

01翻转

最长公共连续子串

组装三角形

最小的矩形

字符串分类

优美的回文串

赶去公司

调整队形

集合

涂棋盘

小易记单词

分饼干

买帽子

度度熊回家

寻找三角形

有趣的排序

神奇数

添加字符

数组变换

Java代码实现

Learn ,Practice ,Summary !