I just wrote a tiny method to count the number of pages for cell phone SMS. I didn't have the option to round up using Math.ceil
, and honestly it seems to be very ugly.
Here is my code:
public class Main {
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
String message = "today we stumbled upon a huge performance leak while optimizing a raycasting algorithm. Much to our surprise, the Math.floor() method took almost half of the calculation time: 3 floor operations took the same amount of time as one trilinear interpolation. Since we could not belive that the floor-method could produce such a enourmous overhead, we wrote a small test program that reproduce";
System.out.printf("COunt is %d ",(int)messagePageCount(message));
}
public static double messagePageCount(String message){
if(message.trim().isEmpty() || message.trim().length() == 0){
return 0;
} else{
if(message.length() <= 160){
return 1;
} else {
return Math.ceil((double)message.length()/153);
}
}
}
I don't really like this piece of code and I'm looking for a more elegant way of doing this. With this, I'm expecting 3 and not 3.0000000. Any ideas?
This question is related to
java
math
types
formatting
(message.length() + 152) / 153
This will give a "rounded up" integer.
Another one-liner that is not too complicated:
private int countNumberOfPages(int numberOfObjects, int pageSize) {
return numberOfObjects / pageSize + (numberOfObjects % pageSize == 0 ? 0 : 1);
}
Could use long instead of int; just change the parameter types and return type.
Use Math.ceil()
and cast the result to int:
Example:
(int) Math.ceil((double)divident / divisor);
long numberOfPages = new BigDecimal(resultsSize).divide(new BigDecimal(pageSize), RoundingMode.UP).longValue();
Google's Guava library handles this in the IntMath class:
IntMath.divide(numerator, divisor, RoundingMode.CEILING);
Unlike many answers here, it handles negative numbers. It also throws an appropriate exception when attempting to divide by zero.
this might be helpfull,, Subtract the remainder to the legnth and make it a divisible number and then divide it with 153
int r=message.length()%153; //Calculate the remainder by %153
return (message.length()-r)/153; // find the pages by adding the remainder and
//then divide by 153
If you want to calculate a divided by b rounded up you can use (a+(-a%b))/b
Expanding on Peter's solution, this is what I've found works for me to always round 'towards positive infinity':
public static long divideAndRoundUp(long num, long divisor) {
if (num == 0 || divisor == 0) { return 0; }
int sign = (num > 0 ? 1 : -1) * (divisor > 0 ? 1 : -1);
if (sign > 0) {
return (num + divisor - 1) / divisor;
}
else {
return (num / divisor);
}
}
Source: Stackoverflow.com