JS interview coding question

Author: KishanMaurya

AddDigits.js

@@ -0,0 +1,12 @@
+const AddDigits = (num) =>{
+    while (num >= 10) {
+        let sum = 0;
+        while (num > 0) {
+          sum += num % 10;
+          num = Math.floor(num / 10);
+        }
+        num = sum;
+      }
+      return num;
+}
+console.log(AddDigits(38))

AddToArray.js

@@ -0,0 +1,11 @@
+let array1 = [1,2,3,4,5,6,7,8]
+let array2 = [2,3,4,5,6,7,8,9]
+let result = []
+for(let i=0; i<array1.length; i++){
+    for(let j=0; j<array2.length; j++){
+        let add = array1[i] + array2[2];
+        result.push(add)
+    }
+}
+
+console.log(result)

Array/arrayreplace.js

@@ -0,0 +1,15 @@
+function solution(inputArray, elemToReplace, substitutionElem) {
+    if(inputArray.length < 0) return inputArray
+    let arr = []
+    for(let i=0; i<inputArray.length; i++){
+        if(inputArray && inputArray[i] === elemToReplace){
+            arr.splice(i,0,substitutionElem)
+        }else{
+            arr.push(inputArray[i])
+        }
+    }
+    return arr
+}
+
+let inputArray = [1, 2, 1], elemToReplace = 1,  substitutionElem = 3
+console.log(solution(inputArray,elemToReplace,substitutionElem))

Array/checkEvenOrOdd.js

@@ -0,0 +1,10 @@
+function solution(n) {
+    if(n <= 1) return false;
+
+    if(n % 2 === 0){
+        return true;
+    }
+    return false
+}
+let n = 2;
+console.log(solution(n))

Array/checkVariable.js

@@ -0,0 +1,17 @@
+function solution(name) {
+    // Check if the name starts with a digit
+    if (/^\d/.test(name)) {
+        return false;
+    }
+    
+    // Check if the name contains only valid characters
+    if (/^[a-zA-Z0-9_]+$/.test(name)) {
+        return true;
+    } else {
+        return false;
+    }
+}
+
+let name = "var_1__Int";
+// let name = "qq-q"
+console.log(solution(name))

Array/chessMaster.js

@@ -0,0 +1,8 @@
+function solution(cell1, cell2) {
+    // Extract the row and column numbers for each cell
+    const [row1, col1] = [parseInt(cell1[1]), cell1.charCodeAt(0) - 64];
+    const [row2, col2] = [parseInt(cell2[1]), cell2.charCodeAt(0) - 64];
+    
+    // Check if the sum of the row and column numbers is even for both cells
+    return (row1 + col1) % 2 === (row2 + col2) % 2;
+}

Array/circleOfNum.js

@@ -0,0 +1,7 @@
+function circleOfNumbers(n, firstNumber) {
+    // Calculate the number opposite to firstNumber using modulo arithmetic
+    const oppositeNumber = (firstNumber + n/2) % n;
+    
+    return oppositeNumber;
+  }
+  

Array/evenNumbers.js

@@ -0,0 +1,13 @@
+const evenNumbers = (arr) =>{
+    let result = [];
+    for(let i=0; i< arr.length; i++){
+        if(arr[i] % 2 === 0){
+            result.push(arr[i])
+        } 
+    }
+    return result
+}
+
+const arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+const evens = evenNumbers(arr);
+console.log(evens); // output: [2, 4, 6, 8, 10]

Array/findDuplicateSortIncreasingOrder.js

@@ -0,0 +1,15 @@
+const findDuplicateSortIncreasingOrder = (arr)=>{
+    let unique = []
+    let duplicate = []
+    for(let i=0; i<arr.length; i++){
+        if(!unique.includes(arr[i])){
+            unique.push(arr[i])
+        }else{
+            duplicate.push(arr[i])
+        }
+    }
+    let res = duplicate.sort((a,b)=>a-b)
+    return res
+}
+let arr = [2,3,4,5,5,6,7,2,21,1,1,7,8,9,10]
+console.log(findDuplicateSortIncreasingOrder(arr))

Array/findNumbersInArray.js

@@ -0,0 +1,14 @@
+const findNumbersInArray = (arr, find)=>{
+    let count = 0;
+    for(let i=0; i<arr.length; i++){
+        if(arr[i] === find){
+            count ++;
+        }
+    }
+    return count
+}
+
+const arr = [1, 5, 2, 5, 3, 5, 4];
+const find = 5;
+const count = findNumbersInArray(arr, find);
+console.log(count); // output: 3

Array/getMedianArray.js

@@ -0,0 +1,19 @@
+const getMedian = (arr)=>{
+    let sortedArray = arr.sort((a,b)=>{ return a-b })
+    let minIndex = Math.floor(sortedArray.length/2);
+    if(sortedArray.length % 2 === 0){
+        return (sortedArray[minIndex  -1] + sortedArray[minIndex]) / 2
+    }
+    else{
+        return sortedArray[minIndex]
+    }
+}
+
+
+const arr = [1, 2, 3, 4, 5];
+const median = getMedian(arr);
+console.log(median); // output: 3
+
+const arr2 = [1, 2, 3, 4, 5, 6];
+const median2 = getMedian(arr2);
+console.log(median2); // output: 3.5

