String To Integer Atoi

                                            
class Solution {
public:
    int myAtoi(string s) {
        int i = 0, sign = 1, result = 0;
        
        // Remove leading whitespaces
        while (i < s.length() && s[i] == ' ') {
            i++;
        }
        
        // Check for sign
        if (i < s.length() && (s[i] == '-' || s[i] == '+')) {
            sign = (s[i++] == '-') ? -1 : 1;
        }
        
        // Convert digits to integer
        while (i < s.length() && isdigit(s[i])) {
            int digit = s[i] - '0';
            
            // Check for overflow
            if (result > INT_MAX / 10 || (result == INT_MAX / 10 && digit > INT_MAX % 10)) {
                return (sign == 1) ? INT_MAX : INT_MIN;
            }
            
            result = result * 10 + digit;
            i++;
        }
        
        return sign * result;
    }
};

                                            
class Solution:
    def myAtoi(self, s):
        s = s.strip()
        if not s:
            return 0
        
        sign = 1
        if s[0] == '-':
            sign = -1
            s = s[1:]
        elif s[0] == '+':
            s = s[1:]
        
        res = 0
        for char in s:
            if not char.isdigit():
                break
            res = res * 10 + int(char)
        
        res = max(-2**31, min(sign * res, 2**31 - 1))
        
        return res

                                            
int myAtoi(char* s) {
    int result = 0;
    int sign = 1;
    int i = 0;
    
    // Skip leading whitespace
    while (s[i] == ' ') {
        i++;
    }
    
    // Check for sign
    if (s[i] == '-') {
        sign = -1;
        i++;
    } else if (s[i] == '+') {
        i++;
    }
    
    // Read digits and convert to integer
    while (s[i] >= '0' && s[i] <= '9') {
        int digit = s[i] - '0';
        
        // Check for overflow
        if (result > INT_MAX / 10 || (result == INT_MAX / 10 && digit > INT_MAX % 10)) {
            return sign == 1 ? INT_MAX : INT_MIN;
        }
        
        result = result * 10 + digit;
        i++;
    }
    
    return sign * result;
}

                                            
const myAtoi = (s) => {
    const MAX_INT = Math.pow(2, 31) - 1;
    const MIN_INT = -Math.pow(2, 31);

    let sign = 1;
    let result = 0;
    let i = 0;

    while (s[i] === ' ') {
        i++;
    }

    if (s[i] === '+' || s[i] === '-') {
        sign = s[i] === '+' ? 1 : -1;
        i++;
    }

    while (i < s.length && !isNaN(parseInt(s[i]))) {
        result = result * 10 + parseInt(s[i]);
        i++;
    }

    result *= sign;

    if (result > MAX_INT) {
        return MAX_INT;
    } else if (result < MIN_INT) {
        return MIN_INT;
    } else {
        return result;
    }
};

                                            
function myAtoi(s: string): number {
    const maxInt = Math.pow(2, 31) - 1;
    const minInt = -Math.pow(2, 31);
    
    let sign = 1;
    let result = 0;
    let i = 0;
    
    while (s[i] === ' ') {
        i++;
    }
    
    if (s[i] === '-' || s[i] === '+') {
        sign = s[i] === '-' ? -1 : 1;
        i++;
    }
    
    for (; i < s.length; i++) {
        const digit = s.charCodeAt(i) - 48;
        
        if (digit < 0 || digit > 9) {
            break;
        }
        
        if (result > Math.floor((maxInt - digit) / 10)) {
            return sign === 1 ? maxInt : minInt;
        }
        
        result = result * 10 + digit;
    }
    
    return sign * result;
}

                                            
class Solution {
    func myAtoi(_ s: String) -> Int {
        var result = 0
        var sign = 1
        var i = s.startIndex
        
        while i < s.endIndex && s[i] == " " {
            i = s.index(after: i)
        }
        
        if i < s.endIndex && (s[i] == "+" || s[i] == "-") {
            sign = s[i] == "+" ? 1 : -1
            i = s.index(after: i)
        }
        
        while i < s.endIndex, let digit = s[i].wholeNumberValue {
            if result > Int32.max / 10 || (result == Int32.max / 10 && digit > Int32.max % 10) {
                return sign == 1 ? Int(Int32.max) : Int(Int32.min)
            }
            
            result = result * 10 + digit
            i = s.index(after: i)
        }
        
        return result * sign
    }
}

                                            
class Solution {
    fun myAtoi(s: String): Int {
        var index = 0
        var sign = 1
        var result = 0

        while (index < s.length && s[index] == ' ') {
            index++
        }

        if (index < s.length && (s[index] == '-' || s[index] == '+')) {
            sign = if (s[index] == '-') -1 else 1
            index++
        }

        while (index < s.length && s[index].isDigit()) {
            val digit = s[index] - '0'
            if (result > Int.MAX_VALUE / 10 || (result == Int.MAX_VALUE / 10 && digit > 7)) {
                return if (sign == 1) Int.MAX_VALUE else Int.MIN_VALUE
            }
            result = result * 10 + digit
            index++
        }

        return sign * result
    }
}

