一篇学会字符串转换整数 (Atoi)

开发 前端
实现一个 func myAtoi(_ str: String) -> Int 函数,使其能将字符串转换成一个 32 位有符号整数(类似 C/C++ 中的 atoi 函数)。

1. 描述

实现一个 func myAtoi(_ str: String) -> Int 函数,使其能将字符串转换成一个 32 位有符号整数(类似 C/C++ 中的 atoi 函数)。

函数 func myAtoi(_ str: String) -> Int 的算法如下:

  • 读入字符串并丢弃无用的前导空格
  • 检查下一个字符(假设还未到字符末尾)为正还是负号,读取该字符(如果有)。确定最终结果是负数还是正数。如果两者都不存在,则假定结果为正。
  • 读入下一个字符,直到到达下一个非数字字符或到达输入的结尾。字符串的其余部分将被忽略。
  • 将前面步骤读入的这些数字转换为整数(即,"123" -> 123, "0032" -> 32)。如果没有读入数字,则整数为 0 。必要时更改符号(从步骤 2 开始)。
  • 如果整数数超过 32 位有符号整数范围 [?2^31, 2^31 ? 1] ,需要截断这个整数,使其保持在这个范围内。具体来说,小于 ?2^31 的整数应该被固定为 ?2^31 ,大于 2^31 ? 1 的整数应该被固定为 2^31 ? 1 。
  • 返回整数作为最终结果。

注意:

  • 本题中的空白字符只包括空格字符 ' ' 。

除前导空格或数字后的其余字符串外,请勿忽略 任何其他字符。

2. 示例

示例 1

  1. 输入:str = "42" 
  2. 输出:42 
  3. 解释:加粗的字符串为已经读入的字符,插入符号是当前读取的字符。 
  4. 第 1 步:"42"(当前没有读入字符,因为没有前导空格) 
  5.          ^ 
  6. 第 2 步:"42"(当前没有读入字符,因为这里不存在 '-' 或者 '+') 
  7.          ^ 
  8. 第 3 步:"42"(读入 "42") 
  9.            ^ 
  10. 解析得到整数 42 。 
  11. 由于 "42" 在范围 [-231, 231 - 1] 内,最终结果为 42 。 

示例 2

  1. 输入:str = "-42" 
  2. 输出:-42 
  3. 解释: 
  4. 第 1 步:"   -42"(读入前导空格,但忽视掉) 
  5.             ^ 
  6. 第 2 步:"   -42"(读入 '-' 字符,所以结果应该是负数) 
  7.              ^ 
  8. 第 3 步:"   -42"(读入 "42") 
  9.                ^ 
  10. 解析得到整数 -42 。 
  11. 由于 "-42" 在范围 [-231, 231 - 1] 内,最终结果为 -42 。 

示例 3

  1. 输入:str = "4193 with words" 
  2. 输出:4193 
  3. 解释: 
  4. 第 1 步:"4193 with words"(当前没有读入字符,因为没有前导空格) 
  5.          ^ 
  6. 第 2 步:"4193 with words"(当前没有读入字符,因为这里不存在 '-' 或者 '+') 
  7.          ^ 
  8. 第 3 步:"4193 with words"(读入 "4193";由于下一个字符不是一个数字,所以读入停止) 
  9.              ^ 
  10. 解析得到整数 4193 。 
  11. 由于 "4193" 在范围 [-231, 231 - 1] 内,最终结果为 4193 。 

示例 4

  1. 输入:str = "words and 987" 
  2. 输出:0 
  3. 解释: 
  4. 第 1 步:"words and 987"(当前没有读入字符,因为没有前导空格) 
  5.          ^ 
  6. 第 2 步:"words and 987"(当前没有读入字符,因为这里不存在 '-' 或者 '+') 
  7.          ^ 
  8. 第 3 步:"words and 987"(由于当前字符 'w' 不是一个数字,所以读入停止) 
  9.          ^ 
  10. 解析得到整数 0 ,因为没有读入任何数字。 
  11. 由于 0 在范围 [-231, 231 - 1] 内,最终结果为 0 。 

