atoi

atoi/atoi.go

@@ -0,0 +1,56 @@
+package atoi
+
+import (
+	"math"
+	"regexp"
+	"strings"
+)
+
+var pattern, _ = regexp.Compile(`^\s*([-+]?)(\d+)`)
+
+func min(a, b int) int {
+	if a < b {
+		return a
+	}
+	return b
+}
+
+func max(a, b int) int {
+	if a > b {
+		return a
+	}
+	return b
+}
+
+func bound(num, low, hi int) int {
+	return min(max(low, num), hi)
+}
+
+func myAtoi(s string) int {
+	groups := pattern.FindStringSubmatch(s)
+	if groups == nil {
+		return 0
+	}
+
+	sign := 1
+	if groups[1] == "-" {
+		sign = -1
+	}
+
+	digits := strings.TrimLeft(groups[2], "0")
+	size := len(digits)
+	if size > 10 {
+		return bound(math.MaxInt64*sign, math.MinInt32, math.MaxInt32)
+	}
+	result := 0
+	for i, d := range digits {
+		val := int(d) - 48
+		result += int(math.Pow10(size-i-1)) * val
+	}
+
+	return bound(result*sign, math.MinInt32, math.MaxInt32)
+}
+
+func Convert(s string) int {
+	return myAtoi(s)
+}

atoi/atoi_test.go

@@ -0,0 +1,44 @@
+package atoi_test
+
+import (
+	"testing"
+
+	"git.jxs.me/leetgo/atoi"
+	"github.com/stretchr/testify/require"
+)
+
+func TestEmpty(t *testing.T) {
+	require.Equal(t, 0, atoi.Convert(""))
+}
+
+func TestSingle(t *testing.T) {
+	require.Equal(t, 7, atoi.Convert("7"))
+}
+
+func TestExample1(t *testing.T) {
+	require.Equal(t, 42, atoi.Convert("42"))
+}
+
+func TestExample2(t *testing.T) {
+	require.Equal(t, -42, atoi.Convert("  -42"))
+}
+
+func TestExample3(t *testing.T) {
+	require.Equal(t, 4193, atoi.Convert("4193 with words"))
+}
+
+func TestZeroPrefix(t *testing.T) {
+	require.Equal(t, 101, atoi.Convert("+00101"))
+}
+
+func TestOverflow(t *testing.T) {
+	require.Equal(t, -2147483648, atoi.Convert("-91283472332"))
+}
+
+func TestHuge(t *testing.T) {
+	require.Equal(t, 2147483647, atoi.Convert("20000000000000000000"))
+}
+
+func TestPad(t *testing.T) {
+	require.Equal(t, 12345678, atoi.Convert("  0000000000012345678"))
+}

atoi/readme.md

@@ -0,0 +1,71 @@
+8. String to Integer (atoi)
+Medium
+
+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:
+
+    Read in and ignore any leading whitespace.
+    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.
+    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.
+    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).
+    If the integer is out of the 32-bit signed integer range [-231, 231 - 1], then clamp the integer so that it remains in the range. Specifically, integers less than -231 should be clamped to -231, and integers greater than 231 - 1 should be clamped to 231 - 1.
+    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 '.'.
+
+