Day8~Day14

 
public class Test {
    public static void main(String [] args){
        System.out.println(new B().getValue());
    }
static class A{
    protected int value;
    public A(int v) {
        setValue(v);
    }
    public void setValue(int value){
        this.value = value;
    }
    public int getValue(){
        try{
            value++;
            return value;
        } catch(Exception e){
            System.out.println(e.toString());
        } finally {
            this.setValue(value);
            System.out.println(value);
        }
        return value;
    }
}
static class B extends A{
    public B() {
        super(5);
        setValue(getValue() - 3);
    }
    public void setValue(int value){
        super.setValue(2 * value);
    }
}

public class Test1 {
    static int cnt = 6;
    static {
        cnt += 9;
    }
    public static void main(String[] args) {
        System.out.println("cnt =" + cnt);
    }
    static {
        cnt /= 3;
    }
}

public class Main {
    public static boolean isLengthCompare(String s1,String s2){
        int length=s1.length()-s2.length();
        if(length<0){
            return true;
        }else {
            return false;
        }
    }
    public static boolean isLexicCompare(String s1,String s2){
        int length =s1.compareTo(s2);
        if(length<0){
            return true;
        }else {
            return false;
        }
    }
    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
        int n=scanner.nextInt();
//S需要来读入回车键，否则会占用后面的字符串数组空间
        String S=scanner.nextLine();
        String []arr=new String[n];
        for (int i = 0; i <n; i++) {
            arr[i]=scanner.nextLine();
        }
        int L1=0;
        int L2=0;
        for (int i = 0; i < n-1; i++) {
            if(!isLengthCompare(arr[i],arr[i+1])){
                L1++;
            }
            if(!isLexicCompare(arr[i],arr[i+1])){
                L2++;
            }
        }
        if(L1==0&&L2==0){
            System.out.println("both");
        }else if(L1==0&&L2!=0){
            System.out.println("lengths");
        }else if(L1!=0&&L2==0){
            System.out.println("lexicographically");
        }else {
            System.out.println("none");
        }
    }
}

class Person {
    String name = "No name";
    public Person(String nm) {
        name = nm;
    }
}
class Employee extends Person {
    String empID = "0000";
    public Employee(String id) {
        empID = id;
    }
}
public class Test {
    public static void main(String args[]) {
        Employee e = new Employee("123");
        System.out.println(e.empID);
    }
}

public class TestClass {
    private static void testMethod(){
        System.out.println("testMethod");
    }
    public static void main(String[] args) {
        ((TestClass)null).testMethod();
    }
}

int i=0;
Integer j = new Integer(0);
System.out.println(i==j);//自动拆箱
System.out.println(j.equals(i));

public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n=in.nextInt();
        int m=in.nextInt();
        int sum=getNum(n,m);
        System.out.print(sum);
    }
    public static int getNum(int n,int m){
//当n=1或m=1时，路径个数为m+n
        if(n==1&&m>=1||m==1&&n>=1){
            return m+n;
        }
//递归求m-1的路径总条数和n-1路径总条数
        return getNum(n-1,m)+getNum(n,m-1);
    }
}

 public static void main(String[] args) {
            try{
            int i = 100 / 0;
            System.out.print(i);
        }catch(Exception e){
            System.out.print(1);
            //e.printStackTrace();//异常处理后,try 块内的代码将不再执行,try-catch 后的代码仍会执行
            throw new RuntimeException();//throw 一但抛出异常,其后的代码将不再被执行
        }finally{
            System.out.print(2);
        }
        System.out.print(3);
    }

byte b1=1,b2=2,b3,b6; 
final byte b4=4,b5=6; 
b6=b4+b5; 
b3=(b1+b2); 
System.out.println(b3+b6);

public class HashSet<E>
    extends AbstractSet<E>
    implements Set<E>, Cloneable, java.io.Serializable

