La mayoría de las veces, en programación competitiva, es necesario asignar a la variable, el valor máximo o mínimo que puede contener el tipo de datos, pero recordar un número tan grande y preciso resulta ser un trabajo difícil. Por lo tanto, C/C++ tiene ciertas macros para representar estos números, de modo que se puedan asignar directamente a la variable sin tener que escribir el número entero.

C/C++ proporciona dos de estas macros, a saber, INT_MAX e INT_MIN, que representan los límites de los números enteros. Dependiendo del compilador y del estándar C++, es posible que deba incluir el archivo de encabezado o en su código fuente C o C++ respectivamente. Por lo tanto, es recomendable incluir este archivo de encabezado para usar las macros INT_MAX e INT_MIN. Para leer más sobre este archivo de encabezado, consulte este artículo .

INT_MAX en C/C++

INT_MAX es una macro que especifica que una variable entera no puede almacenar ningún valor más allá de este límite. Representa el valor máximo del límite superior del tipo de datos entero en C/C++.

El valor de INT_MAX es:

java matemáticas.min

• INT_MAX = 2147483647 (para enteros de 32 bits)
• INT_MAX = 9,223,372,036,854,775,807 (para enteros de 64 bits)

INT_MIN en C/C++

INT_MIN es una macro que especifica que una variable entera no puede almacenar ningún valor por debajo de este límite. Representa el valor mínimo o el límite inferior del tipo de datos entero.

El valor de INT_MIN es:

• INT_MÍN = – 2147483648 (para enteros de 32 bits)
• INT_MÍN = – 9,223,372,036,854,775,808 (para enteros de 64 bits)

Nota: Los valores de INT_MAX e INT_MIN pueden variar de un compilador a otro. A continuación se muestran valores típicos en un compilador donde los números enteros se almacenan con 32 bits.

Ejemplo de INT_MIN e INT_MAX

// C++ program to print values of INT_MAX // and INT_MIN #include  #include  using namespace std; int main() {  cout << INT_MAX << endl;  cout << INT_MIN;  return 0; }>

// C program to print values of INT_MAX // and INT_MIN // we have to include limits.h for results in C #include  #include  int main() {  printf('%d
', INT_MAX);  printf('%d', INT_MIN); }>

2147483647 -2147483648>

Aplicaciones de INT_MAX e INT_MIN

Las siguientes son las principales aplicaciones de INT_MAX e INT_MIN

1. Verifique si hay desbordamiento de enteros

Podemos usar las macros INT_MIN e INT_MAX para verificar el desbordamiento de enteros con signo. El siguiente ejemplo demuestra cómo hacerlo.

Ejemplo

// C++ code to check for Integer overflow while // adding 2 numbers #include  #include  using namespace std; // Function to return integer sum after checking overflow int check_overflow(int num1, int num2) {  // Checking if addition will cause overflow  if (num1>INT_MAX - num2) devuelve -1;  // No se produjo ningún desbordamiento; de lo contrario, return num1 + num2; } // Código del controlador int main() { // La suma de estos números será igual a INT_MAX // Si alguno de ellos se incrementa en 1, se producirá un desbordamiento // int num1 = 2147483627;  int número2 = 20;  // El resultado es -1 si se produjo un desbordamiento // Almacena la suma; de lo contrario, int resultado = check_overflow(num1, num2);  // Se produjo un desbordamiento si (resultado == -1) cout<< 'Integer overflow occurred';  // No overflow  else  cout << result;  return 0; }>

// C code to check for Integer overflow while // adding 2 numbers #include  #include  // Function to check integer overflow int check_overflow(int num1, int num2) {  // Checking if addition will cause overflow  if (num1>INT_MAX - num2) devuelve -1;  // No se produjo ningún desbordamiento; de lo contrario, return num1 + num2; } int main(void) { // La suma de estos números será equivalente a // INT_MAX Si alguno de ellos se incrementa en 1, se producirá // desbordamiento int num1 = 2147483627;  int número2 = 20;  // El resultado es -1 si se produjo un desbordamiento // Almacena la suma; de lo contrario, int result = check_overflow(num1, num2);  // Se produjo un desbordamiento if (resultado == -1) printf('Se produjo un desbordamiento de enteros');  // Sin desbordamiento else printf('%d', resultado);  devolver 0; } // Este código es una contribución de sarajadhav12052009>

2147483647>

