Valid Number

• The core idea is to construct a single regular expression that encapsulates all the rules for a valid number.
• The regex is built by defining patterns for each component of a valid number: an optional sign, the mantissa (integer or decimal part), and an optional exponent.
• The components are combined, and anchored with ^ and $ to ensure the entire string must match the pattern.
• The final regex is ^[+-]?(\d+(\.\d*)?|\.\d+)([eE][+-]?\d+)?$.
• The String.matches() method in Java can be used to test the input string against this regex.

A valid number can be broken down into three parts: an optional sign, a number part (mantissa), and an optional exponent part. We can construct a regex that captures all these rules.

• Overall Structure: [sign][mantissa][exponent]
• Sign: [+-]? - An optional + or - at the beginning.
• Mantissa: (\d+(\.\d*)?|\.\d+) - This is the most complex part. It ensures there's at least one digit. It matches either:
  • \d+(\.\d*)?: One or more digits, optionally followed by a dot and zero or more digits. This covers cases like "2", "2.", and "2.3".
  • |: OR
  • \.\d+: A dot followed by one or more digits. This covers cases like ".3".
• Exponent: ([eE][+-]?\d+)? - This matches the optional exponent part. It looks for e or E, followed by an optional sign, and then one or more digits. The ? at the end makes the whole group optional.

Combining these parts and anchoring them with ^ (start of string) and $ (end of string) gives the final regex.

1class Solution {2    public boolean isNumber(String s) {3        // The regex is constructed to match the formal definition of a valid number.4        // ^[+-]?                # optional sign at the start5        // (6        //   \d+(\.\d*)?      # a number with an optional decimal part (e.g., "2", "2.", "2.5")7        //   |8        //   \.\d+             # a decimal part without an integer part (e.g., ".5")9        // )10        // ([eE][+-]?\d+)?      # an optional exponent part (e.g., "e-10")11        // $12        String regex = "^[+-]?(\\d+(\\.\\d*)?|\\.\\d+)([eE][+-]?\\d+)?$";13        return s.matches(regex);14    }15}

• Initialize boolean flags digitSeen, dotSeen, and eSeen to false.
• Iterate through the string character by character from left to right.
• For each character, apply a set of rules based on the current character and the flags:
  • Digit: Set digitSeen to true.
  • Dot .: Return false if a dot or e has already been seen. Otherwise, set dotSeen to true.
  • Exponent e or E: Return false if an e has already been seen or if no digit has been seen before it. Otherwise, set eSeen to true and reset digitSeen to false (to enforce that the exponent part must have digits).
  • Sign + or -: Return false if it's not at the beginning of the string and does not immediately follow an e or E.
  • Other characters: Return false immediately.
• After the loop finishes, return the final value of digitSeen. This final check correctly handles cases like "1e", ".", or "+", which are invalid because they lack a required digit part.

This implementation is a form of a state machine where the flags (digitSeen, dotSeen, eSeen) implicitly define the current state of the parsing process. We scan the string once, character by character, and validate the string's structure on the fly.

The logic ensures that all rules are followed. For instance, a dot . cannot appear after an e or another dot. An e must be preceded by a number and cannot appear more than once. A sign + or - is only allowed at the very beginning or immediately after an e. The final check on digitSeen is crucial to validate that the number or exponent part actually contains digits.

1class Solution {2    public boolean isNumber(String s) {3        boolean digitSeen = false;4        boolean dotSeen = false;5        boolean eSeen = false;6        int n = s.length();7 8        for (int i = 0; i < n; i++) {9            char c = s.charAt(i);10 11            if (Character.isDigit(c)) {12                digitSeen = true;13            } else if (c == '.') {14                if (dotSeen || eSeen) {15                    // A dot cannot appear after another dot or after 'e'16                    return false;17                }18                dotSeen = true;19            } else if (c == 'e' || c == 'E') {20                if (eSeen || !digitSeen) {21                    // 'e' cannot appear after another 'e' or without a preceding number22                    return false;23                }24                eSeen = true;25                digitSeen = false; // Reset digitSeen for the exponent part26            } else if (c == '+' || c == '-') {27                if (i != 0 && s.charAt(i - 1) != 'e' && s.charAt(i - 1) != 'E') {28                    // A sign must be at the start or immediately follow 'e'29                    return false;30                }31            } else {32                // Any other character is invalid33                return false;34            }35        }36 37        // The string is valid only if a digit was seen in the last component.38        // This handles cases like "1e", ".", "+", "1e+", which are invalid.39        return digitSeen;40    }41}