Live Coding

यह कैसे जांचें कि कोई JavaScript ऑब्जेक्ट खाली है?

स्पष्टीकरण: एक ऑब्जेक्ट खाली होता है यदि उसमें कोई खुद की गणनीय प्रॉपर्टी नहीं होती है। हम Object.keys(obj) का उपयोग कर सकते हैं जो दिए गए ऑब्जेक्ट की खुद की गणनीय प्रॉपर्टी नामों के साथ एक सरणी लौटाता है। यदि इस सरणी की लंबाई 0 है, तो ऑब्जेक्ट खाली है।

function isEmpty(obj) {
  return Object.keys(obj).length === 0;
}

console.log(isEmpty({})); // true
console.log(isEmpty({ a: 1 })); // false

दी गई स्ट्रिंग को उलटने के लिए एक फ़ंक्शन लिखें।

स्पष्टीकरण: सबसे सीधा तरीका है स्ट्रिंग को वर्णों की सरणी में बदलना, सरणियों के लिए अंतर्निहित reverse() विधि का उपयोग करना, और फिर वर्णों को वापस एक स्ट्रिंग में जोड़ना।

function reverseString(str) {
  return str.split('').reverse().join('');
}

console.log(reverseString('hello')); // 'olleh'

एक फ़ंक्शन लिखें जो जांचता है कि दी गई स्ट्रिंग एक पैलिंड्रोम है या नहीं।

स्पष्टीकरण: एक पैलिंड्रोम एक शब्द या वाक्यांश होता है जिसे आगे और पीछे दोनों तरफ से पढ़ने पर एक जैसा लगता है। हम स्ट्रिंग को उलटकर (अधिक मज़बूत जाँच के लिए केस और गैर-अल्फ़ान्यूमेरिक वर्णों को अनदेखा करते हुए, लेकिन यहाँ हम एक साधारण जाँच कर रहे हैं) और मूल से इसकी तुलना करके इसकी जाँच कर सकते हैं।

function isPalindrome(str) {
  const reversed = str.split('').reverse().join('');
  return str === reversed;
}

console.log(isPalindrome('racecar')); // true
console.log(isPalindrome('hello')); // false

संख्याओं की सरणी में सबसे बड़ी संख्या ज्ञात करने के लिए एक फ़ंक्शन लिखें।

स्पष्टीकरण: आप सरणी के माध्यम से पुनरावृति कर सकते हैं, अब तक मिली सबसे बड़ी संख्या का ट्रैक रख सकते हैं। वैकल्पिक रूप से, आप सरणी तत्वों को तर्क के रूप में पास करने के लिए स्प्रेड सिंटैक्स (...) के साथ Math.max() फ़ंक्शन का उपयोग कर सकते हैं।

function findMaxNumber(arr) {
  if (arr.length === 0) return undefined; // या त्रुटि फेंकें
  return Math.max(...arr);
}

console.log(findMaxNumber([1, 5, 2, 9, 3])); // 9

एक ऐसा प्रोग्राम लिखें जो 1 से n तक की संख्याएँ प्रिंट करे। लेकिन तीन के गुणकों के लिए, संख्या के बजाय 'Fizz' प्रिंट करें, और पाँच के गुणकों के लिए, 'Buzz' प्रिंट करें। उन संख्याओं के लिए जो तीन और पाँच दोनों के गुणक हैं, 'FizzBuzz' प्रिंट करें।

स्पष्टीकरण: यह क्लासिक समस्या लूप और कंडीशनल के मूल तर्क का मूल्यांकन करती है। आपको 1 से n तक पुनरावृति करने और 3 और 5 से विभाज्यता की जाँच के लिए मॉड्यूलो ऑपरेटर (%) का उपयोग करने की आवश्यकता है।

function fizzBuzz(n) {
  for (let i = 1; i <= n; i++) {
    if (i % 3 === 0 && i % 5 === 0) {
      console.log('FizzBuzz');
    } else if (i % 3 === 0) {
      console.log('Fizz');
    } else if (i % 5 === 0) {
      console.log('Buzz');
    } else {
      console.log(i);
    }
  }
}

fizzBuzz(15);

एक फ़ंक्शन लिखें जो एक सरणी से डुप्लिकेट तत्वों को हटाता है।

स्पष्टीकरण: इसे प्राप्त करने का एक आधुनिक और संक्षिप्त तरीका Set का उपयोग करना है। सेट केवल अद्वितीय मानों को संग्रहीत करते हैं। आप सरणी को एक सेट में और फिर वापस एक सरणी में बदल सकते हैं।

function removeDuplicates(arr) {
  return [...new Set(arr)];
}

console.log(removeDuplicates([1, 2, 2, 3, 4, 4, 5])); // [1, 2, 3, 4, 5]

जांचने के लिए एक फ़ंक्शन लिखें कि क्या दो स्ट्रिंग एक दूसरे के एनाग्राम हैं।

स्पष्टीकरण: एनाग्राम वे शब्द होते हैं जो किसी अन्य के अक्षरों को पुनर्व्यवस्थित करके बनते हैं। इसकी जाँच के लिए, हम स्ट्रिंग को साफ़, सॉर्ट और तुलना कर सकते हैं। सफ़ाई में गैर-अल्फ़ान्यूमेरिक वर्णों को हटाना और एक ही प्रारूप (अपरकेस/लोअरकेस) में बदलना शामिल है।

function isAnagram(str1, str2) {
  const clean = (str) => str.replace(/[^a-z0-9]/gi, '').toLowerCase();
  const sorted = (str) => clean(str).split('').sort().join('');
  
  return sorted(str1) === sorted(str2);
}

console.log(isAnagram('listen', 'silent')); // true
console.log(isAnagram('hello', 'world')); // false

एक गैर-ऋणात्मक पूर्णांक के फैक्टोरियल की गणना करने के लिए एक फ़ंक्शन लिखें।

स्पष्टीकरण: एक संख्या का फैक्टोरियल (n!) n से कम या उसके बराबर सभी धनात्मक पूर्णांकों का गुणनफल होता है। हम 1 से n तक की संख्याओं को गुणा करके इसे पुनरावृत्त रूप से गणना कर सकते हैं।

function factorial(n) {
  if (n < 0) return undefined; // नकारात्मक संख्याओं के लिए फैक्टोरियल परिभाषित नहीं है
  if (n === 0) return 1;
  let result = 1;
  for (let i = 1; i <= n; i++) {
    result *= i;
  }
  return result;
}

console.log(factorial(5)); // 120

एक फ़ंक्शन लिखें जो एक सरणी में सभी संख्याओं का योग लौटाता है।

स्पष्टीकरण: आप reduce विधि का उपयोग कर सकते हैं, जो एक सरणी से एक एकल मान जमा करने के लिए आदर्श है। यह एक कॉलबैक फ़ंक्शन और एक प्रारंभिक मान (योग के लिए 0) लेता है।

