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

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

Si tengo x elementos que quiero mostrar en fragmentos de y por página, ¿cuántas páginas se necesitarán?

Encontró una solución elegante:

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

Fuente: Conversión de números, Roland Backhouse, 2001

La conversión a coma flotante y viceversa parece una gran pérdida de tiempo a nivel de CPU.

La solución de Ian Nelson:

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

Se puede simplificar para:

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

AFAICS, esto no tiene el error de desbordamiento que Brandon DuRette señaló, y debido a que solo lo usa una vez, no necesita almacenar los registrosPerPage especialmente si proviene de una función costosa para obtener el valor de un archivo de configuración o alguna cosa.

Es decir, esto podría ser ineficiente, si config.fetch_value utiliza una búsqueda en la base de datos o algo así:

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

Esto crea una variable que realmente no necesita, que probablemente tenga implicaciones (menores) de memoria y simplemente escriba demasiado:

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

Esta es toda una línea y solo obtiene los datos una vez:

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

Para C #, la solución es convertir los valores a un doble (como Math.Ceiling toma un doble):

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

En java deberías hacer lo mismo con Math.ceil ().

Esto debería darte lo que quieres. Definitivamente querrá x elementos divididos por y elementos 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);

La solución matemática entera que proporcionó Ian es buena, pero sufre un error de desbordamiento de enteros. Suponiendo que las variables son todas int, la solución podría reescribirse para usar las longmatemáticas y evitar el error:

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

Si recordses a long, el error permanece. La solución de módulo no tiene el error.

Una variante de la respuesta de Nick Berardi que evita 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 res cero o negativo, -1 si res positivo. Entonces restarlo qtiene el efecto de sumar 1 si records % recordsPerPage > 0.

Para los registros == 0, la solución de rjmunro da 1. La solución correcta es 0. Dicho esto, si sabe que los registros> 0 (y estoy seguro de que todos hemos asumido recordsPerPage> 0), la solución de rjmunro da los 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

Todas las soluciones matemáticas enteras serán más eficientes que cualquiera de las soluciones de coma flotante.

Necesita un método de extensión:

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

No hay controles aquí (desbordamiento, DivideByZeroetc.), siéntase libre de agregar si lo desea. Por cierto, para aquellos preocupados por la sobrecarga de invocación de métodos, el compilador puede incluir funciones simples como esta, de modo que no creo que sea de lo que se trate. Salud.

PD: también puede ser útil tener en cuenta esto (obtiene el resto):

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

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

Hago lo siguiente, maneja cualquier desbordamiento:

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

Y use esta extensión si hay 0 resultados:

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

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

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

Alternativa para eliminar la ramificación en la prueba de cero:

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

No estoy seguro de si esto funcionará en C #, debería hacerlo en C / C ++.

Un método genérico, cuyo resultado puede iterar puede ser de 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;
}

Tenía una necesidad similar donde necesitaba convertir minutos a horas y minutos. Lo que usé 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);

Lo siguiente debería redondear mejor que las soluciones anteriores, pero a expensas del 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;
}

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