Todos los valores posibles de int desde el más pequeño hasta el más grande, usando Java

Question

Escriba un programa para imprimir todos los valores posibles de tipo de datos int desde el más pequeño hasta el más grande, usando Java.

Algunas soluciones notables como del 8 de mayo de 2009, 10:44 GMT:

1) Daniel Lew fue el primero en publicar correctly working code.

2) Kris ha proporcionado the simplest solution para el problema dado.

3) Tom Hawtin - tachado, se le ocurrió con the most elegant solution.

4) mmyers señaló que la impresión es probable que se convierta en un cuello de botella y can be improved through buffering.

5) Jay's brute force approach es notable ya que, además de desafiar el punto central de la programación, el código fuente resultante toma alrededor de 128 GB y socavará los límites del compilador.

Como nota al margen, creo que las respuestas demuestran que podría ser una buena pregunta para una entrevista, siempre y cuando no se haga hincapié en la capacidad de recordar trivialidades sobre el desbordamiento del tipo de datos y sus implicaciones (que pueden ser fácilmente detectados durante la prueba unitaria), o la forma de obtener los límites MAX y MIN (se puede buscar fácilmente en la documentación), sino más bien en el análisis de varias formas de abordar el problema.

Answer 1

El valor máximo para int es Integer.MAX_VALUE y el mínimo es Integer.MIN_VALUE. Use un bucle para imprimirlos todos.

Answer 2

class Test { 
    public static void main(String[] args) { 
     for (int a = Integer.MIN_VALUE; a < Integer.MAX_VALUE; a++) { 
      System.out.println(a); 
     } 
     System.out.println(Integer.MAX_VALUE); 
    } 
} 

¿Se me contrata?

Answer 3

¿Hay algo complicado que no estoy captando? Probablemente es ... (edición: sí, existe!)

class AllInts { 
    public static void main(String[] args) { 
     // wrong -- i <= Integer.MAX_VALUE will never be false, since 
     // incrementing Integer.MAX_VALUE overflows to Integer.MIN_VALUE. 
     for (int i = Integer.MIN_VALUE; i <= Integer.MAX_VALUE; i++) { 
      System.out.println(i); 
     } 
    } 
} 

Dado que la impresión es el cuello de botella, un buffer mejoraría la velocidad mucho (lo sé porque yo sólo probé):

class AllInts { 
    public static void main(String[] args) { 
     // a rather large cache; I did no calculations to optimize the cache 
     // size, but adding the first group of numbers will make the buffer 
     // as large as it will ever need to be. 
     StringBuilder buffer = new StringBuilder(10000000); 
     int counter = 0; 
     // note that termination check is now < 
     // this means Integer.MAX_VALUE won't be printed in the loop 
     for (int i = Integer.MIN_VALUE; i < Integer.MAX_VALUE; i++) { 
      buffer.append(i).append('\n'); 
      if (++counter > 5000000) { 
       System.out.print(buffer); 
       buffer.delete(0, buffer.length()-1); 
       counter = 0; 
      } 
     } 
     // take care of the last value (also means we don't have to check 
     // if the buffer is empty before printing it) 
     buffer.append(Integer.MAX_VALUE); 
     System.out.println(buffer); 
    } 
} 

Además, esta versión realmente terminar (gracias a Daniel Lew para señalando que no era, de hecho, algo complicado que no estaba coger).

El tiempo total de ejecución para esta versión (ejecutado con -Xmx512m) fue 1:53. Eso es más de 600000 números/segundo; ¡No está mal! Pero sospecho que hubiera sido más lento si no lo hubiera minimizado.

Answer 4

El paquete fj es de here.

import static fj.pre.Show.intShow; 
import static fj.pre.Show.unlineShow; 
import static fj.data.Stream.range; 
import static java.lang.Integer.MIN_VALUE; 
import static java.lang.Integer.MAX_VALUE; 

public class ShowInts 
    {public static void main(final String[] args) 
    {unlineShow(intShow).println(range(MIN_VALUE, MAX_VALUE + 1L));}} 

Answer 5

En 1000 líneas/seg., Estará listo en aproximadamente 7 semanas. ¿Deberíamos tomar café ahora?