function sumArray(arr) {
  return arr.reduce((accumulator, currentValue) => accumulator + currentValue, 0);
}

console.log(sumArray([1, 2, 3, 4])); // 10

एक नेस्टेड सरणी को समतल करने के लिए एक फ़ंक्शन लिखें। सरलता के लिए, केवल एक स्तर के नेस्टिंग को मानें।

स्पष्टीकरण: नेस्टिंग के एक ही स्तर के लिए, आप स्प्रेड ऑपरेटर या flat() विधि (ES2019) के साथ Array.prototype.concat() का उपयोग कर सकते हैं।

function flattenArray(arr) {
  // flat() का उपयोग करके (यदि ES2019+ स्वीकार्य है तो सरल)
  // return arr.flat();

  // reduce और concat का उपयोग करके
  return arr.reduce((acc, val) => acc.concat(val), []);
}

console.log(flattenArray([1, [2, 3], 4, [5]])); // [1, 2, 3, 4, 5]

एक फ़ंक्शन लिखें जो दी गई स्ट्रिंग में स्वरों (a, e, i, o, u) की संख्या गिनता है।

स्पष्टीकरण: स्ट्रिंग के माध्यम से पुनरावृति करें (केस-संवेदी नहीं) और जांचें कि क्या प्रत्येक वर्ण एक स्वर है। एक काउंटर बनाए रखें।

function countVowels(str) {
  const vowels = 'aeiou';
  let count = 0;
  for (let char of str.toLowerCase()) {
    if (vowels.includes(char)) {
      count++;
    }
  }
  return count;
}

console.log(countVowels('Hello World')); // 3

एक फ़ंक्शन लिखें जो एक वाक्य को शीर्षक प्रारूप में बदलता है (प्रत्येक शब्द का पहला अक्षर कैपिटलाइज़ किया गया)।

स्पष्टीकरण: वाक्य को शब्दों में विभाजित करें, फिर प्रत्येक शब्द के माध्यम से पुनरावृति करें, पहले अक्षर को कैपिटलाइज़ करें और शेष को लोअरकेस करें। अंत में, शब्दों को फिर से जोड़ें।

function titleCase(str) {
  return str.toLowerCase().split(' ').map(word => {
    return word.charAt(0).toUpperCase() + word.slice(1);
  }).join(' ');
}

console.log(titleCase('i am a little tea pot')); // 'I Am A Little Tea Pot'

एक पूर्णांक सरणी nums और एक पूर्णांक target दिया गया है, उन दो संख्याओं के सूचकांक लौटाएँ जिनकी योग target है।

स्पष्टीकरण: एक सामान्य दृष्टिकोण पुनरावृति करते समय संख्याओं और उनके सूचकांकों को संग्रहीत करने के लिए एक हैश मैप (या एक JavaScript ऑब्जेक्ट) का उपयोग करना है। प्रत्येक संख्या के लिए, जांचें कि क्या target - current_number मैप में मौजूद है।

function twoSum(nums, target) {
  const map = {};
  for (let i = 0; i < nums.length; i++) {
    const complement = target - nums[i];
    if (map[complement] !== undefined) {
      return [map[complement], i];
    }
    map[nums[i]] = i;
  }
  return []; // या null, या यदि कोई समाधान नहीं है तो त्रुटि फेंकें
}

console.log(twoSum([2, 7, 11, 15], 9)); // [0, 1]

एक फ़ंक्शन बनाएँ जो एक काउंटर फ़ंक्शन लौटाता है। जब भी लौटे हुए फ़ंक्शन को बुलाया जाता है, तो उसे एक गणना को बढ़ाना और वापस करना चाहिए।

स्पष्टीकरण: यह क्लोजर को प्रदर्शित करता है। आंतरिक फ़ंक्शन में बाहरी फ़ंक्शन के दायरे से count वेरिएबल तक पहुंच होती है, भले ही बाहरी फ़ंक्शन ने निष्पादित करना समाप्त कर दिया हो।

function createCounter() {
  let count = 0;
  return function() {
    count++;
    return count;
  };
}

const counter1 = createCounter();
console.log(counter1()); // 1
console.log(counter1()); // 2
const counter2 = createCounter();
console.log(counter2()); // 1

एक फ़ंक्शन लिखें जो एक स्ट्रिंग में पहला गैर-दोहराव वाला वर्ण ज्ञात करता है।

स्पष्टीकरण: आप वर्णों की आवृत्तियों को गिनने के लिए एक हैश मैप का उपयोग कर सकते हैं। सबसे पहले, आवृत्ति मैप बनाने के लिए स्ट्रिंग के माध्यम से पुनरावृति करें। फिर, स्ट्रिंग के माध्यम से फिर से पुनरावृति करें और 1 की गणना के साथ पहला वर्ण लौटाएँ।

function firstNonRepeatingChar(str) {
  const charCount = {};
  for (const char of str) {
    charCount[char] = (charCount[char] || 0) + 1;
  }
  for (const char of str) {
    if (charCount[char] === 1) {
      return char;
    }
  }
  return null; // या कोई संकेतक यदि सभी दोहराए जाते हैं
}

console.log(firstNonRepeatingChar('aabbcdeeff')); // 'c'
console.log(firstNonRepeatingChar('swiss')); // 'w'

एक फ़ंक्शन लिखें जो एक सरणी को एक निर्दिष्ट आकार के समूहों में विभाजित करता है।

स्पष्टीकरण: सरणी के माध्यम से पुनरावृति करें, निर्दिष्ट आकार के 'स्लाइस' लें और उन्हें एक नई सरणी में धकेलें। उस मामले को संभालें जहाँ अंतिम खंड छोटा हो सकता है।

function chunkArray(arr, size) {
  const chunked = [];
  let index = 0;
  while (index < arr.length) {
    chunked.push(arr.slice(index, index + size));
    index += size;
  }
  return chunked;
}

console.log(chunkArray([1, 2, 3, 4, 5, 6, 7], 3)); // [[1, 2, 3], [4, 5, 6], [7]]

यह निर्धारित करने के लिए एक फ़ंक्शन लिखें कि दी गई संख्या एक अभाज्य संख्या है या नहीं।

स्पष्टीकरण: एक अभाज्य संख्या 1 से बड़ी एक प्राकृतिक संख्या है जिसका 1 और स्वयं के अलावा कोई धनात्मक भाजक नहीं होता है। संख्या के वर्गमूल तक 2 से पुनरावृति करें, विभाज्यता की जाँच करें। 1 और 2 जैसे सीमांत मामलों को संभालें।

function isPrime(num) {
  if (num <= 1) return false;
  if (num <= 3) return true;

  if (num % 2 === 0 || num % 3 === 0) return false;

  for (let i = 5; i * i <= num; i = i + 6) {
    if (num % i === 0 || num % (i + 2) === 0) return false;
  }

  return true;
}

