Como arredondar o resultado da divisão inteira?

Estou pensando em particular em como exibir controles de paginação, ao usar uma linguagem como C # ou Java.

Se eu tiver x itens que quero exibir em pedaços de y por página, quantas páginas serão necessárias?

Encontrou uma solução elegante:

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

Fonte: Conversão de números, Roland Backhouse, 2001

Converter em ponto flutuante e vice-versa parece uma enorme perda de tempo no nível da CPU.

A solução de Ian Nelson:

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

Pode ser simplificado para:

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

AFAICS, isso não tem o bug de estouro que Brandon DuRette apontou e, como o usa apenas uma vez, você não precisa armazenar o recordsPerPage especialmente se for de uma função cara para buscar o valor de um arquivo de configuração ou alguma coisa.

Ou seja, isso pode ser ineficiente, se config.fetch_value usou uma pesquisa no banco de dados ou algo assim:

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

Isso cria uma variável que você realmente não precisa, que provavelmente tem implicações (menores) de memória e é muita digitação:

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

Isso é tudo em uma linha e somente busca os dados uma vez:

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

Para C #, a solução é converter os valores em um dobro (como Math.Ceiling recebe um dobro):

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

Em java, você deve fazer o mesmo com Math.ceil ().

Isso deve dar o que você deseja. Você definitivamente desejará x itens divididos por y itens por página, o problema é quando números desiguais aparecem, portanto, se houver uma página parcial, também queremos adicionar uma 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);

A solução matemática inteira fornecida por Ian é boa, mas sofre de um erro de estouro inteiro. Supondo que as variáveis ​​sejam todas int, a solução pode ser reescrita para usar a longmatemática e evitar o erro:

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

Se recordsfor um long, o bug permanece. A solução do módulo não possui o erro.

Uma variante da resposta de Nick Berardi que evita um ramo:

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

Nota: (-r >> (Integer.SIZE - 1))consiste no bit de sinal rrepetido 32 vezes (graças à extensão do sinal do >>operador.) Avalia como 0 se rfor zero ou negativo, -1 se rfor positivo. Portanto, subtraí-lo qtem o efeito de adicionar 1 se records % recordsPerPage > 0.

Para registros == 0, a solução de rjmunro fornece 1. A solução correta é 0. Dito isto, se você souber que registros> 0 (e tenho certeza de que todos assumimos recordsPerPage> 0), a solução rjmunro fornece resultados corretos e não possui nenhum dos problemas de estouro.

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

Todas as soluções matemáticas inteiras serão mais eficientes do que qualquer uma das soluções de ponto flutuante.

Na necessidade de um método de extensão:

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

Nenhuma verificação aqui (excesso, DivideByZeroetc), fique à vontade para adicionar se quiser. A propósito, para aqueles preocupados com a sobrecarga de chamada de método, funções simples como essa podem ser incorporadas pelo compilador de qualquer maneira, então não acho que seja esse o motivo. Felicidades.

PS: você pode achar útil também estar ciente disso (fica o restante):

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

Outra alternativa é usar a função mod () (ou '%'). Se houver um restante diferente de zero, aumente o resultado inteiro da divisão.

Eu faço o seguinte, lida com qualquer excesso:

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

E use esta extensão para se houver 0 resultado:

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

Além disso, para o número da página atual (não foi solicitado, mas pode ser útil):

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

Alternativa para remover ramificação no teste para zero:

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

Não tenho certeza se isso funcionará em C #, deve funcionar em C / C ++.

Um método genérico, cujo resultado você pode repetir pode ser interessante:

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

Eu tinha uma necessidade semelhante em que precisava converter Minutos em horas e minutos. O que eu usei foi:

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

O seguinte deve fazer o arredondamento melhor do que as soluções acima, mas à custa do desempenho (devido ao cálculo do ponto flutuante 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;
}

Você deseja fazer a divisão de ponto flutuante e, em seguida, usar a função de teto, para arredondar o valor para o próximo número inteiro.