示例 5

  1. 输入:str = "-91283472332" 
  2. 输出:-2147483648 
  3. 解释: 
  4. 第 1 步:"-91283472332"(当前没有读入字符,因为没有前导空格) 
  5.          ^ 
  6. 第 2 步:"-91283472332"(读入 '-' 字符,所以结果应该是负数) 
  7.           ^ 
  8. 第 3 步:"-91283472332"(读入 "91283472332") 
  9.                      ^ 
  10. 解析得到整数 -91283472332 。 
  11. 由于 -91283472332 小于范围 [-231, 231 - 1] 的下界,最终结果被截断为 -231 = -2147483648 。 

约束条件:

  • 0 <= s.length <= 200
  • s 由英文字母(大写和小写)、数字(0-9)、' '、'+'、'-' 和 '.' 组成

3. 答案

  1. class Atoi { 
  2.     func myAtoi(_ str: String) -> Int { 
  3.         var res = 0, flag = 1, index = 0 
  4.         let intMax = 2147483647, intMin = -2147483648, strChars = Array(str) 
  5.          
  6.         // trim 
  7.         while index < strChars.count { 
  8.             let currentChar = strChars[index
  9.              
  10.             // trim 
  11.             guard currentChar.isWhitespace else { 
  12.                 break 
  13.             } 
  14.              
  15.             index += 1 
  16.         } 
  17.          
  18.         guard index < strChars.count else { 
  19.             return res 
  20.         } 
  21.          
  22.         // handle flag 
  23.         if strChars[index] == "-" { 
  24.             flag = -1 
  25.             index += 1 
  26.         } else if strChars[index] == "+" { 
  27.             index += 1 
  28.         } 
  29.          
  30.         // cast to number 
  31.         while index < strChars.count { 
  32.             let currentChar = strChars[index
  33.              
  34.             guard currentChar.isNumber else { 
  35.                 break 
  36.             } 
  37.              
  38.             res = res * 10 + currentChar.wholeNumberValue! 
  39.              
  40.             if res >= intMax { 
  41.                 if flag == 1 { 
  42.                     return intMax 
  43.                 } else if flag == -1 && res > intMax { 
  44.                     return intMin 
  45.                 } 
  46.             } 
  47.              
  48.             index += 1 
  49.         } 
  50.          
  51.         return flag * res 
  52.     } 
  • 主要思想:修剪,正和负,整数溢出,是字符数字
  • 时间复杂度:O(n)
  • 空间复杂度:O(1)

 

该算法题解的仓库:LeetCode-Swift[2]

 

责任编辑:武晓燕 来源: Swift社区
相关推荐

2021-12-08 14:02:20

符串排列搜索

2023-03-07 10:07:04

JavaScript字符串反斜杠

2022-01-02 08:43:46

Python

2022-02-07 11:01:23

ZooKeeper

2021-11-15 07:47:40

字符串位置存储

2021-05-28 10:02:05

Swift5 字符串String

2021-07-02 09:45:29

MySQL InnoDB数据

2021-07-05 22:11:38

MySQL体系架构

2021-07-06 08:59:18

抽象工厂模式

2021-05-11 08:54:59

建造者模式设计

2023-01-03 08:31:54

Spring读取器配置

2022-08-26 09:29:01

Kubernetes策略Master

2022-08-23 08:00:59

磁盘性能网络

2023-11-28 08:29:31

Rust内存布局

2021-07-16 22:43:10

Go并发Golang

2022-04-12 08:30:52

回调函数代码调试

2021-10-27 09:59:35

存储

2021-07-02 08:51:29

源码参数Thread

2023-03-13 21:38:08

TCP数据IP地址

2022-10-20 07:39:26

点赞
收藏

51CTO技术栈公众号