console.log(isPrime(7)); // true
console.log(isPrime(10)); // false

एक फ़ंक्शन लिखें जो एक वाक्य में सबसे लंबा शब्द ज्ञात करता है।

स्पष्टीकरण: स्ट्रिंग को शब्दों की सरणी में विभाजित करें। फिर, सरणी के माध्यम से पुनरावृति करें, अब तक मिले सबसे लंबे शब्द (या उसकी लंबाई) का ट्रैक रखें।

function findLongestWord(str) {
  const words = str.split(' ');
  let longestWord = '';
  for (const word of words) {
    // यदि आवश्यक हो तो शब्दों को साफ़ करें (उदा. विराम चिह्न हटाएँ)
    if (word.length > longestWord.length) {
      longestWord = word;
    }
  }
  return longestWord;
}

console.log(findLongestWord('The quick brown fox jumped over the lazy dog')); // 'jumped'

Array.prototype.map फ़ंक्शन का अपना स्वयं का संस्करण लागू करें।

स्पष्टीकरण: map फ़ंक्शन एक कॉलबैक फ़ंक्शन लेता है और मूल सरणी के प्रत्येक तत्व पर कॉलबैक फ़ंक्शन को लागू करके एक नई सरणी बनाता है। आपके फ़ंक्शन को सरणी के माध्यम से पुनरावृति करनी चाहिए और नई सरणी का निर्माण करना चाहिए।

function myMap(arr, callback) {
  const mappedArray = [];
  for (let i = 0; i < arr.length; i++) {
    mappedArray.push(callback(arr[i], i, arr));
  }
  return mappedArray;
}

const numbers = [1, 4, 9];
const roots = myMap(numbers, Math.sqrt);
console.log(roots); // [1, 2, 3]

Array.prototype.filter फ़ंक्शन का अपना स्वयं का संस्करण लागू करें।

स्पष्टीकरण: filter फ़ंक्शन एक कॉलबैक फ़ंक्शन लेता है और प्रदान किए गए कॉलबैक फ़ंक्शन द्वारा लागू परीक्षण को पास करने वाले सभी तत्वों के साथ एक नई सरणी बनाता है।

function myFilter(arr, callback) {
  const filteredArray = [];
  for (let i = 0; i < arr.length; i++) {
    if (callback(arr[i], i, arr)) {
        filteredArray.push(arr[i]);
    }
  }
  return filteredArray;
}

const words = ['spray', 'limit', 'elite', 'exuberant', 'destruction', 'present'];
const result = myFilter(words, word => word.length > 6);
console.log(result); // ['exuberant', 'destruction', 'present']

Array.prototype.reduce फ़ंक्शन का अपना स्वयं का संस्करण लागू करें।

स्पष्टीकरण: reduce फ़ंक्शन सरणी के प्रत्येक तत्व पर उपयोगकर्ता द्वारा प्रदान किए गए 'रिड्यूसर' कॉलबैक फ़ंक्शन को निष्पादित करता है, पिछले तत्व की गणना का वापसी मूल्य पास करता है। सरणी के सभी तत्वों के माध्यम से रिड्यूसर को चलाने का अंतिम परिणाम एक एकल मान है। प्रारंभिक मान तर्क को संभालें।

function myReduce(arr, callback, initialValue) {
  let accumulator = initialValue;
  let startIndex = 0;

  if (initialValue === undefined) {
      if (arr.length === 0) throw new TypeError('प्रारंभिक मान के बिना एक खाली सरणी का रिड्यूस');
      accumulator = arr[0];
      startIndex = 1;
  }

  for (let i = startIndex; i < arr.length; i++) {
    accumulator = callback(accumulator, arr[i], i, arr);
  }
  return accumulator;
}

const array1 = [1, 2, 3, 4];
const sum = myReduce(array1, (acc, curr) => acc + curr, 0);
console.log(sum); // 10

प्रदर्शन को अनुकूलित करने के लिए मेमोइज़ेशन का उपयोग करके एक फाइबोनैचि फ़ंक्शन लागू करें।

स्पष्टीकरण: फाइबोनैचि अनुक्रम में दोहराई जाने वाली गणनाएँ शामिल होती हैं। मेमोइज़ेशन महंगी फ़ंक्शन कॉलों के परिणामों को संग्रहीत करता है और जब समान इनपुट फिर से होते हैं तो कैश किया गया परिणाम लौटाता है।

function memoizedFib() {
  const cache = {};

  function fib(n) {
    if (n in cache) {
      return cache[n];
    }
    if (n <= 1) {
      return n;
    }
    const result = fib(n - 1) + fib(n - 2);
    cache[n] = result;
    return result;
  }
  return fib;
}

const fibonacci = memoizedFib();
console.log(fibonacci(10)); // 55
console.log(fibonacci(40)); // 102334155 (बिना मेमोइज़ेशन के तुलना में बहुत तेज़)

जांचने के लिए एक फ़ंक्शन लिखें कि क्या कोष्ठक {}[]() वाली एक स्ट्रिंग संतुलित है।

स्पष्टीकरण: एक स्टैक का उपयोग करें। जब आपको एक उद्घाटन कोष्ठक मिलता है, तो उसे स्टैक में धकेलें। जब आपको एक समापन कोष्ठक मिलता है, तो जांचें कि क्या स्टैक खाली है या क्या शीर्ष तत्व संगत उद्घाटन कोष्ठक है। यदि यह मेल खाता है, तो तत्व को स्टैक से पॉप करें। यदि नहीं, या यदि स्टैक खाली है, तो यह असंतुलित है। अंत में, एक खाली स्टैक का मतलब है कि यह संतुलित है।

function isBalanced(str) {
  const stack = [];
  const map = { '(': ')', '{': '}', '[': ']' };

  for (let char of str) {
    if (map[char]) {
      stack.push(char);
    } else if (Object.values(map).includes(char)) {
      if (stack.length === 0) return false;
      const lastOpen = stack.pop();
      if (map[lastOpen] !== char) return false;
    }
  }
  return stack.length === 0;
}

console.log(isBalanced('({[]})')); // true
console.log(isBalanced('([)]')); // false

enqueue (अंत में जोड़ें) और dequeue (शुरुआत से हटाएँ) विधियों के साथ एक कतार (Queue) डेटा संरचना लागू करें।

स्पष्टीकरण: एक कतार FIFO (First-In, First-Out) सिद्धांत का पालन करती है। एक सरणी का उपयोग किया जा सकता है, enqueue के लिए push और dequeue के लिए shift के साथ।

class Queue {
  constructor() {
    this.items = [];
  }

  enqueue(element) {
    this.items.push(element);
  }

  dequeue() {
    if (this.isEmpty()) return 'Underflow';
    return this.items.shift();
  }

