Comment obtenir la limite supérieure d'un nombre en C?Si je divise 3 par 2, je veux que la réponse soit 2 (c.-à-d. 1,5 arrondi à 2)
Si je divise 3 par 2, je veux que la réponse soit 2 (c.-à-d. 1,5 arrondie à 2).
Comment obtenir la limite supérieure d'un nombre en C?Si je divise 3 par 2, je veux que la réponse soit 2 (c.-à-d. 1,5 arrondi à 2)
Si je divise 3 par 2, je veux que la réponse soit 2 (c.-à-d. 1,5 arrondie à 2).
#include <math.h>
ceil(3.0/2); //2.0
Notez que les un opérandes doivent être double (ou flotter) parce que vous donne 3/2 1
Êtes-vous sûr '2/3.0' ==' 2.0'? –
Désolé ma mauvaise, merci pour le commentaire: P – Lombo
int x= ceil((float)3/2);
Pour arrondir sans utiliser les fonctions, il suffit d'ajouter la moitié du diviseur avant de vous diviser. si le diviseur est une constante, le compilateur optimise bien le code.
int number = 3;
int divisor = 2;
int result = (number + (divisor+1)/2)/divisor;
Si vous êtes simplement intéressé à la division par 2, puis juste prendre (n + 1)/2 pour le maintenir en mathématiques entier. Par exemple (3 + 1)/2 donne 2. Pour un plus grand nombre x, utilisez x - 1. Par exemple, (3 + 7)/8 = 1, pour 3 divisé par 8.
Pour le cas général , vous recherchez la fonction de plafond - ceil. Une recherche rapide sur Google pour « Ceil math C » a cette page en haut des résultats: http://www.elook.org/programming/c/ceil.html
int i = 3;
int j = 2;
int k = (i + j - 1)/j;
int x = 3.0/2 + 0.5;
OP demande la fonction de plafond, pas la fonction ronde. J'ai aussi pensé à cela jusqu'à ce que je me rende compte qu'il * veut toujours * le plus grand nombre suivant quel que soit l'indice. –
Ah. Ce n'était pas tout à fait clair pour moi. Il utilise le mot «arrondi à ...»: s – wilhelmtell
(Si cela est considéré comme fil nécromancie, vous êtes priés et je vais supprimer cette)
Un moyen rapide de renvoyer un quotient arrondi vers le haut est d'ajouter le diviseur, moins un, au dividende et de le diviser.
int ceil_div(int dividend, int divisor) {
return (dividend + divisor - 1)/divisor;
}
ou bien,
int ceil_div(int dividend, int divisor) {
return (dividend - 1)/divisor + 1;
}
Par voie de conséquence, vous travaillerez en soustrayant 1 de 3, en divisant par 2, et en ajoutant 1.
Je vais essayer de vous expliquer pourquoi cela fonctionne . Si dividende et diviseur étaient tous les deux flotteurs, puis l'équivalent entier tronqué de (dividende/diviseur) serait égal au plafond du quotient si diviseur divise parfaitement dividende, ou une moins si elle ne divise pas parfaitement le dividende. En soustrayant 1, nous garantissons que le nouveau dividende, dividende - 1, lorsqu'il est divisé par diviseur, retournera toujours une valeur inférieure au plafond du quotient en virgule flottante. Il ne reste plus qu'à ajouter 1 à ce quotient, ce qui, accessoirement, est le diviseur floor ((float) dividend/(float)).
Une approche plus facile lorsqu'il s'agit de nombres positifs * dans les langages qui implémentent la division entière par arithmétique solennelle ou euclidienne * est d'annuler le dividende et le résultat (ie arrondi x/y est - ((- x) // y) Malheureusement, beaucoup de langages implémentent la division d'entiers tronqués-vers-zéro plutôt moins utile, et cette technique ne fonctionnera pas avec ceux-ci. – supercat
Essentiellement une copie de SO 2422712 (http://stackoverflow.com/questions/2422712/c-rounding-number-up). Accordé cette question mentionne le point flottant, mais les réponses jusqu'ici ici font aussi. –