Week 2 Async Assignments Completed

week-1/problems/0-horizontal-align/index.html

@@ -8,14 +8,20 @@
     <title>Horizontal Align</title>
     <style>
         .container {
+            display: flex;
+            justify-content: center;
             width: 1200px;
-            /* margin: 0px auto; */
+            margin: 0px auto;
             background-color: red;
         }
 
         .content {
             height: 500px;
         }
+
+        h1{
+            margin: 0px;
+        }
     </style>
 </head>
 

week-2/week-2-async-js/easy/1-counter.js

@@ -0,0 +1,6 @@
+let counter = 0;
+
+setInterval(() => {
+    counter += 1;
+    console.log(counter);
+}, 1000);

week-2/week-2-async-js/easy/2-counter.js

@@ -0,0 +1,9 @@
+let count = 0;
+
+function addCount(){
+    count = count + 1;
+    console.log(count);
+    setTimeout( addCount , 1000);
+}
+
+addCount();

week-2/week-2-async-js/easy/3-readfile.js

@@ -0,0 +1,7 @@
+const fs = require("fs")
+
+fs.readFile('./a.txt', 'utf-8', (err, data) => {
+    console.log(data);
+});
+
+for(i = 1; i < 1000000000; i++){}

week-2/week-2-async-js/easy/4-writefile.js

@@ -0,0 +1,12 @@
+const fs = require("fs")
+
+const readFile = fs.readFileSync('./a.txt', 'utf-8')
+console.log("File contents before writing ", readFile );
+
+fs.writeFile('./a.txt', 'Hello Orca', (err) => {
+    if(err) throw new err;
+    console.log("File has been saved \n");
+
+    const afterWrite = fs.readFileSync('./a.txt', 'utf-8');
+    console.log(afterWrite);
+});

week-2/week-2-async-js/easy/a.txt

@@ -0,0 +1 @@
+Hello Orca

week-2/week-2-async-js/hard (promises)/1-promisify-setTimeout.js

@@ -3,6 +3,11 @@
 */
 
 function wait(n) {
+    const p = new Promise((resolve) => {
+        setTimeout(resolve, n * 1000);
+    });
+
+    return p
 }
 
-module.exports = wait;
+module.exports = wait

week-2/week-2-async-js/hard (promises)/2-sleep-completely.js

@@ -5,6 +5,11 @@
  */
 
 function sleep(milliseconds) {
+    return new Promise((resolve) => {
+        let startTime = new Date().getTime();
+        while (new Date().getTime() < startTime + milliseconds);
+        resolve();
+    });
 }
 
 module.exports = sleep;

week-2/week-2-async-js/hard (promises)/3-promise-all.js

@@ -5,18 +5,30 @@
  */
 
 function wait1(t) {
-
+    return new Promise((resolve) => {
+        setTimeout(resolve, t*1000)
+    })
 }
 
 function wait2(t) {
-
+    return new Promise((resolve) => {
+        setTimeout(resolve, t*1000)
+    });
 }
 
 function wait3(t) {
-
+    return new Promise((resolve) => {
+        setTimeout(resolve, t*1000)
+    });
 }
 