  front() {
    if (this.isEmpty()) return 'No elements in Queue';
    return this.items[0];
  }

  isEmpty() {
    return this.items.length === 0;
  }
}

const q = new Queue();
q.enqueue(10);
q.enqueue(20);
console.log(q.dequeue()); // 10
console.log(q.front()); // 20

push (शीर्ष पर जोड़ें) और pop (शीर्ष से हटाएँ) विधियों के साथ एक स्टैक (Stack) डेटा संरचना लागू करें।

स्पष्टीकरण: एक स्टैक LIFO (Last-In, First-Out) सिद्धांत का पालन करता है। एक सरणी का उपयोग किया जा सकता है, push और pop विधियों के साथ।

class Stack {
  constructor() {
    this.items = [];
  }

  push(element) {
    this.items.push(element);
  }

  pop() {
    if (this.isEmpty()) return 'Underflow';
    return this.items.pop();
  }

  peek() {
    return this.items[this.items.length - 1];
  }

  isEmpty() {
    return this.items.length === 0;
  }
}

const s = new Stack();
s.push(10);
s.push(20);
console.log(s.pop()); // 20
console.log(s.peek()); // 10

एक सरणी दी गई है जिसमें 0, 1, 2, ..., n से लिए गए n विशिष्ट संख्याएँ हैं, सरणी में लापता संख्या ज्ञात करें।

स्पष्टीकरण: 0 से n तक की संख्याओं का योग n*(n+1)/2 सूत्र का उपयोग करके गणना किया जा सकता है। सरणी तत्वों का वास्तविक योग गणना किया जा सकता है। इन दो योगों के बीच का अंतर लापता संख्या होगी।

function findMissingNumber(nums) {
  const n = nums.length;
  const expectedSum = n * (n + 1) / 2;
  const actualSum = nums.reduce((sum, num) => sum + num, 0);
  return expectedSum - actualSum;
}

console.log(findMissingNumber([3, 0, 1])); // 2
console.log(findMissingNumber([9, 6, 4, 2, 3, 5, 7, 0, 1])); // 8

एक डेबाउंस फ़ंक्शन लागू करें। डेबाउंस यह सुनिश्चित करता है कि एक फ़ंक्शन को तब तक फिर से नहीं बुलाया जाएगा जब तक कि एक निश्चित समय बीत न जाए बिना इसे फिर से बुलाया गया हो।

स्पष्टीकरण: setTimeout और clearTimeout का उपयोग करें। हर बार जब डेबाउंस फ़ंक्शन को बुलाया जाता है, तो यह पिछले टाइमआउट को साफ़ करता है और एक नया सेट करता है। वास्तविक फ़ंक्शन कॉल तभी होती है जब टाइमआउट पूरा हो जाता है।

function debounce(func, delay) {
  let timeoutId;
  return function(...args) {
    clearTimeout(timeoutId);
    timeoutId = setTimeout(() => {
      func.apply(this, args);
    }, delay);
  };
}

// उपयोग का उदाहरण:
const sayHello = () => console.log('Hello!');
const debouncedHello = debounce(sayHello, 1000);
debouncedHello(); // 1 सेकंड के बाद बुलाया जाता है (यदि फिर से नहीं बुलाया जाता है)
debouncedHello(); // टाइमर रीसेट करता है
debouncedHello(); // टाइमर रीसेट करता है, इस कॉल के 1 सेकंड बाद निष्पादित होगा।

एक थ्रॉटल फ़ंक्शन लागू करें। थ्रॉटल यह सुनिश्चित करता है कि एक फ़ंक्शन को एक निर्दिष्ट समय अंतराल में अधिकतम एक बार बुलाया जाए।

स्पष्टीकरण: यह इंगित करने के लिए एक ध्वज का उपयोग करें कि क्या कॉल की अनुमति है। जब बुलाया जाता है, यदि अनुमति दी जाती है, तो फ़ंक्शन को निष्पादित करें, ध्वज को असत्य पर सेट करें और अंतराल के बाद ध्वज को रीसेट करने के लिए setTimeout का उपयोग करें।

function throttle(func, limit) {
  let inThrottle = false;
  return function(...args) {
    if (!inThrottle) {
      func.apply(this, args);
      inThrottle = true;
      setTimeout(() => inThrottle = false, limit);
    }
  };
}

// उपयोग का उदाहरण:
const logScroll = () => console.log('Scrolling...');
const throttledScroll = throttle(logScroll, 1000);
// window.addEventListener('scroll', throttledScroll); // प्रति सेकंड अधिकतम एक बार लॉग करेगा।

एक फ़ंक्शन लिखें जो दो तर्कों के साथ एक फ़ंक्शन लेता है और उसका एक करीड संस्करण लौटाता है।

स्पष्टीकरण: करीइंग एक फ़ंक्शन को कई तर्कों के साथ फ़ंक्शंस के अनुक्रम में बदल देता है, प्रत्येक एक एकल तर्क लेता है। f(a, b) f(a)(b) बन जाता है।

function curry(fn) {
  return function(a) {
    return function(b) {
      return fn(a, b);
    };
  };
}

function add(a, b) {
  return a + b;
}

const curriedAdd = curry(add);
const add5 = curriedAdd(5);
console.log(add5(3)); // 8
console.log(curriedAdd(10)(20)); // 30

एक JavaScript ऑब्जेक्ट का गहरा क्लोनिंग करने के लिए एक फ़ंक्शन लिखें।

स्पष्टीकरण: एक उथला क्लोन केवल शीर्ष-स्तरीय गुणों की प्रतिलिपि बनाता है। एक गहरा क्लोन सभी गुणों को पुनरावृत्त रूप से कॉपी करता है, जिसमें नेस्टेड ऑब्जेक्ट और सरणियाँ शामिल हैं। एक सरल तरीका (सीमाओं के साथ, उदाहरण के लिए, फ़ंक्शन, तिथियां, नियमित अभिव्यक्ति को अच्छी तरह से नहीं संभालता है) JSON.parse(JSON.stringify(obj)) का उपयोग कर रहा है। एक पुनरावर्ती दृष्टिकोण अधिक मज़बूत है।

function deepClone(obj) {
  // सरल संस्करण (सीमाओं के साथ)
  try {
      return JSON.parse(JSON.stringify(obj));
  } catch (e) {
      console.error("क्लोनिंग विफल:", e);
      return null;
  }
  
  // अधिक मज़बूत पुनरावर्ती संस्करण (मूल उदाहरण):
  /*
  if (obj === null || typeof obj !== 'object') {
      return obj;
  }
  let clone = Array.isArray(obj) ? [] : {};
  for (let key in obj) {
      if (Object.prototype.hasOwnProperty.call(obj, key)) {
          clone[key] = deepClone(obj[key]);
      }
  }
  return clone;
  */
}

