一个数学题，求个算法。

class Main { public static void main(String[] args) {
// TODO Auto-generated method stub
System.out.println(getLevel(3));
System.out.println(getLevel(53));
System.out.println(getLevel(103));
System.out.println(getLevel(153));
System.out.println(getLevel(203));
} private static String getLevel(final int x) {
int left = x / 50;
int right = left + 1;
return "[" + (left * 50 + 1) + ", " + right * 50 + "]";
}
}
// result：
// [1, 50]
// [51, 100]
// [101, 150]
// [151, 200]
// [201, 250]

没看明白。。感觉有点像cobol

@brightyq
是这样的，有5个级别的数据。
1 2 3 4 5
1对应的是1-50
第2个级别的数据就是从51开始
第1级别的每个数字每个同样都有50个儿子
那么第2级别的数字就是50*50这个区间的
例：1对应的第2级别子数据就是51-100，2对应的就是 101-150，依次类推。
第2级别的数据每个在第3级别同样有对应的50个数据。
第3级别对应第4级别与第4级别对应第5级别都是一样的。
第5级别就是最后一层了。

晕，我后面有个说明的。
求当前数字为 X(X>0 为正整数，不会超过第5级的最大值) 时，得到第5级的区间,当x为第5级的数字时，提示当前为第5级.

按50个级别为1个区间，那就X除以50就可以得到区间了
int X = 200;
int level = (X-1) / 50 + 1; //因为除以50的话，是从0级开始计算的，所以+1不知道是不是这个意思

算法代码sample
public int getLevel(int score) {
return (score-1)/50 + 1;
}

原来是这个意思？
public int getLevel(int score) {
    TreeMap<Integer, Integer> map = new TreeMap<Integer, Integer>();
    int sum = 0, base = 1, step = 50;
    for (int i=0; i<5; i++) {
        map.put(sum, i+1);
        base *= step;
        sum += base;
    }    Map.Entry<Integer, Integer> lower = map.lowerEntry(score);
    if (lower == null) return -1; //输入了超出等级范围的数据，返回-1    return lower.getValue().intValue();
}

还是不太明白LZ你的要求，LZ要求每个级别包含的元素是50的倍数，还是说之要求最大的是50的倍数？
即
第1级是 1-50
第2级是 51-2500(这样的话,51-2500只有2450个元素，最大的2500是50的倍数) --A
还是说
第2级是 51-2550(也就是说第2级有2500个元素，也就是说元素的个数是50的倍数) --B16L的代码是 --B 的情况如果是--A情况，改下代码就可以了
给LZ写了段测试代码import java.util.*;
public class Test {
    static TreeMap<Integer, Integer> map = new TreeMap<Integer, Integer>();
    static { //因为map信息是重复使用的，所以把16L的map部分抽出来
        int sum = 0, times = 50;
        for (int i=0; i<5; i++) {
            map.put(sum, i+1);
            sum = (sum == 0 ? times : sum*times);
        }
    }    public static void main(String[] args) throws Throwable {
        for (int i=0, j=1; i<5; i++, j*=50) {
            System.out.printf("边界测试当前分数：分数=%d, 级别=%d\n", j, getLevel(j));
            System.out.printf("边界测试下个分数：分数=%d, 级别=%d\n", j+1, getLevel(j+1));
            int k = (int)(Math.random()*j);
            System.out.printf("随机测试：分数=%d, 级别=%d\n", k, getLevel(k));
            System.out.println();
        }        Scanner sc = new Scanner(System.in);
        System.out.print("请输入一个[1-312500000]范围内的整数:");
        int score = sc.nextInt();
        System.out.printf("输入的分数为:%d，该分数对应的等级为:%d\n", score, getLevel(score));
    }    public static int getLevel(int score) {
        if (score < 1 || score > 312500000) return -1; //超出范围
        return map.lowerEntry(score).getValue().intValue();
    }
}

当然,LZ可能希望是个简单的计算过程的算法,那么其实也很简单
给定一个数X,如果 Math.pow(50, i) <= X < Math.pow(50, i+1)
那么X的等级就是 i所以算法为public static int getLevel(int score) {
    if (score < 1 || score > 312500000) return -1;    int level=1, next=50;
    for (; next<score; level++, next*=50);
    return level;
}

