¿Cómo redondear el resultado de la división de enteros?

Question

Estoy pensando en particular en cómo mostrar los controles de paginación cuando utilizo un lenguaje como C# o Java.

Si tengo x artículos que quiero mostrar en trozos de y por página, el número de páginas se necesitarán?

Answer 1

encontrado una solución elegante:

int pageCount = (records + recordsPerPage - 1)/recordsPerPage; 

Fuente: Number Conversion, Roland Backhouse, 2001

Answer 2

Querrá hacer la división de coma flotante, y luego usar la función de techo, para redondear el valor al siguiente entero.

Answer 3

Otra alternativa es usar la función mod() (o '%'). Si hay un resto distinto de cero, entonces incremente el resultado entero de la división.

Answer 4

Esto debería darle lo que desea. Definitivamente querrá x elementos divididos por elementos y por página, el problema es cuando aparecen números desiguales, por lo que si hay una página parcial también queremos agregar una página.

int x = number_of_items; 
int y = items_per_page; 

// with out library 
int pages = x/y + (x % y > 0 ? 1 : 0) 

// with library 
int pages = (int)Math.Ceiling((double)x/(double)y); 

Answer 5

para C# es la solución a emitir los valores a un doble (como Math.Ceiling lleva una doble):

int nPages = (int)Math.Ceiling((double)nItems/(double)nItemsPerPage); 

en Java que debe hacer lo mismo con Math.ceil().

Answer 6

La solución matemáticas entero que Ian proporcionado es agradable, pero sufre de un error de desbordamiento de enteros. Suponiendo que las variables son todas int, la solución podría ser reescrito para usar long matemáticas y evitar el error:

int pageCount = (-1L + records + recordsPerPage)/recordsPerPage;

Si records es una long, el error se mantiene. La solución del módulo no tiene el error.

Answer 7

La conversión a punto flotante y viceversa parece una enorme pérdida de tiempo en el nivel de la CPU.

solución de Ian Nelson:

int pageCount = (records + recordsPerPage - 1)/recordsPerPage; 

se puede simplificar a:

int pageCount = (records - 1)/recordsPerPage + 1; 

AFAICS, esto no tiene el error de desbordamiento que Brandon DURETTE señaló, y debido a que sólo se utiliza una vez , no es necesario almacenar RecordPerPage especialmente si proviene de una función costosa para recuperar el valor de un archivo de configuración o algo así.

I.e. esto podría ser ineficiente, si config.fetch_value utiliza una búsqueda de base de datos o algo:

int pageCount = (records + config.fetch_value('records per page') - 1)/config.fetch_value('records per page'); 

Esto crea una variable que realmente no necesita, lo que probablemente tiene implicaciones (menores) de memoria y es simplemente demasiado escribiendo:

int recordsPerPage = config.fetch_value('records per page') 
int pageCount = (records + recordsPerPage - 1)/recordsPerPage; 

Este es toda una línea, y sólo recoge los datos una vez:

int pageCount = (records - 1)/config.fetch_value('records per page') + 1; 

Answer 8

Para los registros == 0, la solución de rjmunro da 1. La solución correcta es 0. dicho esto, si usted sabe que los registros> 0 (y estoy Seguro que tenemos al l asumió recordsPerPage> 0), luego la solución rjmunro da resultados correctos y no tiene ninguno de los problemas de desbordamiento.

int pageCount = 0; 
if (records > 0) 
{ 
    pageCount = (((records - 1)/recordsPerPage) + 1); 
} 
// no else required 

Todos soluciones matemáticas del número entero van a ser más eficiente que cualquier de las soluciones de punto flotante.

Answer 9

alternativa para eliminar la ramificación en las pruebas de cero:

int pageCount = (records + recordsPerPage - 1)/recordsPerPage * (records != 0); 

No estoy seguro si esto va a funcionar en C#, debe hacerlo en C/C++.

Answer 10

Un método genérico, cuyo resultado se puede iterar sobre pueda ser de su interés:

public static Object[][] chunk(Object[] src, int chunkSize) { 

    int overflow = src.length%chunkSize; 
    int numChunks = (src.length/chunkSize) + (overflow>0?1:0); 
    Object[][] dest = new Object[numChunks][];  
    for (int i=0; i<numChunks; i++) { 
     dest[i] = new Object[ (i<numChunks-1 || overflow==0) ? chunkSize : overflow ]; 
     System.arraycopy(src, i*chunkSize, dest[i], 0, dest[i].length); 
    } 
    return dest; 
} 

Answer 11

Una variante de Nick Berardi's answer que evite una rama:

int q = records/recordsPerPage, r = records % recordsPerPage; 
int pageCount = q - (-r >> (Integer.SIZE - 1)); 

Nota: (-r >> (Integer.SIZE - 1)) consiste en el bit de signo de r, repetido 32 veces (gracias a la extensión de signo del operador >>.) Esto se evalúa a 0 si r es cero o negativo, -1 si r es positivo mi. Así que restarlo de q tiene el efecto de agregar 1 si records % recordsPerPage > 0.

Answer 12

Tenía una necesidad similar donde necesitaba convertir Minutos a horas & minutos. Lo que utilicé fue:

int hrs = 0; int mins = 0; 

float tm = totalmins; 

if (tm > 60) (hrs = (int) (tm/60); 

mins = (int) (tm - (hrs * 60)); 

System.out.println("Total time in Hours & Minutes = " + hrs + ":" + mins); 

Answer 13

Lo siguiente debe hacer redondeo mejor que las soluciones anteriores, pero a expensas de rendimiento (debido al cálculo de coma flotante de 0.5 * rctDenominator):

uint64_t integerDivide(const uint64_t& rctNumerator, const uint64_t& rctDenominator) 
{ 
    // Ensure .5 upwards is rounded up (otherwise integer division just truncates - ie gives no remainder) 
    return (rctDenominator == 0) ? 0 : (rctNumerator + (int)(0.5*rctDenominator))/rctDenominator; 
} 

Answer 14

hago lo siguiente, se ocupa de cualquier desbordamientos:

var totalPages = totalResults.IsDivisble(recordsperpage) ? totalResults/(recordsperpage) : totalResults/(recordsperpage) + 1; 

y utilizar esta extensión de si hay 0 resultados:

public static bool IsDivisble(this int x, int n) 
{ 
      return (x%n) == 0; 
} 

Además, para la corriente número de página (no se le preguntó, pero podría serle útil):

var currentPage = (int) Math.Ceiling(recordsperpage/(double) recordsperpage) + 1; 

Answer 15

En la necesidad de un método de extensión:

public static int DivideUp(this int dividend, int divisor) 
    { 
     return (dividend + (divisor - 1))/divisor; 
    } 

Sin verificación de aquí (desbordamiento, DivideByZero, etc), no dude en añadir si lo desea. Por cierto, para aquellos preocupados por la sobrecarga de invocación de métodos, funciones sencillas como esta podrían ser delineadas por el compilador de todos modos, así que no creo que sea por eso. Aclamaciones.

P.S. es posible que también le resulte útil tener esto en cuenta (obtiene el resto):

int remainder; 
    int result = Math.DivRem(dividend, divisor, out remainder);