Come arrotondare il risultato della divisione intera?

Sto pensando in particolare a come visualizzare i controlli di impaginazione, quando si utilizza un linguaggio come C # o Java.

Se ho x elementi che voglio visualizzare in blocchi di y per pagina, quante pagine saranno necessarie?

Trovato una soluzione elegante:

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

Fonte: conversione numerica, Roland Backhouse, 2001

La conversione in virgola mobile e ritorno sembra una grande perdita di tempo a livello di CPU.

La soluzione di Ian Nelson:

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

Può essere semplificato per:

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

AFAICS, questo non ha il bug di overflow che Brandon DuRette ha sottolineato e poiché lo utilizza solo una volta, non è necessario archiviare recordsPerPage specialmente se proviene da una funzione costosa per recuperare il valore da un file di configurazione o qualcosa.

Vale a dire questo potrebbe essere inefficiente, se config.fetch_value utilizzava una ricerca nel database o qualcosa del genere:

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

Questo crea una variabile di cui non hai davvero bisogno, che probabilmente ha implicazioni di memoria (minori) ed è semplicemente troppa battitura:

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

Questa è tutta una riga e recupera i dati una sola volta:

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

Per C # la soluzione è quella di lanciare i valori in un doppio (come Math.Ceiling prende un doppio):

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

In java dovresti fare lo stesso con Math.ceil ().

Questo dovrebbe darti quello che vuoi. Avrai sicuramente bisogno di x elementi divisi per y articoli per pagina, il problema è quando si presentano numeri irregolari, quindi se c'è una pagina parziale vogliamo anche aggiungere una pagina.

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 soluzione matematica integra fornita da Ian è buona, ma soffre di un bug di overflow dell'intero. Supponendo che le variabili siano tutte int, la soluzione potrebbe essere riscritta per usare la longmatematica ed evitare il bug:

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

Se recordsè un long, il bug rimane. La soluzione del modulo non ha il bug.

Una variante della risposta di Nick Berardi che evita un ramo:

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

Nota: è (-r >> (Integer.SIZE - 1))costituito dal bit di segno di r, ripetuto 32 volte (grazie all'estensione di segno >>dell'operatore). rViene valutato 0 se è zero o negativo, -1 se rè positivo. Quindi sottraendolo da qha l'effetto di aggiungere 1 se records % recordsPerPage > 0.

Per records == 0, la soluzione di rjmunro fornisce 1. La soluzione corretta è 0. Detto questo, se sai che records> 0 (e sono sicuro che tutti abbiamo assunto recordsPerPage> 0), allora la soluzione rjmunro fornisce risultati corretti e non presenta alcun problema di overflow.

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

Tutte le soluzioni matematiche intere saranno più efficienti di qualsiasi soluzione a virgola mobile.

Necessario un metodo di estensione:

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

Nessun controllo qui (overflow, DivideByZeroecc.), Sentiti libero di aggiungere se vuoi. A proposito, per coloro che sono preoccupati per il sovraccarico di invocazione del metodo, funzioni semplici come questa potrebbero essere delineate dal compilatore, quindi non credo che sia questo il motivo. Saluti.

PS potresti trovare utile essere a conoscenza anche di questo (ottiene il resto):

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

Un'altra alternativa è usare la funzione mod () (o '%'). Se è presente un resto diverso da zero, incrementare il risultato intero della divisione.

Faccio quanto segue, gestisce eventuali overflow:

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

E usa questa estensione per se ci sono 0 risultati:

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

Inoltre, per il numero di pagina corrente (non è stato chiesto ma potrebbe essere utile):

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

Alternativa per rimuovere la ramificazione nei test per zero:

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

Non sono sicuro che funzionerà in C #, dovrebbe farlo in C / C ++.

Un metodo generico, di cui è possibile ripetere il risultato può essere 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;
}

Avevo un bisogno simile in cui dovevo convertire i minuti in ore e minuti. Quello che ho usato è stato:

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

Quanto segue dovrebbe arrotondare meglio delle soluzioni di cui sopra, ma a scapito delle prestazioni (a causa del calcolo in virgola mobile di 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;
}

Ti consigliamo di eseguire la divisione in virgola mobile, quindi utilizzare la funzione soffitto, per arrotondare il valore al numero intero successivo.