Answer 6

forma más simple (código mínimo):

for (long i = Integer.MIN_VALUE; i <= Integer.MAX_VALUE; i++) { 
     System.out.println(i); 
    } 

Sin desbordamiento de entero, no cheques adicionales (sólo un poco más el uso de memoria, pero que no tiene 32 bits de reserva por ahí).

Aunque supongo

for (long i = Integer.MIN_VALUE; i <= Integer.MAX_VALUE; i++) 
     System.out.println(i); 

tiene menos caracteres, en realidad no puedo decir que es más simple . Más corto no es necesariamente más simple, aunque tiene menos código.

Answer 7

Sólo la mejora de las StringBuilder 's se acercan un poco:

2 hilos + 2 buffers (es decir StringBuilder): La idea principal es que un hilo se llena una memoria intermedia, mientras que el otro hilo vuelca el contenido de la otra memoria intermedia.

Obviamente, el subproceso "volcado" será siempre ejecute más lento que el subproceso "relleno".

Answer 8

Sólo tengo que añadir una respuesta ...

public class PrintInts { 
    public static void main(String[] args) { 
     int i = Integer.MIN_VALUE; 
     do { 
      System.out.println(i); 
      ++i; 
     } while (i != Integer.MIN_VALUE); 
    } 
} 

• No queremos que el cuerpo repetida (pensar en el mantenimiento!)
• No hace un bucle infinito.
• Utiliza un tipo apropiado para el contador.
• No requiere una biblioteca de weirdo de terceros.

Answer 9

Cuando lo vi por primera vez, mi primera pregunta fue '¿cómo se define la más pequeña y la más grande'? Por lo que yo pensaba que era la definición más obvia ('más pequeño' == 'más cercano a 0') la respuesta sería

for (int i = 0; i >= 0; i++) { 
    System.out.println(i); 
    System.out.println(-i-1); 
} 

Pero todo el mundo parece leer 'más pequeño' como 'mínimo' y 'grande' como 'máximo'

Answer 10

Vamos gente, que dijo que el uso de java. No dijo usar un int en el ciclo for. :-)

public class Silly { 
    public static void main(String[] args) { 
    for (long x = Integer.MIN_VALUE; x <= Integer.MAX_VALUE; x++) { 
     System.out.println(x); 
    } 
    } 
} 

Answer 11

Otra forma de recorrer todos los valores usando un tipo int.

public static void main(String[] args) { 
    int i = Integer.MIN_VALUE; 
    do { 
     System.out.println(i); 
    } while (i++ < Integer.MAX_VALUE); 
} 

Answer 12

Ah, y aquí solo había comenzado a escribir

System.out.println(-2147483648); 
System.out.println(-2147483647); 
System.out.println(-2147483646); 

bien, sólo dame un par de semanas para terminar de escribir esto ...

Las instrucciones no he dicho que tiene que usar un bucle, y al menos este método no tiene ningún problema de desbordamiento.

Answer 13

Dada la visión general de las mejores respuestas, me di cuenta de que estamos seriamente escaso en el departamento de fuerza bruta. La respuesta de Jay es agradable, pero en realidad no funcionará. En nombre de la ciencia, presento - Bozo Rango:

import java.util.Random; 
import java.util.HashSet; 

class Test { 
    public static void main(String[] args) { 
     Random rand = new Random(); 
     HashSet<Integer> found = new HashSet<Integer>(); 
     long range = Math.abs(Integer.MAX_VALUE - (long) Integer.MIN_VALUE); 
     while (found.size() < range) { 
      int n = rand.nextInt(); 
      if (!found.contains(n)) { 
       found.add(n); 
       System.out.println(n); 
      } 
     } 
    } 
} 

Tenga en cuenta que tendrá que dejar de lado al menos 4 GB de RAM para ejecutar este programa. (Posiblemente 8 GB, si está en una máquina de 64 bits, que probablemente necesitará para ejecutar este programa ...). Este análisis no cuenta la saturación que la clase Integer agrega a ningún int dado, tampoco, ni el tamaño del propio HashSet.