refactor: Renamed js to nodejs

- feat: Added util module

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

@@ -0,0 +1,146 @@
+/* 
+ * 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'); 
+
+/**
+ * @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.
+*/