const original = { a: 1, b: { c: 2 } };
const cloned = deepClone(original);
cloned.b.c = 3;
console.log(original.b.c); // 2 (यह दर्शाता है कि यह एक गहरा क्लोन है)
console.log(cloned.b.c); // 3

किसी ऑब्जेक्ट से कुंजियों का एक सरणी (array) कैसे प्राप्त करें?

स्पष्टीकरण: Object.keys(obj) का उपयोग करें।

function getKeys(obj) {
  return Object.keys(obj);
}
console.log(getKeys({a: 1, b: 2})); // ['a', 'b']

किसी ऑब्जेक्ट से मानों का एक सरणी (array) कैसे प्राप्त करें?

स्पष्टीकरण: Object.values(obj) का उपयोग करें।

function getValues(obj) {
  return Object.values(obj);
}
console.log(getValues({a: 1, b: 2})); // [1, 2]

यह कैसे जांचें कि क्या किसी सरणी में कोई विशिष्ट मान है?

स्पष्टीकरण: Array.prototype.includes(value) का उपयोग करें।

function checkIncludes(arr, val) {
  return arr.includes(val);
}
console.log(checkIncludes([1, 2, 3], 2)); // true

दो सरणियों को एक में कैसे मर्ज करें?

स्पष्टीकरण: स्प्रेड सिंटैक्स (...) या Array.prototype.concat() का उपयोग करें।

function mergeArrays(arr1, arr2) {
  return [...arr1, ...arr2];
}
console.log(mergeArrays([1, 2], [3, 4])); // [1, 2, 3, 4]

एक ब्राउज़र में ग्लोबल स्कोप में this किसे संदर्भित करता है?

स्पष्टीकरण: ग्लोबल एग्जीक्यूशन कॉन्टेक्स्ट (किसी भी फ़ंक्शन के बाहर) में, this ग्लोबल ऑब्जेक्ट को संदर्भित करता है, जो वेब ब्राउज़र में window है।

console.log(this === window); // true (एक ब्राउज़र वातावरण में)

एक ऑब्जेक्ट के मेथड के अंदर उपयोग किए जाने पर this किसे संदर्भित करता है?

स्पष्टीकरण: जब एक फ़ंक्शन को एक ऑब्जेक्ट के मेथड के रूप में कॉल किया जाता है, तो this उस ऑब्जेक्ट को संदर्भित करता है जिस पर मेथड को कॉल किया जाता है।

const myObject = {
  prop: 'Hello',
  greet() {
    return this.prop;
  }
};
console.log(myObject.greet()); // 'Hello'

एरो फ़ंक्शंस this को कैसे संभालते हैं?

स्पष्टीकरण: एरो फ़ंक्शंस का अपना this कॉन्टेक्स्ट नहीं होता है। इसके बजाय, वे अपने आसपास के (लेक्सिकल) स्कोप से this को इनहेरिट करते हैं जहाँ उन्हें परिभाषित किया जाता है।

function MyClass() {
  this.value = 42;
  setTimeout(() => {
    console.log(this.value); // 42 दिखाता है क्योंकि 'this' इनहेरिट किया गया है
  }, 100);
}
new MyClass();

let, const और var के बीच मुख्य अंतर क्या हैं?

स्पष्टीकरण: var में फ़ंक्शन स्कोप होता है और वह होइस्टेड होता है। let और const में ब्लॉक स्कोप होता है और वे होइस्टेड होते हैं, लेकिन डिक्लेरेशन तक 'टेम्पोरल डेड ज़ोन' में होते हैं। const को इनिशियलाइज़ किया जाना चाहिए और उसे फिर से असाइन नहीं किया जा सकता है।

function scopeTest() {
  var a = 1;
  let b = 2;
  const c = 3;
  if (true) {
    var a = 10; // 'a' को फिर से डिक्लेयर करता है और बाहरी 'a' को प्रभावित करता है
    let b = 20; // ब्लॉक के अंदर नया 'b'
    // const c = 30; // एक नया 'c' होगा
    console.log(a, b, c); // 10, 20, 3
  }
  console.log(a, b, c); // 10, 2, 3
}
scopeTest();

जावास्क्रिप्ट में प्रॉमिस क्या है, समझाएं।

स्पष्टीकरण: एक प्रॉमिस एक ऑब्जेक्ट है जो एक असिंक्रोनस ऑपरेशन के अंतिम समापन (या विफलता) और उसके परिणामस्वरूप मूल्य का प्रतिनिधित्व करता है। यह तीन अवस्थाओं में से किसी एक में हो सकता है: लंबित (pending), पूर्ण (fulfilled) या अस्वीकृत (rejected)।

const myPromise = new Promise((resolve, reject) => {
  setTimeout(() => {
    resolve('सफलता!');
    // reject('त्रुटि!');
  }, 1000);
});

myPromise
  .then(result => console.log(result))
  .catch(error => console.error(error));

async और await प्रॉमिस के साथ काम करना कैसे आसान बनाते हैं?

स्पष्टीकरण: async/await प्रॉमिस पर एक सरल सिंटैक्स प्रदान करता है, जिससे असिंक्रोनस कोड थोड़ा और सिंक्रोनस कोड जैसा दिखता और व्यवहार करता है। एक async फ़ंक्शन हमेशा एक प्रॉमिस लौटाता है, और await तब तक निष्पादन को रोकता है जब तक कि एक प्रॉमिस हल या अस्वीकृत न हो जाए।

function delay(ms) {
  return new Promise(resolve => setTimeout(resolve, ms));
}

async function run() {
  console.log('शुरू हो रहा है...');
  await delay(1000);
  console.log('1 सेकंड इंतजार किया।');
  await delay(500);
  console.log('और 0.5 सेकंड इंतजार किया।');
  return 'हो गया!';
}

run().then(console.log);

एक टेक्स्ट स्ट्रिंग को नंबर में कैसे बदलें?

स्पष्टीकरण: parseInt(), parseFloat() या यूनरी प्लस ऑपरेटर (+) का उपयोग करें।

const str = '123.45';
console.log(parseInt(str)); // 123
console.log(parseFloat(str)); // 123.45
console.log(+str); // 123.45

एक नंबर को टेक्स्ट स्ट्रिंग में कैसे बदलें?

स्पष्टीकरण: String(), number.toString() या स्ट्रिंग कॉनकेटिनेशन का उपयोग करें।

const num = 123;
console.log(String(num)); // '123'
console.log(num.toString()); // '123'
console.log('' + num); // '123'

JSON.stringify क्या करता है?

स्पष्टीकरण: यह एक जावास्क्रिप्ट ऑब्जेक्ट या वैल्यू को JSON स्ट्रिंग में बदलता है।

const obj = { name: 'Alice', age: 30 };
const jsonString = JSON.stringify(obj);
console.log(jsonString); // '{"name":"Alice","age":30}'

