Comment arrondir le résultat d'une division entière?

Je pense notamment à la façon d'afficher les contrôles de pagination, lors de l'utilisation d'un langage tel que C # ou Java.

Si j'ai x éléments que je veux afficher en morceaux de y par page, combien de pages seront nécessaires?

Trouvé une solution élégante:

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

Source: Conversion de nombres, Roland Backhouse, 2001

La conversion en virgule flottante et en arrière semble être une énorme perte de temps au niveau du processeur.

La solution d'Ian Nelson:

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

Peut être simplifié pour:

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

AFAICS, cela n'a pas le bogue de débordement que Brandon DuRette a souligné, et parce qu'il ne l'utilise qu'une seule fois, vous n'avez pas besoin de stocker le recordsPerPage spécialement s'il provient d'une fonction coûteuse pour récupérer la valeur d'un fichier de configuration ou quelque chose.

C'est à dire que cela pourrait être inefficace, si config.fetch_value a utilisé une recherche de base de données ou quelque chose:

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

Cela crée une variable dont vous n'avez pas vraiment besoin, qui a probablement des implications de mémoire (mineures) et est tout simplement trop de frappe:

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

Il s'agit d'une seule ligne et ne récupère les données qu'une seule fois:

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

Pour C #, la solution consiste à convertir les valeurs en double (comme Math.Ceiling prend un double):

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

En java, vous devriez faire de même avec Math.ceil ().

Cela devrait vous donner ce que vous voulez. Vous voudrez certainement x éléments divisés par y éléments par page, le problème est lorsque des nombres inégaux apparaissent, donc s'il y a une page partielle, nous voulons également ajouter une page.

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 solution mathématique d'entier fournie par Ian est intéressante, mais souffre d'un bogue de dépassement d'entier. En supposant que les variables sont toutes int, la solution pourrait être réécrite pour utiliser les longmathématiques et éviter le bogue:

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

Si recordsc'est un long, le bogue persiste. La solution de module n'a pas le bogue.

Une variante de la réponse de Nick Berardi qui évite une branche:

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

Remarque: se (-r >> (Integer.SIZE - 1))compose du bit de signe de r, répété 32 fois (grâce à l'extension de signe de l' >>opérateur.) Il est évalué à 0 si rest nul ou négatif, -1 si rest positif. La soustraire qa donc pour effet d'ajouter 1 si records % recordsPerPage > 0.

Pour les enregistrements == 0, la solution de rjmunro donne 1. La solution correcte est 0. Cela dit, si vous savez que records> 0 (et je suis sûr que nous avons tous supposé recordsPerPage> 0), alors la solution rjmunro donne des résultats corrects et n'a aucun des problèmes de débordement.

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

Toutes les solutions mathématiques entières vont être plus efficaces que toutes les solutions à virgule flottante.

Besoin d'une méthode d'extension:

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

Aucun contrôle ici (débordement, DivideByZero etc.), n'hésitez pas à ajouter si vous le souhaitez. Soit dit en passant, pour ceux qui s'inquiètent de la surcharge de l'appel de méthode, des fonctions simples comme celle-ci peuvent de toute façon être intégrées par le compilateur, donc je ne pense pas que ce soit le cas. À votre santé.

PS, vous trouverez peut-être utile de le savoir également (il obtient le reste):

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

Une autre alternative consiste à utiliser la fonction mod () (ou '%'). S'il y a un reste non nul, incrémentez le résultat entier de la division.

Je fais ce qui suit, gère tous les débordements:

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

Et utilisez cette extension pour s'il y a 0 résultat:

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

Aussi, pour le numéro de page actuel (n'a pas été demandé mais pourrait être utile):

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

Alternative pour supprimer la ramification lors du test de zéro:

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

Je ne sais pas si cela fonctionnera en C #, devrait le faire en C / C ++.

Une méthode générique, dont vous pouvez parcourir le résultat peut être intéressante:

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

J'avais un besoin similaire où j'avais besoin de convertir des minutes en heures et minutes. Ce que j'ai utilisé était:

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

Les éléments suivants devraient mieux arrondir que les solutions ci-dessus, mais au détriment des performances (en raison du calcul en virgule flottante 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;
}

Vous voudrez faire une division en virgule flottante, puis utiliser la fonction plafond, pour arrondir la valeur à l'entier suivant.