Java shortcut: generating an array to change a for loop into a for-each loop

Question

I have considered using this shortcut in my competition programming. I define a function:

private static int[] range(int n) {
    int[] ret = new int[n];
    for (int i = 0; i < n; i++) {
        ret[i] = i;
    }
    return ret;
}

so that I can write my for loops slightly quicker, and slightly neater looking (when scanning code):

for (int i: range(n)) { doit(i); }

instead of:

for (int i = 0; i < n; i++) { doit(i); }

Are there any significant performance issues with this approach and what are they?

The code has a time limit to calculate a solution, but using the right algorithm it's usually possible to do this in a fraction of the time limit. The range function runs in O(n) and because we are going to run a O(n) loop anyway, there is no increase in time complexity. What about garbage collection? Anything else I'm not thinking of?

I will determine if I actually like using this method later, and if it's worth the overhead of typing out the functions at the start of the competition. Please don't answer about the style. (Competition coding produces some of the worst looking code you've ever seen, but it's all about getting it done on time and never looking at it again.)

---

To clarify, actual coding time is crucial in this competition and we can't bring pre-typed code. This generally means no code snippets either. The foreach will make for loops quicker to type, and less error prone, in the rushed and messy coding environment. It is an alternative to macros in C++.

Answer 1

I would prefer to do it this way, in this kinda situation.

for (int i = 0; i < n; i++) { doit(i); }

Converting it to an array is not really giving any benefit, IMO. Performance is not much of a concern for me here, may be it will be but second. First, I don't do that because its about writing one more method, which is giving nothing much. Moreover, why execute 2 loops when just 1 would have been sufficient.

In case you will write many many for-loops, then foreach loop might not be suitable for every situation and you might end up using traditional for-loop, anyway, perhaps most of the time. You must consider the problems we usually get in programming competition. You might need the index in the loop to do some calculation. Who knows. Further, I didn't find myself not too slow in coming up with for-loop before foreach came into Java.

Moreover, in competition we usually we don't care about performance, unless its mentioned explicitly. And if it is, your workaround would not be taken very positively.

Answer 2

I would suggest use of:

for (int i = 0; i < n; i++) { doit(i); }

if you are looking for fast execution time.

Other approach will consume time in performing array look-up and copying values when assigning value to i.

I tried to run a quick test to verify:

class Main {
private static int[] range(int n) {
  int[] ret = new int[n];
  for (int i = 0; i < n; i++) {
    ret[i] = i;
  }
  return ret;
}

public static void main (String[] args) throws java.lang.Exception
{
  int n = 10;
  for(int x =0; x<3; x++){

  int[] ret = range(n);
  long t1 = System.nanoTime() ;
  for (int i: ret ) { }
  long t2 = System.nanoTime() ;
  for (int i = 0; i < n; i++) { }
  long t3 = System.nanoTime() ;
  System.out.println(n + " : " + (t2-t1));
  System.out.println(n + " : " + (t3-t2));
  n = n*n;
  }  
  }
  }

The result obtained is:

10 : 1382
10 : 728
100 : 5239
100 : 1774
10000 : 450105
10000 : 1741059

Answer 3

For small array it will not be an issue (you may just benchmark it if you not sure).

Where is better way to do same thing. Foreach loop can iterate over Iterable instances. You can ccreate class RangeIterable implements Iterable, and make static method RangeIterable range(int from, int to), like you do. It'll be a little more OOP-way, and it's cheeper in terms of memory. And even integer boxing will not be an issue for ranges inside [-127,128], which is default range for precach Integer instances

Answer 4

I don't think that creating an array will improve the performace.

You also might want to look at this:

Premature optimization is the root of all evil