Live Coding

جاوا اسکرپٹ آبجیکٹ کے خالی ہونے کی جانچ کیسے کریں؟

وضاحت: ایک آبجیکٹ اس وقت خالی ہوتا ہے جب اس میں کوئی اپنی قابل شمار خصوصیات نہ ہوں۔ ہم 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 تک نمبرز پرنٹ کرتا ہے۔ لیکن تین کے ضربوں کے لیے، نمبر کے بجائے 'فز' پرنٹ کریں اور پانچ کے ضربوں کے لیے، 'بز' پرنٹ کریں۔ ایسے نمبروں کے لیے جو تین اور پانچ دونوں کے ضرب ہیں، 'فز بز' پرنٹ کریں۔

وضاحت: یہ کلاسک مسئلہ بنیادی لوپ اور کنڈیشنل منطق کو ٹیسٹ کرتا ہے۔ آپ کو 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 تک بڑھ جائیں۔

وضاحت: ایک عام طریقہ یہ ہے کہ ایک ہیش میپ (یا ایک جاوا اسکرپٹ آبجیکٹ) کا استعمال کریں تاکہ نمبروں اور ان کے انڈیکسز کو اسٹور کیا جا سکے جیسے ہی آپ لٹریشن کرتے ہیں۔ ہر نمبر کے لیے، جانچ کریں کہ آیا 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('Reduce of empty array with no initial value');
      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 (سامنے سے ہٹائیں) طریقوں کے ساتھ ایک قطار ڈیٹا ڈھانچہ کو لاگو کریں۔

وضاحت: ایک قطار First-In, First-Out (FIFO) اصول کی پیروی کرتی ہے۔ ایک ارے کو استعمال کیا جا سکتا ہے، جس میں 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 'قطار میں کوئی عناصر نہیں ہیں';
    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 (اوپر سے ہٹائیں) طریقوں کے ساتھ ایک اسٹیک ڈیٹا ڈھانچہ کو لاگو کریں۔

وضاحت: ایک اسٹیک Last-In, First-Out (LIFO) اصول کی پیروی کرتا ہے۔ ایک ارے کو استعمال کیا جا سکتا ہے، جس میں 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('ہیلو!');
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('اسکرول ہو رہا ہے...');
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

ایک جاوا اسکرپٹ آبجیکٹ کا گہرا کلون انجام دینے کے لیے ایک فنکشن لکھیں۔

وضاحت: ایک کم گہرا کلون صرف اوپری سطح کی خصوصیات کو کاپی کرتا ہے۔ ایک گہرا کلون تمام خصوصیات کو ریکرسیولی کاپی کرتا ہے، بشمول نیسٹڈ آبجیکٹس اور ایریز۔ ایک سادہ طریقہ (حدود کے ساتھ، مثلاً فنکشنز، تاریخوں، ریجیکس کو اچھی طرح سے ہینڈل نہیں کرتا) 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

ایک آبجیکٹ سے کلیدوں کی ایک ارے کیسے حاصل کریں؟

وضاحت: Object.keys(obj) استعمال کریں۔

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

ایک آبجیکٹ سے قدروں کی ایک ارے کیسے حاصل کریں؟

وضاحت: 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();

جاوا اسکرپٹ میں پراومس کیا ہے اس کی وضاحت کریں۔

وضاحت: ایک پراومس ایک آبجیکٹ ہے جو ایک غیر ہم آہنگ آپریشن کی ممکنہ تکمیل (یا ناکامی) اور اس کی نتیجے والی ویلیو کی نمائندگی کرتا ہے۔ یہ تین حالتوں میں سے ایک میں ہو سکتا ہے: زیر التوا، مکمل، یا مسترد۔

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'

اریز کے ساتھ اسپریڈ آپریٹر کیسے استعمال ہوتا ہے؟

وضاحت: یہ ایک لٹریبل (جیسے ایک ارے) کو ان جگہوں پر پھیلانے کی اجازت دیتا ہے جہاں صفر یا زیادہ آرگومنٹ یا عناصر کی توقع ہوتی ہے۔ کاپی کرنے، ضم کرنے، اور عناصر کو شامل کرنے کے لیے مفید ہے۔

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

آبجیکٹس کے ساتھ اسپریڈ آپریٹر کیسے استعمال ہوتا ہے؟

وضاحت: یہ آبجیکٹ کی خصوصیات کو کاپی کرنے اور ضم کرنے کی اجازت دیتا ہے۔

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' }, 'ہیلو', '!'); // ہیلو، چارلی!

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' }, ['ہیلو', '.']); // ہیلو، ڈیوڈ۔

جاوا اسکرپٹ ایونٹ لوپ کی مختصر وضاحت کریں۔

