Finding if input has exactly one pair and zero or more triplets java

I am a Java Developer and I was on a interview with an algorithm problem which I cannot seem to solve nor find a solution already for it, but I'm really curious how it can be solved.

Here is the problem.

>You’re working on making some mini-games, and you’ve decided to make a simpler variant of the game Mahjong. In this variant, players have a number of tiles, each marked 0-9. The tiles can be grouped into pairs or triples of the same tile. A “complete hand” is defined as a collection of tiles where all the tiles can be grouped into any number of triples (zero or more) and exactly one pair, and each tile is used in exactly one triple or pair. Write a function that takes a string representing a player’s tiles in no particular order, and returns the string “COMPLETE” if the hand is complete, and “NOT COMPLETE” if it is not. Each tile may only be used in a single group (either a pair or a triple). All tiles must be used to complete a hand. There may be a pair and triples of the same tile. A single pair with no triples (ex: 99) is a valid hand. The input will only consist of characters 0-9.
>
>Examples
>
>These three hands would all return “COMPLETE”:
>
>33344466 -> 333 444 66
This hand can be grouped into a triple of 3s and 4s, and a pair of 6s
>
>55555555 -> 555 555 55
This hand can be grouped into two triples of 5s and a pair of 5s
>
>22 -> 22
This hand is a single pair of 2s (no triples are required)
>
>These three hands would all return “NOT COMPLETE”:
>
>1357
This hand has tiles which cannot be formed into pairs or triples.
>
>335577
This hand has three pairs, a complete hand must have exactly one pair.
>
>666888
This hand has two triples, but no pairs.

Here's my solution.
It is not the only solution. Refer to the comment from @Bohemian.
(Explanations after the code.)

import java.util.Arrays;

public class Mahjongs {
    private static final String  COMPLETE = "COMPLETE";
    private static final String  NOT_COMPLETE = "NOT COMPLETE";

    private static String isComplete(String hand) {
        String msg = "Tile %d is not valid: '%c'";
        String result = COMPLETE;
        if (hand == null) {
            result = NOT_COMPLETE;
        }
        else {
            hand = hand.strip();
            if (hand.length() < 2) {
                result = NOT_COMPLETE;
            }
            else {
                char[] tiles = hand.toCharArray();
                Arrays.sort(tiles);
                char last = tiles[0];
                if (!Character.isDigit(last)) {
                    throw new IllegalArgumentException(String.format(msg, 0, last));
                }
                int count = 1;
                int doubles = 0;
                for (int i = 1; i < tiles.length; i++) {
                    if (!Character.isDigit(tiles[i])) {
                        throw new IllegalArgumentException(String.format(msg, i, tiles[i]));
                    }
                    if (tiles[i] == last) {
                        count++;
                        if (count == 3) {
                            count = 0;
                        }
                    }
                    else {
                        if (count == 1) {
                            result = NOT_COMPLETE;
                            break;
                        }
                        if (count == 2) {
                            doubles++;
                            if (doubles != 1) {
                                result = NOT_COMPLETE;
                                break;
                            }
                        }
                        count = 1;
                        last = tiles[i];
                    }
                }
                if (count == 1) {
                    result = NOT_COMPLETE;
                }
                else if (count == 2) {
                    doubles++;
                }
                if (result.equals(COMPLETE)  &&  doubles != 1) {
                    result = NOT_COMPLETE;
                }
            }
        }
        return result;
    }

    public static void main(String[] args) {
        System.out.println(isComplete("33344466"));
        System.out.println(isComplete("55555555"));
        System.out.println(isComplete("22"));
        System.out.println(isComplete("1357"));
        System.out.println(isComplete("335577"));
        System.out.println(isComplete("666888"));
        System.out.println();
    }
}

• Method isComplete is the method you were asked to write. It takes a single, String parameter and returns a String which is either COMPLETE or NOT_COMPLETE.
• Firstly, the method checks the validity of its parameter. While not explicitly mentioned in the problem statement, I think it's always a good idea to do so.
  • If the method parameter is null, the method returns NOT_COMPLETE, otherwise...
  • Remove leading and trailing spaces from the parameter.
  • hand is complete if it contains at least a single pair, hence the length of the parameter must be at least 2, so if the length is less than 2, the method returns NOT_COMPLETE.
• Convert the parameter to an array of char.
• Sort the array (since the question does not explicitly state that hand is sorted).
• Save the first element of the array in variable last.
  (There must be a first element because, at this point, the array contains at least two elements.)
• Iterate through the characters in the array, starting from the second character.
• If a character is not a digit then the method parameter is illegal and the method throws an exception.
• Variable count holds the number of consecutive appearances of a given character. If count reaches 3, we have a triple and we start counting again.
• When the "current" character is different to last, then if count equals one, that means there is only a single, consecutive appearance of a digit and that means that the hand is incomplete and therefore the method returns NOT_COMPLETE.
• Variable doubles holds the number of "pairs". There must only be precisely one double so if we count more than one double, the method returns NOT_COMPLETE.
• When the "current" character differs from last reset last and also reset count.
• At the end of the for loop, check the value of count and update doubles if required.
• Also at the end of the for loop, check the value of doubles. If it is not exactly 1 (one), then the method returns NOT COMPLETE.
• Finally, return the value of result – which is either COMPLETE or NOT COMPLETE.

Running the above code produces the following output:

COMPLETE
COMPLETE
COMPLETE
NOT COMPLETE
NOT COMPLETE
NOT COMPLETE

This method implements the important part. It should be easy to understand given the comments.

public static boolean isComplete(String s) {
// map characters to counts; if only digits, could have just stored in array-of-counts
HashMap<Integer, Integer> map = new HashMap<>();
s.chars().forEach(c -> map.put(c, map.getOrDefault(c, 0)+1));
// check that there is exactly 1 pair, and any number of triples, and no left-overs
boolean foundPair = false;
for (int v : map.values()) {
v %= 3; // keep only remainder modulo-three, as triples can be freely ignored
if (v == 2 && !foundPair) {
foundPair = true;                
} else if (v != 0) {
return false; // only triples (or 1 pair) allowed!
} 
}
return foundPair;
}