Java: Integer division de la tour

Je suis en train d'écrire un programme qui demande à l'utilisateur d'entrer le montant total de la étages dans un hôtel, le nombre de chambres à chaque étage, et le nombre de occupé chambres. À la fin, il doit afficher le nombre total de chambres, nombre total de chambres occupées et le pourcentage de chambres occupées. Je vais avoir des problèmes avec l'affichage du pourcentage de chambres occupées. Je suis l'aide de tous les int des nombres.

C'est l'équation que j'ai mis:

roomsOccPercentage = (totalRoomsOccupied * 100) / totalRooms ;

Quand je soumettre le programme à mon professeur de Java runner il affiche: 

65 % of the Rooms are occupied.

Mais l'un de mes professeur fourni en sortie la réponse de 66% au lieu de sorte que le programme n'accepte pas mon fichier.

Personne ne sait ce que je fais mal? Est-il un DecimalFormat erreur?

Edit: Voici le code entier

import java.util.Scanner; 
import java.text.DecimalFormat;
public class hw7_1 {
public static void main(String[]args) {
Scanner keyboard = new Scanner(System.in);
DecimalFormat formatter = new DecimalFormat("#0");
int totalFloors;
int totalRooms = 0;
int numFloors;
int numRooms;
int roomsOccupied;
int totalRoomsOccupied = 0;
int roomsOccPercentage = 0;
//prompting users to input # of floors, no inputs below 1 floor
do {
System.out.println("Please enter the number of floors in the hotel: ");
numFloors = keyboard.nextInt();
if (numFloors < 1) {
System.out.println("You have entered an invalid number of floors. ");
}
}
while (numFloors < 1);
//for loops on how many rooms on each hotel floors
for ( int Floors = 1; Floors <= numFloors; Floors++) {
if (Floors == 13 ) {
continue;
}
do {
System.out.println("Please enter the number of rooms on floor #: " + Floors );
numRooms = keyboard.nextInt();
if (numRooms < 10) {
System.out.println("You have entered an invalid number of rooms. ");
}
} while (numRooms < 10);
System.out.println("Please enter the number of occupied rooms on floor #: " + Floors);
roomsOccupied = keyboard.nextInt();
totalRooms = totalRooms + numRooms;
totalRoomsOccupied = totalRoomsOccupied + roomsOccupied;
roomsOccPercentage = (totalRoomsOccupied * 100) / totalRooms ;
}
System.out.println("\nThe hotel has a total of " + totalRooms + " rooms.");
System.out.println(totalRoomsOccupied + " of the rooms are occupied.");
System.out.println(formatter.format(roomsOccPercentage) + "% of the rooms are occupied.");
}
}
Il pourrait très probablement être le cas. Vous pouvez essayer de jeter un 1 des opérandes de sorte qu'il n'est plus une division entière. roomsOccPercentage = ((float)totalRoomsOccupied * 100) / totalRooms;
commentaire devrait résoudre votre problème.
Le truc, c'est que nous n'avons pas à apprendre cette méthode dans la classe encore. Est-il plus du débutant?
Vous n'avez pas utilisé le double ou float type de données?
nous avons. Je voulais dire nous n'avons généralement pas utilisé l'opérateur de coulée sur nos calculs encore. Je ne sais à partir de la lecture sur la programmation. Les Mathématiques.ceil semblait avoir travaillé, mais QUE nous n'avons pas allé plus en classe encore à tous. Merci!!!!

OriginalL'auteur Sam Young | 2013-11-18

  1. 6

    Vous avez besoin pour faire de votre roomsOccPercentage une double première.

    double roomsOccPercentage = 0.0;

    et puis, exprimés soit des opérandes afin d'éviter une division entière.

    roomsOccPercentage = (totalRoomsOccupied * 100.0) / totalRooms;

    Vous pouvez soit utiliser un cast explicite comme (double)totalRoomsOccupied ou tout simplement faire 100 comme 100.0 qui est un nombre à virgule flottante, ce qui rend la division de trop, un flottant et non pas une division entière.

    OriginalL'auteur SudoRahul

  2. 17

    Noter que java joue avec sa propre règle, Vous devez leur obéir. Décidez si vous voulez de plancher ou de plafond de la suite, Suivre l'exemple donné ci-dessous.

    double roomsOccPercentage;