Array/getUnique.js

@@ -0,0 +1,12 @@
+const getUniqueElements = (arr) =>{
+    let result = [];
+    for(let i=0; i<arr.length; i++){
+        if(arr.indexOf(arr[i]) === arr.lastIndexOf(arr[i])){
+            result.push(arr[i])
+        }
+    }
+    return result
+}
+const arr = [1, 2, 3, 2, 4, 5, 1, 6, 7, 5];
+const uniqueArr = getUniqueElements(arr);
+console.log(uniqueArr); // output: [3, 4, 6, 7]

Array/intersection.js

@@ -0,0 +1,17 @@
+const intersection = (arr1,arr2) =>{
+    let result = []
+    for(let i=0; i<arr1.length; i++){
+        for(let j=0; j<arr2.length; j++){
+            if(arr1[i] === arr2[j]){
+                result.push(arr1[i])
+            }
+        }
+    }
+    return result;
+}
+
+
+const arr1 = [1, 2, 3, 4, 5];
+const arr2 = [3, 4, 5, 6, 7];
+const common = intersection(arr1, arr2);
+console.log(common); // output: [3, 4, 5]

Array/largestNumber.js

@@ -0,0 +1,14 @@
+const largestNumber = (arr)=>{
+    let largest = [0]
+    for(let i=0; i<arr.length; i++){
+        if(arr[i] > largest){
+            largest = arr[i]
+        }
+    }
+    return largest
+}
+
+
+const arr = [10, 5, 2, 20, 8];
+const largest = largestNumber(arr);
+console.log(largest); // output: 20

Array/mergeSorted.js

@@ -0,0 +1,16 @@
+// Input: nums1 = [1,2,3,0,0,0], m = 3, nums2 = [2,5,6], n = 3
+// Output: [1,2,2,3,5,6]
+
+const mergeSortedArray = (arr1,arr2)=>{
+    let result = []
+    let mergeArray = [...arr1,...arr2]
+    for(let i=0; i<mergeArray.length; i++){
+        if(mergeArray[i] !== 0){
+            result.push(mergeArray[i])
+        }
+    }
+    
+    return result.sort((a,b)=> { return a - b})
+}
+
+console.log(mergeSortedArray([1,2,3,0,0,0],[2,5,6]))

Array/mongoDB/chapter.md

@@ -0,0 +1,95 @@
+## What is sharding in MongoDB?
+
+Sharding is a method for distributing data across multiple machines. MongoDB uses sharding to support deployments with very large data sets and high throughput operations. Database systems with large data sets or high throughput applications can challenge the capacity of a single server.
+
+sharding is a technique used in MongoDB to horizontally partition data across multiple servers or "shards". This is done to scale MongoDB horizontally, by distributing the data across multiple machines
+
+
+# Key Features of MongoDB
+Some of the key features of MongoDB are as follows:
+
+Schema-less database
+Document Oriented
+Indexing
+Sharding
+
+
+## How does MongoDB ensure high availability and data durability?
+---
+
+
+# Indexing
+Indexing helps in improving the performance of search queries. When you continuously perform searches in MongoDB documents, you can index those files which match your search criteria. Therefore, in MongoDB documents, users can index any field with primary or secondary indices, making the query search faster.
+
+# Sharding
+Sharding in MongoDB is performed when you want to work with larger datasets. With sharding, you can distribute such large data to multiple MongoDB instances. The collections in MongoDB having larger sizes are distributed in multiple collections, called ‘shards.’ Shards are implemented through clusters.
+
+# What is the role of indexes in MongoDB?
+
+Indexes support the efficient execution of queries in MongoDB. Without indexes, MongoDB must perform a collection scan, i.e. scan every document in a collection, to select those documents that match the query statement.
+
+
+# Stages of MongoDB Aggregation Pipeline
+$project.
+$match.
+$group.
+$sort.
+$skip & $limit.
+$first & $last.
+$unwind.
+
+# What is aggregation in MongoDB?
+What is Aggregation in MongoDB? Aggregation is a way of processing a large number of documents in a collection by means of passing them through different stages. The stages make up what is known as a pipeline. The stages in a pipeline can filter, sort, group, reshape and modify documents that pass through the pipeline.
+
+
+# How does MongoDB handle transactions?
+
+MongoDB supports multi-document transactions for replica sets and sharded clusters in version 4.0 and later. Transactions allow for atomic, consistent, isolated, and durable (ACID) operations on multiple documents within a single transaction.
+
+To use transactions in MongoDB, you need to follow these steps:
+
+Start a transaction: You can start a transaction by calling the startSession() method to create a session, and then calling the startTransaction() method on the session object.
+
+Perform transactional operations: Within a transaction, you can perform read and write operations on multiple documents and collections as if they were a single operation.
+
+Commit or abort the transaction: If all operations in the transaction succeed, you can call the commitTransaction() method to commit the transaction. If any operation fails, you can call the abortTransaction() method to roll back the entire transaction.
+
+MongoDB uses a two-phase commit protocol to ensure that transactions are atomic and durable. In the first phase, the transaction coordinator (which could be a mongos instance or a replica set primary) asks each shard to prepare for the commit by validating the transaction and making sure that all the necessary changes can be made. In the second phase, the coordinator instructs each shard to commit the transaction and persist the changes to disk.
+
+It's important to note that transactions in MongoDB have some limitations and requirements. For example, all documents that are part of a transaction must belong to the same replica set or sharded cluster, and you cannot perform certain operations within a transaction, such as creating or dropping a collection or index.
+
+Overall, MongoDB's support for transactions provides a powerful tool for ensuring data integrity and consistency in complex operations that span multiple documents and collections.
+
+
+# Here are some best practices for MongoDB performance optimization:
+
+Indexing: Create indexes on fields that are frequently queried and ensure that your queries are using the correct indexes. Use the explain() method to analyze the performance of your queries and identify slow queries that need optimization.
+
+Schema design: Design your data schema to match the query patterns of your application. Denormalize data if necessary to reduce the number of joins required for your queries. Avoid using overly complex data structures, such as arrays with large numbers of elements.
+
+Sharding: Use sharding to distribute your data across multiple nodes to achieve better scalability and performance. Choose an appropriate shard key that evenly distributes your data across the cluster and avoids hotspots.
+
+Server configuration: Configure your MongoDB servers to use the appropriate hardware and operating system settings. Use SSDs for storage to improve read and write performance. Use the WiredTiger storage engine for improved performance and compression.
+
+Monitoring: Monitor your MongoDB deployment to identify performance issues and potential bottlenecks. Use tools like MongoDB Compass, the mongostat and mongotop command-line utilities, and third-party monitoring tools to track performance metrics like CPU usage, memory usage, and disk I/O.
+
+Compression: Use compression to reduce the size of your data and improve read and write performance. MongoDB supports both document-level compression and storage engine-level compression.
+
+Query optimization: Optimize your queries by reducing the amount of data returned, using projection to select only the fields you need, and limiting the number of results returned with pagination or aggregation.
+
+Caching: Use caching to reduce the number of queries to the database. Use caching solutions like Redis or Memcached to store frequently accessed data in memory.
+
+By following these best practices, you can optimize the performance of your MongoDB deployment and achieve better scalability, faster query performance, and improved data management.
+
+# MongoDB supports several data models, including:
+
+Document model
+Key-value model
+Graph model
+Tabular model: MongoDB supports a tabular data model through the use of the MongoDB Connector for BI
+
+
+# What is the role of a replica set in MongoDB?
+
+A replica set in MongoDB is a group of mongod processes that maintain the same data set. Replica sets provide redundancy and high availability, and are the basis for all production deployments
+

