added practice questiongit add .

ashish8513 · ashish8513 · commit 2f0d9ace8594 · 2024-09-21T10:45:10.000+05:30
diff --git a/DSA JS Practice/Reverse.js b/DSA JS Practice/Reverse.js
diff --git a/DSA JS Practice/ReverseVowel.js b/DSA JS Practice/ReverseVowel.js
diff --git a/DSA JS Practice/SumofTwoNO.js b/DSA JS Practice/SumofTwoNO.js
diff --git a/DailyContestQuestion/Lexicographical.js b/DailyContestQuestion/Lexicographical.js
@@ -0,0 +1,24 @@
+// Given an integer n, return all the numbers in the range [1, n] sorted in lexicographical order.
+
+// You must write an algorithm that runs in O(n) time and uses O(1) extra space. 
+
+/**
+ * @param {number} n
+ * @return {number[]}
+ */
+var lexicalOrder = function(n) {
+    const result=[];
+    let current =1;
+    for(let i=0;i<n;i++){
+      result.push(current);
+      if(current*10<=n){
+          current *=10;
+      }else{
+          while(current%10 ===9 || current+1>n){
+              current=Math.floor(current/10)
+          }
+          current ++
+      }
+    }  
+    return result;
+  };
diff --git a/self/Fibonicc_series.js b/self/Fibonicc_series.js
@@ -0,0 +1,24 @@
+function generateFibonacciSeries(terms) {
+    // Check if the number of terms is less than 1
+    if (terms <= 0) {
+        return [];
+    }
+    
+    // Initialize the first two terms of the Fibonacci series
+    let series = [0];
+    if (terms > 1) {
+        series.push(1);
+    }
+    
+    // Generate the remaining terms of the series
+    for (let i = 2; i < terms; i++) {
+        let nextTerm = series[i - 1] + series[i - 2];
+        series.push(nextTerm);
+    }
+    
+    return series;
+}
+
+// Example usage
+let numberOfTerms = 10; // Change this value to generate more or fewer terms
+console.log(generateFibonacciSeries(numberOfTerms));
diff --git a/self/Patten Js.js b/self/Patten Js.js
@@ -0,0 +1,92 @@
+/**--------- 
+ ****
+ ****
+ ****
+ ****
+------------*/
+
+let n = 4
+for (let row = 1; row <= n; row += 1) {
+    let str = "";
+    for (let row = 1; row <= n; row++) {
+        str += "*"
+    }
+    console.log(str)
+}
+
+/** --------------
+ * 
+ **
+ ***
+ ****
+ *****
+ ----------------*/
+let a = 5;
+for (let row = 1; row <= a; row++) {
+    let str = "*"
+    console.log(str.repeat(row))
+}
+
+let b = 4;
+for (let col = 1; col >= b; col++) {
+    let str = "*";
+    let space = ' ';
+    console.log(space.repeat((b - 1)) + str.repeat(col))
+}
+
+/** --------------
+
+           *
+          **
+         ***
+        ****
+       *****
+      ******
+     *******
+    ********
+   *********
+
+
+   ----------------*/
+
+let str5 = "";
+let y = 10;
+let x = 10;
+for (let i = 1; i < y; i++) {
+    for (let j = 1; j < x; j++) {
+        if (i <= y / 2 && j >= (y / 2) - (i - 1) && j <= (y / 2) + (i - 1)) {
+            str5 = str5.concat("*");
+        } else if (i >= y / 2
+            && j > ((y / 2) - i) * (-1)
+            && j < (y - ((y / 2) - i) * (-1))) {
+            str5 = str5.concat("*");
+        }
+        else {
+            str5 = str5.concat(" ");
+        }
+    }
+    str5 = str5.concat("\n");
+}
+
+console.log(str5)
+
+/**------------------------
+
+
+    *
+   * *
+  * * *
+ * * * *
+* * * * *
+
+---------------------------*/
+
+var h = '';
+var f = 5;
+var m = (f - 1);
+for (i = 1; i <= n; i++) {
+    h = h.trim();
+    h = ' '.repeat(m) + h + (i > 1 ? ' ' : '') + '*';
+    console.log(h);
+    m--;
+}
diff --git a/self/Pattern2.js b/self/Pattern2.js
diff --git a/self/SearchInAray.js b/self/SearchInAray.js
@@ -0,0 +1,28 @@
+// Javascript program to implement linear 
+// search in unsorted array
+
+
+// Function to implement search operation 
+function findElement( arr, n, key)
+{
+    let i;
+    for (i = 0; i < n; i++)
+        if (arr[i] == key)
+            return i;
+
+    return -1;
+}
+
+
+    let arr = [12, 34, 10, 6, 40];
+    let n = arr.length;
+
+    // Using a last element as search element
+    let key = 40;
+    let position = findElement(arr, n, key);
+
+    if (position == - 1)
+        console.log("Element not found");
+    else
+        console.log("Element Found at Position: " 
+             + (position + 1));
diff --git a/self/Sleep.js b/self/Sleep.js
@@ -0,0 +1,8 @@
+/**Given a positive integer millis, write an asynchronous function that sleeps for millis milliseconds. It can resolve any value.*/
+async function sleep(millis) {
+    return new Promise(resolve => {
+        setTimeout(resolve(200), millis)
+    });
+}
+ 
+sleep(200).then(result => console.log(result));
diff --git a/self/addTwoSorted.js b/self/addTwoSorted.js
@@ -0,0 +1,11 @@
+
+function mergedArry(arr1, arr2) {
+
+    const mergedArry = arr2.concat(arr1)
+    mergedArry.sort((a, b) => a - b)
+    return mergedArry
+}
+const arr1 = [1, 2, 4]
+const arr2 = [1, 3, 4]
+const output = (mergedArry(arr1, arr2))
+console.log(output)
diff --git a/self/api.js b/self/api.js
@@ -0,0 +1,13 @@
+async function quotes() {
+    try {
+
+        const response = await fetch('https://type.fit/api/quotes')
+        const data = await response.json()
+        console.log(data);
+    } catch (err) {
+        console.log('Error fetching data', err);
+    } finally {
+        console.log("api closed in the data ");
+    }
+}
+quotes();
diff --git a/self/arrayInser.js b/self/arrayInser.js
@@ -0,0 +1,18 @@
+
+function insertAM() {
+    let data = [10, 3, 60, 46, 76, 54]
+    let newEle = document.getElementById('newEl').vlaue;
+    newEle=parseInt(newEle)
+    let position = document.getElementById('position').value
+    console.warn(data);
+
+    for (let i = data.length - 1; i >= 0; i--) {
+        if (i >= position) {
+            data[i + 1] = data[i];
+            if (i == position) {
+                data[i] = newEle;
+            }
+        }
+    }
+    console.warn(data);
+}
diff --git a/self/array_delete.js b/self/array_delete.js
@@ -0,0 +1,7 @@
+let data = [20, 49, 50, 51, 52, 36];
+let postion = 3;
+for (let i = postion; i <= data.length - 1; i++) {
+    data[i] = data[i + 1];
+}               
+data.length = data.length - 1
+console.warn(data);
diff --git a/self/async.js b/self/async.js
@@ -0,0 +1,4 @@
+async function result(){
+    return "ashish"
+}
+console.log(result)
diff --git a/self/bubbleShort.js b/self/bubbleShort.js
@@ -0,0 +1,31 @@
+
+function bubbleSort(arr) {
+    let n = arr.length;
+    let swapped;
+
+    // Traverse through all array elements
+    for (let i = 0; i < n - 1; i++) {
+        swapped = false;
+
+        // Last i elements are already in place
+        for (let j = 0; j < n - i - 1; j++) {
+            // Compare adjacent elements
+            if (arr[j] > arr[j + 1]) {
+                // Swap if elements are in the wrong order
+                [arr[j], arr[j + 1]] = [arr[j + 1], arr[j]];
+                swapped = true;
+            }
+        }
+
+        // If no two elements were swapped by the inner loop, break
+        if (!swapped) break;
+    }
+
+    return arr;
+}
+
+// Example usage:
+const array = [64, 34, 25, 12, 22, 11, 90];
+console.log('Unsorted array:', array);
+const sortedArray = bubbleSort(array);
+console.log('Sorted array:', sortedArray);
diff --git a/self/even.js b/self/even.js
@@ -0,0 +1,9 @@
+let a = 10;
+
+// Check if a is even or odd
+
+if (a % 2 === 0) {
+    console.log(" even number");
+} else {
+    console.log("  odd number");
+}
diff --git a/self/finanobicc.js b/self/finanobicc.js
@@ -0,0 +1,18 @@
+function isPalindrome(str) {
+    let j = str.length - 1
+    for (let i = 0; i < str.length / 2; i++) {
+        if (str[i] != str[j]) {
+            return false;
+        }
+        j--;
+    }
+    return true;
+}
+
+let str1 = "ashish";
+let str2 = "madhu";
+let str3 = "rama";
+
+console.log(isPalindrome(str1));
+console.log(isPalindrome(str2));
+console.log(isPalindrome(str3));
diff --git a/self/highest.js b/self/highest.js
@@ -0,0 +1,13 @@
+let a = 10;
+let b = 20;
+let c = 30;
+// find higest no.
+
+let max = a;
+if (b > max) {
+    max = b;
+}
+if (c > max) {
+    max = c;
+}
+console.log(max)
diff --git a/self/highest2.js b/self/highest2.js
@@ -0,0 +1,9 @@
+let a=10;
+let b=20;
+//find highest value
+
+let max = a;
+if (b > max) {
+    max = b;
+}
+console.log(max)
diff --git a/self/learn.js b/self/learn.js
@@ -0,0 +1,7 @@
+// const powerTwo=(n)=>{
+//     return n**2
+// }
+// function powerCube(powerTwo,n){
+// return powerTwo(n)*n
+// }
+// console.log(powerCube(powerTwo,3))
diff --git a/self/length.js b/self/length.js
@@ -0,0 +1,9 @@
+function CalculateNumberoflength(str) {
+    let length = 0;
+    while (str[length] !== undefined) {
+        length++
+    }
+    return length;
+}
+let strExample = "Ashishprabhakar"
+console.log(CalculateNumberoflength(strExample))
diff --git a/self/moves.js b/self/moves.js
@@ -0,0 +1,37 @@
+function moveZeroes(num) {
+    let nonZeroIndex = 0;
+    for (let i = 0; i <= num.length; i++) {
+        if (num[i] == 0) {
+            num[nonZeroIndex] = num[i]
+            nonZeroIndex++;
+        }
+    }
+    for (let i = nonZeroIndex; i < num.length; i++) {
+        num[i] = 0;
+    }
+    return num;function generateFibonacciSeries(terms) {
+        // Check if the number of terms is less than 1
+        if (terms <= 0) {
+            return [];
+        }
+        
+        // Initialize the first two terms of the Fibonacci series
+        let series = [0];
+        if (terms > 1) {
+            series.push(1);
+        }
+        
+        // Generate the remaining terms of the series
+        for (let i = 2; i < terms; i++) {
+            let nextTerm = series[i - 1] + series[i - 2];
+            series.push(nextTerm);
+        }
+        
+        return series;
+    }
+    
+    // Example usage
+    let numberOfTerms = 10; // Change this value to generate more or fewer terms
+    console.log(generateFibonacciSeries(numberOfTerms));
+    
+}
diff --git a/self/practice.js b/self/practice.js
diff --git a/self/prommise.js b/self/prommise.js
diff --git a/self/removeElement.js b/self/removeElement.js
diff --git a/self/this.js b/self/this.js
