Toutes les valeurs possibles de int, de la plus petite à la plus grande, en utilisant Java

Question

Écrire un programme pour imprimer toutes les valeurs possibles du type de données int, de la plus petite à la plus grande, en utilisant Java.

Quelques solutions notables au 8 mai 2009, 10:44 GMT :

1) Daniel Lew a été le premier à poster code fonctionnant correctement .

2) Kris a fourni la solution la plus simple pour le problème donné.

3) Tom Hawtin - tackline, est venu sans doute avec la solution la plus élégante .

4) mmyers a souligné que l'impression est susceptible de devenir un goulot d'étranglement et qu'il est nécessaire d'améliorer la qualité de l'impression. peut être améliorée par la mise en place de tampons .

5) Jay's approche par force brute est remarquable car, outre le fait qu'il défie le principe même de la programmation, le code source qui en résulte prend environ 128 Go et dépasse les limites des compilateurs.

Par ailleurs, je pense que les réponses montrent que cela pourrait être une bonne question d'entretien, tant que l'accent n'est pas mis sur la capacité à se souvenir de futilités sur le débordement du type de données et ses implications (qui peuvent être facilement repérées pendant les tests unitaires), ou sur la façon d'obtenir les limites MAX et MIN (qui peuvent être facilement recherchées dans la documentation), mais plutôt sur l'analyse des différentes façons de traiter le problème.

Answer 1

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);
    }
}

Suis-je engagé ?

Answer 2

Forme la plus simple (code minimum) :

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

Pas de débordement d'entier, pas de vérifications supplémentaires (juste un peu plus d'utilisation de la mémoire, mais qui n'a pas 32 bits de libre qui traînent).

Bien que je suppose que

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

a moins de caractères, je ne peux pas vraiment dire qu'il est plus simple . Plus court n'est pas nécessairement plus simple, mais il y a moins de code.

Answer 3

Je me dois d'ajouter une réponse...

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);
    }
}

• Nous ne voulons pas que le corps soit répété (pensez à l'entretien !)
• La boucle n'est pas éternelle.
• Il utilise un type approprié pour le compteur.
• Il n'est pas nécessaire de disposer d'une bibliothèque tierce bizarre.

Answer 4

Y a-t-il quelque chose de délicat que je n'ai pas compris ? C'est probablement le cas... ( éditer : oui, il y en a une !)

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);
        }
    }
}

L'impression étant le goulot d'étranglement, un tampon améliorerait considérablement la vitesse (je le sais parce que je viens de l'essayer) :

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);
    }
}

De plus, cette version se terminera (merci à Daniel Lew de m'avoir fait remarquer qu'il y avait en fait quelque chose de délicat que je n'avais pas remarqué).

Le temps d'exécution total de cette version (exécutée avec -Xmx512m) était de 1:53. Cela représente plus de 600 000 nombres par seconde, ce qui n'est pas mal du tout ! Mais je pense qu'il aurait été plus lent si je ne l'avais pas exécuté en mode réduit.

Answer 5

Ah, et je venais juste de commencer à écrire

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

D'accord, donnez-moi quelques semaines pour finir de taper ce texte...

Les instructions n'indiquaient pas que je devais utiliser une boucle, et au moins cette méthode ne pose pas de problème de débordement.