JavaScript-এ অবজেক্ট থেকে n সংখ্যক হাইএস্ট ভ্যালু বের করা

ভূমিকা

একটি অবজেক্টে কী-ভ্যালু জোড়া থাকে। লক্ষ্য: স 거기서 সবচেয়ে বড় `n` টি ভ্যালু वाले কী-ভ্যালু জোড়া বের করে একটি নতুন অবজেক্ট বানানো।

সম্পূর্ণ কোড

const qualities = {
  defence: 82,
  attack: 92,
  heading: 91,
  pace: 96,
  dribbling: 88,
  tenacity: 97,
  vision: 91,
  passing: 95,
  shooting: 90
};

const pickHighest = (obj, num = 1) => {
  const requiredObj = {};
  if (num > Object.keys(obj).length) return false;
  
  Object.keys(obj)
    .sort((a, b) => obj[b] - obj[a]) // ডিসেন্ডিং সর্ট
    .forEach((key, ind) => {
      if (ind < num) {
        requiredObj[key] = obj[key];
      }
    });
  return requiredObj;
};

console.log(pickHighest(qualities, 3));
// { tenacity: 97, pace: 96, passing: 95 }

কোড ব্যাখ্যা

1. Object.keys(obj) - সব কী পাওয়া
2. sort((a,b) => obj[b] - obj[a]) - ভ্যালু অনুযায়ী ডিসেন্ডিং সর্ট
3. forEach - প্রথম `num` টি কী পিক করে নতুন অবজেক্টে যোগ
4. ভ্যালিডেশন: `num` অবজেক্টের সাইজ চেয়ে বড় হলে `false` রিটার্ন

আউটপুট

{ tenacity: 97, pace: 96, passing: 95 }

বিকল্প ও উন্নত পদ্ধতিগুলো

১. Object.entries + Sort + Slice (আরো ক্লিন)

const pickHighest = (obj, n = 1) => 
  Object.fromEntries(
    Object.entries(obj)
      .sort(([,a], [,b]) => b - a)
      .slice(0, n)
  );

২. Partial Sorting (Heap/Selection - O(k log n))

// বড় অবজেক্টের জন্য দ্রুত (n বড়, k ছোট হলে)
const pickHighestHeap = (obj, k) => {
  const entries = Object.entries(obj);
  // Min-heap of size k
  const heap = entries.slice(0, k).sort((a,b) => a[1] - b[1]);
  
  for (let i = k; i < entries.length; i++) {
    if (entries[i][1] > heap[0][1]) {
      heap[0] = entries[i];
      heap.sort((a,b) => a[1] - b[1]);
    }
  }
  return Object.fromEntries(heap.sort((a,b) => b[1] - a[1]));
};

৩. Top-k সিলেকশন (QuickSelect - O(n) গড়ে)

//lodash: _.pickBy(obj, (v, k) => _.includes(_.orderBy(obj, v, 'desc').slice(0,k), k))

Edge Cases

const pickHighestRobust = (obj, n = 1) => {
  if (!obj || typeof obj !== 'object') return {};
  if (n <= 0) return {};
  
  const entries = Object.entries(obj);
  const validN = Math.min(n, entries.length);
  
  return Object.fromEntries(
    entries
      .sort(([,a], [,b]) => b - a)
      .slice(0, validN)
  );
};

ব্যবহারিক অ্যাপ্লিকেশন

• গেমিং: টপ प्लেয়ার স্ট্যাটস, লিডারবোর্ড
• ই-কমার্স: টপ সেলিং প্রোডাক্ট, হাইয়েস্ট রেটেড
• অ্যানালিটিক্স: টপ KPIs, সবচেয়ে গুরুত্বপূর্ণ মেট্রিক্স
• ML/এআই: ফিচার ইম্পোর্টেন্স, অ্যাটেনশন ওয়েটস

সারাংশ

`Object.entries().sort().slice().Object.fromEntries()` চেইন সবচেয়ে আধুনিক, পঠনযোগ্য এবং ফাংশনাল পদ্ধতি। বড় ডেটাসেটের জন্য হিপ-ভিত্তিক পদ্ধতি দ্রুত।