升级打怪穿装备，看看你能升几级

我鶸鰯才升到lv3

class MyClass {
    private final int base;
    private int current;

    public MyClass(int base,int current){
        this.base = base < 0 ? 0 : base > 15 ? 15 : base;
        this.current = current < 0 ? 0 : current > 30 ? 30 : current;
    }

    public int getValue(){
        return base + current;
    }

    public void changeMyClass(int input){
        current = current/2 + (input < 0 ? 0 : input);
    }
}

LV1、写一个方法 int getBase(MyClass myClass);输出myClass的base值。

LV2、写一个方法 List<Integer> max(MyClass myClass, List<Integer> list);输出一个的list，使结果list能达到如下效果：选择原list中任意个数放入结果list，按照结果list的顺序，进行changeMyClass的操作，可以使最终的getValue得到最大值。

LV3、写一个方法 List<Integer> minSum(int wantedValue, MyClass myClass, List<Integer> list);输出一个的list，使结果list能达到如下效果：选择原list中任意个数放入结果list，按照结果list的顺序，进行changeMyClass的操作，可以使最终的getValue大于等于wantedValue，且结果list中所有数的和最小。若不存在结果，抛出异常。

LV4、写一个方法 List<Integer> minMax(int wantedValue, MyClass myClass, List<Integer> list,int limit);输出一个的list，使结果list能达到如下效果：选择原list中小于等于limit数量的数放入结果list，按照结果list的顺序，进行changeMyClass的操作，可以使最终的getValue大于等于wantedValue，且结果list中最大的数比其他结果list的最大数都小，若相等，比较第二大的数，以此类推。若不存在结果，抛出异常。

LV5、

class MyPairClass{
    MyClass myLeftClass;
    MyClass myRightClass;
    public MyPairClass(int base,int current){
        myLeftClass = new MyClass(base,current);
        myRightClass = new MyClass(base,current);
    }
}

class PairInt{
    int left;
    int right;
    public PairInt(int left, int right){
        this.left = left;
        this.right = right;
    }
}

试写出List<PairInt> minSum(PairInt wantedValue, MyPairClass myPairClass, List<PairInt> list);
和List<PairInt> minMax(PairInt wantedValue, MyPairClass myPairClass, List<PairInt> list,int limit);

.有点难度。lv1。。都悬啊

LV1 没问题，中间利用调用changeMyClass一次，可以得到两个getValue，由此可计算出base
LV2开始理解上有问题了，给出的方法中理论上最大值是45，难道要以这个做判断？不然穷举的话，我没仔细想，实现起来估计会很麻烦。。。。。
从LV2以后都不想看了，哈哈

45只是构造的时候的最大值，change不受影响的

lv1就是不断用0来change，getValue不变时，getValue得到的就是base；

lv2开始要关注MyClass的特性了，
特性1：change的参数input等于current/2+current%2的时候，change刚好不变:
特性2：input>0时，一直用同一个input来change，current的值最终会一直保持在2*input-1
得出的结论就是input>current/2+current%2的数就可以让current增大，同时保证下次用同样大input进行change的时候，current不会变小

于是先算出base，就得到原始的current。然后把传入的list升序排序，从排序list里截取大于等于current/2+current%2的部分。这样能保证每次change都可以增大current的值

lv3要让结果list的和最小，关键就是要尽快提高current的值，因为每次change，current就有损失值，这里的损失，都是要list里的值来填补的

于是就推导出一个笨的办法，就是用list{最大}尝试change，不成功就用list{第2大，最大}尝试，以此类推，成功以后再尝试减小结果list第一个数，如果能让getValue等于wanted，那必然list的和最小，如果不能相等，可能要穷举list里第1个数与第2个数可能的组合来得到结果

直接反射强取 .. 不折腾算法

int getBase(MyClass myClass)
	{
		int result=0;
		try 
		{
			Field field=myClass.getClass().getDeclaredField("base");
			field.setAccessible(true);
			result=field.getInt(myClass);
		}
		catch (Exception e) 
		{
			e.printStackTrace();
		}
		return result;
    }

来强的了

够暴力

Lv1:

public int getBase(MyClass m) {
    	
    	int key = 30;
    	while (key > 0) {
    		m.changeMyClass(-1);
    		key /= 2;
    	}
    	return m.getValue();
    }

哎哟喂，有意思，拿回去看看！
哎哟喂1 应该是解二元一次方程；


顺便问一句：鶸鰯 是嘛东东？

弱弱问下。java代码
private final int base; 
final修饰的变量不初始化为什么不报错呢？