-function calculateTime(t1, t2, t3) {
+async function calculateTime(t1, t2, t3) {
+    const start = Date.now();
+
+    await Promise.all([wait1(t1), wait2(t2), wait3(t3)])
+
+    const end = Date.now();
+    return end - start;
 
 }
 

week-2/week-2-async-js/hard (promises)/4-promise-chain.js

@@ -6,19 +6,34 @@
  */
 
 function wait1(t) {
-
+    return new Promise(resolve => setTimeout(resolve, t*1000));
 }
 
 function wait2(t) {
-
+    return new Promise(resolve => setTimeout(resolve, t*1000));
 }
 
 function wait3(t) {
-
+    return new Promise(resolve => setTimeout(resolve, t*1000));
 }
 
-function calculateTime(t1, t2, t3) {
+async function calculateTime(t1, t2, t3) {
+    const start = new Date();
+    await wait1(t1);
+    console.log(t1, " seconds have passed");
+    await wait2(t2);
+    console.log(t2, " seconds have passed");
+    await wait3(t3);
+    console.log(t3, " seconds have passed");
 
+    const end = new Date();
+
+    return end - start;
 }
 
+const t1 = 1;
+const t2 = 2;
+const t3 = 3;
+
+calculateTime(t1, t2, t3);
 module.exports = calculateTime;

week-2/week-2-async-js/medium/clock.js

@@ -0,0 +1,19 @@
+function currentTime(){
+    const now = new Date();
+
+    const hr = now.getHours();
+    const mins = now.getMinutes().toString().padStart(2, '0');
+    const secs = now.getSeconds().toString().padStart(2, '0');
+
+    const ampm = hr >= 12 ? 'PM' : 'AM';
+    const ampmhr = (hr - 12).toString()
+    const hr12 = ampmhr+":"+mins+":"+secs+" "+ampm;
+    const hr24 = hr+":"+mins+":"+secs;
+
+    console.log(hr12);
+    console.log(hr24, "\n");
+
+    setTimeout(currentTime, 1000);
+}
+
+currentTime();

week-2/week-2-async-js/medium/prob1.js

@@ -0,0 +1,23 @@
+/* 
+The regular expression `/\s+/g` is used to match sequences of one or more whitespace characters in a string. Let’s break down its components:
+
+- `/.../`: Delimiters for the regular expression in many programming languages like JavaScript.
+- `\s`: A shorthand character class that matches any whitespace character (spaces, tabs, line breaks, etc.).
+- `+`: A quantifier that means "one or more" of the preceding element. So, `\s+` matches one or more whitespace characters.
+- `g`: A flag that stands for "global," meaning the pattern will be applied to the entire string, not just the first occurrence.
+
+In summary, `/\s+/g` finds all sequences of whitespace characters in a string. For example, if you have the string `"Hello    world!  How are   you?"`, using this regex would match `"    "` (multiple spaces) and `"  "` (two spaces), and you could use it to replace all such sequences with a single space or another character of your choice.
+*/
+
+
+const fs = require("fs")
+
+fs.readFile('./prob1.txt', 'utf-8', (err, data) => {
+    console.log("data before: ", data);
+    const words = data.replace(/\s+/g, ' ').trim();
+    console.log(words);
+
+    fs.writeFile('./prob1.txt', words, (err) => {
+        console.log("Done!");
+    })
+})

week-2/week-2-async-js/medium/prob1.txt

@@ -0,0 +1 @@
+  Hello        I        am       Raju       

week-2/week-2-js/easy/anagram.js

@@ -6,6 +6,17 @@
 
 function isAnagram(str1, str2) {
 
+  if(str1.length == str2.length){
+
+    let arr1 = str1.toLowerCase().split('').sort().join();
+    let arr2 = str2.toLowerCase().split('').sort().join();
+
+    return(arr1 === arr2);
+  }
+
+  return false;
 }
 
+console.log(isAnagram('spar', 'rasp'));
+
 module.exports = isAnagram;

week-2/week-2-js/easy/expenditure-analysis.js

@@ -14,7 +14,26 @@
 */
 
 function calculateTotalSpentByCategory(transactions) {
-  return [];
+
+  let output = [];
+
+  for(i = 0; i < transactions.length; i++){
+
+    const isIndex = output.findIndex(domain => domain.category === transactions[i].category)
+
+    if(isIndex != -1){
+      output[isIndex].totalSpent += transactions[i].price;
+    }
+    else{
+      output.push({
+        category: transactions[i].category,
+        totalSpent: transactions[i].price
+      })
+    }
+  }
+
+  return output;
 }
 
+
 module.exports = calculateTotalSpentByCategory;

week-2/week-2-js/easy/findLargestElement.js

@@ -6,7 +6,20 @@
 */
 
 function findLargestElement(numbers) {
-
+    const size = numbers.length;
+    if(size <= 0) return;
+
+    var maxValue = Number.MIN_SAFE_INTEGER;
+
+    for(i = 0; i < size; i++){
+        if(numbers[i] > maxValue){
+            maxValue = numbers[i];
+        }
+    }
+
+    return maxValue;
 }
 
+console.log(findLargestElement([3, 7, 2, 9, 1]));
+
 module.exports = findLargestElement;

week-2/week-2-js/hard/calculator.js

@@ -16,6 +16,61 @@
   Once you've implemented the logic, test your code by running
 */
 
-class Calculator {}
+class Calculator {
+
+  constructor(){
+    this.result = 0;
+  }
+
+  add(num){
+    this.result = this.result + num;
+
+  }
+
+  subtract(num){
+    this.result = this.result - num;
+  }
+
+  multiply(num){
+    this.result = this.result * num;
+  }
+
+  divide(num){
+    if(num == 0){
+      throw new Error("Numbers cannot be divided by zero")
+    }
+    this.result = this.result / num;
+  }
+
+  clear(){
+    this.result = 0;
+  }
+
+  getResult(){
+    return this.result;
+  }
+
+  calculate(inputExpression){
+    const temp = inputExpression;
+    const cleanedExpression = temp.replace('/\s+/g', ' ');
+    const isNotExpression = /^[0-9+\-*/().]+$/.test(cleanedExpression);
+
+    if (isNotExpression) {
+      throw new Error("Invalid expression");
+    }
+
+    try {
+      this.result = eval(inputExpression);
+    } catch (error) {
+      throw new Error("Invalid expression.");
+    }
+
+    if (this.result === Infinity) {
+      throw new Error("Cannot divide a number by 0.");
+    }
+
+    return this.result;
+  }
+}
 
 module.exports = Calculator;

week-2/week-2-js/hard/todo-list.js

@@ -11,7 +11,42 @@
 */
 
 class Todo {
+  constructor(){
+    this.todos = [];
+  }
 
+  add(todo){
+    this.todos.push(todo)
+  }
+
+  remove(indexOfTodo){
+    if(indexOfTodo >= 0 && indexOfTodo < this.todos.length){
+      this.todos.splice(indexOfTodo, 1);
+    }
+  }
+
+  update(index, updatedTodo){
+    if(index >= 0 && index < this.todos.length){
+      this.todos[index] = updatedTodo;
+    } 
+  }
+
+  getAll(){
+    return this.todos;
+  }
+
+  get(indexOfTodo){
+    if(indexOfTodo >= 0 && indexOfTodo < this.todos.length){
+      return this.todos[indexOfTodo];
+    }
+    else{
+      return null;
+    }
+  }
+
+  clear(){
+    this.todos = [];
+  }
 }
 
 module.exports = Todo;