Valid Number

class Solution {
public:
    bool isValidNumeric(string str) {
        map<string, int> stateMachine[8] = {{{"digit", 1}, {"sign", 2}, {"dot", 3}},
                                            {{"digit", 1}, {"dot", 4}, {"exp", 5}},
                                            {{"digit", 1}, {"dot", 3}},
                                            {{"digit", 4}},
                                            {{"digit", 4}, {"exp", 5}},
                                            {{"sign", 6}, {"digit", 7}},
                                            {{"digit", 7}},
                                            {{"digit", 7}}};
        int state = 0;
        string category;
        for (char c : str) {
            if (isdigit(c)) {
                category = "digit";
            } else if (c == '+' || c == '-') {
                category = "sign";
            } else if (c == 'e' || c == 'E') {
                category = "exp";
            } else if (c == '.') {
                category = "dot";
            } else {
                return false;
            }
            if (stateMachine[state].find(category) == stateMachine[state].end()) {
                return false;
            }
            state = stateMachine[state][category];
        }
        return state == 1 || state == 4 || state == 7;
    }
};

This C++ solution tackles the problem of validating whether a given string represents a valid numeric value. The function isValidNumeric operates by utilizing a finite state machine represented by an array of maps, where each map dictates valid transitions based on input character categories like digits, signs, exponentials, and decimal points.

• The solution defines eight states within the state machine, each corresponding to different validation scenarios:
  • State transitions are defined based on the character category encountered: digits, plus or minus signs, exponential symbols (e or E), and dots (decimal points).
• The character analysis within the string is handled with a loop:
  • It classifies each character into one of the predefined categories.
  • If a character does not fit into any known category, or if there's no valid transition available for the current state and the current character category, the function returns false, indicating the string is not a valid number.
• After processing all characters, the validity of the numeric string is concluded based on the end state:
  • A valid termination state (where the string could naturally end as a number) includes states that correspond to a complete number without pending numeric or sign inputs (states 1, 4, or 7 in this case).

Through these logical state transitions, the solution effectively parses and validates the structure of numeric strings, ensuring coherence with numerical formats that can include integers, decimals, and scientific notation.

class Solution {
    private static final List<Map<String, Integer>> stateMachine = List.of(
        Map.of("integer", 1, "sign", 2, "decimal", 3),
        Map.of("integer", 1, "decimal", 4, "exponent", 5),
        Map.of("integer", 1, "decimal", 3),
        Map.of("integer", 4),
        Map.of("integer", 4, "exponent", 5),
        Map.of("sign", 6, "integer", 7),
        Map.of("integer", 7),
        Map.of("integer", 7)
    );
    
    private static final Set<Integer> acceptedStates = Set.of(1, 4, 7);
    
    public boolean isNumber(String input) {
        int currentState = 0;
        String type = "";
    
        for (int i = 0; i < input.length(); i++) {
            char charAtCurrent = input.charAt(i);
            if (Character.isDigit(charAtCurrent)) {
                type = "integer";
            } else if (charAtCurrent == '+' || charAtCurrent == '-') {
                type = "sign";
            } else if (charAtCurrent == 'e' || charAtCurrent == 'E') {
                type = "exponent";
            } else if (charAtCurrent == '.') {
                type = "decimal";
            } else {
                return false;
            }
    
            if (!stateMachine.get(currentState).containsKey(type)) {
                return false;
            }
    
            currentState = stateMachine.get(currentState).get(type);
        }
    
        return acceptedStates.contains(currentState);
    }
}

The provided Java solution determines whether a given string can be interpreted as a valid number. The solution utilizes a finite state machine (FSM), which is a model of computation used to design both computer programs and sequential logic circuits. Below are the key components of the solution:

• State Machine Definition: The stateMachine is a list of maps where each map represents possible transitions from a state based on the type of character encountered (e.g., integer, sign, decimal, exponent). Each character in the input string guides the transition to the next state.

• Accepted States: The acceptedStates set defines which states indicate a valid number if the FSM ends in one of these states after processing the entire input string.

• Input Processing: The isNumber method processes each character of the input string, categorizing it as 'integer', 'sign', 'exponent', or 'decimal'. Based on the current state and the character category, the FSM transitions to the next state.

