Wie kann man das Ergebnis der Ganzzahldivision aufrunden?

Ich denke insbesondere darüber nach, wie Paginierungssteuerelemente angezeigt werden, wenn eine Sprache wie C # oder Java verwendet wird.

Wenn ich x Elemente habe, die in Blöcken von y pro Seite angezeigt werden sollen, wie viele Seiten werden benötigt?

Eine elegante Lösung gefunden:

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

Quelle: Number Conversion, Roland Backhouse, 2001

Die Konvertierung in Gleitkomma und zurück scheint auf CPU-Ebene eine enorme Zeitverschwendung zu sein.

Ian Nelsons Lösung:

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

Kann vereinfacht werden zu:

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

AFAICS, dies hat nicht den Überlauffehler, auf den Brandon DuRette hingewiesen hat, und da er nur einmal verwendet wird, müssen Sie die recordsPerPage nicht speziell speichern, wenn sie von einer teuren Funktion stammt, um den Wert aus einer Konfigurationsdatei oder abzurufen etwas.

Das heißt, dies könnte ineffizient sein, wenn config.fetch_value eine Datenbanksuche verwendet hat oder so:

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

Dadurch wird eine Variable erstellt, die Sie nicht wirklich benötigen. Dies hat wahrscheinlich (geringfügige) Auswirkungen auf den Speicher und ist einfach zu viel Eingabe:

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

Dies ist alles eine Zeile und ruft die Daten nur einmal ab:

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

Für C # besteht die Lösung darin, die Werte in ein Double umzuwandeln (da Math.Ceiling ein Double verwendet):

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

In Java sollten Sie dasselbe mit Math.ceil () tun.

Dies sollte Ihnen geben, was Sie wollen. Sie werden auf jeden Fall x Elemente geteilt durch y Elemente pro Seite wollen. Das Problem ist, wenn ungerade Zahlen auftauchen. Wenn es also eine Teilseite gibt, möchten wir auch eine Seite hinzufügen.

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

Die von Ian bereitgestellte ganzzahlige mathematische Lösung ist nett, leidet jedoch an einem ganzzahligen Überlauffehler. Unter der Annahme, dass alle Variablen vorhanden sind int, könnte die Lösung neu geschrieben werden, um longMathematik zu verwenden und den Fehler zu vermeiden:

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

Wenn a recordsist long, bleibt der Fehler bestehen. Die Modullösung hat den Fehler nicht.

Eine Variante von Nick Berardis Antwort , die einen Zweig vermeidet:

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

Hinweis: (-r >> (Integer.SIZE - 1))besteht aus dem Vorzeichenbit von r, das 32 Mal wiederholt wird (dank der Vorzeichenerweiterung des >>Operators). Dies rergibt 0, wenn es Null oder negativ ist, -1, wenn res positiv ist. Das Subtrahieren von qbewirkt also, dass 1 if addiert wird records % recordsPerPage > 0.

Für Datensätze == 0 ergibt die Lösung von rjmunro 1. Die richtige Lösung ist 0. Wenn Sie jedoch wissen, dass Datensätze> 0 sind (und ich bin sicher, dass wir alle recordsPerPage> 0 angenommen haben), liefert die Lösung von rjmunro korrekte Ergebnisse und hat keine der Überlaufprobleme.

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

Alle ganzzahligen mathematischen Lösungen sind effizienter als alle Gleitkomma-Lösungen.

Benötigen Sie eine Erweiterungsmethode:

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

Keine Kontrollen hier (Überlauf, DivideByZero usw.). Wenn Sie möchten, können Sie diese hinzufügen. Übrigens, für diejenigen, die sich Sorgen über den Aufwand für Methodenaufrufe machen, könnten einfache Funktionen wie diese sowieso vom Compiler eingebunden werden, daher denke ich nicht, dass dies von Belang ist. Prost.

PS Vielleicht ist es auch nützlich, sich dessen bewusst zu sein (der Rest wird erhalten):

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

Eine andere Alternative ist die Verwendung der Funktion mod () (oder '%'). Wenn der Rest ungleich Null ist, erhöhen Sie das ganzzahlige Ergebnis der Division.

Ich mache folgendes, behandle eventuelle Überläufe:

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

Verwenden Sie diese Erweiterung, wenn 0 Ergebnisse vorliegen:

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

Auch für die aktuelle Seitenzahl (wurde nicht gefragt, könnte aber nützlich sein):

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

Alternative zum Entfernen der Verzweigung beim Testen auf Null:

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

Nicht sicher, ob dies in C # funktioniert, sollte in C / C ++ funktionieren.

Eine generische Methode, über deren Ergebnis Sie iterieren können, kann von Interesse sein:

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

Ich hatte ein ähnliches Bedürfnis, bei dem ich Minuten in Stunden und Minuten umrechnen musste. Was ich benutzt habe war:

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

Folgendes sollte besser runden als die oben genannten Lösungen, jedoch auf Kosten der Leistung (aufgrund der Gleitkommaberechnung von 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;
}

Sie möchten eine Gleitkommadivision durchführen und dann die Deckenfunktion verwenden, um den Wert auf die nächste Ganzzahl aufzurunden.