Add some folders

Author: anxhukumar

C programming/a.out

@@ -0,0 +1,13 @@
+#include<stdio.h>
+
+//Function to calculate the cube of a number that the user provided. 
+
+int main() {
+    int n;
+
+    printf("Give n: \n");
+    scanf("%d", &n);
+
+    printf("The cube of n is: %d\n", (n*n*n));
+    return 0;
+}

C programming/cube.c

@@ -0,0 +1,15 @@
+# include<stdio.h>
+
+int main() {
+    int a,b;
+
+    printf("Enter a: \n");
+    scanf("%d", &a);
+
+    printf("Enter b: \n");
+    scanf("%d", &b);
+
+    int sum = a + b;
+    printf("Sum is: %d\n", sum);
+    return 0;
+}

C programming/hello_world.c

@@ -0,0 +1,9 @@
+#include <stdio.h>
+#include <math.h>
+
+int main() {
+    int a;
+    scanf("%d", &a);
+    printf("%d \n", a%2==0);
+    return 0;
+}

C programming/index.c

@@ -0,0 +1,16 @@
+# include<stdio.h>
+
+// function to calculate the perimeter of rectangle after taking sides from user. 
+int main() {
+    int a,b;
+    
+    printf("Give the side a: \n");
+    scanf("%d", &a);
+    
+    printf("Give the side b: \n");
+    scanf("%d", &b);
+    
+    printf("The perimeter is: %d \n", 2*(a+b));
+    
+    return 0;
+}

C programming/perimeter_of_rectangle.c

@@ -0,0 +1,50 @@
+// Q) You are given an array of Integers in which each subsequent value is not less than the previous value.
+//  Write a function that takes this array as an input and returns a new array with the squares of each number sorted in ascending order.
+
+
+
+// Brute force method of solving this problem, the time complexity in this case is O(nlogn) and space is O(n).
+const arr = [-5, 0, 1, 1, 3];
+// const squaredArray = (inputArray) => {
+//     let finalArray = new Array(inputArray.length).fill(0); //This way of creating array is more optimised that let arr = []; as it takes fix memory.
+//     for(let i=0; i<inputArray.length; i++) {
+//         let squared = (inputArray[i] * inputArray[i]);
+//         finalArray[i] = (squared);
+//     }
+//     finalArray.sort((a,b) => a-b)
+
+//     return finalArray;   
+// }
+
+// const output = squaredArray(arr);
+// console.log(output);
+
+
+
+// The most optimized solution that has Time = O(n) Space = O(n)
+const squaredArray = (inputArray) => {
+    let finalArray = new Array(inputArray.length).fill(0);
+    
+    let leftPointer = 0;
+    let rightPointer = inputArray.length - 1;
+
+    for (let i=finalArray.length-1; i>=0; i--) {
+
+        let leftSquaredElement = inputArray[leftPointer] * inputArray[leftPointer] ;
+        const rightSquaredElement = inputArray[rightPointer] * inputArray[rightPointer];
+
+        if(leftSquaredElement < rightSquaredElement) {
+            finalArray[i] = rightSquaredElement;
+            rightPointer--;
+        }else {
+            finalArray[i] = leftSquaredElement;
+            leftPointer++;
+        }
+
+    }
+
+    return finalArray;
+}
+
+const output = squaredArray(arr);
+console.log(output);

DSA /course-questions/q1.js

