This problem has a nice array solution:

    q)where mod[;2] sum 0=til[500] mod/: til[500]
    0 1 4 9 16 25 36 49 64 81 100 121 144 169 196 225 256 289 324 361 400 441 484

    q){x*x} til ceiling sqrt 500
    0 1 4 9 16 25 36 49 64 81 100 121 144 169 196 225 256 289 324 361 400 441 484

but I think it's very interesting to look at them side by side: Do you see the "triangle" in the above that suggests the sqrt-solution?

    q)0=til[500] mod/: til[500]
    00000000000000000000000000000000000000000000000000000000000000000000000000000..
    11111111111111111111111111111111111111111111111111111111111111111111111111111..
    10101010101010101010101010101010101010101010101010101010101010101010101010101..
    10010010010010010010010010010010010010010010010010010010010010010010010010010..
    10001000100010001000100010001000100010001000100010001000100010001000100010001..
    10000100001000010000100001000010000100001000010000100001000010000100001000010..
    10000010000010000010000010000010000010000010000010000010000010000010000010000..
    10000001000000100000010000001000000100000010000001000000100000010000001000000..
    10000000100000001000000010000000100000001000000010000000100000001000000010000..
    10000000010000000010000000010000000010000000010000000010000000010000000010000..
    10000000001000000000100000000010000000001000000000100000000010000000001000000..
    10000000000100000000001000000000010000000000100000000001000000000010000000000..
    10000000000010000000000010000000000010000000000010000000000010000000000010000..
    10000000000001000000000000100000000000010000000000001000000000000100000000000..
    10000000000000100000000000001000000000000010000000000000100000000000001000000..
    10000000000000010000000000000010000000000000010000000000000010000000000000010..
    10000000000000001000000000000000100000000000000010000000000000001000000000000..
    10000000000000000100000000000000001000000000000000010000000000000000100000000..
    10000000000000000010000000000000000010000000000000000010000000000000000010000..
    10000000000000000001000000000000000000100000000000000000010000000000000000001..
    10000000000000000000100000000000000000001000000000000000000010000000000000000..
    10000000000000000000010000000000000000000010000000000000000000010000000000000..
    ..
    

Isn't that beautiful? This is really illustrative of what I think is valuable in learning array programming, and whilst I've noted it previously on HN[1], this might be an even better example. Try writing the algorithm in C or Python:

    void main(){
      int i,j,k;
      for(i=0;i<500;++i) {
        for(j=k=0;j<499;++j)if(!(i%(1+j)))++k;
        if(k%2)printf("%d ",i);
      }
      puts("");
    }

Now because I can't see the shape of the data so easily anymore, I might not so quickly recognise the optimisation waiting for me in that code, especially if this spanned more than a screenful (because e.g. we were doing something else besides printing the results)

[1]: https://news.ycombinator.com/item?id=16851862