To solve this coding challenge, we need to write a function that converts a string into a 32-bit signed integer. This is akin to the atoi function in C/C++. This challenge involves several distinct steps as outlined below.

Explanation

Whitespace Handling :

Ignore any leading spaces or tabs. These are considered insignificant.

Sign Determination :

Check if the next character (after leading whitespace) is either '-' or '+'. This determines whether the resulting integer is negative or positive. If neither symbol is present, we assume the number is positive.

Numeric Conversion :

Read the sequence of digits and convert them into an integer. Ignore any leading zeros because they do not affect the integer value.

Non-Digit Characters :

Stop reading the string once a non-digit character is found or the end of the string is reached. Before this stopping point, the characters are converted to their integer equivalents.

Range Enforcement :

Ensure that the resulting integer fits within the 32-bit signed integer range, which is between -2,147,483,648 and 2,147,483,647. If the integer is out of this range, we should clamp it to fit within this range.

The following pseudocode outlines the detailed steps:

Pseudocode with Comments:

                                            
# Function to convert the given string to a 32-bit signed integer
function myAtoi(inputString):

# Step 1: trim leading whitespace
inputString = trimLeadingWhitespace(inputString)

# If the string is empty, return 0
if inputString is empty:
return 0

# Initialize the result and the sign
integerResult = 0
sign = 1

# Step 2: check for the sign
if inputString starts with '-':
sign = -1
remove the first character from inputString
else if inputString starts with '+':
remove the first character from inputString

# Step 3: convert the numeric part
for each character in inputString:
if character is not a digit:
break
# Update the result by shifting left (multiplying by 10) and adding the new digit
integerResult = integerResult * 10 + convertCharacterToDigit(character)

# Apply the sign to the result
integerResult = sign * integerResult

# Step 4: enforce the 32-bit signed integer range
if integerResult < -2147483648:
return -2147483648
else if integerResult > 2147483647:
return 2147483647

# Return the final result
return integerResult

Detailed Steps in Pseudocode

Whitespace Handling :

Remove leading whitespace characters from the string.
If the string becomes empty after trimming, the function should return 0 as there are no numeric characters to process.

Sign Determination :

If the first character of the trimmed string is '-', set the
sign

variable to -1 and remove this character from the string.
If the first character is '+', simply remove this character without changing the
sign

(it remains positive).

Numeric Conversion :

Initialize
integerResult

to 0.
Iterate through each character of the remaining string. If the character is a digit, convert it to its numeric value and update
integerResult

accordingly using
integerResult = integerResult * 10 + digitValue

.
If a non-digit character is encountered, break out of the loop as it indicates the end of the number sequence.

Range Enforcement :

Multiply
integerResult

by
sign

to obtain the final value.
Check if this final value falls within the 32-bit signed integer range, which is from -2,147,483,648 to 2,147,483,647.
If the final value is less than -2,147,483,648, return -2,147,483,648.
If the final value is greater than 2,147,483,647, return 2,147,483,647.
Otherwise, return the final value.

Making sure that each of these steps is carefully and correctly implemented ensures that the solution adheres to the constraints and requirements of the problem statement.