All possible values of int from the smallest to the largest, using Java.

Question

Write a program to print out all possible values of int data type from the smallest to the largest, using Java.

Some notable solutions as of 8th of May 2009, 10:44 GMT:

1) Daniel Lew was the first to post correctly working code.

2) Kris has provided the simplest solution for the given problem.

3) Tom Hawtin - tackline, came up arguably with the most elegant solution.

4) mmyers pointed out that printing is likely to become a bottleneck and can be improved through buffering.

5) Jay's brute force approach is notable since, besides defying the core point of programming, the resulting source code takes about 128 GB and will blow compiler limits.

As a side note I believe that the answers do demonstrate that it could be a good interview question, as long as the emphasis is not on the ability to remember trivia about the data type overflow and its implications (that can be easily spotted during unit testing), or the way of obtaining MAX and MIN limits (can easily be looked up in the documentation) but rather on the analysis of various ways of dealing with the problem.

Answer 1

The maximum value for int is Integer.MAX_VALUE and the minimum is Integer.MIN_VALUE. Use a loop to print all of them.

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

Am I hired?

Answer 3

Is there something tricky that I'm not catching? There probably is... (edit: yes, there is!)

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

Since the printing is the bottleneck, a buffer would improve the speed quite a lot (I know because I just tried it):

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

Also, this version will actually terminate (thanks to Daniel Lew for pointing out that there was, in fact, something tricky that I wasn't catching).

The total run time for this version (run with -Xmx512m) was 1:53. That's over 600000 numbers/second; not bad at all! But I suspect that it would have been slower if I hadn't run it minimized.

Answer 4

Package fj is from 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

At 1000 lines/sec you'll be done in about 7 weeks. Should we get coffee now?

Answer 6

Simplest form (minimum code):

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

No integer overflow, no extra checks (just a little more memory usage, but who doesn't have 32 spare bits lying around).

While I suppose

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

has fewer characters, I can't really say that it is simpler. Shorter isn't necessarily simpler, it does have less code though.

Answer 7

Just improving the StringBuilder's approach a little:

2 threads + 2 buffers (i.e. StringBuilder): The main idea is that one thread fills one buffer while the other thread dumps the content of the other buffer.

Obviously, the "dumper" thread will always run slower than the "filler" thread.

Answer 8

I just have to add an answer...

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

• We don't want the body repeated (think of the maintenance!)
• It doesn't loop forever.
• It uses an appropriate type for the counter.
• It doesn't require some wild third-party weirdo library.

Answer 9

When I first looked at this, my first question was 'how do you define smallest and largest'. For what I thought was the most obvious definition ('smallest' == 'closest to 0') the answer would be

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

But everyone else seems to read 'smallest' as 'minimum' and 'largest' as 'maximum'

Answer 10

Come on folks, it said using java. It didn't say use an int in the for loop. :-)

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

Another way to loop through every value using an int type.

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

Answer 12

Ah, and here I had just started writing

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

Okay, just give me a few weeks to finish typing this up ...

The instructions didn't say I have to use a loop, and at least this method doesn't have any overflow problems.

Answer 13

Given the overview of the best answers, I realized that we're seriously lacking in the brute-force department. Jay's answer is nice, but it won't actually work. In the name of Science, I present - Bozo Range:

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

Note that you'll need to set aside at least 4 GB of RAM in order to run this program. (Possibly 8 GB, if you're on a 64-bit machine, which you'll probably require to actually run this program...). This analysis doesn't count the bloat that the Integer class adds to any given int, either, nor the size of the HashSet itself.