web-dev-qa-db-fra.com

Java Reste de la division entière?

Je cherchais autour de ce sujet mais je ne comprends toujours pas, si quelqu'un peut élaborer je serais très reconnaissant.

Ma tâche consiste à diviser deux variables en une division entière avec un reste .. Le problème est que je n'ai aucune idée de ce qu'est un reste, pour l'instant j'ai fait quelque chose comme ça, c'est ce que j'ai trouvé en cherchant sur Internet:

int a;
int b;
int remainder = Math.Pow(a,2) % b;

System.out.println("a^2 / b = " + Math.Pow(a,2) / b);
System.out.println("remainder = " + remainder);

si je par exemple définir (a = 43) et (b = 67)

Ensuite, je vais obtenir cette retaille:

a^2 / b = 27
remainder = 40

Maintenant que je n'ai aucune idée de ce que le reste est (ce n'est qu'une suggestion sur Internet), je n'ai aucune idée si c'est la bonne réponse ..?

Merci pour toute aide,

Sincères amitiés

javamathdivide
7
DisasterCoder

Si vous recherchez l'opération modulo mathématique que vous pourriez utiliser

int x = -22;
int y = 24;
System.out.println(Math.floorMod(x, y));

Si vous n'êtes pas intéressé par le modulo mathématique (juste le reste), vous pouvez utiliser

int x = -22;
int y = 24;
System.out.println(x%y);
15
SomeJavaGuy
    public static void main(String[] args) {
        int dividend = 139, divisor = 7;

        int quotient = dividend / divisor;
        int remainder = dividend % divisor;

        System.out.println("The Quotient is = " + quotient);
        System.out.println("The Remainder is = " + remainder);
    }

Sortie:

Le quotient est = 19

Le reste est = 6

3
Taras Melnyk

Oui le % L'opérateur retournera le reste de la division Integer.

Pour en savoir plus sur le reste de la division Integer, consultez Wikipedia :

Si a et d sont des entiers, avec d différent de zéro, il peut être prouvé qu'il existe des entiers uniques q et r, tels que a = qd + r et 0 ≤ r <| d |. Le nombre q est appelé le quotient, tandis que r est appelé le reste.

1
João Neves

L'opérateur % renverra le reste de la division Integer.

Quels modules font réellement sous le capot?

Les modules ont tendance à supprimer cycles du nombre, jusqu'à ce qu'il atteigne un nombre positif inférieur au numéro du cycle que nous appelons modulo OR un nombre négatif que nous appelons un reminder.

Cependant, l'utilisation de l'opérateur % est coûteuse en temps.

Pour éviter d'utiliser % tout en obtenant le même résultat, nous pouvons utiliser ce qui suit:

  • While(a >= n) a -= n; (lorsque a est un nombre positif)

  • While(a < 0) a += n; (lorsque a est un nombre négatif)

  • a = n*q + r cela signifie r = a - n*q Alors que q is the integer division of a/n ce qui signifie a%n == a - n * Math.toIntExact(a/n) Ce qui est suffisant lorsque a est un nombre positif.

  • Alors que a est un nombre négatif, nous pouvons utiliser (a%n + n) % n qui vous donnera le module.

Scénario de cas sur l'horloge:

s'il est maintenant 9 heures, quelle heure après 4 heures => 9 + 4 = 13h => 13% 12 = 1 while 12 is the cycle number in the clock

Et si nous devons calculer le temps avant 24 heures (Hier) à partir de maintenant qui est 9 O'clock, alors: 24(2*12)=> Hier signifie 9-24 = -15h Alors que la bonne réponse est 9, pour résoudre ce problème, nous utiliserons (a%n + n) % n While a%n == (a - n * Math.toIntExact(a/n)) puis -15 - 12 * Math.toIntExact(-15/12) = -3 => -3 + 12 = 9 => 9%12 => 9 - 12 * Math.toIntExact(9/12) = 9 Quelle est la bonne réponse.

Voici le code du scénario d'horloge:

public static void main(String args[]){
    Scanner scanner = new Scanner(System.in);
    int a = scanner.nextInt(); // a = -15
    int n = scanner.nextInt(); // cycle = 12

    int reminder = a - (n * Math.toIntExact(a / n));
    int reminder_plus_n = (reminder + n);
    int modulo = reminder_plus_n - (n * Math.toIntExact(reminder_plus_n / n));
    System.out.println(modulo); // Answer = 9
}
0
Abdel-Raouf

int remainder = a % b; vous triera. L'opérateur restant renvoie le reste de la division.

Notez que l'opérateur restant est également appelé opérateur modulo. Cependant, ceci est incorrect pour Java as Java renverra une valeur négative si l'opérande gauche a est négatif).

0
hd1