饥饿的小易、另类加法

1.用命令方式运行以下代码的运行结果是（C）

public class f{
    public static void main(String[] args){
        String foo1 = args[1];
        String foo2 = args[2];
        String foo3 = args[3];
    }
}

命令: java f a b c
A.程序编译错误
B.a b c
C.程序运行错误
D.f
解析：
数组越界
2.以下哪项不属于java类加载过程？B
A.生成java.langClass对象
B.int类型对象成员变量赋予默认值
C.执行static块代码
D.类方法解析
3.标题：另类加法
请编写一个函数，将两个数字相加。不得使用+或其他算数运算符。
给定两个int A和B。请返回A＋B的值

import java.util.*;
public class UnusualAdd {
    public int addAB(int A, int B) {
        if(B==0)
        return A;
        int sum = A ^ B; //相加但不进位
        int jin =(A & B) << 1; //进位但不相加
        return addAB(sum, jin);
     }
}

4.标题：饥饿的小易
小易总是感觉饥饿，所以作为章鱼的小易经常出去寻找贝壳吃。最开始小易在一个初始位置x_0。对于小易所处的当前位置x，他只能通过神秘的力量移动到 4x + 3或者8x + 7。因为使用神秘力量要耗费太多体力，所以它只能使用神秘力量最多100,000次。贝壳总生长在能被1,000,000,007整除的位置(比如：位置0，位置1,000,000,007，位置2,000,000,014等)。小易需要你帮忙计算最少需要使用多少次神秘力量就能吃到贝壳。
输入描述：
输入一个初始位置x_0,范围在1到1,000,000,006
输出描述：
输出小易最少需要使用神秘力量的次数，如果使用次数使用完还没找到贝壳，则输出-1
示例1:
输入
125000000
输出
1
解析：
f(x)= 4x + 4
g(x)=8x + 7
计算可以得出两个规律：
1.g(f(x))= f(g(x)) 即f和g的执行顺序没有影响
2. f(f(f(x)))=g(g(x)) 即做3次f的变换等价于做2次g的变换
由规律1可以得出对于一个可行方案，可以调整其变换顺序。比如：ffffggfggffff 可以转换为fffffffffgggg
由规律2并且为了减少执行次数，每3个f可以转换为2个g 如方案fffffffffgggg可以转换为ffffgggggg
因此一个最优的策略：f的执行次数为 0， 1， 2。 对于输入x， 只需要要求x , 4x+3, 4(4x+3)+3 的最小g执行次数即可

//正确答案
import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        long x0 = scanner.nextLong();
        long m = 1000000007;
        //取模的值 
        long s = 100000;
        //神秘力量使用的次数
        long[] begin = new long[3];
        //f(x) = 4x+3 执行3次 
        //3次的取值 
        begin[0] = x0;
        begin[1] = (4 * begin[0] + 3) % m;
        begin[2] = (4 * begin[1] + 3) % m;
        long minStep = s;
        long cur = 0;
        int step = 0;
        //执行的步数 
        for (int i = 0; i < 3; i++) {
            cur = begin[i];
            step = i;
            while (cur != 0 && step < minStep) {
                cur = (8 * cur + 7) % m;
            //g(x) = 8x+7 执行 
                step++;
            }
            minStep = minStep < step ? minStep : step;
        }
        if (minStep < s) {
            //如果执行步长没有超过s输出最小步长 
            System.out.println(minStep);
        } else {
            //超过返回-1 
            System.out.println(-1);
        }
    }
}