obtener - como separar la parte entera y decimal de un numero en c#

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

Question

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

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

Answer 1

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

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

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

Answer 2

En necesidad de 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, DivideByZero , etc.), siéntase libre de agregar si lo desea. Por cierto, para aquellos preocupados por la sobrecarga de invocación de métodos, el compilador de todas formas podría incluir funciones simples como esta, por lo que no creo que eso sea lo que nos preocupa. Aclamaciones.

PD: puede que también le resulte útil estar consciente de esto (obtiene el resto):

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

Answer 3

Encontró una solución elegante:

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

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

Answer 4

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

Answer 5

La conversión a punto flotante y viceversa parece una gran pérdida de tiempo en el nivel de la 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 el recordsPerPage 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 usó 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 es demasiado escribir:

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

Esto es todo una línea, y solo obtiene los datos una vez:

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

Answer 6

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

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

Si los records son long , el error permanece. La solución de módulo no tiene el error.

Answer 7

Lo siguiente debería redondearse mejor que las soluciones anteriores, pero a expensas del rendimiento (debido al cálculo de punto flotante de 0.5 * rctDenominador):

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 8

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

Answer 9

Para C #, la solución es convertir los valores en 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 ().

Answer 10

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), entonces 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 de enteros serán más eficientes que cualquiera de las soluciones de punto flotante.

Answer 11

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

Answer 12

Tenía una necesidad similar donde necesitaba convertir minutos en horas y 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

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

Answer 14

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 r es cero o negativo, - 1 si r es positivo. Entonces restarlo de q tiene el efecto de agregar 1 si los records % recordsPerPage > 0 .

Answer 15

Yo hago lo siguiente, maneja cualquier desbordamiento:

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

Y usa 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 la página actual (no se solicitó, pero podría ser útil):

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