8. String to Integer (atoi) #array #java

Author: santosh

problems/8/README.md

@@ -0,0 +1,76 @@
+# 8. String to Integer (atoi)
+
+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 <code>[-2<sup>31</sup>, 2<sup>31</sup> - 1]</code>, then clamp the integer so that it remains in the range. Specifically, integers less than -2<sup>31</sup> should be clamped to -2<sup>31</sup>, and integers greater than 2<sup>31</sup> - 1 should be clamped to 2<sup>31</sup> - 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**:
+
+```
+Input: s = "42"
+Output: 42
+Explanation: The underlined characters are what is read in, 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 [-231, 231 - 1], the final result is 42.
+```
+
+**Example 2**:
+
+```
+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 [-231, 231 - 1], the final result is -42.
+```
+
+**Example 3**:
+
+```
+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 [-231, 231 - 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 `'.'`.
+
+
+---
+
+#array #java

problems/8/StringToInteger.class

@@ -0,0 +1,66 @@
+import java.util.ArrayList;
+import java.util.Objects;
+
+public class StringToInteger {
+    public static int myAtoi(String s) {
+        // definitions
+        boolean numIsNegative = false;
+        int counter = 0;
+
+        // ignore leading whitespace
+        s = s.stripLeading();
+
+        if (Objects.equals(s, "")) {
+            return 0;
+        }
+
+        char[] charArray = s.toCharArray();
+        if (charArray[0] == '-') {
+            numIsNegative = true;
+            counter = 1;
+        } else if (charArray[0] == '+') {
+            counter = 1;
+        }
+
+        ArrayList<Integer> num = new ArrayList<Integer>();
+
+        for (; counter < charArray.length; counter++) {
+            // check if the character is in int digit range from ascii table
+            if (charArray[counter] - '0' > 9 || charArray[counter] - '0' < 0) {
+                break;
+            }
+            num.add(charArray[counter] - '0');
+        }
+
+        int finalNum = 0;
+        int maxLimit = Integer.MAX_VALUE / 10;
+
+        for (int i = 0; i<num.size(); i++) {
+            int tempNum = num.get(i);
+            if(finalNum > maxLimit  || (finalNum == maxLimit && tempNum > 7)){
+                return numIsNegative ? Integer.MIN_VALUE : Integer.MAX_VALUE;
+            }
+            if (tempNum != 0) {
+                while (tempNum > 0) {
+                    finalNum *= 10;
+                    tempNum /= 10;
+                }
+            finalNum += num.get(i);
+            } else {
+                finalNum *= 10;
+            }
+        }
+
+        return numIsNegative ? -finalNum : finalNum;
+    }
+
+    public static void main(String[] args) {
+        System.out.println(myAtoi("42"));
+        System.out.println(myAtoi("+42"));
+        System.out.println(myAtoi("   -42"));
+        System.out.println(myAtoi("004193 with words"));
+        System.out.println(myAtoi("4193 with words"));
+        System.out.println(myAtoi("21474836460"));
+        System.out.println(myAtoi("2147483646")); // 2147483646
+    }
+}