JSON.parse क्या करता है?

स्पष्टीकरण: यह एक JSON स्ट्रिंग को पार्स करता है, स्ट्रिंग द्वारा वर्णित जावास्क्रिप्ट वैल्यू या ऑब्जेक्ट का निर्माण करता है।

const jsonString = '{"name":"Alice","age":30}';
const obj = JSON.parse(jsonString);
console.log(obj.name); // 'Alice'

सरणियों के साथ स्प्रेड ऑपरेटर (spread operator) का उपयोग कैसे किया जाता है?

स्पष्टीकरण: यह एक इटरेबल (जैसे एक सरणी) को उन जगहों पर विस्तारित करने की अनुमति देता है जहाँ शून्य या अधिक तर्क या तत्व अपेक्षित होते हैं। कॉपी करने, मर्ज करने और तत्वों को जोड़ने के लिए उपयोगी।

const arr1 = [1, 2];
const arr2 = [3, 4];
const combined = [...arr1, ...arr2]; // [1, 2, 3, 4]
const copy = [...arr1]; // [1, 2]

ऑब्जेक्ट्स के साथ स्प्रेड ऑपरेटर (spread operator) का उपयोग कैसे किया जाता है?

स्पष्टीकरण: यह ऑब्जेक्ट गुणों को कॉपी और मर्ज करने की अनुमति देता है।

const obj1 = { a: 1, b: 2 };
const obj2 = { b: 3, c: 4 };
const merged = { ...obj1, ...obj2 }; // { a: 1, b: 3, c: 4 }
const copy = { ...obj1 }; // { a: 1, b: 2 }

एक उदाहरण के साथ सरणी डीस्ट्रक्चरिंग समझाएं।

स्पष्टीकरण: यह एक सिंटैक्स है जो सरणियों से मानों को अलग-अलग वेरिएबल्स में अनपैक करने की अनुमति देता है।

const [a, b] = [10, 20];
console.log(a); // 10
console.log(b); // 20

const [x, , z] = [1, 2, 3];
console.log(z); // 3

एक उदाहरण के साथ ऑब्जेक्ट डीस्ट्रक्चरिंग समझाएं।

स्पष्टीकरण: यह ऑब्जेक्ट के गुणों को अलग-अलग वेरिएबल्स में अनपैक करने की अनुमति देता है।

const person = { name: 'Bob', age: 25 };
const { name, age } = person;
console.log(name); // 'Bob'
console.log(age); // 25

const { name: personName } = person;
console.log(personName); // 'Bob'

आप Function.prototype.call का एक बुनियादी संस्करण कैसे लागू करेंगे?

स्पष्टीकरण: call एक फ़ंक्शन को एक निर्दिष्ट this मान और व्यक्तिगत रूप से प्रदान किए गए तर्कों के साथ इनवोक करता है। आप फ़ंक्शन को this कॉन्टेक्स्ट से अटैच कर सकते हैं, उसे कॉल कर सकते हैं, और फिर उसे हटा सकते हैं।

Function.prototype.myCall = function(context, ...args) {
  context = context || window;
  const uniqueId = Symbol(); // एक अद्वितीय कुंजी का उपयोग करें
  context[uniqueId] = this;
  const result = context[uniqueId](...args);
  delete context[uniqueId];
  return result;
}

function greet(greeting, punctuation) {
  console.log(`${greeting}, ${this.name}${punctuation}`);
}

greet.myCall({ name: 'Charlie' }, 'Hi', '!'); // Hi, Charlie!

आप Function.prototype.apply का एक बुनियादी संस्करण कैसे लागू करेंगे?

स्पष्टीकरण: apply call के समान है, लेकिन तर्कों को एक सरणी के रूप में स्वीकार करता है।

Function.prototype.myApply = function(context, argsArray) {
  context = context || window;
  const uniqueId = Symbol();
  context[uniqueId] = this;
  const result = context[uniqueId](...(argsArray || []));
  delete context[uniqueId];
  return result;
}

function greet(greeting, punctuation) {
  console.log(`${greeting}, ${this.name}${punctuation}`);
}

greet.myApply({ name: 'David' }, ['Hello', '.']); // Hello, David.

जावास्क्रिप्ट के इवेंट लूप को संक्षेप में समझाएं।

स्पष्टीकरण: जावास्क्रिप्ट सिंगल-थ्रेडेड है, लेकिन यह इवेंट लूप का उपयोग करके कंकरेंसी प्राप्त करता है। कॉल स्टैक सिंक्रोनस कोड को संभालता है। वेब APIs असिंक्रोनस ऑपरेशन (जैसे setTimeout, fetch) को संभालती हैं। जब एक असिंक्रोनस ऑपरेशन समाप्त होता है, तो उसका कॉलबैक कॉलबैक क्यू (या प्रॉमिस के लिए माइक्रोटास्क क्यू) में जाता है। इवेंट लूप लगातार जांचता है कि क्या कॉल स्टैक खाली है; यदि यह खाली है, तो यह निष्पादन के लिए क्यू से अगला कॉलबैक स्टैक में ले जाता है।

console.log('शुरू');

setTimeout(() => {
  console.log('टाइमआउट कॉलबैक'); // कॉलबैक क्यू में जाता है
}, 0);

Promise.resolve().then(() => {
  console.log('प्रॉमिस रिजॉल्व हुआ'); // माइक्रोटास्क क्यू में जाता है
});

console.log('समाप्त');

// आउटपुट ऑर्डर: शुरू, समाप्त, प्रॉमिस रिजॉल्व हुआ, टाइमआउट कॉलबैक
// (माइक्रोटास्क मैक्रोटास्क/कॉलबैक से पहले निष्पादित होते हैं)

एक सॉर्टेड सरणी के लिए एक बाइनरी सर्च फ़ंक्शन लागू करें।

स्पष्टीकरण: बाइनरी सर्च एक सॉर्टेड सरणी में एक तत्व को खोज के अंतराल को आधा करके कुशलता से पाता है। यदि सर्च कुंजी का मान अंतराल के मध्य में तत्व से कम है, तो यह अंतराल को निचले आधे तक कम कर देता है। अन्यथा, यह ऊपरी आधे तक कम कर देता है। यह तब तक किया जाता है जब तक मान नहीं मिल जाता या अंतराल खाली नहीं हो जाता।

function binarySearch(sortedArray, key) {
  let start = 0;
  let end = sortedArray.length - 1;

  while (start <= end) {
    let middle = Math.floor((start + end) / 2);

    if (sortedArray[middle] === key) {
      return middle; // मिल गया
    } else if (sortedArray[middle] < key) {
      start = middle + 1; // दाहिने आधे में खोजें
    } else {
      end = middle - 1; // बाएं आधे में खोजें
    }
  }
  return -1; // नहीं मिला
}