Array/nonDecreasingOrder.js

@@ -0,0 +1,18 @@
+// takes an array of integers and returns true if the array is sorted in non-decreasing order, false otherwise:
+const isNonDecreasing = (arr)=>{
+    for(let i=0; i<arr.length; i++){
+        if(arr[i] > arr[i+1]){
+            return false;
+        }
+    }
+    return true;
+}
+
+
+
+const arr1 = [1, 2, 3, 4, 5];
+const arr2 = [1, 2, 5, 3, 4];
+const isNonDecreasing1 = isNonDecreasing(arr1);
+const isNonDecreasing2 = isNonDecreasing(arr2);
+console.log(isNonDecreasing1); // output: true
+console.log(isNonDecreasing2); // output: false

Array/removeDuplicates.js

@@ -0,0 +1,18 @@
+// const removeDuplicates = (arr) =>{
+//     return [...new Set(arr)]
+// }
+
+// console.log(removeDuplicates([1,1,2]))
+
+const removeDuplicates1 = (arr) =>{
+    let result = []
+    arr.sort((a,b)=>{ return a-b})
+    for(let i=0; i<arr.length; i++){
+        if(!result.includes(arr[i])){
+            result.push(arr[i])
+        }
+    }
+    return result
+}
+
+console.log(removeDuplicates1([1,1,2,9,9]))

Array/removeElement.js

@@ -0,0 +1,14 @@
+// nums = [3,2,2,3], val = 3
+
+const removeElement = (arr, val)=>{
+    let count = 0;
+    for(let i=0; i<arr.length; i++){
+        if(arr[i] !== val){
+            count ++;
+            arr[count] = arr[i]
+        }
+    }
+    return count;
+}
+
+console.log(removeElement([3,2,2,3],3))

Array/replaceStrinfs.js

@@ -0,0 +1,19 @@
+// For inputString = "crazy", the output should be solution(inputString) = "dsbaz"
+function solution(inputString) {
+    let str = ""
+    for(let i=0; i < inputString.length; i++){
+        let char = inputString[i]
+        if(char !== "z"){
+            let inc = char.charCodeAt(0) + 1;
+            let nextChar = String.fromCharCode(inc).toLowerCase();
+            str+=nextChar;
+        }else{
+            let inc = 97;
+            let nextChar = String.fromCharCode(inc).toLowerCase();
+            str+=nextChar;
+        }
+    }
+    return str
+}
+
+console.log(solution("crazy"))