# Issue

This Content is from Stack Overflow. Question asked by Nutnicha

I have written a code that would return either 1 or 4 as the output, and here it is

``````public static int findSum(int k) {
int sum = 0;
boolean foundNonZero = false;
for (; k != 0; k /= 10) {
if (foundNonZero) {
sum += (k % 10)*(k % 10);
} else {
foundNonZero = k % 10 != 0;
}
}
return sum;
}
``````

Now, I’m trying to write a function `public static long[] firstK(int k)` that would return `k` numbers starting from 0 that would satisfy the condition that `findsum` = 1.

I’m struggling to understand how to do it, despite reading Java syntax and information. and here is my code so far:

``````public static long[] firstK(int k) {
while (int x = 0;) {
if (findSum(x) = 1;)
System.out.println(x);
}
``````

I know that int(k) isn’t used in this, but I have no idea how to implement it. Any help would be greatly appreciated ðŸ™‚

# Solution

Maybe something like this:

``````public static List<Integer> firstK(int k) {
List<Integer> result = new ArrayList<>();
for (int x = 0 ; result.size() < k ; x++)
if (findSum(x) == 1)
return result;
}
``````

If you really want an array rather than a List, I would still use a List to compute the result. I would then create an array from that list and return that as the function’s result to have the function return a `int[]` or `long[]`. I can’t see why you’d want to return `long[]` or `List<Long>` rather than `int[]` or `List<Integer>`, I doubt the code involved would ever be given the chance to iterate past the maximum integer value.

UPDATE: Here’s a complete example that uses an `array` throughout:

``````public class Test {

public static int findSum(int k) {
int sum = 0;
boolean foundNonZero = false;
for (; k != 0; k /= 10) {
if (foundNonZero) {
sum += (k % 10)*(k % 10);
} else {
foundNonZero = k % 10 != 0;
}
}
return sum;
}

public static long[] firstK(int k) {
long[] result = new long[k];
int i = 0;
for (int x = 0; i < k; x++)
if (findSum(x) == 1)
result[i++] = x;
return result;
}

public static void main(String[] args) {
long[] r = firstK(5);
System.out.println(Arrays.toString(r));
}
}
``````

Result:

``````[11, 12, 13, 14, 15]
``````

The use of an `array` during the operation is fine because you do know the size of that array up front. You often don’t, in which case it is usually cleaner to use a `List` to collect terms, and then convert to an `array` at the end. I did it this way initially out of habit. In practice, at least in my case, I pretty much never use arrays due to them being less flexible. They ARE more compact and can perform better, but it is rarely the case that the difference matters.

``` This Question was asked in  StackOverflow by  Nutnicha and Answered by CryptoFool It is licensed under the terms of
CC BY-SA 2.5. - CC BY-SA 3.0. - CC BY-SA 4.0.```