console.log(binarySearch([1, 3, 5, 7, 9, 11], 7)); // 3
console.log(binarySearch([1, 3, 5, 7, 9, 11], 2)); // -1

मर्ज सॉर्ट एल्गोरिथम लागू करें।

स्पष्टीकरण: मर्ज सॉर्ट एक डिवाइड-एंड-कॉन्कर एल्गोरिथम है। यह इनपुट सरणी को दो हिस्सों में विभाजित करता है, खुद को दोनों हिस्सों के लिए कॉल करता है, और फिर दोनों सॉर्टेड हिस्सों को मर्ज करता है। मर्ज फ़ंक्शन महत्वपूर्ण है; यह दो सॉर्टेड सब-सरणियों को एक सॉर्टेड सरणी में जोड़ता है।

function mergeSort(arr) {
  if (arr.length <= 1) return arr;

  const mid = Math.floor(arr.length / 2);
  const left = mergeSort(arr.slice(0, mid));
  const right = mergeSort(arr.slice(mid));

  return merge(left, right);
}

function merge(left, right) {
  let result = [];
  let leftIndex = 0;
  let rightIndex = 0;

  while (leftIndex < left.length && rightIndex < right.length) {
    if (left[leftIndex] < right[rightIndex]) {
      result.push(left[leftIndex]);
      leftIndex++;
    } else {
      result.push(right[rightIndex]);
      rightIndex++;
    }
  }

  return result.concat(left.slice(leftIndex)).concat(right.slice(rightIndex));
}

console.log(mergeSort([38, 27, 43, 3, 9, 82, 10])); // [3, 9, 10, 27, 38, 43, 82]

क्विक सॉर्ट एल्गोरिथम लागू करें।

स्पष्टीकरण: क्विक सॉर्ट भी एक डिवाइड-एंड-कॉन्कर एल्गोरिथम है। यह एक तत्व को पिवट के रूप में चुनता है और दिए गए सरणी को चुने हुए पिवट के चारों ओर विभाजित करता है। पिवट से छोटे तत्व बाईं ओर जाते हैं, और बड़े तत्व दाहिनी ओर जाते हैं। फिर यह सब-सरणियों को रिकर्सिव रूप से सॉर्ट करता है।

function quickSort(arr) {
  if (arr.length <= 1) return arr;

  const pivot = arr[arr.length - 1];
  const left = [];
  const right = [];

  for (let i = 0; i < arr.length - 1; i++) {
    if (arr[i] < pivot) {
      left.push(arr[i]);
    } else {
      right.push(arr[i]);
    }
  }

  return [...quickSort(left), pivot, ...quickSort(right)];
}

console.log(quickSort([10, 8, 2, 1, 6, 3, 9, 4, 7, 5])); // [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

बबल सॉर्ट एल्गोरिथम लागू करें।

स्पष्टीकरण: बबल सॉर्ट एक सरल सॉर्टिंग एल्गोरिथम है जो सूची को बार-बार पार करता है, आसन्न तत्वों की तुलना करता है और यदि वे गलत क्रम में हैं तो उन्हें स्वैप करता है। सूची के माध्यम से पास तब तक दोहराया जाता है जब तक सूची सॉर्ट नहीं हो जाती।

function bubbleSort(arr) {
  let n = arr.length;
  let swapped;
  do {
    swapped = false;
    for (let i = 0; i < n - 1; i++) {
      if (arr[i] > arr[i + 1]) {
        [arr[i], arr[i + 1]] = [arr[i + 1], arr[i]]; // स्वैप करें
        swapped = true;
      }
    }
    n--; // अनुकूलन: अंतिम तत्व पहले से ही अपनी जगह पर है
  } while (swapped);
  return arr;
}

console.log(bubbleSort([64, 34, 25, 12, 22, 11, 90])); // [11, 12, 22, 25, 34, 64, 90]

दी गई स्ट्रिंग में, सबसे लंबी सबस्ट्रिंग की लंबाई ज्ञात करें जिसमें कोई दोहराए गए वर्ण नहीं हैं।

स्पष्टीकरण: 'स्लाइडिंग विंडो' तकनीक का उपयोग करें। एक विंडो (सबस्ट्रिंग) और उस विंडो में वर्णों का एक सेट रखें। दाहिने पॉइंटर को ले जाकर विंडो का विस्तार करें। यदि कोई दोहराया गया वर्ण मिलता है, तो विंडो को बाईं ओर से तब तक सिकोड़ें जब तक दोहराया गया वर्ण हटा न जाए।

function lengthOfLongestSubstring(s) {
  let maxLength = 0;
  let start = 0;
  const charMap = {};

  for (let end = 0; end < s.length; end++) {
    const char = s[end];
    if (charMap[char] >= start) {
        start = charMap[char] + 1;
    }
    charMap[char] = end;
    maxLength = Math.max(maxLength, end - start + 1);
  }
  return maxLength;
}

console.log(lengthOfLongestSubstring('abcabcbb')); // 3 ('abc')
console.log(lengthOfLongestSubstring('bbbbb')); // 1 ('b')
console.log(lengthOfLongestSubstring('pwwkew')); // 3 ('wke')

add और print मेथड्स के साथ एक सरल लिंक्ड लिस्ट लागू करें।

स्पष्टीकरण: एक लिंक्ड लिस्ट एक रेखीय डेटा संरचना है जहाँ तत्व सन्निहित मेमोरी स्थानों में संग्रहीत नहीं होते हैं। प्रत्येक तत्व (नोड) अगले को इंगित करता है। हेड को प्रबंधित करने और नए नोड्स जोड़ने के लिए आपको एक Node क्लास और एक LinkedList क्लास की आवश्यकता है।

class Node {
  constructor(data, next = null) {
    this.data = data;
    this.next = next;
  }
}

class LinkedList {
  constructor() {
    this.head = null;
  }

  add(data) {
    const newNode = new Node(data);
    if (!this.head) {
      this.head = newNode;
    } else {
      let current = this.head;
      while (current.next) {
        current = current.next;
      }
      current.next = newNode;
    }
  }

  print() {
    let current = this.head;
    let list = '';
    while (current) {
      list += current.data + ' -> ';
      current = current.next;
    }
    console.log(list + 'null');
  }
}

const list = new LinkedList();
list.add(10);
list.add(20);
list.add(30);
list.print(); // 10 -> 20 -> 30 -> null

insert और find मेथड्स के साथ एक बाइनरी सर्च ट्री लागू करें।

स्पष्टीकरण: एक BST एक नोड-आधारित बाइनरी ट्री डेटा संरचना है जिसमें निम्नलिखित गुण होते हैं: एक नोड का बायाँ सबट्री केवल उन नोड्स को शामिल करता है जिनकी कुंजियाँ नोड की कुंजी से कम हैं। एक नोड का दाहिना सबट्री केवल उन नोड्स को शामिल करता है जिनकी कुंजियाँ नोड की कुंजी से अधिक हैं। दोनों सबट्री भी बाइनरी सर्च ट्री होने चाहिए।

