diff --git a/src/exercises/1/exercise.js b/src/exercises/1/exercise.js
index fcf3805e..3d7b399c 100644
--- a/src/exercises/1/exercise.js
+++ b/src/exercises/1/exercise.js
@@ -3,7 +3,12 @@
 //  - Fix the issue.
 
 function printOneToTen() {
-  for (const number = 1; number <= 10; number++) {
-    console.log(`\n${number}`);
+  let x = [];
+  for (let number = 1; number <= 10; number++) {
+    // Variables defined with const cannot be Reassigned
+    //console.log(`\n${number}`);
+    x.push(number);
   }
+  return x;
 }
+module.exports = printOneToTen;
\ No newline at end of file
diff --git a/src/exercises/1/exercise1.test.js b/src/exercises/1/exercise1.test.js
new file mode 100644
index 00000000..8f977cfc
--- /dev/null
+++ b/src/exercises/1/exercise1.test.js
@@ -0,0 +1,5 @@
+const printOneToTen = require('./exercise.js');
+
+test('print one to ten', () => {
+  expect(printOneToTen()).toEqual([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
+});
\ No newline at end of file
diff --git a/src/exercises/10/exercise.js b/src/exercises/10/exercise.js
index 0deb7689..599c5bf4 100644
--- a/src/exercises/10/exercise.js
+++ b/src/exercises/10/exercise.js
@@ -15,4 +15,8 @@
 		}
 	]
 */
-function findVoteEligibleCandidates(populationList) {}
+function findVoteEligibleCandidates(populationList) {
+	console.log(`${populationList.filter((element) => element.age >= 18).map((element) => element.name)}`);
+}
+
+module.exports = findVoteEligibleCandidates;
\ No newline at end of file
diff --git a/src/exercises/10/exercise10.test.js b/src/exercises/10/exercise10.test.js
new file mode 100644
index 00000000..ee1ca867
--- /dev/null
+++ b/src/exercises/10/exercise10.test.js
@@ -0,0 +1,9 @@
+const findVoteEligibleCandidates = require('./exercise.js');
+
+test('find vote eligible candidates', () => {
+    const consolepass = jest.spyOn(console, 'log');
+    findVoteEligibleCandidates([10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 65, 70, 75, 80, 85, 90, 95, 100]);
+    expect(consolepass).toHaveBeenCalledWith(`${[10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 65, 70, 75, 80, 85, 90, 95, 100].filter((element) => element.age >= 18).map((element) => element.name)}`);
+    findVoteEligibleCandidates([1, 12, 14]);
+    expect(consolepass).toHaveBeenCalledWith(`${[1, 12, 14].filter((element) => element.age >= 18).map((element) => element.name)}`);
+});
\ No newline at end of file
diff --git a/src/exercises/11/exercise.js b/src/exercises/11/exercise.js
index 0317df9e..dd700279 100644
--- a/src/exercises/11/exercise.js
+++ b/src/exercises/11/exercise.js
@@ -2,4 +2,6 @@
 // - Use Array methods
 // - Do not use loops
 
-function sumOfArray(inputArray) {}
+function sumOfArray(inputArray) {
+    return `${inputArray.reduce((total, value) => total + value)}`;
+}
diff --git a/src/exercises/12/exercise.js b/src/exercises/12/exercise.js
index dd4df555..270d313a 100644
--- a/src/exercises/12/exercise.js
+++ b/src/exercises/12/exercise.js
@@ -5,5 +5,10 @@ function errorFunction() {
 }
 
 function errorCaller() {
-  errorFunction();
-}
+  try {
+    errorFunction();
+  }
+  catch (error) {
+    console.log(error);
+  }
+}
\ No newline at end of file
diff --git a/src/exercises/13/exercise.js b/src/exercises/13/exercise.js
index cb1ceaeb..ef92727b 100644
--- a/src/exercises/13/exercise.js
+++ b/src/exercises/13/exercise.js
@@ -5,6 +5,14 @@ const employee = {
   lastName: "Teja",
   age: 29,
   id: 1122,
-  getFullName: function () {},
-  checkVoteEligiblity: function () {},
+  getFullName: function () {
+    return this.firstName + " " + this.lastName;
+  },
+  checkVoteEligiblity: function () {
+    if (this.age >= 18) {
+      return "Eligible";
+    } else {
+      return "Not Eligible";
+    }
+  },
 };
diff --git a/src/exercises/14/exercise.js b/src/exercises/14/exercise.js
index 6e47dd07..42dd17cb 100644
--- a/src/exercises/14/exercise.js
+++ b/src/exercises/14/exercise.js
@@ -8,10 +8,19 @@ const employee = {
   id: 1122,
   getFullName: function () {
     //Copy the solution from the exercise before this.
+    return this.firstName + " " + this.lastName;
   },
 };
 
 const newEmployee = {
   firstName: "New",
   lastName: "Employee",
+  getFullName: employee.getFullName,
+  // or in place of getFullName: employee.getFullName,
+  // you can also write getFullName: employee.getFullName.bind(newEmployee)
+  /* or in place of getFullName: employee.getFullName, this can also be done 
+  __proto__: employee
+  */
 };
+
+//const getFullName = employee.getFullName.call(newEmployee);  //This is one of the way it can be done.
\ No newline at end of file
diff --git a/src/exercises/15/exercise.js b/src/exercises/15/exercise.js
index 1c4a7d48..6b03c672 100644
--- a/src/exercises/15/exercise.js
+++ b/src/exercises/15/exercise.js
@@ -1,10 +1,8 @@
 // Convert the below functions into arrow functions.
 
-const greetings = function () {
-  return "Hello World";
-};
+const greetings = () => "Hello World";
 
