Smallest number in array quirk

Question

I am trying to solve a problem on CodeWars that has me finding the smallest number in an array. Here is my current code:

public class SmallestIntegerFinder {
public int findSmallestInt(int[] args){
    int smallest = args[0];
    for(int i=1; i < args.length; ++i){
        if(args[i] < args[0]){
            smallest = args[i];
        }
    }
    return smallest;
 }
}

Why doesn't this work? But when I change args[0] in the if statement to the variable smallest it works. What's the difference between the two? They both point to args[0] don't they?

public class SmallestIntegerFinder {
public int findSmallestInt(int[] args){
    int smallest = args[0];
    for(int i=1; i < args.length; ++i){
        if(args[i] < smallest){
            smallest = args[i];
        }
    }
    return smallest;
 }
}

The test array i'm using is: {78,56,232,12,11,43}

Answer 1

Because args[0] is the first element in the array, while smallest starts with the first element; it updates to the next smallest value (consider 3, 1, 2; 2 is smaller than 3 but 1 is smaller than 2). You could also use Math.min(int, int) like

public int findSmallestInt(int[] args) {
    int smallest = args[0];
    for (int i = 1; i < args.length; ++i) {
        smallest = Math.min(smallest, args[i]);
    }
    return smallest;
}

Answer 2

Smallest gets assigned the value that was in args[0], it's not a pointer to that memory location. Changing smallest does not change args[0]. So in your loop you are always comparing to args[0] instead of the lowest value you have seen so far.

Answer 3

Its not the same,

1. In the first case, you are putting the smallest as args[i], but again comparing with args[0]. So the base value for comparision is never updating.

2. In the second case, your base value is being updated to the current smallest value and you are comparing with that, and so you get the overall least value.

Answer 4

Using java-8.

public static int findSmallestInt(int[] args){
    return IntStream.of(args)
                    .min()
                    .getAsInt();
}

OR

public static int findSmallestInt(int[] args){
    return IntStream.of(args)
                    .min()
                    .orElseThrow(IllegalArgumentException::new);
}

Answer 5

The other answers have already explained to you why your code is (not) working: in the comparison args[i] < args[0], you always compare to the first value of your array.

One remark: if you are using Java 8, there is a somewhat more readable solution:

import java.util.stream.IntStream;
public class Test {
  public static void main(String[] args) {
    int[] array = {78,56,232,12,11,43};
    int min     = IntStream.of(array).min().getAsInt();
    System.out.println("Minimum: "+min);
  }
}

Answer 6

What you are doing is copying the contents of args[0] into smallest. arg[0] and smallest are not the same memory locations.

In the first code block you are updating the contents of smallest if the ith value is less than the 0th. Updating smallest will only update the value in that variable, not in args[0]

In the second code block you are both comparing, and updating, smallest with the values from args[i].

---

You need to understand what happens when you write something like int smallest. This allocates a new portion of memory for that variable. Running the code int smallest = 1 will put 1 in smallest.

If you have two different variables you will have two distinct memory locations, even if you write smallest = largest. All this does is copy the contents from largest into smallest.

This can be confusing when you have objects, rather than primitive types, being copied.
Obviously, in the case of primitives the value (for example 1) is copied from one variable to another. You'd end up with the case where smallest = 1 and largest = 1.
When it comes to objects it's a little different. In the case of Object smallest = new Object(), smallest would not contain an Object but rather the location that Object exists in memory. If you now do largest = smallest you would be copying the location, not the actual object.

If you're interested in this you can read more about it from one of my favourite answers on here: Is Java “pass-by-reference” or “pass-by-value”?

Answer 7

It is because by doing smallest = args[i]; you are updating the smallest value in smallest variable and not args[0].

In your first solution you are comparing each and every value in the array with args[0] but if the value of any ith element is found smaller then you update the smallest variable instead of args[0].

You should update args[0] if you want your first code snippet to work.

Here is the corrected code snippet:

public class SmallestIntegerFinder {
    public int findSmallestInt(int[] args) {
        int smallest = args[0];
        for(int i=1; i < args.length; ++i) {
            if(args[i] < args[0]){
                args[0] = args[i];
            }
        }
        return args[0];
    }
}

Answer 8

The problem is that you are comparing with args[0]. You should compare with the the smaller, so that if there is something smaller than the smaller it will be the new smaller :)

this should work:

public static int findSmallestInt(int[] args) {
    int smallest = args[0];
    for (int i = 1; i < args.length; ++i) {
        if (args[i] < smallest ) {
            smallest = args[i];
        }
    }
    return smallest;
}

Answer 9

The other answers have told you why the first bit of code doesn't work and offered a lot of alternatives, but allow me to break down exactly where your code breaks. I feel this will be helpful in avoiding similar mistakes.

Here is your original code:

public class SmallestIntegerFinder {
    public int findSmallestInt(int[] args){
        int smallest = args[0];
        for(int i=1; i < args.length; ++i){
            if(args[i] < args[0]){
                smallest = args[i];
            }
        }
        return smallest;
     }
 }

And here is your input: {78,56,232,12,11,43}

Your original code works perfectly fine up to a certain point, but it's ultimately the comparison args[i] < args[0] that causes your code to break.

As your code loops through the array, at some point smallest contains the correct value, 11. But since 11 is not the last element in your array, the code does one more comparison for 43. Since your comparison is always with args[0] = 56, your code checks if 43 is less than 56, and since it is, overwrites smallest with 43, causing you to get the wrong value.

Changing the comparison to args[i] < smallest avoids this problem, because the last iteration of your loop will now check if 43 is less than 11. Since it is not, your function returns the correct value, 11.

Answer 10

There's a simpler solution to this:

final List<Integer> myList = Arrays.asList(78,56,232,12,11,43);
int smallest = myList.stream()
      .sorted()
      .findFirst()
      .get();
System.out.println("Smallest number is "+smallest);