class Node {
  constructor(data) {
    this.data = data;
    this.left = null;
    this.right = null;
  }
}

class BST {
  constructor() {
    this.root = null;
  }

  insert(data) {
    const newNode = new Node(data);
    if (!this.root) {
      this.root = newNode;
      return;
    }
    this._insertNode(this.root, newNode);
  }

  _insertNode(node, newNode) {
    if (newNode.data < node.data) {
      if (!node.left) node.left = newNode;
      else this._insertNode(node.left, newNode);
    } else {
      if (!node.right) node.right = newNode;
      else this._insertNode(node.right, newNode);
    }
  }

  find(data) {
    return this._findNode(this.root, data);
  }

  _findNode(node, data) {
    if (!node) return null;
    if (data < node.data) return this._findNode(node.left, data);
    else if (data > node.data) return this._findNode(node.right, data);
    else return node;
  }
}

const bst = new BST();
bst.insert(10);
bst.insert(5);
bst.insert(15);
bst.insert(7);
console.log(bst.find(7)); // Node { data: 7, left: null, right: null }
console.log(bst.find(12)); // null

एक सरणी को दाएं k चरणों तक घुमाने के लिए एक फ़ंक्शन लिखें।

स्पष्टीकरण: एक सरणी को घुमाने का अर्थ है उसके तत्वों को स्थानांतरित करना। दाएं रोटेशन के लिए, अंतिम तत्व पहला बन जाता है। इसे k बार दोहराना काम करता है लेकिन अक्षम है। एक बेहतर तरीका सरणी हेरफेर का उपयोग करना या नई स्थितियों की गणना करना है।

function rotateArray(nums, k) {
  k = k % nums.length; // उन मामलों को संभालें जहां k > लंबाई है
  if (k === 0) return nums;

  const partToMove = nums.splice(nums.length - k);
  nums.unshift(...partToMove);
  return nums;
}

console.log(rotateArray([1, 2, 3, 4, 5, 6, 7], 3)); // [5, 6, 7, 1, 2, 3, 4]

दो सरणियाँ दी गई हैं, उनके इंटरसेक्शन (दोनों में सामान्य तत्व) की गणना करने के लिए एक फ़ंक्शन लिखें।

स्पष्टीकरण: एक अच्छा दृष्टिकोण एक सरणी को Set में बदलना है ताकि औसत समय में O(1) खोज हो सके। फिर, दूसरी सरणी के माध्यम से इटरेट करें और जांचें कि क्या प्रत्येक तत्व सेट में मौजूद है। मिलान इकट्ठा करें।

function intersection(nums1, nums2) {
  const set1 = new Set(nums1);
  const resultSet = new Set();

  for (const num of nums2) {
    if (set1.has(num)) {
      resultSet.add(num);
    }
  }

  return [...resultSet];
}

console.log(intersection([1, 2, 2, 1], [2, 2])); // [2]
console.log(intersection([4, 9, 5], [9, 4, 9, 8, 4])); // [9, 4]

स्ट्रिंग्स की एक सरणी दी गई है, एनाग्राम को एक साथ समूहबद्ध करें।

स्पष्टीकरण: प्रत्येक एनाग्राम समूह के लिए एक अद्वितीय हस्ताक्षर खोजना महत्वपूर्ण है। एक सामान्य तरीका प्रत्येक शब्द को वर्णानुक्रम में सॉर्ट करना है। जिन शब्दों का परिणाम समान सॉर्टेड स्ट्रिंग में होता है वे एनाग्राम होते हैं। एक हैश मैप का उपयोग करें जहां कुंजियाँ सॉर्टेड शब्द हैं और मान मूल शब्दों की सरणियाँ हैं।

function groupAnagrams(strs) {
  const map = {};
  for (const str of strs) {
    const sortedStr = str.split('').sort().join('');
    if (!map[sortedStr]) {
      map[sortedStr] = [];
    }
    map[sortedStr].push(str);
  }
  return Object.values(map);
}

console.log(groupAnagrams(['eat', 'tea', 'tan', 'ate', 'nat', 'bat'])); 
// आउटपुट: [['eat', 'tea', 'ate'], ['tan', 'nat'], ['bat']]

एक सरणी nums दी गई है, सभी 0 को अंत तक ले जाने के लिए एक फ़ंक्शन लिखें, गैर-शून्य तत्वों के सापेक्ष क्रम को बनाए रखते हुए।

स्पष्टीकरण: 'दो-पॉइंटर' या 'स्नोबॉल' दृष्टिकोण का उपयोग करें। एक पॉइंटर उस स्थिति को ट्रैक करता है जहाँ अगला गैर-शून्य तत्व जाना चाहिए। सरणी के माध्यम से पुनरावृति करें; यदि कोई तत्व शून्य नहीं है, तो उसे पॉइंटर की स्थिति पर रखें और पॉइंटर को बढ़ाएँ। अंत में, शेष को शून्य से भरें।

function moveZeroes(nums) {
  let nonZeroIndex = 0;

  // सभी गैर-शून्य तत्वों को शुरुआत में ले जाएँ
  for (let i = 0; i < nums.length; i++) {
    if (nums[i] !== 0) {
      nums[nonZeroIndex] = nums[i];
      nonZeroIndex++;
    }
  }

  // शेष को शून्य से भरें
  for (let i = nonZeroIndex; i < nums.length; i++) {
    nums[i] = 0;
  }

  return nums;
}

console.log(moveZeroes([0, 1, 0, 3, 12])); // [1, 3, 12, 0, 0]

पूर्णांकों की एक सरणी nums दी गई है, सन्निहित सबएरे (जिसमें कम से कम एक संख्या हो) ढूँढें जिसका योग सबसे बड़ा हो और उसका योग लौटाएँ।

स्पष्टीकरण: कडाने का एल्गोरिथम इसे हल करने का एक कुशल तरीका है। सरणी के माध्यम से पुनरावृति करें, वर्तमान स्थिति पर समाप्त होने वाले currentMax योग और अब तक पाए गए globalMax योग का ट्रैक रखें। यदि currentMax नकारात्मक हो जाता है, तो इसे 0 पर रीसेट करें (या बेहतर, वर्तमान तत्व पर)।

function maxSubArray(nums) {
  let globalMax = -Infinity;
  let currentMax = 0;

  for (let i = 0; i < nums.length; i++) {
    currentMax = Math.max(nums[i], currentMax + nums[i]);
    if (currentMax > globalMax) {
      globalMax = currentMax;
    }
  }
  return globalMax;
}

console.log(maxSubArray([-2, 1, -3, 4, -1, 2, 1, -5, 4])); // 6 ([4, -1, 2, 1] से)