Leetcode 0008: cadena a entero (atoi)

Descripción del Título:

Implemente la función myAtoi (string s), que convierte una cadena en un entero de 32 bits con signo (similar a la función atoi de C / C ++).
El algoritmo para myAtoi (string s) es el siguiente:
Lea e ignore cualquier espacio en blanco inicial.
Compruebe si el siguiente carácter (si aún no está al final de la cadena) es '-' o '+'. Lea este personaje si lo es. Esto determina si el resultado final es negativo o positivo respectivamente. Suponga que el resultado es positivo si ninguno está presente.
Lea a continuación los caracteres hasta que se alcance el siguiente carácter que no sea un dígito o el final de la entrada. El resto de la cadena se ignora.
Convierta estos dígitos en un número entero (es decir, "123" -> 123, "0032" -> 32). Si no se leyeron dígitos, entonces el número entero es 0. Cambie el signo según sea necesario (desde el paso 2).
Si el número entero está fuera del rango de números enteros con signo de 32 bits [-2 ³¹ , 2 ³¹ - 1], fije el número entero para que permanezca en el rango. Específicamente, los enteros menores que -2 ^{31 se} deben restringir a -2 ³¹ , y los enteros mayores que 2 ³¹ - 1 se deben restringir a 2 ³¹ - 1.
Devuelve el entero como resultado final.

Nota:

Solo el carácter de espacio '' se considera un carácter de espacio en blanco.
No ignore ningún carácter que no sea el espacio en blanco inicial o el resto de la cadena después de los dígitos.

Ejemplo 1:

Entrada: s = “42”
Salida: 42
Explicación: Los caracteres subrayados son lo que se lee, el signo de intercalación es la posición actual del lector.
Paso 1: "42" (no se leen caracteres porque no hay espacios en blanco iniciales)
Paso 2: "42" (no se leen caracteres porque no hay un '-' ni un '+')
Paso 3: "42" ("42" se lee)
El entero analizado es 42.
Dado que 42 está en el rango [-2 ³¹ , 2 ³¹ - 1], el resultado final es 42.

Ejemplo 2:

Entrada: s = "-42"
Salida: -42
Explicación:
Paso 1: "-42" (el espacio en blanco inicial se lee y se ignora)
Paso 2: "-42" (se lee '-', por lo que el resultado debe ser negativo)
Paso 3: "-42" (se lee "42")
El entero analizado es -42.
Dado que -42 está en el rango [-2 ³¹ , 2 ³¹ - 1], el resultado final es -42.

Ejemplo 3:

Entrada: s = “4193 con palabras”
Salida: 4193
Explicación:
Paso 1: “4193 con palabras” (no se leen caracteres porque no hay espacios en blanco iniciales)
Paso 2: “4193 con palabras” (no se leen caracteres porque no hay un '-' ni '+')
Paso 3: “4193 con palabras” (se lee “4193”; la lectura se detiene porque el siguiente carácter no es un dígito)
El entero analizado es 4193.
Dado que 4193 está en el rango [- 2 ³¹ , 2 ³¹ - 1], el resultado final es 4193.

Ejemplo 4:

Entrada: s = "palabras y 987"
Salida: 0
Explicación:
Paso 1: "palabras y 987" (no se leen caracteres porque no hay espacios en blanco iniciales)
Paso 2: "palabras y 987" (no se leen caracteres porque no hay un '-' ni '+')
Paso 3: “palabras y 987” (la lectura se detiene inmediatamente porque hay una 'w' que no es un dígito)
El entero analizado es 0 porque no se leyeron dígitos.
Dado que 0 está en el rango [-2 ³¹ , 2 ³¹ - 1], el resultado final es 0.

Ejemplo 5:

Entrada: s = “-91283472332”
Salida: -2147483648
Explicación:
Paso 1: “-91283472332” (no se leen caracteres porque no hay espacios en blanco
iniciales ) Paso 2: “-91283472332” (se lee '-', por lo que el resultado debe ser negativo)
Paso 3: “-91283472332” (se lee “91283472332”)
El entero analizado es -91283472332.
Dado que -91283472332 es menor que el límite inferior del rango [-2 ³¹ , 2 ³¹ - 1], el resultado final se limita a -2 ³¹ = -2147483648.

Restricciones:

0 <= s.length <= 200
s consta de letras en inglés (minúsculas y mayúsculas), dígitos (0-9), '', '+', '-' y '.'.

Complejidad de tiempo: O (n)
usa solo registros int:

1. Recorra cada carácter de la cadena de izquierda a derecha. El puntero es k
2. Si la posición del carácter k es un carácter nulo, el puntero k continúa moviéndose hacia atrás, si k == n, significa que todos son caracteres nulos y devuelven 0 directamente
3. sign registra el positivo y negativo del entero interceptado. Si hay un signo negativo "-", entonces el signo es -1, de lo contrario el signo es 1.
4. Use int type res para almacenar el todo interceptado en un momento determinado
5. Si el signo es 1, (res * 10 + x) * signo> INT_MAX, es decir, res * signo> (INT_MAX-x) / 10, entonces se devuelve INF_MAX, lo que indica que se ha excedido (donde x es un número positivo)
6. Si el signo es -1, (res * 10 + x) * signo <INT_MIN, es decir, res * signo> (INT_MIN-x * (-1)) / 10, se devuelve INF_MIN, lo que indica que se ha excedido (donde x es un número negativo)
   4 、 Si res> INT_MAX o res <INT_MIN, devuelve INF_MAX o INT_MIN
   5, y finalmente devuelve el signo res *.

class Solution {
    
    
    public int myAtoi(String s) {
    
    
        int n = s.length();
        int k = 0;
        while(k < n && s.charAt(k) == ' ') k++;
        if(k == n) return 0;
        int sign = 1;
        if(s.charAt(k) == '-'){
    
    
            sign = -1;
            k++;
        }else if(s.charAt(k) == '+'){
    
    
            k++;
        }
        int res = 0;
        while( k < n && s.charAt(k) >= '0' && s.charAt(k) <= '9'){
    
    
            int x = s.charAt(k) - '0';
            if(sign > 0 && res > (Integer.MAX_VALUE - x)/10){
    
    
                res = Integer.MAX_VALUE;
                break;
            }
            if(sign < 0 && res*sign < (Integer.MIN_VALUE - (-1)*x)/10){
    
    
                res = Integer.MIN_VALUE;
                break;
            }
            res = res*10+x;
            k++;
        }
        return res*sign;
    }
}