¿En qué casos se utiliza la operación Módulo (%) en la programación?

signo de módulo o (%) devuelve recordatorio.

El uso más fácil y común que sigo es envolverlo.

por ejemplo, si quieres desplazarte por algo repetidamente, puedes usar

int main (nulo) {

para (int i = 0; i <= 12; i ++) {
printf (“% d”, i% 4); // envuelto alrededor de 4
}
}
/ *
imprimirá: – 0,1,2,3,0,1,2,3,0,1,2,3,
módulo asegura aquí imprimir números dentro del rango [0,3] solamente
* /

Además, se puede usar para recorrer una matriz

int a [10];
para (int i = 0; verdadero; i = (i + 1)% 10) {
//…ai]..
}

El módulo asegura que i permanezca en el rango [0, 10).

El objetivo principal es en criptografía.

fuente: desbordamiento de pila

El operador de módulo se usa realmente en criptografía bastante.

Por ejemplo, el esquema de intercambio de clave pública RSA se basa en las propiedades de la aritmética modular y utiliza el operador de módulo. Puede leer sobre cómo RSA usa la aritmética modular aquí: RSA (criptosistema)

También el intercambio de claves Diffie-Hellman es otro uso del operador de módulo en el cifrado de clave pública: intercambio de claves Diffie-Hellman

Algunos ejemplos incluyen:

• limitar un generador de números aleatorios (C)

int random = rand ()% 100

• comprobar si un número divide a otro

si (! (a% b))

• Cifrado

La primera aplicación del operador de módulo que viene a la mente: una calculadora de día de la semana.

Estás en Unix / Linux y llamas a time () time () – Unix, Linux System Call obteniendo el número de segundos de la época de Unix, que era un jueves.
Hay 24 * 60 * 60 = 86400 segundos al día, así que int dayCount = time() / 86400 es el número de días desde la época.
Si cuenta los días laborables del lunes (0), el jueves es 3.
Si quieres saber el día de la semana de hoy solo tienes que calcular

(3 * time() / 86400) % 7

Mira: hoy es sábado: día de la semana = 5.

El FizzBuzz es un ejemplo clásico que prueba los conocimientos de Modulo.

/ ************************************************* ************************
Autor: John Sprunger
Fecha: 22/06/2016
Descripción: Prueba FizzBuzz: imprima los números del 1 al 100. Si un número es
divisible por 3 y 5 imprime “FizzBuzz”. Si el número es divisible
por 3 imprime “Fizz”, si es divisible por 5 imprime “Buzz”. Si el numero
no pasa ninguna de las pruebas anteriores imprimirlo.
************************************************** *********************** /
clase pública FizzBuzz {

public static void main (String [] args) {
// para contador de bucles
int theNumber;
for (theNumber = 1; theNumber <= 100; theNumber ++) {
// Prueba si un número es divisible por 3 y 5
if (theNumber% 15 == 0)
System.out.println (“FizzBuzz”);
// Prueba si un número es divisible por 3
si no (theNumber% 3 == 0)
System.out.println (“Fizz”);
// Prueba si un número es divisible por 5
si no (theNumber% 5 == 0)
System.out.println (“Buzz”);
más
System.out.println (theNumber);
}
}
}

Donde sea que sea útil el resto de una operación de división. El resto no es una fracción. Es lo que queda después de que todo lo demás se haya dividido equitativamente. Entonces, 14% 5 = 4, porque, si piensas en términos de división larga, 14/5 = 2, más un resto de 4, ya que 2 * 5 = 10. Restas 10 de 14, y queda 4.

Cuando quieres saber el resto de una división. Veamos este ejemplo juntos;

Entonces sabemos que:
– Si el year % 4 = 0 , entonces es un año bisiesto
– si un year % 100 y si el year % 400 = 0 , entonces es un año bisiesto
– si un year % 100 y si el year % 400 != 0 , entonces no es un año bisiesto
– de lo contrario, no es un año bisiesto

Al usar algunas declaraciones if, puede determinar si es un año bisiesto o no. Esto se vería así:

if (((año% 4 == 0) && (año% 100! = 0)) || (año% 400 == 0)
año es un año bisiesto
más
el año no es bisiesto

Hay muchos casos en los que utilizará el operador del módulo, pero una situación común es cuando recorre los índices de una matriz varias veces, por ejemplo, una matriz circular. Si la matriz tiene 5 elementos, y usa un contador, n, para recorrer los valores de la matriz dos veces, su índice se puede encontrar usando el módulo. Cuando n = 0,1,2,3 y 4 su índice = n% 5 = 0,1,2,3 y 4, respectivamente, lo que significa que accede a los elementos de matriz 1º, 2º, 3º, 4º y 5º. Luego, cuando n = 5,6,7,8, y 9 su índice = n% 5 = 0,1,2,3, y 4 nuevamente, lo que le permite recorrer los 5 valores de la matriz dos veces. Puede ver que el operador del módulo es útil para recorrer un conjunto específico de números en este caso, lo que puede ser útil con índices de matriz en muchas aplicaciones.

Hay varios casos en los que debe usarse. El caso más común es cuando está imprimiendo una tabla en su aplicación y desea alternar los colores dentro de las filas. Es posible que desee blanco y gris, de modo que verifique el módulo para ver si está en una fila impar o par.

Otra famosa prueba básica de reclutamiento es la prueba Fizz Buzz que elimina a los no programadores y requiere el módulo para resolverla:

Zumbido

La operación de módulo aparece naturalmente en varios tipos de programación. Es el resto de la división de enteros (es decir, normalmente no se usa con flotantes y muchos lenguajes de programación ni siquiera lo permiten; algunos como Visual Basic implementan el esquema de resto IEEE pero muchos no)

Estas son algunas de las formas en que personalmente lo he usado.

• Comprobación de año bisiesto
• Determinar si algo es impar o par
• Hacer algo a cada enésimo elemento de una lista
• Para asegurarse de que un contador se mantuvo dentro de un cierto rango.

Para el último, debería explicar un poco. Alguien en algún lugar decidió que la rotación debería ser un rango de 0 a 65535. Pero también decidieron que debería realizarse en un int 32bit. Entonces, cada vez que tenía que lidiar con eso, era más fácil tomar el módulo para volver a la base y no preocuparse por cuántas veces ya había dado vueltas.