Jak mogę zapewnić, że podział liczb całkowitych jest zawsze zaokrąglany w górę?

Ostateczna odpowiedź oparta na int

Dla liczby całkowitej podpisanej:

int div = a / b;
if (((a ^ b) >= 0) && (a % b != 0))
    div++;

Dla liczb całkowitych niepodpisanych:

int div = a / b;
if (a % b != 0)
    div++;

Uzasadnienie dla tej odpowiedzi

Liczba całkowita '/ ' jest zdefiniowana jako Zaokrąglanie w kierunku zera (7.7.2 specyfikacji), ale chcemy zaokrąglać. Oznacza to, że odpowiedzi negatywne są już prawidłowo zaokrąglane, ale odpowiedzi pozytywne muszą zostać skorygowane.

Niezerowe pozytywne odpowiedzi są łatwe do wykrycia, ale odpowiedź zero jest trochę trudniejsza, ponieważ może być zaokrągleniem w górę wartości ujemnej lub zaokrągleniem w dół wartości dodatniej.

Najbezpieczniej jest wykryć, kiedy odpowiedź powinna być pozytywna, sprawdzając, czy znaki obu liczb całkowitych są identyczne. Operator XOR Integer '^ ' na obu wartościach spowoduje, że znak 0 będzie w takim przypadku bitem, co oznacza wynik nieujemny, więc sprawdzenie (a ^ b) >= 0 określa, że wynik powinien być dodatni przed zaokrągleniem. Zauważ również, że dla niepodpisanych liczb całkowitych każda odpowiedź jest oczywiście pozytywny, więc ten czek można pominąć.

Pozostaje tylko sprawdzenie, czy doszło do zaokrąglenia, dla którego a % b != 0 wykona zadanie.

Wyciągnięte wnioski

Arytmetyka (liczba całkowita lub inna) nie jest tak prosta, jak się wydaje. Uważne myślenie wymagane przez cały czas.

Ponadto, chociaż moja ostateczna odpowiedź nie jest być może tak "prosta" lub "oczywista", a może nawet "szybka" jak odpowiedzi zmiennoprzecinkowe, ma jedną bardzo silną jakość odkupienia dla mnie; teraz rozumowałem przez odpowiedź, więc jestem rzeczywiście pewien, że jest poprawna (dopóki ktoś mądrzejszy nie powie mi inaczej- {40]}furtywne spojrzenie w kierunku Erica {41]}-).

Aby uzyskać to samo poczucie pewności co do odpowiedzi zmiennoprzecinkowej, musiałbym zrobić więcej (i być może bardziej skomplikowane) myśląc o tym, czy istnieją jakiekolwiek warunki, w których precyzja zmiennoprzecinkowa może stać na drodze, i czy Math.Ceiling być może robi coś niepożądanego na "tylko właściwym" wejścia.

The path traveled

Zastąp (Uwaga zamieniłem drugie myInt1 na myInt2, zakładając, że o to ci chodziło):

(int)Math.Ceiling((double)myInt1 / myInt2)

Z:

(myInt1 - 1 + myInt2) / myInt2

Jedynym zastrzeżeniem jest to, że jeśli myInt1 - 1 + myInt2 przepełnia Typ integer, którego używasz, możesz nie uzyskać tego, czego oczekujesz.

dlatego jest to błędne: -1000000 i 3999 powinno dać -250, to daje -249

EDIT:
Biorąc pod uwagę, że ma ten sam błąd co druga liczba całkowita rozwiązanie dla ujemnych wartości myInt1, może być łatwiej zrobić coś takiego:

int rem;
int div = Math.DivRem(myInt1, myInt2, out rem);
if (rem > 0)
  div++;

To powinno dać poprawny wynik w div używając tylko operacji integer.

powód jest zły : -1 i -5 powinno dać 1, to daje 0

EDIT (jeszcze raz z feelingiem):
Operator podziału zaokrągla się do zera; dla wyników ujemnych jest to dokładnie poprawne, więc tylko wyniki nieujemne wymagają korekty. Również biorąc pod uwagę, że DivRem po prostu robi / i % w każdym razie pomińmy wywołanie (i zacznijmy od łatwego porównania, aby uniknąć obliczeń modulo, gdy nie jest to potrzebne):

int div = myInt1 / myInt2;
if ((div >= 0) && (myInt1 % myInt2 != 0))
    div++;

powód jest zły : -1 i 5 powinno dać 0, to daje 1

(w mojej obronie przed ostatnią próbą nigdy nie powinienem był próbować uzasadnionej odpowiedzi, gdy mój umysł mówił mi, że spóźniłem się 2 godziny na sen)

Wszystkie odpowiedzi tutaj do tej pory wydają się dość skomplikowane.

W C # i Javie, aby uzyskać dodatnią dywidendę i dzielnik, wystarczy wykonać:

( dividend + divisor - 1 ) / divisor 

Źródło: Konwersja Liczb, Roland Backhouse, 2001

Doskonała szansa na użycie metody rozszerzenia:

public static class Int32Methods
{
    public static int DivideByAndRoundUp(this int number, int divideBy)
    {                        
        return (int)Math.Ceiling((float)number / (float)divideBy);
    }
}

To sprawia, że Twój kod też jest czytelny:

int result = myInt.DivideByAndRoundUp(4);

Możesz napisać pomocnika.

static int DivideRoundUp(int p1, int p2) {
  return (int)Math.Ceiling((double)p1 / p2);
}

Przydałoby się coś takiego jak poniżej.

a / b + ((Math.Sign(a) * Math.Sign(b) > 0) && (a % b != 0)) ? 1 : 0)

Problem ze wszystkimi rozwiązaniami tutaj jest albo to, że potrzebują obsady, albo mają problem liczbowy. Rzucanie na float lub double jest zawsze opcją, ale możemy zrobić lepiej.

Gdy używasz kodu odpowiedzi z @ jerryjvl

int div = myInt1 / myInt2;
if ((div >= 0) && (myInt1 % myInt2 != 0))
    div++;

Występuje błąd zaokrąglania. 1 / 5 by się zebrało, Bo 1% 5 != 0. Ale jest to złe, ponieważ zaokrąglenie nastąpi tylko wtedy, gdy zastąpisz 1 na 3, więc wynik wynosi 0,6. Musimy znaleźć sposób, aby zaokrąglić, gdy obliczenia dają nas wartość większa lub równa 0,5. Wynik operatora modulo w górnym przykładzie ma zakres od 0 do 2-1. Zaokrąglenie nastąpi tylko wtedy, gdy pozostała część jest większa niż 50% dzielnika. Więc skorygowany kod wygląda tak:

int div = myInt1 / myInt2;
if (myInt1 % myInt2 >= myInt2 / 2)
    div++;

Oczywiście mamy problem z zaokrągleniem w myInt2 / 2, ale ten wynik da Ci lepsze rozwiązanie niż inne na tej stronie.