• Character Type Detection: The method determines the character type using simple conditional checks:

  • Characters '0'-'9' are classified as "integer".
  • Characters '+' and '-' are classified as "sign".
  • Characters 'e' and 'E' are classified as "exponent".
  • The character '.' is classified as "decimal".

• State Transition: If a character type is not valid for the current state (i.e., no transition defined in the stateMachine for this type from the current state), the method returns false. This also implies that any non-defined character leads to an invalid number.

• Final State Validation: After all characters are processed, the method checks if the current state is one of the accepted states. If so, the input is considered a valid number; otherwise, it is not.

This structure offers a robust handling of numerical string validation, ensuring precise conformity to formatting rules such as the presence of signs, integers, decimals, and exponents in a number. Implementing this solution ensures that one can accurately validate if a string qualifies as a proper numeric representation under standard numeric rules.

struct transition_state {
    int value;
    char label[20];
    UT_hash_handle hh;
};
    
bool validateNumber(char *str) {
    struct transition_state *stateTable[8];
    for (int index = 0; index < 8; index++) stateTable[index] = NULL;
    
    void insertState(struct transition_state **target, char *label, int value) {
        struct transition_state *entry = malloc(sizeof(struct transition_state));
        strcpy(entry->label, label);
        entry->value = value;
        HASH_ADD_STR(*target, label, entry);
    }
    
    insertState(&stateTable[0], "digit", 1);
    insertState(&stateTable[0], "sign", 2);
    insertState(&stateTable[0], "dot", 3);
    insertState(&stateTable[1], "digit", 1);
    insertState(&stateTable[1], "dot", 4);
    insertState(&stateTable[1], "exponent", 5);
    insertState(&stateTable[2], "digit", 1);
    insertState(&stateTable[2], "dot", 3);
    insertState(&stateTable[3], "digit", 4);
    insertState(&stateTable[4], "digit", 4);
    insertState(&stateTable[4], "exponent", 5);
    insertState(&stateTable[5], "sign", 6);
    insertState(&stateTable[5], "digit", 7);
    insertState(&stateTable[6], "digit", 7);
    insertState(&stateTable[7], "digit", 7);
    
    int currentState = 0;
    struct transition_state *found;
    for (int index = 0; str[index] != '\0'; index++) {
        char category[10];
        if (isdigit(str[index])) {
            strcpy(category, "digit");
        } else if (str[index] == '+' || str[index] == '-') {
            strcpy(category, "sign");
        } else if (str[index] == 'e' || str[index] == 'E') {
            strcpy(category, "exponent");
        } else if (str[index] == '.') {
            strcpy(category, "dot");
        } else {
            return false;
        }
    
        HASH_FIND_STR(stateTable[currentState], category, found);
        if (found == NULL) {
            return false;
        }
        currentState = found->value;
    }
    return currentState == 1 || currentState == 4 || currentState == 7;
}

This C programming solution employs a finite state machine (FSM) approach for validating if a given string represents a valid numerical value. The solution involves defining a structure called transition_state to represent states and transitions based on input characters. Here's a breakdown of the solution implementation:

• Define a struct transition_state to manage states and transitions, which includes an integer value and a character array label to store the state transition condition, and a hash handle hh for quick lookup.

• Implement the validateNumber function that initializes a state table as an array of pointers to transition_state structs for different states of the FSM.

• Utilize a helper function insertState to add new state transitions to the state table. This function inserts state transitions based on character categories such as 'digit', 'sign', 'dot', and 'exponent'.

• Populate the state table specifically for each character type and set transitions between states based on valid numerical format (digits, signs, decimal points, and exponents).

• The core validation process in validateNumber involves iterating over each character of the input string, classifying it, and using the FSM to check the validity based on the transitions defined in the state table.

• Validate the final state after processing all the characters to ensure it ends in a valid terminal state (states that represent a complete valid number).

• Return true if the string is a valid number according to the FSM defined; otherwise, return false.

This method of using a finite state machine is effective for parsing and validation tasks such as this, as it clearly defines permissible transitions for different input types and simplifies the validation logic.

