求教，关于一取整算法的思路？

Question

max,min两个数
1.max要求向上取整，min 要求向下取整，
2.max，min要求是以0.5，5。00，结尾
3.(max-min)/int(x) 的值是 0.5，5 ，00结尾的如：max =123 向上取整 125min =17 向下取整 15如果是小数 max =0.7 取整1.0，min =0.2向下取整0.0

Answer 1

int i = 1;
int j= 1;
while(max < 1)
{
     max = max *10;
     i = i * 10;
}
max = ((max/5 + 1) * 5) / i;
while(min < 1)
{
   min = min * 10;
   j= j*10;
} 
min = ((min/5 - 1) * 5)/j;
我不是用java写的，对于int,double，BigDecimal考虑得也不多，就是给这么个思路，也不知道对不对，如果能给你点启发也行，楼下的给出好代码啊

Answer 2

当然了，对于min 的，你可以在加个判断就是当 min = ((min/5 - 1) * 5)/j;这个公式里的等号右面的(min/5 -1) < 0 的时候，你可以直接让min = 0.0就行了。

Answer 3

不管怎么样，还是谢谢你，你的思路是行不通，关键是对double类型的值的操作。如果是int 好判断。对吧，
我直接
while(max%5!=0){
max++;
}
max+5;
最多也不过循环4次。

Answer 4

我现在关键问题是如何确定一个步长，什么是(max%5) 5，什么时候应该是0.5，什么时候是0.05。

Answer 5

while(max%5!=0){
max++;
}
你这样的思想只适合整数，我的循环不是做你的这个处理，是为了让你确定步长
max = ((max/5 + 1) * 5)
min = ((min/5 - 1) * 5)
这两句完全就可以代替你的
while(max%5!=0){
max++;
}
我让结果/i(或j)就是为了让他还原到小数，因为此时的i（或j）是10的x次方，而这个x就是你的步长阿

Answer 6

int i=0;
while(max<0){
int ga=rount(max);
if(ga==1||ga==0){
  break;
}
}
while(max>0){
if(max%5<3){
max=max-i;
if(max%5==0){
  break;
}
}else if(max%5>2){
max=max+i;
if(max%5==0){
  break;
}
}
i++;
}这样不知可不可以试试吧！

Answer 7

to:For_suzhen(不懂装懂)
谢谢，思路我明白，可是还是没有达到目的，
.max，min要求是以0.5，5，00，......结尾

Answer 8

如果max是一个double,且是大于1的，
ok,(max/5+1)*5向上取整，
((max/5 + 1) * 5)/i还原小数的时候，你认为会出现什么情况。
呵呵，请指教 !

Answer 9

public class QuZheng { public static void main(String[] args) { String input = "123.45";//enter a number
boolean isXiaoShu = false;
int point = 0; int length = input.length();
for (int i = 0; i < length; i++) {
if (input.charAt(i) == '.') {
isXiaoShu = true;
point = i;
break;
}
}
if (isXiaoShu) {
double max, min;
double doubleInput = Double.parseDouble(input);
String subInput = input.substring(point);
String zhengInput = input.substring(0, point);
double zhengDoubleInput = Double.parseDouble(zhengInput);
double subDoubleInput = Double.parseDouble(subInput);
if (subDoubleInput > 0 && subDoubleInput < 0.5) {
max = zhengDoubleInput + 0.5;
min = zhengDoubleInput;
} else if (subDoubleInput > 0.5 && subDoubleInput < 1.0) {
max = zhengDoubleInput + 1;
min = zhengDoubleInput + 0.5; } else {
max = zhengDoubleInput + 0.5;
min = zhengDoubleInput - 0.5;
} System.out.println("max = " + max + " min = " + min);
} else {
int max, min;
int intInput = Integer.parseInt(input);
int last = intInput % 10;
if (last > 5 && last < 10) {
max = intInput + (10 - last);
min = intInput - (last - 5); } else if (last > 0 && last < 5) {
max = intInput + (5 - last);
min = intInput - last;
} else {
max = intInput + 5;
min = intInput - 5;
}
System.out.println("max = " + max + " min = " + min);
} }
}这个方案可以

Answer 10

