LeetCode problem: 8. String to Integer (atoi)

Author: borrelunde

src/main/java/com/bl/string_to_integer_atoi/README.md

@@ -0,0 +1,81 @@
+# 8. String to Integer (atoi)
+
+Difficulty: `Medium`  
+Topics: `String`
+
+Implement the `myAtoi(string s)` function, which converts a string to a 32-bit signed integer (similar to C/C++'s `atoi`
+function).
+
+The algorithm for `myAtoi(string s)` is as follows:
+
+1. Read in and ignore any leading whitespace.
+2. Check if the next character (if not already at the end of the string) is `'-'` or `'+'`. Read this character in if it
+   is either. This determines if the final result is negative or positive respectively. Assume the result is positive if
+   neither is present.
+3. Read in next the characters until the next non-digit character or the end of the input is reached. The rest of the
+   string is ignored.
+4. Convert these digits into an integer (i.e. `"123" -> 123`, `"0032" -> 32`). If no digits were read, then the integer
+   is `0`. Change the sign as necessary (from step 2).
+5. If the integer is out of the 32-bit signed integer range `[-2^31, 2^31 - 1]`, then clamp the integer so that it
+   remains
+   in the range. Specifically, integers less than `-2^31` should be clamped to `-2^31`, and integers greater
+   than `2^31 - 1` should be clamped to `2^31 - 1`.
+6. Return the integer as the final result.
+
+Note:
+
+- Only the space character `' '` is considered a whitespace character.
+- **Do not ignore** any characters other than the leading whitespace or the rest of the string after the digits.
+
+**Example 1:**
+
+```text
+Input: s = "42"
+Output: 42
+Explanation: The caret is the current reader position.
+Step 1: "42" (no characters read because there is no leading whitespace)
+         ^
+Step 2: "42" (no characters read because there is neither a '-' nor '+')
+         ^
+Step 3: "42" ("42" is read in)
+           ^
+The parsed integer is 42.
+Since 42 is in the range [-2^31, 2^31 - 1], the final result is 42.
+```
+
+**Example 2:**
+
+```text
+Input: s = "   -42"
+Output: -42
+Explanation:
+Step 1: "   -42" (leading whitespace is read and ignored)
+            ^
+Step 2: "   -42" ('-' is read, so the result should be negative)
+            ^
+Step 3: "   -42" ("42" is read in)
+               ^
+The parsed integer is -42.
+Since -42 is in the range [-2^31, 2^31 - 1], the final result is -42.
+```
+
+**Example 3:**
+
+```text
+Input: s = "4193 with words"
+Output: 4193
+Explanation:
+Step 1: "4193 with words" (no characters read because there is no leading whitespace)
+         ^
+Step 2: "4193 with words" (no characters read because there is neither a '-' nor '+')
+         ^
+Step 3: "4193 with words" ("4193" is read in; reading stops because the next character is a non-digit)
+             ^
+The parsed integer is 4193.
+Since 4193 is in the range [-2^31, 2^31 - 1], the final result is 4193.
+```
+
+**Constraints:**
+
+- `0 <= s.length <= 200`
+- `s` consists of English letters (lower-case and upper-case), digits (`0-9`), `' '`, `'+'`, `'-'`, and `'.'`.

src/main/java/com/bl/string_to_integer_atoi/Solution.java

@@ -0,0 +1,111 @@
+package com.bl.string_to_integer_atoi;
+
+/**
+ * This is the solution to the LeetCode problem: 8. String to Integer (atoi)
+ *
+ * @author Børre A. Opedal Lunde
+ * @since 2024.01.25
+ */
+public class Solution {
+
+	static final char WHITESPACE = ' ';
+
+	static final char PLUS = '+';
+	static final char MINUS = '-';
+
+	static final int MINIMUM_VALUE = 0x80000000;  // -2^31
+	static final int MAXIMUM_VALUE = 0x7fffffff;  //  2^31 - 1
+
+	public int myAtoi(String s) {
+
+		// If the string is empty, return zero.
+		if (s.isEmpty()) {
+			return 0;
+		}
+
+		// Convert the string to a character array that we'll iterate over.
+		final char[] characters = s.toCharArray();
+
+		// Used to keep track of whether the number is negative or not.
+		boolean negative = false;
+
+		// This is the index used to iterate over the character array. It is
+		// declared outside the loop so that it can be used in both loops.
+		int i = 0;
+
+		// First, ignore leading whitespace and account for explicit sign
+		// symbol.
+		for (; i < characters.length; i++) {
+			char character = characters[i];
+
+			// Ignore leading whitespace.
+			if (character == WHITESPACE) {
+				continue;
+			}
+
+			// Account for explicit sign symbol.
+			else if (character == PLUS) {
+				// The number is positive by default, so we don't need to do
+				// set the negative flag to false.
+
+				// Increment the index to skip the sign symbol.
+				i++;
+			} else if (character == MINUS) {
+				negative = true;
+
+				// Same as above.
+				i++;
+			}
+
+			// If the character is not whitespace nor a sign symbol, we will
+			// delegate the rest of the work to the next loop. It is responsible
+			// for parsing the number.
+			break;
+		}
+
+		// We're parsing an integer, but we're using a long to avoid overflow
+		// and underflow.
+		long number = 0;
+
+		// Parse the number.
+		for (; i < characters.length; i++) {
+			final char character = characters[i];
+
+			// If the character is not a digit, we will break out of the loop.
+			if (! characterIsDigit(character)) {
+				break;
+			}
+
+			// Convert the character to a digit.
+			final int digit = digitFromCharacter(character);
+
+			// First, multiply the number by ten to make room for the new digit.
+			// Then, add the digit to the number, taking into account whether
+			// the number is negative or not.
+			number = number * 10 + (negative ? - digit : digit);
+
+			// Clamp the number if it is greater than the maximum value.
+			if (number <= MINIMUM_VALUE) {
+				return MINIMUM_VALUE;
+			}
+
+			// Clamp the number if it is less than the minimum value.
+			else if (number >= MAXIMUM_VALUE) {
+				return MAXIMUM_VALUE;
+			}
+		}
+
+		// Return the number as an integer.
+		return (int) number;
+	}
+
+	static int digitFromCharacter(final char character) {
+		// Assumes the digit character is in the ASCII table.
+		return character - '0';
+	}
+
+	static boolean characterIsDigit(final char character) {
+		// Assumes the character is in the ASCII table.
+		return character >= '0' && character <= '9';
+	}
+}