وضاحت: جاوا اسکرپٹ سنگل تھریڈڈ ہے، لیکن یہ ایک ایونٹ لوپ کا استعمال کرتے ہوئے ہم آہنگی حاصل کرتا ہے۔ کال اسٹیک ہم وقت ساز کوڈ کو ہینڈل کرتا ہے۔ ویب APIs async آپریشنز کو ہینڈل کرتی ہیں (جیسے setTimeout, fetch)۔ جب ایک async op ختم ہوتا ہے، تو اس کا کال بیک کال بیک کیو (یا پرومیسز کے لیے مائیکرو ٹاسک کیو) میں چلا جاتا ہے۔ ایونٹ لوپ مسلسل چیک کرتا ہے کہ آیا کال اسٹیک خالی ہے؛ اگر یہ خالی ہے، تو یہ اگلے کال بیک کو کیو سے اسٹیک میں ایگزیکیوشن کے لیے منتقل کر دیتا ہے۔

console.log('Start');

setTimeout(() => {
  console.log('Timeout Callback'); // Goes to Callback Queue
}, 0);

Promise.resolve().then(() => {
  console.log('Promise Resolved'); // Goes to Microtask Queue
});

console.log('End');

// Output Order: Start, End, Promise Resolved, Timeout Callback
// (Microtasks run before Macrotasks/Callbacks)

ایک ترتیب شدہ صف کے لیے بائنری سرچ فنکشن نافذ کریں۔

وضاحت: بائنری سرچ ایک ترتیب شدہ صف میں کسی آئٹم کو تلاش کرنے کے لیے تلاش کے وقفے کو بار بار آدھا تقسیم کرکے موثر طریقے سے تلاش کرتا ہے۔ اگر تلاش کی کلید کی قدر وقفے کے بیچ میں موجود آئٹم سے کم ہے، تو وقفے کو نچلے نصف تک محدود کریں۔ بصورت دیگر، اسے اوپری نصف تک محدود کریں۔ آپ یہ اس وقت تک کرتے ہیں جب تک کہ قدر نہ مل جائے یا وقفہ خالی نہ ہو جائے۔

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; // Found
    } else if (sortedArray[middle] < key) {
      start = middle + 1; // Search right half
    } else {
      end = middle - 1; // Search left half
    }
  }
  return -1; // Not found
}

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]]; // Swap
        swapped = true;
      }
    }
    n--; // Optimization: last element is already in place
  } 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 طریقوں کے ساتھ ایک سنگلی لنکڈ لسٹ نافذ کریں۔

وضاحت: ایک لنکڈ لسٹ ایک لکیری ڈیٹا ڈھانچہ ہے جہاں عناصر ملحقہ میموری مقامات پر ذخیرہ نہیں ہوتے ہیں۔ ہر عنصر (نوڈ) اگلے کی طرف اشارہ کرتا ہے۔ آپ کو ہیڈ اور نئے نوڈز کو شامل کرنے کے لیے ایک نوڈ کلاس اور ایک لنکڈ لسٹ کلاس کی ضرورت ہے۔

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; // Handle cases where k > length
  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]

دو صفیں دی گئی ہیں، ان کا تقاطع (دونوں میں مشترک عناصر) معلوم کرنے کے لیے ایک فنکشن لکھیں۔

وضاحت: ایک اچھا طریقہ یہ ہے کہ 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'])); 
// Output: [['eat', 'tea', 'ate'], ['tan', 'nat'], ['bat']]

ایک صف nums دی گئی ہے، اس کے تمام 0s کو آخر میں منتقل کرنے کے لیے ایک فنکشن لکھیں جبکہ غیر صفر عناصر کی نسبتی ترتیب کو برقرار رکھیں۔

وضاحت: ٹو پوائنٹر یا سنو بال کا طریقہ استعمال کریں۔ ایک پوائنٹر اس پوزیشن کو ٹریک کرتا ہے جہاں اگلا غیر صفر عنصر جانا چاہیے۔ صف کے ذریعے دہرائیں؛ اگر کوئی عنصر غیر صفر ہے، تو اسے پوائنٹر کی پوزیشن پر رکھیں اور پوائنٹر کو بڑھائیں۔ آخر میں، باقی کو صفر سے بھریں۔

function moveZeroes(nums) {
  let nonZeroIndex = 0;

  // Move all non-zero elements to the front
  for (let i = 0; i < nums.length; i++) {
    if (nums[i] !== 0) {
      nums[nonZeroIndex] = nums[i];
      nonZeroIndex++;
    }
  }

  // Fill the rest with zeros
  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 (from [4, -1, 2, 1])