一个数学题，求个算法。

[leafy]

5个级别的数字
第一级为1-50，第2级从51开始，每个数字对应的区间为50，第5级为最后的级别
例子：
第1级 第2级 第3级 第4级 第5级

51 同样的有50个区间 依次类推 第5级后面就没有了。
1 52
53
...
100

2 101

3
4
...
50



求当前数字为 X(X>0 为正整数，不会超过第5级的最大值) 时，得到第5级的区间,当x为第5级的数字时，提示当前为第5级.

小弟数学不好，哪位大神帮下忙，谢谢！

[a-shitou]

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

[brightyq]

[Quote=引用 1 楼 的回复:]
实在是没太看懂。
是5个区间，每个区间是50个数，然后随便录入一个数，问这个数在哪个区间？
如果这样，那除以50就好了，结果是几，再加1就对了。
应该不是这么简单的要求吧？
[/Quote]
楼主出来说说，应该不是这么简单的题目才对。

[leafy]

[Quote=引用 1 楼 的回复:]

实在是没太看懂。
是5个区间，每个区间是50个数，然后随便录入一个数，问这个数在哪个区间？
如果这样，那除以50就好了，结果是几，再加1就对了。
应该不是这么简单的要求吧？
[/Quote]
@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级别就是最后一层了。

[leafy]

[Quote=引用 3 楼 的回复:]

Java code

class Main {

public static void main(String[] args) {
// TODO Auto-generated method stub
System.out.println(getLevel(3));
System.out.println(getLevel(53));
……
[/Quote]
首先谢谢你的回答
其次说明下，我想得到的是 第5级别的哪个区间的数据，而不是他下一级的数据。

[leafy]

刚开会去了，所以现在才回复大家，不好意思哇。

[少年太天真]

[Quote=引用 1 楼 的回复:]
实在是没太看懂。
是5个区间，每个区间是50个数，然后随便录入一个数，问这个数在哪个区间？
如果这样，那除以50就好了，结果是几，再加1就对了。
应该不是这么简单的要求吧？
[/Quote]
貌似就是这个要求

[leafy]

[Quote=引用 9 楼 的回复:]

引用 1 楼 的回复:
实在是没太看懂。
是5个区间，每个区间是50个数，然后随便录入一个数，问这个数在哪个区间？
如果这样，那除以50就好了，结果是几，再加1就对了。
应该不是这么简单的要求吧？

貌似就是这个要求
[/Quote]

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

[sdojqy1122]

看懂了点了。那第五个级别就有 50*50*50*50*50 个数了。
1级别 2级别 3级别 4级别 5级别
50 50*50 50*50*50 50*50*50*50 50*50*50*50*50
楼主把他们加起来就可以了。。。。
5级别区间
开始数字 ：50 + 50*50 + 50*50*50 + 50*50*50*50
结束数字 ：开始数字 + 50*50*50*50*50

[leafy]

[Quote=引用 12 楼 的回复:]

看懂了点了。那第五个级别就有 50*50*50*50*50 个数了。
1级别 2级别 3级别 4级别 5级别
50 50*50 50*50*50 50*50*50*50 50*50*50*50*50
楼主把他们加起来就可以了。。。。
5级别区间
开始数字 ：50 + 50*50 + 50*50*50 + 50*50*50*50
结束数字 ：开始数字 +……
[/Quote]

是这样滴，我想要的算法是 当我输入某个数的时候，输出它所对应的第5个级别的区间。

[qybao]

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

不知道是不是这个意思

[qybao]

算法代码sample

public int getLevel(int score) {
    return (score-1)/50 + 1;
}

[qybao]

[Quote=引用 12 楼 的回复:]
看懂了点了。那第五个级别就有 50*50*50*50*50 个数了。
1级别 2级别 3级别 4级别 5级别
50 50*50 50*50*50 50*50*50*50 50*50*50*50*50
楼主把他们加起来就可以了。。。。
5级别区间
开始数字 ：50 + 50*50 + 50*50*50 + 50*50*50*50
结束数字 ：开始数字 + 50*50*50*50*50
[/Quote]

原来是这个意思？

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();
}

[brightyq]

呵呵，我理解能力有限，还是没太看懂。支持吧！

[leafy]

[Quote=引用 16 楼 的回复:]

引用 12 楼 的回复:
看懂了点了。那第五个级别就有 50*50*50*50*50 个数了。
1级别 2级别 3级别 4级别 5级别
50 50*50 50*50*50 50*50*50*50 50*50*50*50*50
楼主把他们加起来就可以了。。。。
5级别区间
开始数字 ：50 + 50*50 + 50*50*50 + 50*50*50*50
结束数字 ：开始数字 + ……
[/Quote]

首先谢谢您的回答。
嗯，我没描述清楚。
这么说把。
第1区间的范围是 1--50
第2区间的范围是 51--50*50=2500
第3区间的范围是 2501--50*50*50=125000
第4区间的范围是 125001--50*50*50*50=6250000
第5区间的范围是 6250001--50*50*50*50*50=312 500 000
1所对应第2级的区间是51-100，51所对应的第3级别区间是2501--2500+50
51-100所对应的第3级别区间是：2501--2500+50*50
那么1多对应的第3级别的区间是2501--2500+50*50

我想得到的是1所对应的 第5级别的区间数据6250001--6250000+50*50*50*50

[qybao]

还是不太明白LZ你的要求，LZ要求每个级别包含的元素是50的倍数，还是说之要求最大的是50的倍数？
即
第1级是 1-50
第2级是 51-2500(这样的话,51-2500只有2450个元素，最大的2500是50的倍数) --A
还是说
第2级是 51-2550(也就是说第2级有2500个元素，也就是说元素的个数是50的倍数) --B

16L的代码是 --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();
    }
}

[qybao]

当然,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;
}

[sdojqy1122]

昨晚忘了贴代码了。大致的思路是这样的。

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();
           }
     }
}

我觉得我写的思路大致没什么问题，也不知道符不符合要求。手写的，如果有拼写错误，自己修改下吧。

[sdojqy1122]

[Quote=引用 21 楼 的回复:]
if(data > Math.pow(50,lev)){
data = data - (int)Math.pow(50,lev);
lev++;
}
[/Quote]
改成
while(data > Math.pow(50,lev)){
data = data - (int)Math.pow(50,lev);
lev++;
}

[leafy]

谢谢大家的关注，非常感谢！
下面贴出我要的结果
最后的答案：

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();
    }

[leafy]

之前的有些小问题，下面是改善的。

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);
			}
		}
	}