昨晚忘了贴代码了。大致的思路是这样的。public class Test{
     public static void main(){
           getQUJIAN(1);
     }
     public static int[] getQUJIAN(int data){
           int start;
           int end;
           start = end = 0;
           int lev = getLev(data);
           if(lev==5){
                start = end = data;
                return new int[]{start,end};
           }
           else{
                start =(int)(data * Math.pow(5-lev)) + 1;
                end = start +(int)Math.pow(5-lev) - 1;
                return new int[]{start,end};
           }
     }
     public static int getLev(int data){
           int lev = 1;
           if(data > Math.pow(50,lev)){
                 data = data - (int)Math.pow(50,lev);
                 lev++;
           }
           if(lev > 5){
                 throw new RuntimeException();
           }
     }
}
我觉得我写的思路大致没什么问题，也不知道符不符合要求。手写的，如果有拼写错误，自己修改下吧。

改成
while(data > Math.pow(50,lev)){
data = data - (int)Math.pow(50,lev);
lev++;
}

谢谢大家的关注，非常感谢！
下面贴出我要的结果
最后的答案：static TreeMap<Integer, Integer> map = new TreeMap<Integer, Integer>();
static { //因为map信息是重复使用的，所以把16L的map部分抽出来
        int sum = 0, times = 50;
        for (int i=0; i<5; i++) {
            map.put(sum, i+1);
            sum = (sum == 0 ? times : sum*times);
        }
    }
public static void main(String[] args) {
int x=1;//当前ID
System.out.println(getLevel(x));
int j=getLevel(x);
System.out.println("当前级别为："+j);
int start=0,end=0;
int c;//差值
// TODO 关于类型测试
c=(int) (x-Math.pow(50, j-1));
//System.out.println(c);
for (int i = 0; i <= j; i++) {
if(j>=5)
break;
if(c>1)
start=(int) (Math.pow(50, j)+50*(c-1)+1);
else
start=(int) (Math.pow(50, j)+50+1);
end=(int) (Math.pow(50, j)+50*c);
//System.out.println((i+1)+"    下一级左边的数："+start+"  \n下一级右边的数："+end);
j++;
}
System.out.println("左边的数："+start+"\n右边的数："+end);
}

public static int getLevel(int score) {
        if (score < 1 || score > 312500000) return -1; //超出范围
        return map.lowerEntry(score).getValue().intValue();
    }

之前的有些小问题，下面是改善的。private void getRange(GoodsDTO targetGoods) {
if (null != targetGoods && null != targetGoods.getTypeCon()) {
int num = targetGoods.getTypeCon().intValue();
int index = Constants.EVERY_COUNT;
int totalCeng = Constants.MAX_LEVEL;
double curentStartNum = 0;// 目标层的起始值
int curentCeng = 0;// 目标数位的层数
double curentCount = 0;// 目标层的个数
double startNum = 0;// 最后范围的起始值
double endNum = 0;// 最后范围的结束值
for (int i = 1; i <= totalCeng; i++) {
double a = 0;
double b = 0;
for (int j = 0; j < i; j++) {
a += Math.pow(index, j);
}
for (int k = 1; k <= i; k++) {
b += Math.pow(index, k);
}
}
for (int i = 1; i <= totalCeng; i++) {
curentStartNum = 0;
double curentEndNum = 0;
for (int j = 0; j < i; j++) {
curentStartNum += Math.pow(index, j);
}
for (int k = 1; k <= i; k++) {
curentEndNum += Math.pow(index, k);
}
if (curentStartNum <= num && num <= curentEndNum) {
curentCeng = i;
curentCount = Math.pow(index, curentCeng);
break;
}
}
for (int i = totalCeng; i >= 1; i--) {
double laseCount = 0;// 最后层的个数
double laseStartNum = 0;// 最后一层起始值
double laseNumIndex = 0;// 目标值在最后一层的最后一个位置
int j = 0;
while (j < i) {
laseStartNum += Math.pow(index, j);
j++;
}
laseCount = Math.pow(index, i);// 个数 laseNumIndex = (num - curentStartNum + 1) * laseCount
/ curentCount;
endNum = laseStartNum + laseNumIndex - 1;
startNum = endNum - Math.pow(index, i - curentCeng) + 1;
if (startNum < num) {
break;
}
try {
Integer count = this.goodsDAO.isExistsGoodsType(
(int) startNum, (int) endNum);
if (null != count && count.intValue() > 0) {
targetGoods.setStartType(new Integer((int) startNum));
targetGoods.setEndType(new Integer((int) endNum));
}
} catch (PafaDAOException e) {
e.printStackTrace();
}
System.err.println("起始=" + (long) startNum + " 结束="
+ (long) endNum);
}
}
}

调试易

一个数学题，求个算法。

解决方案 »