-const isEven = function (num) {
+const isEven = (num) => {
   if (num % 2 == 0) {
     return true;
   } else {
diff --git a/src/exercises/16/exercise.js b/src/exercises/16/exercise.js
index 01561081..a36c20ab 100644
--- a/src/exercises/16/exercise.js
+++ b/src/exercises/16/exercise.js
@@ -2,6 +2,51 @@
 // - Identify the class variables
 // - Create function for all the possible functionalities.
 
-class Leave {
+export class Leave {
   //...
+  constructor(leaveType, leaveStartDate, leaveEndDate) {
+    //...
+    this._leaveType = leaveType;
+    this._leaveStartDate = leaveStartDate;
+    this._leaveEndDate = leaveEndDate;
+    this._leaveDays = this.calculateLeaveDays();
+  }
+
+  get leaveType() {
+    return this._leaveType;
+  }
+
+  get leaveStartDate() {
+    return this._leaveStartDate;
+  }
+
+  get leaveEndDate() {
+    return this._leaveEndDate;
+  }
+
+  set leaveType(leaveType) {
+    this._leaveType = leaveType;
+  }
+
+  set leaveStartDate(leaveStartDate) {
+    this._leaveStartDate = leaveStartDate;
+  }
+
+  set leaveEndDate(leaveEndDate) {
+    this._leaveEndDate = leaveEndDate;
+  }
+
+  calculateLeaveDays() {
+    //...
+    return this._leaveEndDate - this._leaveStartDate;
+  }
+
+  approveLeave() {
+    //...
+    if (this._leaveDays > 5) {
+      console.log("Leave Rejected");
+    } else {
+      console.log("Leave approved");
+    }
+  }
 }
diff --git a/src/exercises/17/exercise.js b/src/exercises/17/exercise.js
index f344d030..9a4d5797 100644
--- a/src/exercises/17/exercise.js
+++ b/src/exercises/17/exercise.js
@@ -1 +1,45 @@
 // Extend the Leave class, to create different classes for different Leave types.
+import { Leave } from "../16/exercise.js";
+class SickLeave extends Leave {
+    constructor(leaveStartDate, leaveEndDate) {
+        super("Sick", leaveStartDate, leaveEndDate);
+        this.limit = 5;
+    }
+
+    approveLeave() {
+        if (this._leaveDays > this.limit) {
+            console.log("Leave Rejected");
+        } else {
+            console.log("Leave approved");
+        }
+        sickLeavesLeft(this.limit - this._leaveDays);
+    }
+
+    sickLeavesLeft(limit) {
+        this.limit = limit;
+        console.log("Sick leaves left: " + this.limit);
+    }
+}
+
+class CasualLeave extends Leave {
+    constructor(leaveStartDate, leaveEndDate) {
+        super("Casual", leaveStartDate, leaveEndDate);
+        this.limit = 10;
+    }
+
+    approveLeave() {
+        if (this._leaveDays > this.limit) {
+            console.log("Leave Rejected");
+        } else {
+            console.log("Leave approved");
+        }
+        casuaLeavesLeft(this.limit - this._leaveDays);
+    }
+
+    casuaLeavesLeft(limit) {
+        this.limit = limit;
+        console.log("Casual leaves left: " + this.limit);
+    }
+}
+
+
diff --git a/src/exercises/18/CasualLeaveClass.js b/src/exercises/18/CasualLeaveClass.js
new file mode 100644
index 00000000..f7ee7964
--- /dev/null
+++ b/src/exercises/18/CasualLeaveClass.js
@@ -0,0 +1,21 @@
+import { Leave } from "../16/exercise.js";
+class CasualLeave extends Leave {
+    constructor(leaveStartDate, leaveEndDate) {
+        super("Casual", leaveStartDate, leaveEndDate);
+        this.limit = 10;
+    }
+
+    approveLeave() {
+        if (this._leaveDays > this.limit) {
+            console.log("Leave Rejected");
+        } else {
+            console.log("Leave approved");
+        }
+        casuaLeavesLeft(this.limit - this._leaveDays);
+    }
+
+    casuaLeavesLeft(limit) {
+        this.limit = limit;
+        console.log("Casual leaves left: " + this.limit);
+    }
+}
\ No newline at end of file
diff --git a/src/exercises/18/SickLeaveClass.js b/src/exercises/18/SickLeaveClass.js
new file mode 100644
index 00000000..67595247
--- /dev/null
+++ b/src/exercises/18/SickLeaveClass.js
@@ -0,0 +1,21 @@
+import { Leave } from "../16/exercise.js";
+class SickLeave extends Leave {
+    constructor(leaveStartDate, leaveEndDate) {
+        super("Sick", leaveStartDate, leaveEndDate);
+        this.limit = 5;
+    }
+
+    approveLeave() {
+        if (this._leaveDays > this.limit) {
+            console.log("Leave Rejected");
+        } else {
+            console.log("Leave approved");
+        }
+        sickLeavesLeft(this.limit - this._leaveDays);
+    }
+
+    sickLeavesLeft(limit) {
+        this.limit = limit;
+        console.log("Sick leaves left: " + this.limit);
+    }
+}
\ No newline at end of file
diff --git a/src/exercises/18/exercise.js b/src/exercises/18/exercise.js
index e0fd230c..21a921a9 100644
--- a/src/exercises/18/exercise.js
+++ b/src/exercises/18/exercise.js
@@ -1,3 +1,13 @@
 // Use Javascript modules to create seperate files for each of the Leave type classes.
 // - Comment your understanding about import
 // - Comment your understanding about export
+
+/****Import*****/
+//import allows us to import the class, functions, variables from other files and use them in the current file. Modules can be imported in two ways based on the type of export.
+//The imported values are read-only views of the features that were exported. Similar to const variables, you cannot re-assign the variable that was imported, but you can still modify properties of object values. The value can only be re-assigned by the module exporting it.
+
+/****export*****/
+//export allows us to export the class, functions, variables to be used in other files.
+//There are two types of exports: Named Exports and Default Exports. Named Exports are used when we have multiple things to export from a file. Default Exports are used when we have only one thing to export from a file.
+
+//you need to include type="module" in the <script> element, to declare this script as a module. You can only use import and export statements inside modules, not regular scripts. 
\ No newline at end of file
diff --git a/src/exercises/19/exercise.js b/src/exercises/19/exercise.js
index ec707066..0c919eb7 100644
--- a/src/exercises/19/exercise.js
+++ b/src/exercises/19/exercise.js
@@ -1,3 +1,42 @@
 // Comment below what did you understand from the previous 3 exercises about
 // - prototype
 // - __proto__
+
+/*********Prototype*******/
+//  prototype: The prototype property is used to add methods or properties to an object's prototype. The prototype is a shared property of all instances of an object created using the constructor function, and adding a method or property to it will make it available to all instances of that object. It can be used to add methods and properties to an object after it has been created.
+/*                              // A constructor function
+                                function Box(value) {
+                                  this.value = value;
+                                }
+
+                                // Properties all boxes created from the Box() constructor
+                                // will have
+                                Box.prototype.getValue = function () {
+                                  return this.value;
+                                };
+
+                                const boxes = [new Box(1), new Box(2), new Box(3)];
+//Box.prototype it's just a plain object. Every instance created from a constructor function will automatically have the constructor's prototype property as its [[Prototype]] — that is, Object.getPrototypeOf(new Box()) === Box.prototype. Constructor.prototype by default has one own property: constructor, which references the constructor function itself — that is, Box.prototype.constructor === Box. This allows one to access the original constructor from any instance.
+*/
+
+
+/*********__proto__*******/
+// __proto__: The __proto__ property is an internal property of an object that points to its prototype. It is used to access the prototype of an object, and can also be used to set the prototype of an object. When a property is accessed on an object, JavaScript first looks for the property on the object itself, and if it is not found, it looks for it in the object's prototype, and so on up the prototype chain until the property is found or the end of the prototype chain is reached.
+/*                           const o = {
+                                a: 1,
+                                b: 2,
+                                // __proto__ sets the [[Prototype]]. It's specified here
+                                // as another object literal.
+                                __proto__: {
+                                  b: 3,
+                                  c: 4,
+                                  __proto__: {
+                                    d: 5,
+                                  },
+                                },
+                              };
+                              
+                              // { a: 1, b: 2 } ---> { b: 3, c: 4 } ---> { d: 5 } ---> Object.prototype ---> null
+                              
+                              console.log(o.d); // 5
+*/
\ No newline at end of file
diff --git a/src/exercises/2/exercise.js b/src/exercises/2/exercise.js
index a9a49c16..db8e05df 100644
--- a/src/exercises/2/exercise.js
+++ b/src/exercises/2/exercise.js
@@ -3,11 +3,16 @@
 //  - Fix the issue.
 
 function divideTenByNumber(number) {
+  //Variables defined with let have block scope. They are only accessible within the block they are defined in.
+  let result;
   if (number != 0) {
-    let result = 10 / number;
+    result = 10 / number;
   } else {
-    let result = "Indeterminate";
+    result = "Indeterminate";
   }
 
-  console.log(`Result after dividing 10 by ${number} is ${result}`);
+  //console.log(`Result after dividing 10 by ${number} is ${result}`);
+  return result;
 }
+
+module.exports = divideTenByNumber;
\ No newline at end of file
diff --git a/src/exercises/2/exercise2.test.js b/src/exercises/2/exercise2.test.js
new file mode 100644
index 00000000..dff98c9c
--- /dev/null
+++ b/src/exercises/2/exercise2.test.js
@@ -0,0 +1,6 @@
+const divideTenByNumber = require('./exercise.js');
+
+test('divide ten by number', () => {
+    expect(divideTenByNumber(5)).toEqual(2);
+    expect(divideTenByNumber(0)).toEqual("Indeterminate");
+});
\ No newline at end of file
diff --git a/src/exercises/20/exercise.js b/src/exercises/20/exercise.js
index 9a30e605..8448ad87 100644
--- a/src/exercises/20/exercise.js
+++ b/src/exercises/20/exercise.js
@@ -1,3 +1,22 @@
 // What is debugger;
 // - Comment your understanding of it.
 // - Paste the link of the MDN article here.
+
+
+// Debugger is a keyword that stops the execution of the code and allows you to inspect the current state of the code. It is useful for debugging purposes.
+
+/*Debugging is the process of finding and fixing errors within a script.
+  A breakpoint is a point of code where the debugger will automatically pause the JavaScript execution.
+  While the code is paused, we can examine current variables, execute commands in the console etc. In other words, we can debug it.
+
+  Watch – shows current values for any expressions.(You can click the plus + and input an expression. The debugger will show its value, automatically recalculating it in the process of execution.)
+
+  Call Stack – shows the nested calls chain.
+
+  Scope – current variables.
+  Local shows local function variables. You can also see their values highlighted right over the source.
+  Global has global variables (out of any functions).
+
+*/
+
+// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/debugger
\ No newline at end of file
diff --git a/src/exercises/21/exercise.js b/src/exercises/21/exercise.js
index 4fe9d13e..da4572ec 100644
--- a/src/exercises/21/exercise.js
+++ b/src/exercises/21/exercise.js
@@ -1 +1,8 @@
 // What are the different levels of logs and how do we print them to the console?
+
+/* logs are used to debug the code. There are 4 levels of logs:
+1. console.log() - used to print the output to the console.
+2. console.info() - used to print the information to the console.
+3. console.warn() - used to print the warning to the console.
+4. console.error() - used to print the error to the console.
+*/
\ No newline at end of file
diff --git a/src/exercises/22/1.png b/src/exercises/22/1.png
new file mode 100644
index 00000000..374a8472
Binary files /dev/null and b/src/exercises/22/1.png differ
diff --git a/src/exercises/22/2.png b/src/exercises/22/2.png
new file mode 100644
index 00000000..c398e298
Binary files /dev/null and b/src/exercises/22/2.png differ
diff --git a/src/exercises/22/3.png b/src/exercises/22/3.png
new file mode 100644
index 00000000..47e8e5dd
Binary files /dev/null and b/src/exercises/22/3.png differ
diff --git a/src/exercises/22/4.png b/src/exercises/22/4.png
new file mode 100644
index 00000000..dbeb2ced
Binary files /dev/null and b/src/exercises/22/4.png differ
diff --git a/src/exercises/22/5.png b/src/exercises/22/5.png
new file mode 100644
index 00000000..d17f9d62
Binary files /dev/null and b/src/exercises/22/5.png differ
diff --git a/src/exercises/22/6.png b/src/exercises/22/6.png
new file mode 100644
index 00000000..583d3b7e
Binary files /dev/null and b/src/exercises/22/6.png differ
diff --git a/src/exercises/22/exercise.js b/src/exercises/22/exercise.js
index fbcfc74d..2c908778 100644
--- a/src/exercises/22/exercise.js
+++ b/src/exercises/22/exercise.js
@@ -3,6 +3,7 @@
 // - What is "Watch" in chrome debugging console. Share a screenshot of the watch variables at each step.
 
 function randomCalculator() {
+  debugger;
   let x = 10,
     y = 0;
   x = x * 10 + 1 - (2 / 2) * 3;
@@ -11,3 +12,9 @@ function randomCalculator() {
   x = x + 10 - 2 - 3 * 2;
   console.log(x);
 }
+
+// Watch – shows current values for any expressions.(You can click the plus + and input an expression. The debugger will show its value, automatically recalculating it in the process of execution.)
+
+/* Scope – current variables.
+  Local shows local function variables. You can also see their values highlighted right over the source.
+  Global has global variables (out of any functions).*/
diff --git a/src/exercises/23/exercise.js b/src/exercises/23/exercise.js
index 92160dd9..926b65d1 100644
--- a/src/exercises/23/exercise.js
+++ b/src/exercises/23/exercise.js
@@ -1,27 +1,50 @@
 // What does a call to the noDelayPrint() do.
+// "You asked me to print the sheet 0" "Printing sheet number undefined"
+// When a function is used as a callback, this is lost. so we need to bind the function to the object.
+
+
 // Is 'this' inside print function referrring to an instance of Printer
+// Yes it is referring to an instance of Printer.
+
+
 // Is the correct sheet printed?
+// No, it is not printing the correct sheet.
+// Index is incremented before the print function is called it is beacause the setTimeout function stays in the call stack until all the messages in the queue are processed.
+
+
 //  Comment your understanding
+//  Delay in setTimeout is not a delay in execution of the function. It is a delay in adding the function to the queue. So, the function is executed immediately after the current function is executed. So, the index is incremented before the print function is called. So, it is printing the wrong sheet number.
+
+
 //  Provide a fix.
+// We can fix this by binding the print function to the object. So, the print function will be called with the correct context.
 
 class Printer {
   constructor() {
     this.index = 0;
+    this.print = this.print.bind(this);
   }
 
   print() {
     console.log(`Printing sheet number ${this.index}`);
   }
 
+  // print = () => { // Arrow function will also work
+  //   console.log(`Printing sheet number ${this.index}`);
+  // }
+  // this in arrow function is lexically scoped. So, it will refer to the object in which the function is defined.
+
   noDelayPrint() {
     console.log(`You asked me to print the sheet ${this.index}`);
     setTimeout(this.print, 0); // 0 milli-sec delay
     this.index++;
   }
 
-  noDelayPrint() {
+  DelayPrint() {
     console.log(`You asked me to print the sheet ${this.index}`);
     setTimeout(this.print, 1000); //1 sec dely
     this.index++;
   }
 }
+
+//When we define two methods with same name then the second defined method overrides the first defined method.
\ No newline at end of file
diff --git a/src/exercises/24/exercise.js b/src/exercises/24/exercise.js
index 58d4ace3..6ec429b2 100644
--- a/src/exercises/24/exercise.js
+++ b/src/exercises/24/exercise.js
@@ -2,3 +2,6 @@
 // - Share the resource link here.
 // - Update all the exercises you have finished above by following the style guide.
 // From the next exercise write your code following the style guide
+
+
+// https://www.w3schools.com/js/js_conventions.asp
\ No newline at end of file
diff --git a/src/exercises/25/exercise.js b/src/exercises/25/exercise.js
index 294b8b6b..d04fa85c 100644
--- a/src/exercises/25/exercise.js
+++ b/src/exercises/25/exercise.js
@@ -1 +1,32 @@
 // Read what is a closure and give an example here
+
+
+// Closure is a function that has access to the parent scope, even after the parent function has closed. 
+// The closure has access to the variables in three scopes: 
+// 1. Variables for which there are no local variables
+// 2. Variables declared as local variables in the parent function
+// 3. Parameters of the parent function
+
+// example
+function parent() {
+    let a = 1;
+    function child() {
+        console.log(a);
+    }
+    return child;
+}
+
+const closure = parent();
+closure(); // 1
+
+// The closure has access to the variable a, even after the parent function has closed.
+// The closure has access to the variable a, because it is declared as a local variable in the parent function.
+
+//or
+const add = (function () {
+    let counter = 0;
+    return function () { counter += 1; return counter }
+})();
+
+add();
+// The counter is protected by the scope of the anonymous function, and can only be changed using the add function.
\ No newline at end of file
diff --git a/src/exercises/26/exercise.js b/src/exercises/26/exercise.js
index b886e948..f3ba5d55 100644
--- a/src/exercises/26/exercise.js
+++ b/src/exercises/26/exercise.js
@@ -1,10 +1,38 @@
 // Create a Counter using closures.
 // - counter should have "increment","decrement" and "value" functions.
 // - Is there a anonymus function used here? Is so where is it?
+//   yes, it is used, it is the self-invoking function. It is used to create a private scope. 
+
+
 // - What is an IIFE? Have we used one here?
+//  IIFE is an Immediately Invoked Function Expression. It is a function that is executed immediately after it is created. Yes, we have used one here. 
+
+
 // - Discuss about "Revealing Module Pattern" and how we have used it.
+//  The Revealing Module Pattern is a way of organizing code using closures to create private and public members. Private members are those that are not accessible from outside the module, while public members are those that are accessible from outside the module.
+//  The Revealing Module Pattern is a design pattern that uses closures to hide state and reveal behavior. We have used it here, because we have used a self-invoking function to create a private scope. 
+
 // - What are higher order functions?
+// Higher order functions are functions that take other functions as arguments or return functions as results. 
 
 const counter = (function () {
   //Your code goes here.
+  let counter = 0;
+  return {
+    increment: function () {
+      counter += 1;
+    },
+    decrement: function () {
+      counter -= 1;
+    },
+    value: function () {
+      return counter;
+    },
+  };
 })();
+
+counter.increment();
+counter.increment();
+counter.increment();
+counter.decrement();
+console.log(counter.value()); // 2
diff --git a/src/exercises/27/exercise.js b/src/exercises/27/exercise.js
index 41ddb7f7..3bb31524 100644
--- a/src/exercises/27/exercise.js
+++ b/src/exercises/27/exercise.js
@@ -1,8 +1,10 @@
 // What is a callback?
+// - A callback is a function that is passed as an argument to another function, , which is then invoked inside the outer function to complete some kind of routine or action. A callback function can run after another function has finished. 
 
-function welcome(name) {
+function welcome(name, callback) {
   setTimeout(() => {
     console.log(`Welcome ${name}`);
+    callback();
   }, 1000);
 }
 
@@ -10,8 +12,7 @@ function success() {
   console.log("Greetings successful!!");
 }
 
-welcome();
-success();
+welcome("Gautham", success);
 
 // In the above example:
 // - Before welcoming, success message is printed.
diff --git a/src/exercises/28/exercise.js b/src/exercises/28/exercise.js
index 37050f14..f4c44096 100644
--- a/src/exercises/28/exercise.js
+++ b/src/exercises/28/exercise.js
@@ -1,7 +1,25 @@
 // Execute the below function.
 // - There is an issue with the order of messages
 // - Reason here why is it so.
+
+/*Function calls form a stack of frames.
+The function that is currently being executed is at the top of the stack.
+When the function returns, the control is passed to the caller.
+The stack is used to store all local variables of the function.
+When a function is called, the parameters and local variables are pushed into the stack.
+When the function returns, the local variables are popped out of the stack.
+*/
+/*A JavaScript runtime uses a message queue, which is a list of messages to be processed. Each message has an associated function that gets called to handle the message. 
+At some point during the event loop, the runtime starts handling the messages on the queue, starting with the oldest one. To do so, the message is removed from the queue and its corresponding function is called with the message as an input parameter. As always, calling a function creates a new stack frame for that function's use. The processing of functions continues until the stack is once again empty. Then, the event loop will process the next message in the queue (if there is one). 
+*/
+/*The first two arguments to the function setTimeout are a message to add to the queue and a time value (optional; defaults to 0). The time value represents the (minimum) delay after which the message will be pushed into the queue. If there is no other message in the queue, and the stack is empty, the message is processed right after the delay. However, if there are messages, the setTimeout message will have to wait for other messages to be processed. For this reason, the second argument indicates a minimum time — not a guaranteed time. Zero delay doesn't mean the call back will fire-off after zero milliseconds. Calling setTimeout with a delay of 0 (zero) milliseconds doesn't execute the callback function after the given interval. It schedules the execution of the callback function after the given interval.
+*/
+
+
+
 // - Explain in your own terms what are event loops?
+/* The event loop is a programming construct or design pattern that waits for and dispatches events or messages in a program. It works by making a request to some internal or external "event provider" (that generally blocks the request until an event has arrived), and then it calls the relevant event handler ("dispatches the event"). 
+*/
 
 function learnEventLoops() {
   console.log("Learning event loops");
@@ -13,4 +31,4 @@ function learnEventLoops() {
   }, 1); // 1 millisec
   console.log("Learning completed!!");
 }
-main();
+learnEventLoops();
diff --git a/src/exercises/29/exercise.js b/src/exercises/29/exercise.js
index e841af66..889602b5 100644
--- a/src/exercises/29/exercise.js
+++ b/src/exercises/29/exercise.js
@@ -1,6 +1,14 @@
 // - Explain currying.
+// currying is a technique of evaluating function with multiple arguments, into sequence of functions with single argument. 
+
+
+
 // - Convert the below function to curry function
 
-function calculateVolume(length, breadth, height) {
-  return length * breadth * height;
+function calculateVolume(length) {
+  return function (breadth) {
+    return function (height) {
+      return length * breadth * height;
+    };
+  }
 }
diff --git a/src/exercises/3/exercise.js b/src/exercises/3/exercise.js
index ddfc8767..d9e1ec42 100644
--- a/src/exercises/3/exercise.js
+++ b/src/exercises/3/exercise.js
@@ -2,9 +2,9 @@
 //  - Comment what is the operator that you have used.
 
 function checkIfArray(input) {
-  let isInputAnArray = false;
+  let isInputAnArray = input instanceof Array;
 
-  //...
+  //The instanceof operator returns true if an object is an instance of a specified object
 
   if (isInputAnArray) {
     console.log("Given input is an Array");
@@ -12,3 +12,5 @@ function checkIfArray(input) {
     console.log("Given input is not an Array");
   }
 }
+
+module.exports = checkIfArray;
\ No newline at end of file
diff --git a/src/exercises/3/exercise3.test.js b/src/exercises/3/exercise3.test.js
new file mode 100644
index 00000000..2bfc3359
--- /dev/null
+++ b/src/exercises/3/exercise3.test.js
@@ -0,0 +1,9 @@
+const checkIfArray = require("./exercise.js");
+
+test("check if array", () => {
+    const consolepass = jest.spyOn(console, 'log');
+    checkIfArray([1, 2, 3]);
+    expect(consolepass).toHaveBeenCalledWith("Given input is an Array");
+    checkIfArray(1, 2, 3);
+    expect(consolepass).toHaveBeenCalledWith("Given input is not an Array");
+});
\ No newline at end of file
diff --git a/src/exercises/30/exercise.js b/src/exercises/30/exercise.js
index 9cf6aa66..f5f61272 100644
--- a/src/exercises/30/exercise.js
+++ b/src/exercises/30/exercise.js
@@ -3,3 +3,12 @@
 // - Stop the timer at exactly 1min
 // - Display it on a HTML page
 // - What is the function that you have used?
+
+let timer = 0;
+let interval = setInterval(() => {
+    timer += 1;
+    if (timer === 60) {
+        clearInterval(interval);
+    }
+    document.getElementById('timer').innerHTML = timer;
+}, 1000);
\ No newline at end of file
diff --git a/src/exercises/30/index.html b/src/exercises/30/index.html
new file mode 100644
index 00000000..bd79abde
--- /dev/null
+++ b/src/exercises/30/index.html
@@ -0,0 +1,16 @@
+<!DOCTYPE html>
+<html lang="en">
+
+<head>
+    <meta charset="UTF-8">
+    <meta http-equiv="X-UA-Compatible" content="IE=edge">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Document</title>
+</head>
+
+<body>
+    <h1 id="timer" style="text-align: center;"></h1>
+    <script src="./exercise.js"></script>
+</body>
+
+</html>
\ No newline at end of file
diff --git a/src/exercises/31/exercise.js b/src/exercises/31/exercise.js
index 8409e2ba..9a7a976c 100644
--- a/src/exercises/31/exercise.js
+++ b/src/exercises/31/exercise.js
@@ -11,3 +11,29 @@
 
 // Declaration of translate
 // function translate(sourceString:string, targetLanguage:string)
+class Translator {
+    static translate(sourceString, targetLanguage) {
+        // Your code here
+        const encodedParams = new URLSearchParams();
+        encodedParams.append("q", sourceString);
+        encodedParams.append("target", targetLanguage);
+        encodedParams.append("source", "en");
+
+        const options = {
+            method: 'POST',
+            headers: {
+                'content-type': 'application/x-www-form-urlencoded',
+                'Accept-Encoding': 'application/gzip',
+                'X-RapidAPI-Key': '26e8a0f98fmshdcd189ad8bdba07p129d5djsnf0c06a093d31',
+                'X-RapidAPI-Host': 'google-translate1.p.rapidapi.com'
+            },
+            body: encodedParams
+        };
+
+        fetch('https://google-translate1.p.rapidapi.com/language/translate/v2', options)
+            .then(response => response.json())
+            .then(response => console.log(response.data.translations[0].translatedText))
+            .catch(err => console.error(err));
+    }
+}
+Translator.translate("Hello", "fr");
diff --git a/src/exercises/32/exercise.js b/src/exercises/32/exercise.js
index f990b0a5..135fc840 100644
--- a/src/exercises/32/exercise.js
+++ b/src/exercises/32/exercise.js
@@ -35,3 +35,38 @@
 
 
 */
+class Airport {
+    async getInfoFromIATA(iata) {
+        // Your code here
+        const options = {
+            method: 'GET',
+            headers: {
+                'X-RapidAPI-Key': '26e8a0f98fmshdcd189ad8bdba07p129d5djsnf0c06a093d31',
+                'X-RapidAPI-Host': 'airport-info.p.rapidapi.com'
+            }
+        };
+        const res = await fetch(`https://airport-info.p.rapidapi.com/airport?iata=${iata}`, options);
+        const data = await res.json();
+        return data
+    }
+
+    async getInfoFromICAO(icao) {
+        // Your code here
+        const options = {
+            method: 'GET',
+            headers: {
+                'X-RapidAPI-Key': '26e8a0f98fmshdcd189ad8bdba07p129d5djsnf0c06a093d31',
+                'X-RapidAPI-Host': 'airport-info.p.rapidapi.com'
+            }
+        };
+
+        fetch(`https://airport-info.p.rapidapi.com/airport?icao=${icao}`, options)
+            .then(response => response.json())
+            .then(response => console.log(response))
+            .catch(err => console.error(err));
+    }
+}
+let temp = new Airport()
+temp.getInfoFromIATA("hyd").then(response => console.log(response))
+    .catch(err => console.error(err));
+temp.getInfoFromICAO("hyd");
\ No newline at end of file
diff --git a/src/exercises/33/exercise.js b/src/exercises/33/exercise.js
index 1d66757b..d3e7c199 100644
--- a/src/exercises/33/exercise.js
+++ b/src/exercises/33/exercise.js
@@ -4,11 +4,11 @@
 // - Read : https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Spread_syntax
 
 // Given an object
-// 	{
-// 		name: "Ravi",
-// 		id : 1122,
-// 		age : 29
-// 	}
+object = {
+    name: "Ravi",
+    id: 1122,
+    age: 29
+}
 
 // Create a two variables
 // 1. name - Its value should be "Ravi"
@@ -16,3 +16,7 @@
 // 	id : 1122,
 // 	age : 29
 // }
+
+const { name, ...otherProperties } = object;
+console.log(name);
+console.log(otherProperties);
diff --git a/src/exercises/34/exercise.js b/src/exercises/34/exercise.js
index c018d0e3..3f1d5eeb 100644
--- a/src/exercises/34/exercise.js
+++ b/src/exercises/34/exercise.js
@@ -1,10 +1,14 @@
 // Default parameters
 // - Read : https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/Default_parameters
 
-function multiply(num1, num2) {
+function multiply(num1 = 1, num2 = 1) {
   return num1 * num2;
 }
 
+console.log(multiply(2, 3));
+console.log(multiply(4));
+console.log(multiply());
+
 // multiply(2,3) - returns 6
 // multiple(4) - return NaN
 
diff --git a/src/exercises/35/exercise.js b/src/exercises/35/exercise.js
index 0b86ce11..33ba81fe 100644
--- a/src/exercises/35/exercise.js
+++ b/src/exercises/35/exercise.js
@@ -11,9 +11,9 @@ const employeeRavi = {
 };
 
 function getExperienceOfRavi() {
-  if (employeeRavi.getExperience) {
-    console.log(employeeRavi.getExperience());
-  }
+  console.log(employeeRavi.getExperience?.());
 }
 
+getExperienceOfRavi();
+
 // - Modify the above function to use optional chaining.
diff --git a/src/exercises/36/exercise.js b/src/exercises/36/exercise.js
index 23047b1f..fb8fb462 100644
--- a/src/exercises/36/exercise.js
+++ b/src/exercises/36/exercise.js
@@ -21,3 +21,14 @@ console.log(A() ?? C() ?? D());
 console.log(B() ?? D());
 
 //Comment the outputs below and reason
+/*
+                  A was called
+                  C was called
+                  D was called
+                  foo
+                  B was called
+                  false
+*/
+
+// First A is called and it returns undefined. So the next value is C which returns null. So the next value is D which returns "foo". So the final value is "foo".
+// In the second case B is called and it returns false. So it doesn't go to the next value.
\ No newline at end of file
diff --git a/src/exercises/4/exercise.js b/src/exercises/4/exercise.js
index d977ce66..889f2896 100644
--- a/src/exercises/4/exercise.js
+++ b/src/exercises/4/exercise.js
@@ -3,7 +3,8 @@
 //  - Comment its uses.
 
 function greeting(firstName, lastName) {
-  let welcomeGreeting;
-
+  let welcomeGreeting = `Hello ${firstName} ${lastName}!`;
+  //Template literals provide an easy way to interpolate variables and expressions into strings.
   console.log(welcomeGreeting);
 }
+module.exports = greeting;
\ No newline at end of file
diff --git a/src/exercises/4/exercise4.test.js b/src/exercises/4/exercise4.test.js
new file mode 100644
index 00000000..90bc7a50
--- /dev/null
+++ b/src/exercises/4/exercise4.test.js
@@ -0,0 +1,7 @@
+const greeting = require('./exercise.js');
+
+test('greeting', () => {
+    const consolepass = jest.spyOn(console, 'log');
+    greeting("John", "Doe");
+    expect(consolepass).toHaveBeenCalledWith("Hello John Doe!");
+});
\ No newline at end of file
diff --git a/src/exercises/5/exercise.js b/src/exercises/5/exercise.js
index 14ea345c..c034d9f2 100644
--- a/src/exercises/5/exercise.js
+++ b/src/exercises/5/exercise.js
@@ -3,8 +3,10 @@
 // - Comment the function that you used.
 
 function binaryToDecimal(binaryString) {
-  let decimalValue;
+  let decimalValue = parseInt(binaryString, 2);
+  //parseInt() function parses a string argument and returns an integer of the specified radix (the base in mathematical numeral systems).
   console.log(
     `Decimal for the given binary string ${binaryString} is ${decimalValue}`
   );
 }
+module.exports = binaryToDecimal;
\ No newline at end of file
diff --git a/src/exercises/5/exercise5.test.js b/src/exercises/5/exercise5.test.js
new file mode 100644
index 00000000..c1291025
--- /dev/null
+++ b/src/exercises/5/exercise5.test.js
@@ -0,0 +1,11 @@
+const binaryToDecimal = require('./exercise.js');
+
+test('binary to decimal', () => {
+    const consolepass = jest.spyOn(console, 'log');
+    binaryToDecimal(1001);
+    expect(consolepass).toHaveBeenCalledWith("Decimal for the given binary string 1001 is 9");
+    binaryToDecimal(11);
+    expect(consolepass).toHaveBeenCalledWith("Decimal for the given binary string 11 is 3");
+    binaryToDecimal(0);
+    expect(consolepass).toHaveBeenCalledWith("Decimal for the given binary string 0 is 0");
+});
\ No newline at end of file
diff --git a/src/exercises/6/exercise.js b/src/exercises/6/exercise.js
index a7149958..ed9024da 100644
--- a/src/exercises/6/exercise.js
+++ b/src/exercises/6/exercise.js
@@ -2,6 +2,13 @@
 // - Also validate the input. Accept the input only if its an array.
 
 function findTheLength(inputArray) {
-  let lengthOfArray;
-  console.log(`Length of the given input array is ${lengthOfArray}`);
+  const validate = inputArray instanceof Array; // Array.isArray(inputArray) is another way to validate the input
+  let lengthOfArray = inputArray.length;
+  if (validate) {
+    console.log(`Length of the given input array is ${lengthOfArray}`);
+  }
+  else {
+    console.log("Please enter an array");
+  }
 }
+//module.exports = findTheLength;
\ No newline at end of file
diff --git a/src/exercises/6/exercise6.test.js b/src/exercises/6/exercise6.test.js
new file mode 100644
index 00000000..62586ba2
--- /dev/null
+++ b/src/exercises/6/exercise6.test.js
@@ -0,0 +1,11 @@
+const findTheLength = require('./exercise.js');
+
+test('find the length', () => {
+    const consolepass = jest.spyOn(console, 'log');
+    findTheLength("Hello World!");
+    expect(consolepass).toHaveBeenCalledWith("Please enter an array");
+    findTheLength([]);
+    expect(consolepass).toHaveBeenCalledWith("Length of the given input array is 0");
+    findTheLength([1, 2, 3]);
+    expect(consolepass).toHaveBeenCalledWith("Length of the given input array is 3");
+});
\ No newline at end of file
diff --git a/src/exercises/7/exercise.js b/src/exercises/7/exercise.js
index 8c18d178..3c4e4a63 100644
--- a/src/exercises/7/exercise.js
+++ b/src/exercises/7/exercise.js
@@ -4,4 +4,6 @@
 function commaSeparatedString(inputArray) {
   // Given an Array like ["firstName","lastName"]
   // Return a comma separated String like "firstName,lastName"
+  return inputArray.join(",");
 }
+module.exports = commaSeparatedString;
\ No newline at end of file
diff --git a/src/exercises/7/exercise7.test.js b/src/exercises/7/exercise7.test.js
new file mode 100644
index 00000000..9648a20b
--- /dev/null
+++ b/src/exercises/7/exercise7.test.js
@@ -0,0 +1,7 @@
+const commaSeparatedString = require('./exercise.js');
+
+test('comma separated string', () => {
+    expect(commaSeparatedString(["John", "Doe", "Jane", "Doe"])).toEqual("John,Doe,Jane,Doe");
+    expect(commaSeparatedString(["John", "Doe"])).toEqual("John,Doe");
+    expect(commaSeparatedString(["John"])).toEqual("John");
+});
\ No newline at end of file
diff --git a/src/exercises/8/exercise.js b/src/exercises/8/exercise.js
index e127b842..d28db3f2 100644
--- a/src/exercises/8/exercise.js
+++ b/src/exercises/8/exercise.js
@@ -2,4 +2,7 @@
 // - Print the given Array. One element in one line
 // - Use loops
 
-function printArray(inputArray) {}
+function printArray(inputArray) {
+    inputArray.forEach((element) => { console.log(element); });
+}
+//module.exports = printArray;
\ No newline at end of file
diff --git a/src/exercises/8/exercise8.test.js b/src/exercises/8/exercise8.test.js
new file mode 100644
index 00000000..90e9754d
--- /dev/null
+++ b/src/exercises/8/exercise8.test.js
@@ -0,0 +1,9 @@
+const printArray = require('./exercise.js');
+
+test('print array', () => {
+    const consolepass = jest.spyOn(console, 'log');
+    printArray([1, 2, 3]);
+    [1, 2, 3].forEach((ele) => { expect(consolepass).toHaveBeenCalledWith(ele) });
+    printArray([]);
+    [].forEach((ele) => { expect(consolepass).toHaveBeenCalledWith(ele) });
+});
\ No newline at end of file
diff --git a/src/exercises/9/exercise.js b/src/exercises/9/exercise.js
index d63979cf..56ff4e89 100644
--- a/src/exercises/9/exercise.js
+++ b/src/exercises/9/exercise.js
@@ -3,5 +3,6 @@
 // - Do not use loops
 
 function multiplyArrayByTwo(inputArray) {
-  console.log(`Given input array is ${inputArray}`);
+  console.log(`Given input array is ${inputArray.map((element) => element * 2)}`);
 }
+module.exports = multiplyArrayByTwo;
\ No newline at end of file
diff --git a/src/exercises/9/exercise9.test.js b/src/exercises/9/exercise9.test.js
new file mode 100644
index 00000000..00cf787f
--- /dev/null
+++ b/src/exercises/9/exercise9.test.js
@@ -0,0 +1,9 @@
+const multiplyArrayByTwo = require('./exercise.js');
+
+test('multiply array by two', () => {
+    const consolepass = jest.spyOn(console, 'log');
+    multiplyArrayByTwo([1, 2, 3]);
+    expect(consolepass).toHaveBeenCalledWith(`Given input array is ${[1, 2, 3].map((element) => element * 2)}`);
+    multiplyArrayByTwo([]);
+    expect(consolepass).toHaveBeenCalledWith(`Given input array is ${[].map((element) => element * 2)}`);
+});
\ No newline at end of file