@@ -0,0 +1,44 @@
+// Q) An array is monotonic if it is either monotone increasing or monotone decreasing. 
+// An array is monotone increasing if all its elements from left to right are non-decreasing. 
+// An array is monotone decreasing if all  its elements from left to right are non-increasing.
+//  Given an integer array return true if the given array is monotonic, or false otherwise.
+
+const arr1 = [1, 2, 2, 5]; //true
+const arr2 = [2, 2, 5, 6]; //true
+const arr3  = [1, 1, 1]; // true
+
+
+const ifMonotonic = (inputArray) => {
+
+    if(inputArray.length<=1) return true;
+
+    let first = inputArray[0];
+    let last = inputArray[inputArray.length-1];
+
+    if(first === last) {
+        for(let i=0; i<inputArray.length - 1; i++) {
+            if (inputArray[i] != inputArray[i + 1]) {
+                return false;
+            }
+        }
+        
+        
+    }else if(first > last) {
+        for(let i=0; i<inputArray.length - 1; i++) {
+            if (inputArray[i] < inputArray[i + 1]) {
+                return false;
+            }
+        }
+        
+    }else {
+        for(let i=0; i<inputArray.length - 1; i++) {
+            if (inputArray[i] > inputArray[i + 1]) {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+
+const output = ifMonotonic(arr3);
+console.log(output)

DSA /course-questions/q2.js

@@ -0,0 +1,23 @@
+// Q) Coding Exercise (k-th symbol in Grammar)
+// We build a table of n rows (1-indexed). We start by writing 0 in the 1st row. 
+// Now in every subsequent row, we look at the previous row and replace each occurrence of 0 with 01,
+// and each occurrence of 1 with 10.  For example, for n = 3, the 1st row is 0, 
+// the 2nd row is 01, and the 3rd row is 0110. 
+// Given two integer n and k, return the kth (1-indexed) symbol in the nth row of a table of n rows.
+
+const kthGrammar = (n, k) => {
+    // base case
+    if (n===1) return 0;
+
+    //recursive case
+    let length = Math.pow(2, (n-1));
+    let midPoint = length / 2;
+
+    if(k<=midPoint) {
+        return kthGrammar(n-1, k);
+    }else {
+        return 1 - kthGrammar(n-1, k-midPoint);
+    }
+}
+
+console.log(kthGrammar(3, 3))

DSA /course-questions/q3.js

@@ -0,0 +1,68 @@
+// Q) There are n friends that are playing a game. 
+// The friends are sitting in a circle and are numbered from 1 to n in clockwise order.
+// More formally, moving clockwise from the ith friend brings you to the (i+1)th friend for 1 <= i < n,
+// and moving clockwise from the nth friend brings you to the 1st friend. 
+// The rules of the game are as follows:  Start at the 1st friend.
+// Count the next k friends in the clockwise direction including the friend you started at. 
+// The counting wraps around the circle and may count some friends more than once. 
+// The last friend you counted leaves the circle and loses the game. 
+// If there is still more than one friend in the circle, go back to step 2 
+// starting from the friend immediately clockwise of the friend who just lost and repeat. 
+// Else, the last friend in the circle wins the game.
+// Given the number of friends, n, and an integer k, return the winner of the game.
+
+
+//APPROACH 1 Time=O(n*n) Space=O(n)
+// const josephus = (n, k) => {
+//     //creating an array with n
+//     let arr = Array.from({length:n}, (_,i)=>i+1);
+   
+//     //Function to remove the element
+//     function helper(arr, start) {
+//         //base case
+//         if (arr.length===1) return arr[0];
+
+//         //recursive case
+//         let indexToRemove = (start + k -1) % arr.length;
+
+//         arr.splice(indexToRemove, 1);
+
+//         return helper(arr, indexToRemove)
+//     }
+
+//     return helper(arr, 0)
+// }
+
+// console.log(josephus(41, 2));
+
+
+//APPROACH 2 Time=O(n) Space=O(n)
+
+// const josephus = (n, k) => {
+
+//     function helper(n) {
+//         //base case
+//         if (n===1) return 0;
+
+//         //recursive case
+//         return ((helper(n-1, k) + k) % n)
+//     }
+
+//     return helper(n) + 1;
+   
+// }
+
+// console.log(josephus(41,2))
+
+
+//APPROACH 3 Time=O(n) Space=O(1)
+
+const josephus = (n, k) => {    
+    let safeIndex = 0;
+    for (let i=1; i<=n; i++) {
+        safeIndex = ((safeIndex + k) % i)
+    }
+    return (safeIndex + 1);
+}
+
+console.log(josephus(41, 2));

DSA /course-questions/q4.js

@@ -0,0 +1,26 @@
+// Q) The tower of Hanoi is a famous puzzle where we have three rods and N disks. The objective of the puzzle is to move the entire stack to another rod. You are given the number of discs N. Initially, these discs are in the rod 1. You need to print all the steps of discs movement so that all the discs reach the 3rd rod. Also, you need to find the total moves.
+// Note: The discs are arranged such that the top disc is numbered 1 and the bottom-most disc is numbered N. Also, all the discs have different sizes and a bigger disc cannot be put on the top of a smaller disc. Refer the provided link to get a better clarity about the puzzle.
+
+
+
+function toh(n, fromRod, toRod, auxiliaryRod) {
+    
+    let count = 0;
+    
+    function helper(n, fromRod, toRod, auxiliaryRod) {
+        if (n===1) {
+            count++;
+        console.log(`move disk ${n} from rod ${fromRod} to ${toRod}`);
+        return;
+        }
+    
+        helper(n-1, fromRod, auxiliaryRod, toRod);
+        count++;
+        console.log(`move disk ${n} from rod ${fromRod} to ${auxiliaryRod}`);
+        helper(n-1, auxiliaryRod, toRod, fromRod)
+        
+    }
+    
+    helper(n, fromRod, toRod, auxiliaryRod);
+    return count;
+}

DSA /course-questions/q5.js

@@ -0,0 +1,71 @@
+// Q) Write a recursive function called sumToN that takes a positive integer n as input and returns the sum of all integers from 1 to n.
+
+// function sumToN(n) {
+//     //base case
+//     if(n===1) return 1;
+//     //recursive case
+//     return (sumToN(n-1) + n)
+// }
+
+// console.log(sumToN(3));
+
+// Q) Write a recursive function called countDown that takes a positive integer n and returns an array counting down from n to 1.
+
+// function countDown(n) {
+//     //base case
+//     if(n===1) return [1];
+//     //recursive case
+//     return [n, ...countDown(n-1)];
+// }
+
+// console.log(countDown(5));
+
+
+// Q) Write a recursive function factorial that calculates the factorial of a number n.
+
+function factorial(n) {
+    //base case
+    if(n===1) return 1;
+    //recursive case
+    return (factorial(n-1) * n)
+}
+
+console.log(factorial(5));
+
+// T = O(n) as the number of operations * number of nodes is equal to n and S = O(n) as the depth of the tree is equal to n as well
+
+// Q) Write a recursive function fibonacci that returns the nth number in the Fibonacci sequence.
+
+function fibonacci(n) {
+    // base case
+    if(n<=2) return 1;
+    //recursive case
+    return (fibonacci(n-1) + fibonacci(n-2))
+}
+
+console.log(fibonacci(9));
+
+
+// Q) Write a recursive function reverseString that reverses a string.
+
+function reverseString(str) {
+    //base case
+    if(str.length<=1) return str;
+    //recursive case
+    return reverseString(str.slice(1)) + str[0];
+}
+
+console.log(reverseString("apple"))
+
+//"apple" => "elppa"
+
+// Q) Write a recursive function arraySum that adds up all numbers in an array.
+
+function arraySum(arr) {
+   //base case
+    if(arr.length===0) return 0;
+   //recursive case
+    return (arr[0] + arraySum(arr.slice(1)))
+}
+
+console.log(arraySum([1,2, 3, 4]))

DSA /course-questions/sample.js

@@ -0,0 +1 @@
+// SCOPE + LEXICAL SCOPE