roomsOccPercentage =Math.ceil((double)5/4); //will be 2
roomsOccPercentage =Math.ceil(5/4); //will be 1
roomsOccPercentage =Math.floor((double)5/4); //will be 1

    J'espère que vous pouvez maintenant trouver java intéressant

    je vous remercie. Oui j'ai cherché sur cette méthode. C'est juste que ma classe n'est pas allé plus encore donc je suis très réticent à l'utiliser. Je suis juste essayer de comprendre si j'ai oublié quelque chose d'autre.

    OriginalL'auteur surya

  3. 1

    a /b + a % b /(b/2) ??

    1 diviser par 3, il devrait être 0

    1 /3 + 1 % 3 /(3/2) = 0 + 1 /1 = 1 qui n'est PAS 0

    Je recommande ce: 

    (a + a % b) / b
    Si a = 4, b = 3, (a + a % b) / b = 1

    OriginalL'auteur user5119722

  4. 0

    Il n'y a rien qui s'appelle arrondi au nombre entier divisant car il va prendre la partie entière uniquement à diviser le résultat. utilisation double de la valeur pour vos calculs et l'utilisation Math.round().

    OriginalL'auteur Ruchira Gayan Ranaweera

  5. 0

    Heres un moyen simple de round up:

    double dnum; = 47.213; //make this your value to round up
int inum; //null for now, will be your rounded up integer
if(dnum > (int)num)
inum = (int)(num + 1.0);
else
inum = (int)num;

    Si ce n'est pas déjà un entier, il ajoute un, et il jette vers le bas. Si c'est un entier, il le lance comme un entier.

    OriginalL'auteur abrahimladha

  6. 0

    Donné a/b, si vous le souhaitez arrondir à l'entier le plus proche, vous avez besoin pour ajouter 1 si le reste est la moitié ou plus de la moitié de b, donc:

    a / b + a % b / (b/2)

    Fera l'affaire.

    downvote: démenti dans @user5119722 réponse
    peut-être a / b + (a % b) * 2 / b, de cette façon, vous ne perdez pas de précision dans la division entière par 2

    OriginalL'auteur Matthew Mitchell

  7. 0

    Si vous préférez aller en double pour faire une division d'entier qui arrondit, vous pouvez le faire. Si vous préférez ne pas, vous n'avez pas besoin, c'est juste une très légère peu difficile:

    private static int divideRoundUp(int denominator, int divisor) {
return (denominator + divisor - 1) / divisor;
}

    Essayons:

        System.out.println(divideRoundUp(196, 3));
System.out.println(divideRoundUp(197, 3));
System.out.println(divideRoundUp(118, 2));
System.out.println(divideRoundUp(119, 2));

    Cette affiche:

    66
66
59
60

    Si il n'y a pas de reste, comme dans 118 /2, vous obtenez le résultat normal. Dans d'autres cas, le résultat est arrondi vers le haut. Comment gérer les négatifs dénominateur et/ou diviseur est laissé comme exercice pour le lecteur.

    À l'école, beaucoup d'entre nous ont appris que 65.5 et plus doit être arrondi à 66, où, comme les numéros entre 65.0 et de 65,5 doit être arrondi à la baisse à 65 ans. Si vous voulez cela, la méthode est un peu différente:

    private static int divideRoundHalfUp(int denominator, int divisor) {
return (denominator + divisor / 2) / divisor;
}

    Démonstration:

        System.out.println(divideRoundHalfUp(196, 3));
System.out.println(divideRoundHalfUp(197, 3));
System.out.println(divideRoundHalfUp(118, 2));
System.out.println(divideRoundHalfUp(119, 2));

    De sortie:

    65
66
59
60

    OriginalL'auteur Ole V.V.