public class HashMap<K,V> extends AbstractMap<K,V>
    implements Map<K,V>, Cloneable, Serializable

    private static final int DEFAULT_CAPACITY = 10;
 
    private static final Object[] EMPTY_ELEMENTDATA = {};
 
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {}; 
 
    /**
     * The array buffer into which the elements of the ArrayList are stored.
     * The capacity of the ArrayList is the length of this array buffer. Any
     * empty ArrayList with elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA
     * will be expanded to DEFAULT_CAPACITY when the first element is added.
     */  
 
    /*存储ArrayList 元素的数组缓冲区. ArrayLiat 的容量就是这个数组缓冲区的长度.
     任何带有elementData ==DEFAULTCAPACITY_EMPTY_ELEMENTDATA 的空数组列表
     将在添加第一个元素时扩展为DEFAULT_CAPACITY*/
 
    transient Object[] elementData;
 
    public ArrayList(int initialCapacity) {
        if (initialCapacity > 0) {
            this.elementData = new Object[initialCapacity];
        } else if (initialCapacity == 0) {
            this.elementData = EMPTY_ELEMENTDATA;
        } else {
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        }
    }
 
    public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }

import java.util.*;
 
// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n=in.nextInt();
        int m=in.nextInt();
        int []step=new int[m+1];
        for(int i=0;i<step.length;i++){
            step[i]=Integer.MAX_VALUE;
        }
//通过比较到达每个位置的最小步数来完成
        step[n]=0;
        for(int i=n;i<m;i++){
            if(step[i]==Integer.MAX_VALUE){
                continue;
            }
            List<Integer> list=div(i);
            for(int j=0;j<list.size();j++){
                int num=list.get(j);
                if(i+num<=m&&step[i+num]!=Integer.MAX_VALUE){
                    step[i+num]=Math.min(step[i]+1,step[i+num]);
                }else if(i+num<=m){
                    step[i+num]=step[i]+1;
                }
            }
        }
        if(step[m]==Integer.MAX_VALUE){
            System.out.println(-1);
        }else{
            System.out.println(step[m]);
        }
    }
    public static List<Integer> div(int n){
        List<Integer> list=new ArrayList<>();
        for(int i=2;i*i<=n;i++){
            if(n%i==0){
                list.add(i);
                if(n/i!=i){
                    list.add(n/i);
                }
            }
        }
        return list;
    }
}

public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n=in.nextInt();
        int []arr=new int[n];
        int sum=0;
        int multiply=1;
        for(int i=0;i<n;i++){
            arr[i]=in.nextInt();
        } 
        //当数组为有序时,当加入第i个球时,如果sum!=1&&sum<=multiply,那加入第i+1个球是必定不是幸运的袋子,直接break结束递归.
        Arrays.sort(arr);
        System.out.print(count(arr,arr.length,0,sum,multiply));
    }
    //pos 表明判断有 pos 个球的袋子是否为幸运的袋子,同时是遍历第pos个球的初始位置
    public static int count(int []arr,int n,int pos,int sum,int multiply){
        int count=0;
        for(int i=pos;i<n;i++){
            sum+=arr[i];
            multiply*=arr[i];
            if(sum>multiply){
                //如果前 i 个球是幸运的袋子,在有前i 个球的基础上,去判断 i+1个球的幸运的袋子
                count=count+1+count(arr,n,i+1,sum,multiply);
            }else if(sum==1){
                //sum==1时是拥有一个球的袋子,即球的号码为1,虽然不是幸运袋子,但1+任何数>1*任何数,因此可以在这个情况下判读如何取舍第二个球成为幸运袋子.
                count=count+count(arr,n,i+1,sum,multiply);
            }else{
                break;
            }
            sum-=arr[i];
            multiply/=arr[i];
            //因为相同号码是无区别的,因此跳过相同号码的球.
            while(i<n-1){
                if(arr[i]==arr[i+1]){
                    i++;
                }else{
                    break;
                }
            }
        }
 
        return count;
    }