LeetCode/string-to-integer-aoi/nodejs/index.js

147 lines
4.1 KiB
JavaScript
Raw Normal View History

2019-11-30 13:38:49 -06:00
/*
* Implement atoi which converts a string to an integer.
*
* The function first discards as many whitespace characters as necessary until the first non-whitespace character is found.
* Then, starting from this character, takes an optional initial plus or minus sign followed by as many numerical digits as possible,
* and interprets them as a numerical value.
*
* The string can contain additional characters after those that form the integral number, which are ignored and have no effect
* on the behavior of this function.
*
* If the first sequence of non-whitespace characters in str is not a valid integral number, or if no such sequence exists because
* either str is empty or it contains only whitespace characters, no conversion is performed.
* If no valid conversion could be performed, a zero value is returned.
*
* Note:
* Only the space character ' ' is considered as whitespace character.
* Assume we are dealing with an environment which could only store integers within the 32-bit signed integer range: [231, 231 1]. If the numerical value is out of the range of representable values, INT_MAX (231 1) or INT_MIN (231) is returned.
*/
const { assert } = require('../../util/js');
2019-11-30 13:38:49 -06:00
/**
* @param {string} str
* @return {number}
*/
const myAtoi = function(str) {
const INT_MAX = Math.pow(2,31) -1;
const INT_MIN = Math.pow(2,31)* -1;
let trimmedStr = str.trim();
const valid = ['0', '1', '2','3','4','5','6','7','8','9', '-', '+'];
const signs = ['-', '+'];
if(
!valid.includes(trimmedStr[0])
|| (trimmedStr.length === 1&& signs.includes(trimmedStr[0]))
|| (signs.includes(trimmedStr[0]) && signs.includes(trimmedStr[1]))
|| (signs.includes(trimmedStr[0]) && !valid.includes(trimmedStr[1]))
) {
return 0;
}
const decimalIndx = str.indexOf('.');
if (decimalIndx > -1){
trimmedStr = str.substring(0, decimalIndx);
}
const isNeg = trimmedStr[0] === '-';
const isPlus = trimmedStr[0] === '+';
const queue = [];
const list = trimmedStr.split('');
for(let i = 0; i < list.length; i++){
const char = list[i];
if(!valid.includes(char) ||(signs.includes(char) && i > 0)) {
break;
}
if(valid.includes(char)){
queue.push(char);
}
}
if(isNeg){
queue.shift();
}
if (isPlus){
queue.shift();
}
let integer = parseInt(queue.pop(), 10);
while(queue.length){
let multipler = queue.length;
let char = queue.shift();
integer += (Math.pow(10, multipler)* parseInt(char, 10));
}
if(isNeg){
integer= integer*-1;
}
if (integer >INT_MAX){
return INT_MAX;
}
if (integer < INT_MIN){
return INT_MIN;
}
return integer;
};
/*
* Test Case 1
* Input: "42"
* Output: 42
*/
x = '42';
sol = 42;
assert(myAtoi(x) === sol, 'Output: 42');
/* Explanation: The first non-whitespace character is '-', which is the minus sign.
* Then take as many numerical digits as possible, which gets 42.
*/
/* Test Case 2
* Input: " -42"
* Output: -42
*/
x = " -42";
sol = -42;
assert(myAtoi(x) === sol, 'Output: -42');
/* Test Case 3
* Input: "4193 with words"
* Output: 4193
*/
x = '4193 with words';
sol = 4193;
assert(myAtoi(x) === sol, 'Output: 4193');
/* Explanation: Conversion stops at digit '3' as the next character is not a numerical digit.
*/
/* Test Case 4
* Input: "words and 987"
* Output: 0
*/
x = 'words and 987';
sol = 0;
assert(myAtoi(x) === sol, 'Output: 0');
/* Explanation: The first non-whitespace character is 'w', which is not a numerical digit or a +/- sign.
* Therefore no valid conversion could be performed.
*/
/* Test Case 5
* Input: "-91283472332"
* Output: -2147483648
*/
x = '-91283472332';
sol = -2147483648;
assert(myAtoi(x) === sol, 'Output: -2147483648');
/*Explanation: The number "-91283472332" is out of the range of a 32-bit signed integer.
* Thefore INT_MIN (231) is returned.
*/