De manera similar, podemos verificar el desbordamiento mientras restamos 2 números usando INT_MIN.

leer desde un archivo csv en java

2. Calcular MIN en una matriz con elementos grandes

Generalmente asignamos un valor alto a MIN para calcular el valor mínimo en una matriz. Pero si una matriz tiene elementos grandes, debemos asignar el valor más alto posible a la matriz.

A continuación se muestra la implementación:

Ejemplo

patrón de diseño del método de fábrica

// C++ code to compute MIN element #include  #include  using namespace std; // Function to compute minimum element in array int compute_min(int arr[], int n) {  // Assigning highest value  int MIN = INT_MAX;  // Traversing and updating MIN  for (int i = 0; i < n; i++)  MIN = std::min(MIN, arr[i]);  // Printing MIN element  cout << MIN; } // Driver code int main() {  // array with MIN to compute  int arr[] = { 2019403813, 2147389580, 2145837140,  2108938594, 2112076334 };  // size of array  int n = sizeof(arr) / sizeof(arr[0]);  // Function call to compute MIN  compute_min(arr, n); }>

2019403813>

De manera similar, MAX se puede encontrar en una matriz de números grandes usando INT_MIN.

Preguntas frecuentes sobre INT_MIN e INT_MAX

1. ¿Por qué abs(INT_MIN) no da el resultado esperado?

¿Alguna vez se ha enfrentado a un problema al utilizar la función abs()? Probablemente NO si no ha resuelto ningún problema que requiera una función absoluta. Pero si ha resuelto problemas en techcodeview.com o Leetcode, entonces sabrá que siempre hay un caso de prueba en el que falla y ese caso de prueba es cuando tiene el valor INT_MIN.

Veamos qué sucede si usamos la función absoluta, devuelve el valor mod, lo que significa que devuelve el siguiente valor:

Valores del módulo

Ahora otra cosa que sabemos es que el rango de números enteros es de -2,147,483,648 a 2,147,483,647 o podemos decir que es de -2 ³¹ a 2 ³¹ – 1 para que podamos ver que hay siempre uno más en el lado negativo que en el positivo

Ahora veamos qué sucede cuando intentamos tomar valores absolutos del resultado:

// C++ program to demonstrate the common error faced when // getting absolute value of the INT_MIN #include  #include  using namespace std; int main() {  cout << 'Value Of INT_MIN is : ' << INT_MIN << endl;  cout << 'Value Of abs(INT_MIN) is : ' << abs(INT_MIN)  << endl;  return 0; }>

// C program to demonstrate the common error faced when // getting absolute value of the INT_MIN #include  #include  #include  int main() {  printf('Value of INT_MIN is: %d
', INT_MIN);  printf('Value of abs(INT_MIN) is: %d', abs(INT_MIN));  return 0; }>

Value of INT_MIN is: -2147483648 Value of abs(INT_MIN) is: -2147483648>

Ahora podemos observar que abs(INT_MIN) es el propio INT_MIN, y esto provoca que se produzcan muchos errores cuando damos evaluaciones en línea o solucionamos cualquier problema.

Razón

Ahora, si llegamos a la parte del motivo, podemos ver que actualmente estamos tratando con la parte Entero y abs(entero) devuelve un valor entero en sí mismo, por lo que pasar a la representación INT_MIN se puede representar como

INT_MIN = -2147483648 = 10000000000000000000000000000000>

Aquí el primer bit representa el bit de signo que se establece en uno, lo que significa que es un número negativo y la siguiente parte es una representación binaria de 31 bits para 2147483648.

Ahora, si intentamos tomar el valor absoluto de INT_MIN, intentará darnos +2147483648 y este valor no se puede representar en forma entera ya que el valor máximo que se puede representar es +2147483647, ya que en el lado positivo tenemos que representan 231 números enteros pero también se incluye 0, por lo que el rango de 1 a 2147483648 cambia a 0 a 2147483647 y por esta razón los abs(INT_MIN) no se pueden representar en este rango y la respuesta devuelta es la misma que INT_MIN.

recorrido en orden

Solución

Bueno, puede haber muchas soluciones al problema, pero algunas de las mejores soluciones son:

1. Utilice siempre un caso extremo especial para comprobar if(x == INT_MIN) si está utilizando abs(x) y maneje este caso en consecuencia.
2. Intente utilizar Long en lugar de INTEGER, pero recuerde que LONG_MIN también dará el mismo resultado, así que tenga cuidado.