如果max是一个double,且是大于1的，
ok,(max/5+1)*5向上取整，
((max/5 + 1) * 5)/i还原小数的时候，你认为会出现什么情况。
呵呵，请指教 !///////////////////////////////////////////////////////
你的意思是17.3向上取整应该是20还是17.5？
如果是17.5的话，我的思路确实是不太严密。因为关于int double的取值,到底怎么取，我确实是不明白，楼上的解法可行吗？你可以试试

Answer 11

public class InAttentionTo {
public static void main(String[] args){
String max = "123.5";
String min = "234.0";
double powerN = 1;

if(max.indexOf(".") != -1){
int len = max.length() - max.indexOf(".") - 1;
powerN = Math.pow(10,len);
}
max = "" + getRtn(Double.parseDouble(max) * powerN, true) / powerN;

powerN = 1;
if(min.indexOf(".") != -1){
int len = min.length() - min.indexOf(".") - 1;
powerN = Math.pow(10,len);
}
min = "" + getRtn(Double.parseDouble(min) * powerN, false) / powerN;

System.out.println(max + " : " + min);
}
private static double getRtn(double number,boolean flgUpDown){

if(number%5 == 0) return number;
if(flgUpDown) number = number + 5 - number%5;
if(!flgUpDown) number = number - number%5;

return number;
}
}

Answer 12

稍微改了一下：
public class InAttentionTo {
public static void main(String[] args){
String max = "123.1";
String min = "234.4";
double powerN = 1;

if(max.indexOf(".") != -1){
int len = max.length() - max.indexOf(".") - 1;
powerN = Math.pow(10,len);
}
String rtnMax = "" + getRtn(Double.parseDouble(max) * powerN, true) / powerN;
max = max.indexOf(".") != -1 ? rtnMax : rtnMax.substring(0,rtnMax.indexOf("."));

powerN = 1;
if(min.indexOf(".") != -1){
int len = min.length() - min.indexOf(".") - 1;
powerN = Math.pow(10,len);
}
String rtnMin = "" + getRtn(Double.parseDouble(min) * powerN, false) / powerN;
min = min.indexOf(".") != -1 ? rtnMin : rtnMin.substring(0,rtnMin.indexOf("."));

System.out.println(max + " : " + min);
}
private static double getRtn(double number,boolean flgUpDown){

if(number%5 == 0) return number;
if(flgUpDown) number = number + 5 - number%5;
if(!flgUpDown) number = number - number%5;

return number;
}
}

Answer 13

to:For_suzhen(不懂装懂) 
我的意思是17.3向上取整应该17.5？
没关系，我在参考 下大家的意见，看看还有没有好的算法，下午结贴!

Answer 14

好像只是定位的问题，换个思路用string也许更好。
public static void main(String[] args){
double d = 0.07;
String tmp = "5";
String s = String.valueOf(d);
tmp = s.substring(0,s.length()-1)+tmp;
if(s.compareTo(tmp)>0){
System.out.println(Double.parseDouble(tmp)+Double.parseDouble(tmp));
}else{
System.out.println(Double.parseDouble(tmp));
}

}

Answer 15

这样就没有确认步长的问题了，我的sample是向上取整，你可以随便更改d的值来测试。应该可以很好的满足你的要求

Answer 16

double 以string 来处理，在把string 转换成double,我不知道这种方法是否可行，还有就是精度的问题!我测试了一下你的程序，double=18.7的时候，取完整是37，相差太多了!

Answer 17

。。不好意思，加多了。 public static void main(String[] args) {
double d = 17.7;
String tmp = "5";
String s = String.valueOf(d);
tmp = s.substring(0, s.length() - 1) + tmp;
String regex = "\\d";
String adjust = "";
adjust = s.replaceAll(regex, "0").substring(0, s.length() - 1) + "5";
System.out.println(adjust);
if (s.compareTo(tmp) > 0) {
System.out.println(Double.parseDouble(adjust)
+ Double.parseDouble(tmp));
} else {
System.out.println(Double.parseDouble(tmp));
} }

Answer 18

String regex = "\\d";
String adjust = "";
adjust = s.replaceAll(regex, "0").substring(0, s.length() - 1) + "5";
用个正则表达式把数据变成"00000.00000"+"5"  之前忘记截掉了，变成2倍了。其实意思理解了就ok了阿，按你写出来的要求用这个思路是没有问题的。除非你另有要求。