var isValidNumber = function (input) {
    const stateTable = [
        { digit: 1, sign: 2, dot: 3 },
        { digit: 1, dot: 4, exponent: 5 },
        { digit: 1, dot: 3 },
        { digit: 4 },
        { digit: 4, exponent: 5 },
        { sign: 6, digit: 7 },
        { digit: 7 },
        { digit: 7 },
    ];
    let currentState = 0;
    let characterType;
    for (const char of input) {
        if (char >= "0" && char <= "9") {
            characterType = "digit";
        } else if (char === "+" || char === "-") {
            characterType = "sign";
        } else if (char === "e" || char === "E") {
            characterType = "exponent";
        } else if (char === ".") {
            characterType = "dot";
        } else {
            return false;
        }
        if (!stateTable[currentState][characterType]) {
            return false;
        }
        currentState = stateTable[currentState][characterType];
    }
    return currentState === 1 || currentState === 4 || currentState === 7;
};

The provided JavaScript code defines a function isValidNumber that checks if an input string can be considered a valid number using a finite state machine. Below is a breakdown of how this implementation works:

• The function utilizes a stateTable array where each element corresponds to a specific state in the state machine. Each state is represented as an object which contains possible transitions based on the character type: digit, sign, dot, or exponent.
• The isValidNumber starts at an initial state, currentState = 0. It inspects each character in the input string to determine its type and uses this to update the currentState based on transitioning rules defined in the stateTable.
• Character types are determined as follows:
  • Numeric characters (0-9) are classified as digit.
  • Plus (+) and minus (-) signs are classified as sign.
  • The letter e or E (which denotes an exponent in a number) is classified as exponent.
  • A period . is identified as a dot.
• If a character doesn't fit into any of these classifications or a transition for a character type is undefined in the current state, the function returns false, indicating the input is not a valid number.
• After all characters are processed, the function checks if the currentState is one of 1, 4, or 7. These states indicate a valid terminating state for a number (integer or decimal formats, and numbers with an exponent).

This approach efficiently checks the validity of the string as a numeric representation by leveraging the predictable rules of number formats and transitions between valid states without using regular expressions or manual extensive checks.

class Solution(object):
    def is_valid_number(self, str_input):
        state_machine = [
            {"digit": 1, "sign": 2, "dot": 3},
            {"digit": 1, "dot": 4, "exponent": 5},
            {"digit": 1, "dot": 3},
            {"digit": 4},
            {"digit": 4, "exponent": 5},
            {"sign": 6, "digit": 7},
            {"digit": 7},
            {"digit": 7},
        ]
    
        state = 0
        for char in str_input:
            if char.isdigit():
                category = "digit"
            elif char in ["+", "-"]:
                category = "sign"
            elif char in ["e", "E"]:
                category = "exponent"
            elif char == ".":
                category = "dot"
            else:
                return False
    
            if category not in state_machine[state]:
                return False
    
            state = state_machine[state][category]
    
        return state in [1, 4, 7]

To determine if a given string is a valid number, this Python solution employs a state machine approach. By using a series of states and possible transitions between them based on character categories, the solution efficiently validates the input string.

Below outlines the logic for parsing and validating a string as a number:

• Initializes a dictionary representing a state machine to manage transitions, based on different character categories: digits, signs, decimal points, and exponents.
• Initiates the starting state, and iteratively processes each character in the input string to determine the legality of state transitions:
  • Categorizes each character into digit, sign, dot, or exponent. Any character that doesn't fit these categories leads to an immediate validation failure.
  • Checks if the category of the current character is valid for the current state of the state machine. If it's invalid, the function returns false.
  • Updates the state according to the state transition defined in the state machine.
• After processing all characters, checks if the resulting state is one of the acceptable terminating states, which are states where a number can validly end.

The performance of the solution is dependant on the length of the input string, making it efficient as the state transitions are all handled in constant time for each character. Ensure your input string is not empty or comprised only of whitespace, as this state machine expects at least one valid numeral or sign in the configuration.

By using this method, determining validity of numeric strings is systematic and avoids the common pitfalls of string parsing and type conversion errors.