জাভাস্ক্রিপ্টে অ্যারে ছেদ করার জন্য সবচেয়ে সহজ কোড

Question

জাভাস্ক্রিপ্টে অ্যারে ছেদগুলি কার্যকর করার জন্য সবচেয়ে সহজ, গ্রন্থাগার-মুক্ত কোড কী? আমি লিখতে চাই

intersection([1,2,3], [2,3,4,5])

এবং পেতে

[2, 3]

Comments

আপনি সহজ বা দ্রুত চান?

— স্ল্যাक्स

অগ্রাধিকার সহজ, তবে এটি এতটা মস্তিষ্ক-মৃত হতে পারে না যে এটি একটি পারফরম্যান্স হগ হবে :)

— পিটার

আমি এখানে_স্ট্যান্ডার ছেদ ফাংশনসহ সমস্ত পদ্ধতির জন্য একটি জেএসফিডাল ব্যাঙ্কমার্ক পরীক্ষা পৃষ্ঠা তৈরি করেছি । (উচ্চতর ভাল) ! চিত্রের বিবরণ এখানে প্রবেশ করুন এখন অবধি ছেদ করুন_সেফ সেরা ফলাফল দিয়েছে । আপনি এবং সবচেয়ে খারাপ বুঝতে।

— নিওসউফ

একটি যোগ করার পদ্ধতি breakথেকে Simple js loopsঅপস বৃদ্ধি / সেকেন্ড ~ 10M থেকে

— রিচার্ড

যদি আপনি এটা মিস : সহজ উত্তর গৃহীত কিন্তু এক নীচে এক নয় stackoverflow.com/questions/1885557/...

— redben

Answer 1

Array.prototype.filterএবং এর সমন্বয় ব্যবহার করুন Array.prototype.indexOf:

array1.filter(value => -1 !== array2.indexOf(value))

বা মন্তব্যগুলিতে ভ্রোগেহেগেল যেমন পরামর্শ দিয়েছেন, আপনি Array.prototype.includesআরও সহজ কোডের জন্য আরও সাম্প্রতিক ব্যবহার করতে পারেন :

array1.filter(value => array2.includes(value))

পুরানো ব্রাউজারগুলির জন্য:

array1.filter(function(n) {
    return array2.indexOf(n) !== -1;
});

Comments

যা আপনি অ্যারের প্রোটোটাইপে একটি লাইব্রেরি সংস্করণ যুক্ত করে সমাধান করতে পারেন।

— আনন

হ্যাঁ, তবে এটি উল্লেখ করার মতো ছিল।

— টিম ডাউন

সরলতার জন্য এবং নন-সংখ্যা নিয়ে কাজ করার জন্য এখানে সর্বোত্তম উত্তর

— মুহাদ

intersection([1,2,1,1,3], [1])আয় [1, 1, 1]। এটা ঠিক ফিরে আসা উচিত নয় [1]?

— edjroot

array2.indexOf(n) != -1একের পরিবর্তে array2.includes(n)আরও সহজ কোডের জন্যও লিখতে পারেন ।

— ভ্রোগেহেগেল

Answer 2

ধ্বংসাত্মকটি সহজ বলে মনে হচ্ছে, বিশেষত যদি আমরা ধরে নিতে পারি যে ইনপুটটি সাজানো হয়েছে:

/* destructively finds the intersection of 
 * two arrays in a simple fashion.  
 *
 * PARAMS
 *  a - first array, must already be sorted
 *  b - second array, must already be sorted
 *
 * NOTES
 *  State of input arrays is undefined when
 *  the function returns.  They should be 
 *  (prolly) be dumped.
 *
 *  Should have O(n) operations, where n is 
 *    n = MIN(a.length, b.length)
 */
function intersection_destructive(a, b)
{
  var result = [];
  while( a.length > 0 && b.length > 0 )
  {  
     if      (a[0] < b[0] ){ a.shift(); }
     else if (a[0] > b[0] ){ b.shift(); }
     else /* they're equal */
     {
       result.push(a.shift());
       b.shift();
     }
  }

  return result;
}

আমাদের সূচকগুলি ট্র্যাক করতে করতে যেহেতু অ-ধ্বংসাত্মক চুলকে আরও জটিল হতে হবে:

/* finds the intersection of 
 * two arrays in a simple fashion.  
 *
 * PARAMS
 *  a - first array, must already be sorted
 *  b - second array, must already be sorted
 *
 * NOTES
 *
 *  Should have O(n) operations, where n is 
 *    n = MIN(a.length(), b.length())
 */
function intersect_safe(a, b)
{
  var ai=0, bi=0;
  var result = [];

  while( ai < a.length && bi < b.length )
  {
     if      (a[ai] < b[bi] ){ ai++; }
     else if (a[ai] > b[bi] ){ bi++; }
     else /* they're equal */
     {
       result.push(a[ai]);
       ai++;
       bi++;
     }
  }

  return result;
}

Comments

এতে অসংখ্য ত্রুটি রয়েছে intersect_safe : lengthঅ্যারেতে একটি সম্পত্তি, কোনও পদ্ধতি নয়। এখানে একটি অঘোষিত ভেরিয়েবল iরয়েছে result.push(a[i]);। পরিশেষে, এটি সাধারণ ক্ষেত্রে সহজভাবে কাজ করে না: দুটি অবজেক্ট যেখানে >অপারেটর অনুসারে অপরের চেয়ে বড় হয় না তা অগত্যা সমান হয় না। intersect_safe( [ {} ], [ {} ] )উদাহরণস্বরূপ, একবারে (পূর্বে উল্লিখিত ত্রুটিগুলি স্থির হয়ে গেলে) একটি উপাদান সহ একটি অ্যারে দেবে, যা স্পষ্টতই ভুল।

— টিম ডাউন

@ টিম ডাউন: আপনার নির্দেশিত বাক্য গঠন ত্রুটি সংশোধন করেছেন। জেরাটার বা সমান নয় এমন কোনও বিষয় বিবেচনা করা সঠিক বা ভুল কিনা তা প্রয়োজনীয়তার উপর নির্ভর করে। মূল প্রশ্নে আমি কিছুই লক্ষ্য করছি না যে বিষয়বস্তুগুলিতে অ্যারে থাকবে বলে আশা করা হচ্ছে। এখন, আপনি এই কথাটি সঠিকভাবে বলতে চাই যে অপ্রত্যাশিত ইনপুট হ্যান্ডেল করা উচিত, তবে যদি অনুমানটি ইতিমধ্যে ঘটে থাকে যে ইনপুটটি অবশ্যই সংখ্যার অ্যারে হবে (যেমন আমি ধরে নিয়েছি) তবে কোডটি ঠিক থাকবে।

— atk

@ অ্যাটাক: আমি আপনার বক্তব্যটি দেখছি, প্রশ্নের উদাহরণ হিসাবে দেখেছি যে কেবল অ্যারে রয়েছে এমন অ্যারে ব্যবহার করা হয়।

— টিম ডাউন

আপনি .slice(0)সূচিগুলি intersect_safeট্র্যাক করার পরিবর্তে অ্যারের ক্লোন তৈরি করতে ব্যবহার করতে পারেন ।

— জনলুতেকে

@ থিশমার্ট: আপনি ঠিক বলেছেন, এটি করার আরও অবশ্যই পারফরম্যান্ট উপায় রয়েছে। উপরের কোডটি সহজ হতে চেয়েছিল, দ্রুত নয় :)

— atk

Answer 3

যদি আপনার পরিবেশ ECMAScript 6 সেটটিকে সমর্থন করে তবে একটি সহজ এবং অনুমিত দক্ষ (স্পেসিফিকেশন লিঙ্কটি দেখুন) উপায়:

function intersect(a, b) {
  var setA = new Set(a);
  var setB = new Set(b);
  var intersection = new Set([...setA].filter(x => setB.has(x)));
  return Array.from(intersection);
}

খাটো, তবে কম পঠনযোগ্য (অতিরিক্ত চৌরাস্তা তৈরি না করেও Set):

function intersect(a, b) {
      return [...new Set(a)].filter(x => new Set(b).has(x));
}

প্রতিটি সময় Setথেকে একটি নতুন এড়ানো b:

function intersect(a, b) {
      var setB = new Set(b);
      return [...new Set(a)].filter(x => setB.has(x));
}

নোট করুন যে সেটগুলি ব্যবহার করার সময় আপনি কেবল আলাদা মান পাবেন new Set[1,2,3,3].size মূল্যায়ন করে 3।

Comments

এই [...setA]সিনট্যাক্স কি ? কিছু বিশেষ ধরণের জাভাস্ক্রিপ্ট অপারেশন?

— jxramos

@jxramos যা স্প্রেড সিনট্যাক্স এবং এই ক্ষেত্রে এটি কেবলমাত্র সেটের উপাদানগুলি থেকে একটি অ্যারে তৈরি করতে ব্যবহৃত হচ্ছে। "অ্যারে.ফ্রোম (সেটএ)" এই ক্ষেত্রেও কাজ করবে, তবে যেহেতু প্রশ্নটি "সরলতম" জন্য জিজ্ঞাসা করেছিল আমি সেই লাইনে পড়ার জন্য এটিকে আরও পরিষ্কার করার চেষ্টা করেছি। এই বিষয়ে, আমি মনে করি কোডটি সহজ হতে পারে, তাই আমি স্নিপেটটি আপডেট করব।

— নবারবোসা

@ নরবোসা আমি কৌতূহলী: আপনি অ্যারেটিকে "ক্লোন" করলেন কেন? # ফিল্টার মূল অ্যারেটি ধ্বংস করে না, তাইনা? এটি একটি নতুন অ্যারে তৈরি করে?

— বিপ্লিটল

ডাবলিকেটগুলি সরানোর জন্য @ বিপ্লিট্টল আমি সবে থেকে একটি অ্যারে তৈরি করেছি, অন্যথায়, অ্যারেটি সরাসরি ব্যবহার করার ফলে ডুপ্লিকেটগুলি ফেরত আসতে পারে। উদাহরণস্বরূপ, আমি যদি সরাসরি অ্যারে ব্যবহার করি তবে ছেদ করুন ([1,2,2,4], [2,3]) [2, 2] উপার্জন করতে পারে।

— নবারবোসা

সেই x => new Set(b).has(x)তীর ফাংশনটি প্রতিবার কার্যকর হওয়ার পরে সেটগুলিতে পরিণত bহয় না ? আপনার সম্ভবত সেই সেটটি কোনও চলকতে সংরক্ষণ করা উচিত।

— অরণ-ফে

Answer 4

ব্যবহার Underscore.js বা lodash.js

_.intersection( [0,345,324] , [1,0,324] )  // gives [0,324]

Comments

ওপিকে "লাইব্রেরি-মুক্ত" চেয়েছিলেন।

— লিনাক্সডিসিপল

@ লিনাক্স ডিসিপল এটি হারিয়ে যাওয়ার জন্য আমার ভুল notes নোটের জন্য ধন্যবাদ

— সাঁই রাম

যাই হোক না কেন, এটি এই অনুসন্ধানের জন্য শীর্ষস্থানীয় গুগল তালিকা তাই একটি লাইব্রেরির উত্তর থাকা দরকারী। ধন্যবাদ।

— ওয়েবনুব

আমিও আনন্দিত যে এই পোস্ট করা হয়েছে। প্রথমবার আমি আন্ডারস্কোর.জেএস এর প্রয়োজনীয়তা অনুভব করেছি। সাধারণত জাভাস্ক্রিপ্ট মানচিত্র এবং পাইপলাইনগুলি কমবেশি কাজটি মার্জিতভাবে করে তবে এবার নয়।

— শ্রীধর সারনোবাত

আমি <3 ইন্ডস্কোর এবং আমি <3 জেরেমি আশকেনাস (এর স্রষ্টা), কিন্তু তবুও আমি এর পরিবর্তে লোডাশ পরীক্ষা করার পরামর্শ দিচ্ছি। এটি মূলত ইন্ডসকোর (এটি মূলত একটি কাঁটাচামচ) এর একটি উচ্চতর সংস্করণ যার একমাত্র নিম্নতর দিকটি সুপার-অপ্টিমাইজড (এবং এইভাবে প্রায় অপঠনযোগ্য) সোর্স কোড। অ্যান্ডস্কোরের লোকেরা এমনকি পুরোপুরিভাবে ইন্ডসকোর থেকে মুক্তি পাওয়ার বিষয়টি বিবেচনা করেছিল (এবং লোডাশ ব্যবহারের জন্য লোকদের বলছিল), তবে সোর্স কোড পঠনযোগ্যতার বিষয়ে যত্নশীল লোকেরা এটি ধরে রাখার পক্ষে যুক্তি দিয়েছিল (আমি আসলে সেদিকে ছিলাম, তবে আমি তখন থেকে লোড্যাশে রূপান্তর করেছি)। @see github.com/jashkenas/underscore/issues/2182

— machineghost

Answer 5

ES6 পদগুলিতে আমার অবদান। সাধারণত এটি আর্গুমেন্ট হিসাবে সরবরাহ করা অনির্দিষ্ট সংখ্যক অ্যারে সহ একটি অ্যারের ছেদ খুঁজে পায়।

Array.prototype.intersect = function(...a) {
  return [this,...a].reduce((p,c) => p.filter(e => c.includes(e)));
}
var arrs = [[0,2,4,6,8],[4,5,6,7],[4,6]],
     arr = [0,1,2,3,4,5,6,7,8,9];

document.write("<pre>" + JSON.stringify(arr.intersect(...arrs)) + "</pre>");

Comments

এই কোডটি দুর্দান্ত দেখাচ্ছে তবে আমি এটি পুরোপুরি বুঝতে পারি না। দয়া করে এটি ব্যাখ্যা করা সম্ভব?

— দৈহিক

@ নভেম্বারস্কি এটি সমস্ত সাবজেক্ট অ্যারের মতো অ্যারে সংগ্রহ করে [[0,1,2,3,4,5,6,7,8,9],[0,2,4,6,8],[4,5,6,7],[4,6]]এবং তারপরে প্রয়োগ হয় .reduce()। প্রথম [0,1,2,3,4,5,6,7,8,9].filter( e => [0,2,4,6,8].includes(e)অপারেশন সঞ্চালিত হয় এবং ফলে নতুন হয়ে pএবং cহয়ে [4,5,6,7]পরবর্তী ঘুরে এবং আপ তাই চলতে থাকে যতক্ষণ আছে আর cছেড়ে দেওয়া হয়।

— রেডু

আপনি যদি বড় ডেটা সেট নিয়ে কাজ করছেন তবে এটি একটি ব্যয়বহুল সমাধান।

— ম্যাডব্রেকস

prototypeঅহেতুক পরিবর্তন করবেন না ।

— ফ্রেংতে

Answer 6

// Return elements of array a that are also in b in linear time:
function intersect(a, b) {
  return a.filter(Set.prototype.has, new Set(b));
}

// Example:
console.log(intersect([1,2,3], [2,3,4,5]));

আমি উপরের সংক্ষিপ্ত সমাধানের সুপারিশ করছি যা বড় ইনপুটগুলিতে অন্যান্য প্রয়োগগুলি কার্যকর করে। যদি ছোট ইনপুট বিষয়গুলিতে পারফরম্যান্স হয় তবে নীচের বিকল্পগুলি দেখুন।

বিকল্প এবং পারফরম্যান্স তুলনা:

বিকল্প বাস্তবায়নের জন্য নীচের স্নিপেটটি দেখুন এবং পারফরম্যান্স তুলনার জন্য https://jsperf.com/array-intersication- তুলনা পরীক্ষা করুন ।

function intersect_for(a, b) {
  const result = [];
  const alen = a.length;
  const blen = b.length;
  for (let i = 0; i < alen; ++i) {
    const ai = a[i];
    for (let j = 0; j < blen; ++j) {
      if (ai === b[j]) {
        result.push(ai);
        break;
      }
    }
  } 
  return result;
}

function intersect_filter_indexOf(a, b) {
  return a.filter(el => b.indexOf(el) !== -1);
}

function intersect_filter_in(a, b) {
  const map = b.reduce((map, el) => {map[el] = true; return map}, {});
  return a.filter(el => el in map);
}

function intersect_for_in(a, b) {
  const result = [];
  const map = {};
  for (let i = 0, length = b.length; i < length; ++i) {
    map[b[i]] = true;
  }
  for (let i = 0, length = a.length; i < length; ++i) {
    if (a[i] in map) result.push(a[i]);
  }
  return result;
}

function intersect_filter_includes(a, b) {
  return a.filter(el => b.includes(el));
}

function intersect_filter_has_this(a, b) {
  return a.filter(Set.prototype.has, new Set(b));
}

function intersect_filter_has_arrow(a, b) {
  const set = new Set(b);
  return a.filter(el => set.has(el));
}

function intersect_for_has(a, b) {
  const result = [];
  const set = new Set(b);
  for (let i = 0, length = a.length; i < length; ++i) {
    if (set.has(a[i])) result.push(a[i]);
  }
  return result;
}

ফায়ারফক্স 53 এর ফলাফল:

• বৃহত অ্যারেগুলিতে অপস / সেকেন্ড (10,000 টি উপাদান):

  filter + has (this)               523 (this answer)
  for + has                         482
  for-loop + in                     279
  filter + in                       242
  for-loops                          24
  filter + includes                  14
  filter + indexOf                   10

• ছোট অ্যারেগুলিতে অপস / সেকেন্ড (100 উপাদান):

  for-loop + in                 384,426
  filter + in                   192,066
  for-loops                     159,137
  filter + includes             104,068
  filter + indexOf               71,598
  filter + has (this)            43,531 (this answer)
  filter + has (arrow function)  35,588

Comments

intersect([1,2,2,3], [2,3,4,5]) আয় [2, 2, 3] ।

— সেরেগপি

পছন্দ করুন মন্তব্য অনুসারে "অ্যারেগুলির উপাদানগুলি বিতে থাকাও ফেরত দিন"

— ফেরান

গুণমানের উত্তর, তবে সেটের ব্যবহার মৌলিকভাবে ফলাফলগুলিকে পরিবর্তিত করে যেহেতু অপের প্রশ্নে কেবল অ্যারে ছেদগুলি সম্পর্কে জিজ্ঞাসা করা হয়েছিল এবং নকলগুলি কীভাবে পরিচালনা করতে হবে তার কোনও উল্লেখ / শর্ত নেই। লজ্জাজনক, ডুপ্লিকেট উপস্থিত থাকলে এই উত্তরটি অপ্রত্যাশিত ফলাফল পেতে পারে।

— ম্যাডব্রেকস

এটি পছন্দ করুন, তবে আপনি "ফিল্টার + অন্তর্ভুক্ত" সহ একটি অপ্রয়োজনীয় ফাংশন যুক্ত করেছেন। চেষ্টাa.filter(b.includes) । এটি যথেষ্ট দ্রুত চালানো উচিত (আপনার ফাংশন আপগ্রেডের মতো)।

— এসইওএফ

Answer 7

কীভাবে কেবল সাহসী অ্যারে ব্যবহার করবেন?

function intersect(a, b) {
    var d1 = {};
    var d2 = {};
    var results = [];
    for (var i = 0; i < a.length; i++) {
        d1[a[i]] = true;
    }
    for (var j = 0; j < b.length; j++) {
        d2[b[j]] = true;
    }
    for (var k in d1) {
        if (d2[k]) 
            results.push(k);
    }
    return results;
}

সম্পাদনা:

// new version
function intersect(a, b) {
    var d = {};
    var results = [];
    for (var i = 0; i < b.length; i++) {
        d[b[i]] = true;
    }
    for (var j = 0; j < a.length; j++) {
        if (d[a[j]]) 
            results.push(a[j]);
    }
    return results;
}

Comments

এটি কেবলমাত্র যদি আপনার অ্যারেগুলিতে কেবল স্ট্রিং বা সংখ্যা থাকে এবং যদি আপনার পৃষ্ঠার লিপিটির কোনওটিই মেসে না থাকে তবে এটি কেবলমাত্র একটি সুযোগ রয়েছে Object.prototype।

— টিম ডাউন

ওপি-র উদাহরণটি সংখ্যা ব্যবহার করছিল, এবং কোনও স্ক্রিপ্ট যদি অবজেক্ট.প্রোটোটাইপের সাথে গণ্ডগোল করে থাকে তবে স্ক্রিপ্টটি আবার লিখতে হবে বা মুছে ফেলা উচিত।

— স্টিভেন হুইগ

আপনার (ডি 1) এবং (ডি 2) উভয়ের প্রয়োজন নেই। (ডি 2) তৈরি করুন, তারপরে (ক) এর মাধ্যমে (ডি 1) লুপিংয়ের পরিবর্তে লুপ করুন।

— স্ট্যানলিএইচ

এর d[b[i]] = true;পরিবর্তে d[b[j]] = true;( iনা j) হওয়া উচিত। তবে সম্পাদনার জন্য 6 টি অক্ষর প্রয়োজন।

— ইজাকি

@ ইজাকি ধন্যবাদ, স্থির। (সর্বনিম্ন সম্পাদনার প্রয়োজনীয়তা অর্জনের জন্য একটি // মন্তব্য যুক্ত করা হয়েছে))

— স্টিভেন হুইগ

Answer 8

1. সাজাও
2. সূচক 0 থেকে একে একে চেক করুন, সে থেকে নতুন অ্যারে তৈরি করুন।

এরকম কিছু, যদিও ভালভাবে পরীক্ষা করা হয়নি।

function intersection(x,y){
 x.sort();y.sort();
 var i=j=0;ret=[];
 while(i<x.length && j<y.length){
  if(x[i]<y[j])i++;
  else if(y[j]<x[i])j++;
  else {
   ret.push(x[i]);
   i++,j++;
  }
 }
 return ret;
}

alert(intersection([1,2,3], [2,3,4,5]));

পিএস: অ্যালগোরিদম কেবল সংখ্যা এবং সাধারণ স্ট্রিংয়ের জন্য উদ্দেশ্যে করা হয়, স্বেচ্ছাসেবী বস্তুর অ্যারেগুলির ছেদ কাজ করে না।

Comments

বাছাই অবিচ্ছিন্নভাবে বস্তুর অ্যারেগুলির জন্য প্রয়োজনীয় নয়

— টিম ডাউন

যদি অ্যারে বাছাই না করা হয়, আপনি যখন 1000 দৈর্ঘ্যের অ্যারে x 1000 দৈর্ঘ্যের অ্যারে ছেদ করেন তখন প্রায় 1000,000 বার লুপ করা দরকার

— আপনি

আমি মনে করি আপনি আমার বক্তব্যটি মিস করেছেন, এটি হ'ল জাভাস্ক্রিপ্টে স্বেচ্ছাচারিত বস্তুগুলির কোনও প্রাকৃতিক সাজানোর অর্ড নেই, মানে যে স্বেচ্ছাসেবী বস্তুর অ্যারে বাছাই করার ফলে সমান বস্তুগুলিকে শ্রেণিবদ্ধ করা হবে না। দক্ষ অ্যালগরিদম কাজ করে না এমনটি ভাল নয়।

— টিম ডাউন

আহা দুঃখিত, আমি "স্বেচ্ছাসেবী বিষয়গুলি" মিস করেছি, হ্যাঁ, আপনি ঠিক বলেছেন। এই বিষয়গুলি এটি বাছাই করতে পারে না, এবং অ্যালগরিদম সেগুলির উপরে কাজ করতে পারে না।

— আপনি

Answer 9

আদিমদের বাছাই করা অ্যারেগুলিতে @ অটকের বাস্তবায়নের সম্পাদনা। শিফটের পরিবর্তে .pop ব্যবহার করে উন্নত করা যেতে পারে।

function intersect(array1, array2) {
   var result = [];
   // Don't destroy the original arrays
   var a = array1.slice(0);
   var b = array2.slice(0);
   var aLast = a.length - 1;
   var bLast = b.length - 1;
   while (aLast >= 0 && bLast >= 0) {
      if (a[aLast] > b[bLast] ) {
         a.pop();
         aLast--;
      } else if (a[aLast] < b[bLast] ){
         b.pop();
         bLast--;
      } else /* they're equal */ {
         result.push(a.pop());
         b.pop();
         aLast--;
         bLast--;
      }
   }
   return result;
}

আমি jscreen: http://bit.ly/P9FrZK ব্যবহার করে একটি মাপদণ্ড তৈরি করেছি । .Pop ব্যবহার করা প্রায় তিনগুণ দ্রুত।

Comments

অন্যের জন্য যেমন সাইড নোট - এটি কেবল সংখ্যার জন্য কাজ করবে, স্ট্রিং নয় not

— ইজাকি

মনে রাখবেন যে আপনি যদি (এবং নীচের সাথে একই ) প্রতিস্থাপন a[aLast] > b[bLast]করেন তবে এটি স্ট্রিংগুলিতে কাজ করবে। a[aLast].localeCompare(b[bLast]) > 0else if

— অ্যান্ড্রু

গতির পার্থক্য অ্যারেগুলির আকারের উপর নির্ভর করে কারণ .popও (1) এবং .shift()এটি ও (এন)

— এসেইলাইজা

Answer 10

JQuery ব্যবহার :

var a = [1,2,3];
var b = [2,3,4,5];
var c = $(b).not($(b).not(a));
alert(c);

Comments

এটি হিসাবে লিখিত হতে পারে c = $(b).filter(a);, তবে আমি এই ধরণের অ্যারে ম্যানিপুলেশনের জন্য jQuery এর উপর নির্ভর করার পরামর্শ দেব না কারণ ডকুমেন্টেশনে কেবল উল্লেখ করা হয়েছে যে এটি উপাদানগুলির জন্য কাজ করে।

— স্ট্রাইনার

এটি অপের প্রশ্নের উত্তর দেয় না: "সহজতম, লাইব্রেরি-মুক্ত কোড কী ..."

— ম্যাডব্রেকস

Answer 11

কেবলমাত্র স্ট্রিং বা সংখ্যা সম্বলিত অ্যারেগুলির জন্য আপনি অন্যান্য উত্তরগুলির কয়েকটি অনুসারে বাছাই করে কিছু করতে পারেন। স্বেচ্ছাসেবী বস্তুর অ্যারেগুলির সাধারণ ক্ষেত্রে আমি মনে করি না আপনি এটি দীর্ঘতর করে এড়াতে পারবেন। নিম্নলিখিতটি আপনাকে প্যারামিটার হিসাবে সরবরাহ করা কোনও সংখ্যক অ্যারেগুলির ছেদ দেবে arrayIntersection:

var arrayContains = Array.prototype.indexOf ?
    function(arr, val) {
        return arr.indexOf(val) > -1;
    } :
    function(arr, val) {
        var i = arr.length;
        while (i--) {
            if (arr[i] === val) {
                return true;
            }
        }
        return false;
    };

function arrayIntersection() {
    var val, arrayCount, firstArray, i, j, intersection = [], missing;
    var arrays = Array.prototype.slice.call(arguments); // Convert arguments into a real array

    // Search for common values
    firstArray = arrays.pop();
    if (firstArray) {
        j = firstArray.length;
        arrayCount = arrays.length;
        while (j--) {
            val = firstArray[j];
            missing = false;

            // Check val is present in each remaining array 
            i = arrayCount;
            while (!missing && i--) {
                if ( !arrayContains(arrays[i], val) ) {
                    missing = true;
                }
            }
            if (!missing) {
                intersection.push(val);
            }
        }
    }
    return intersection;
}

arrayIntersection( [1, 2, 3, "a"], [1, "a", 2], ["a", 1] ); // Gives [1, "a"]; 

Comments

এটি কেবলমাত্র সেই ক্ষেত্রেই কাজ করে যেখানে বস্তুর পরিচয়ই সাম্যের একমাত্র রূপ।

— স্টিভেন হিউইগ

হ্যাঁ হ্যাঁ, তবে আমি মনে করি এটি বেশিরভাগ মানুষের কাছেই স্বাভাবিক মনে হবে। ভিন্ন সাম্যতা পরীক্ষা করতে বিকল্প ফাংশনটি প্লাগ করাও তুচ্ছ।

— টিম ডাউন

আমি মনে করি আপনি নিজের উদাহরণে দুর্ঘটনাক্রমে একটি গ্লোবাল ভেরিয়েবল ফার্স্টআর তৈরি করছেন।

— জেসন জ্যাকসন

@ জেসন জ্যাকসন: আপনি ঠিক বলেছেন, ধন্যবাদ। স্পষ্টত কিনা পরিবর্তনশীল কল সম্পর্কে আমার মন পরিবর্তন firstArrবা firstArrayএবং তথ্যসূত্র সব আপডেট করা হয়নি। সংশোধন করা হয়েছে।

— টিম ডাউন

Answer 12

এটি ES2015 এবং সেটগুলি ব্যবহার করে খুব ছোট। স্ট্রিংয়ের মতো অ্যারের মতো মানগুলি গ্রহণ করে এবং সদৃশগুলি সরিয়ে দেয়।

let intersection = function(a, b) {
  a = new Set(a), b = new Set(b);
  return [...a].filter(v => b.has(v));
};

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

console.log(intersection('ccaabbab', 'addb').join(''));

Comments

সেট থেকে অ্যারেতে রূপান্তর করুন [... ক] এর সদৃশ আইটেমগুলি সরিয়ে দেবে, ভাল ধারণা, ধন্যবাদ

— V-SHY

এই সমাধানটি আপনার আগে দুবার সরবরাহ করা হয়েছিল।

— ম্যাডব্রেকস

Answer 13

আপনি একটি ব্যবহার করতে পারে Setযেমন thisArgএর Array#filterএবং নিতে Set#hasকলব্যাক হিসাবে।

function intersection(a, b) {
    return a.filter(Set.prototype.has, new Set(b));
}

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

Comments

কেন জানি এটি বেশি ভোট পেল না। এটি পরিষ্কারভাবে সেরা উত্তর।

— পল রুনি

Answer 14

একটি ক্ষুদ্রতম এটিকে এখানে ছোট ফিলাক ( ফিল্টার / সূচিপত্র সমাধান ), একটি জাভাস্ক্রিপ্ট অবজেক্ট ব্যবহার করে একটি অ্যারেতে মানগুলির একটি সূচক তৈরি করা, এটি ও (এন * এম) থেকে "সম্ভবত" রৈখিক সময়ে হ্রাস করবে। উত্স 1 উত্স 2

function intersect(a, b) {
  var aa = {};
  a.forEach(function(v) { aa[v]=1; });
  return b.filter(function(v) { return v in aa; });
}

এটি খুব সহজ সমাধান নয় (এটি ফিল্টার + ইনডেক্সের চেয়ে বেশি কোড ), না এটি খুব দ্রুততম (সম্ভবত ছেদযুক্ত_সেসে () এর চেয়ে ধ্রুবক ফ্যাক্টর দ্বারা ধীর ) তবে এটি বেশ ভাল ভারসাম্যের মতো বলে মনে হচ্ছে। ভাল পারফরম্যান্স সরবরাহের সময় এটি খুব সাধারণ দিকে রয়েছে এবং এর জন্য প্রাক সাজানো ইনপুটগুলির প্রয়োজন হয় না।

Answer 15

অন্য সূচিকৃত পদ্ধতি একবারে যে কোনও সংখ্যক অ্যারে প্রক্রিয়া করতে সক্ষম:

// Calculate intersection of multiple array or object values.
function intersect (arrList) {
    var arrLength = Object.keys(arrList).length;
        // (Also accepts regular objects as input)
    var index = {};
    for (var i in arrList) {
        for (var j in arrList[i]) {
            var v = arrList[i][j];
            if (index[v] === undefined) index[v] = 0;
            index[v]++;
        };
    };
    var retv = [];
    for (var i in index) {
        if (index[i] == arrLength) retv.push(i);
    };
    return retv;
};

এটি কেবলমাত্র সেই মানগুলির জন্যই কাজ করে যা স্ট্রিং হিসাবে মূল্যায়ন করা যায় এবং আপনার সেগুলি যেমন অ্যারে হিসাবে পাস করা উচিত:

intersect ([arr1, arr2, arr3...]);

... তবে এটি স্বচ্ছভাবে প্যারামিটার হিসাবে বা যে কোনও উপাদানকে ছেদ করার জন্য (সর্বদা সাধারণ মানের অ্যারে ফিরিয়ে দেয়) হিসাবে স্বীকৃতি দেয়। উদাহরণ:

intersect ({foo: [1, 2, 3, 4], bar: {a: 2, j:4}}); // [2, 4]
intersect ([{x: "hello", y: "world"}, ["hello", "user"]]); // ["hello"]

সম্পাদনা: আমি কেবল লক্ষ্য করেছি যে এটি একরকমভাবে কিছুটা বগি।

এটি হ'ল: আমি এটিকে ভেবে কোড করেছিলাম যে ইনপুট অ্যারেগুলিতে নিজেই পুনরাবৃত্তি থাকতে পারে না (প্রদত্ত উদাহরণটি যেমন দেয় না)।

তবে যদি ইনপুট অ্যারেগুলিতে পুনরাবৃত্তি থাকে, তবে এটি ভুল ফলাফল আনবে। উদাহরণ (প্রয়োগের নীচে ব্যবহার করে):

intersect ([[1, 3, 4, 6, 3], [1, 8, 99]]);
// Expected: [ '1' ]
// Actual: [ '1', '3' ]

ভাগ্যক্রমে এটি দ্বিতীয় স্তরের সূচকে যুক্ত করে ঠিক করা সহজ। এটাই:

পরিবর্তন:

        if (index[v] === undefined) index[v] = 0;
        index[v]++;

দ্বারা:

        if (index[v] === undefined) index[v] = {};
        index[v][i] = true; // Mark as present in i input.

...এবং:

         if (index[i] == arrLength) retv.push(i);

দ্বারা:

         if (Object.keys(index[i]).length == arrLength) retv.push(i);

সম্পূর্ণ উদাহরণ:

// Calculate intersection of multiple array or object values.
function intersect (arrList) {
    var arrLength = Object.keys(arrList).length;
        // (Also accepts regular objects as input)
    var index = {};
    for (var i in arrList) {
        for (var j in arrList[i]) {
            var v = arrList[i][j];
            if (index[v] === undefined) index[v] = {};
            index[v][i] = true; // Mark as present in i input.
        };
    };
    var retv = [];
    for (var i in index) {
        if (Object.keys(index[i]).length == arrLength) retv.push(i);
    };
    return retv;
};

intersect ([[1, 3, 4, 6, 3], [1, 8, 99]]); // [ '1' ]

Comments

এটি একটি ছোট পরিবর্তন সহ সেরা উত্তর। var v = লাইন যুক্ত হওয়ার পরে if (typeof v == 'function') continue;এবং এটি ফলাফলগুলিতে যুক্ত ফাংশনগুলি এড়িয়ে যাবে। ধন্যবাদ!

— Zsolti

ধন্যবাদ @ জসোল্টি আমি আপনার পরামর্শটি যুক্ত করি না কারণ ফাংশনগুলি (এবং আমরা যেভাবে এটি পরিচালনা করতে চাই) আসল প্রশ্নের ক্ষেত্রের বাইরে। তবে আমার সম্পাদনাটি দেখুন: আপনি যদি আপনার ইনপুট অ্যারেতে পুনরাবৃত্তি করতে পারেন তবে মূল বাস্তবায়ন বগি g আমি আমার সম্পাদনায় এটি স্থির করেছি। ... অন্যদিকে, আপনি যদি নিশ্চিতভাবে জানেন যে কোনও পুনরাবৃত্তি হবে না, তবে আসল বাস্তবায়ন কিছুটা সস্তা।

— বিটিফেট

... ফাংশন সম্পর্কে, এগুলিও ছেদ করা যায়: আমরা যদি @ Zsolti বলে তাদের সনাক্ত করি (এর সাথে if (typeof v == 'function'), তবে আমরা এর স্ট্রিংফিকেশন ( v.toString()) এর সূচকের জন্য কী হিসাবে ব্যবহার করতে পারি But তবে, এটি অক্ষত রাখার জন্য আমাদের কিছু করা দরকার The এটি করার সহজতম উপায়টি হ'ল একটি সাধারণ বুলিয়ান সত্য মানের পরিবর্তে মূল ফাংশনটি অর্পণ করা হয় But তবে, সেক্ষেত্রে সর্বশেষতম ডিনডেক্সটোনকেও এই শর্তটি সনাক্ত করতে এবং সঠিক মান (ফাংশন) পুনরুদ্ধার করতে হবে

— বিটফিট

এটি 100 টি উপাদান সহ 30 টি অ্যারে দিয়ে কত দ্রুত হতে পারে .. সিপিইউ ব্যবহার কীভাবে হয়?

— ons ই

Answer 16

আপনি (আই বাদে সমস্ত ব্রাউজারের জন্য) ব্যবহার করতে পারেন:

const intersection = array1.filter(element => array2.includes(element));

বা আইই এর জন্য:

const intersection = array1.filter(element => array2.indexOf(element) !== -1);

Comments

যদি আপনি যে তুলতে পারে একটি ফাংশন মধ্যে চমৎকার হবে

— avalanche1

@ avalanche1 কনস্ট্রেশন মোড় = (a1, a2) => a1.filter (e => a2.includes (e));

— jota3

Answer 17

function intersection(A,B){
var result = new Array();
for (i=0; i<A.length; i++) {
    for (j=0; j<B.length; j++) {
        if (A[i] == B[j] && $.inArray(A[i],result) == -1) {
            result.push(A[i]);
        }
    }
}
return result;
}

Answer 18

আপনার ডেটাতে কিছু সীমাবদ্ধতা সহ, আপনি লিনিয়ার সময়ে এটি করতে পারেন !

জন্য ধনাত্মক পূর্ণসংখ্যা : একটি "দেখা / দেখা যায় না" বুলিয়ান একটি অ্যারের মান ম্যাপিং ব্যবহার করুন।

function intersectIntegers(array1,array2) { 
   var seen=[],
       result=[];
   for (var i = 0; i < array1.length; i++) {
     seen[array1[i]] = true;
   }
   for (var i = 0; i < array2.length; i++) {
     if ( seen[array2[i]])
        result.push(array2[i]);
   }
   return result;
}

অবজেক্টগুলির জন্য অনুরূপ কৌশল রয়েছে : একটি ডামি কী নিন, অ্যারের 1 এ প্রতিটি উপাদানটির জন্য এটি "সত্য" এ সেট করুন, তারপরে অ্যারে 2 এর উপাদানগুলিতে এই কীটি সন্ধান করুন। আপনার কাজ শেষ হয়ে গেলে পরিষ্কার করুন।

function intersectObjects(array1,array2) { 
   var result=[];
   var key="tmpKey_intersect"
   for (var i = 0; i < array1.length; i++) {
     array1[i][key] = true;
   }
   for (var i = 0; i < array2.length; i++) {
     if (array2[i][key])
        result.push(array2[i]);
   }
   for (var i = 0; i < array1.length; i++) {
     delete array1[i][key];
   }
   return result;
}

অবশ্যই আপনার অবশ্যই নিশ্চিত হওয়া উচিত যে চাবিটি আগে উপস্থিত হয়নি, অন্যথায় আপনি আপনার ডেটা নষ্ট করবেন ...

Comments

যাইহোক, এটিকে সহজেই যে কোনও সংখ্যক অ্যারেগুলিতে আন্তঃসংযোগ স্থাপনের জন্য বাড়ানো যেতে পারে: পূর্ণসংখ্যার মাধ্যমে বুলিয়ান প্রতিস্থাপন করুন এবং যতবার দেখা হয় বর্ধিত পরিমাণ: আপনি সহজেই শেষ রাউন্ডে ছেদটি পড়তে পারেন।

— তারুলেন

আকর্ষণীয় সমাধান, আমি এটি পছন্দ করি। বেশিরভাগ অন্যান্য সমাধান হ'ল ও (এন ^ 2), তবে এটি ও (এন)। আমি এখানে ইরিপির পারফরম্যান্স ফিডেলে পূর্ণসংখ্যা কোড যুক্ত করেছি ফিডলতে jsfiddle.net/321juyLu/2 । এটি তৃতীয় এসেছিল, আমার মতো :)

— rmcharry

Answer 19

আমার পক্ষে সবচেয়ে বেশি যা কাজ করে যাচ্ছে তাতে আমি অবদান রাখব:

if (!Array.prototype.intersect){
Array.prototype.intersect = function (arr1) {

    var r = [], o = {}, l = this.length, i, v;
    for (i = 0; i < l; i++) {
        o[this[i]] = true;
    }
    l = arr1.length;
    for (i = 0; i < l; i++) {
        v = arr1[i];
        if (v in o) {
            r.push(v);
        }
    }
    return r;
};
}

Answer 20

আইই 9.0, ক্রোম, ফায়ারফক্স, অপেরা,

    function intersection(a,b){
     var rs = [], x = a.length;
     while (x--) b.indexOf(a[x])!=-1 && rs.push(a[x]);
     return rs.sort();
    }

intersection([1,2,3], [2,3,4,5]);
//Result:  [2,3]

Answer 21

'use strict'

// Example 1
function intersection(a1, a2) {
    return a1.filter(x => a2.indexOf(x) > -1)
}

// Example 2 (prototype function)
Array.prototype.intersection = function(arr) {
    return this.filter(x => arr.indexOf(x) > -1)
} 

const a1 = [1, 2, 3]
const a2 = [2, 3, 4, 5]

console.log(intersection(a1, a2))
console.log(a1.intersection(a2))

Answer 22

ES2015 সহ একটি কার্যকরী পদ্ধতির

একটি কার্যকরী পদ্ধতির পার্শ্ব প্রতিক্রিয়া ছাড়াই কেবল খাঁটি ফাংশনগুলি ব্যবহার করা বিবেচনা করতে হবে, যার প্রতিটিই কেবল একটি কাজের সাথে সম্পর্কিত।

এই বিধিনিষেধগুলি জড়িত ক্রিয়াকলাপগুলির সামঞ্জস্যতা এবং পুনরায় ব্যবহারযোগ্যতা বাড়ায়।

// small, reusable auxiliary functions

const createSet = xs => new Set(xs);
const filter = f => xs => xs.filter(apply(f));
const apply = f => x => f(x);


// intersection

const intersect = xs => ys => {
  const zs = createSet(ys);
  return filter(x => zs.has(x)
     ? true
     : false
  ) (xs);
};


// mock data

const xs = [1,2,2,3,4,5];
const ys = [0,1,2,3,3,3,6,7,8,9];


// run it

console.log( intersect(xs) (ys) );

অনুগ্রহ করে নোট করুন যে নেটিভ Setটাইপটি ব্যবহৃত হয়, এটির একটি সুবিধাজনক অনুসন্ধানের কর্মক্ষমতা রয়েছে।

সদৃশগুলি এড়িয়ে চলুন

স্পষ্টতই প্রথম থেকে বারবার সংঘটিত আইটেমগুলি Arrayসংরক্ষণ করা হয়, Arrayঅন্যটি ডি-সদৃশ। এটি পছন্দসই আচরণ হতে পারে বা নাও হতে পারে। আপনার যদি অনন্য ফলাফলের প্রয়োজন dedupeহয় তবে প্রথম যুক্তিতে প্রয়োগ করুন :

// auxiliary functions

const apply = f => x => f(x);
const comp = f => g => x => f(g(x));
const afrom = apply(Array.from);
const createSet = xs => new Set(xs);
const filter = f => xs => xs.filter(apply(f));


// intersection

const intersect = xs => ys => {
  const zs = createSet(ys);
  return filter(x => zs.has(x)
     ? true
     : false
  ) (xs);
};


// de-duplication

const dedupe = comp(afrom) (createSet);


// mock data

const xs = [1,2,2,3,4,5];
const ys = [0,1,2,3,3,3,6,7,8,9];


// unique result

console.log( intersect(dedupe(xs)) (ys) );

যে কোন সংখ্যার ছেদ গণনা Arrayগুলি

আপনি একজন ইচ্ছামত সংখ্যা ছেদ গনা করতে চান, Arrayগুলি শুধু রচনা intersectসঙ্গে foldl। এখানে একটি সুবিধাজনক ফাংশন রয়েছে:

// auxiliary functions

const apply = f => x => f(x);
const uncurry = f => (x, y) => f(x) (y);
const createSet = xs => new Set(xs);
const filter = f => xs => xs.filter(apply(f));
const foldl = f => acc => xs => xs.reduce(uncurry(f), acc);


// intersection

const intersect = xs => ys => {
  const zs = createSet(ys);
  return filter(x => zs.has(x)
     ? true
     : false
  ) (xs);
};


// intersection of an arbitrarily number of Arrays

const intersectn = (head, ...tail) => foldl(intersect) (head) (tail);


// mock data

const xs = [1,2,2,3,4,5];
const ys = [0,1,2,3,3,3,6,7,8,9];
const zs = [0,1,2,3,4,5,6];


// run

console.log( intersectn(xs, ys, zs) );

Comments

চিত্তাকর্ষকভাবে কার্যকর: এটি হ্যাসেল নয় তা নিশ্চিত করার জন্য একটি ডাবল-টিক নিতে হয়েছিল। একমাত্র নীটপিকটি হ'ল: (expr ? true : false)অতিরিক্ত কাজ। exprআসল বুলিয়ানগুলির প্রয়োজন না হলে কেবল ব্যবহার করুন , কেবল সত্য / মিথ্যা।

— জোস_কাস্ট্রো_আরনাড

Answer 23

সরলতা জন্য:

// Usage
const intersection = allLists
  .reduce(intersect, allValues)
  .reduce(removeDuplicates, []);


// Implementation
const intersect = (intersection, list) =>
  intersection.filter(item =>
    list.some(x => x === item));

const removeDuplicates = (uniques, item) =>
  uniques.includes(item) ? uniques : uniques.concat(item);


// Example Data
const somePeople = [bob, doug, jill];
const otherPeople = [sarah, bob, jill];
const morePeople = [jack, jill];

const allPeople = [...somePeople, ...otherPeople, ...morePeople];
const allGroups = [somePeople, otherPeople, morePeople];

// Example Usage
const intersection = allGroups
  .reduce(intersect, allPeople)
  .reduce(removeDuplicates, []);

intersection; // [jill]

উপকারিতা:

• ময়লা সহজ
• তথ্য-কেন্দ্রিক
• তালিকার ইচ্ছামত সংখ্যার জন্য কাজ করে
• তালিকায় নির্বিচারে দৈর্ঘ্যের জন্য কাজ করে
• মান নির্বিচারে ধরণের জন্য কাজ করে
• স্বেচ্ছাসেবী সাজানোর অর্ডার জন্য কাজ করে
• আকৃতি ধরে রাখে (কোনও অ্যারেতে প্রথম উপস্থিতির ক্রম)
• সম্ভব হলে তাড়াতাড়ি প্রস্থান করে
• মেমরি নিরাপদ, ফাংশন / অ্যারে প্রোটোটাইপগুলির সাথে সাম্প্রদায়িকতা কম

অপূর্ণতা:

• উচ্চতর মেমরি ব্যবহার
• উচ্চতর সিপিইউ ব্যবহার
• হ্রাস একটি বোঝার প্রয়োজন
• ডেটা প্রবাহ বোঝার প্রয়োজন

আপনি এটি 3 ডি ইঞ্জিন বা কার্নেল কাজের জন্য ব্যবহার করতে চাইবেন না, তবে ইভেন্ট-ভিত্তিক অ্যাপ্লিকেশনটিতে চালানোর জন্য যদি আপনার সমস্যা হয় তবে আপনার ডিজাইনে আরও বড় সমস্যা রয়েছে।

Answer 24

.reduceএকটি মানচিত্র তৈরি .filterকরতে এবং ছেদটি সন্ধান করতে। deleteএর মধ্যে .filterআমাদের দ্বিতীয় অ্যারেটি আচরণ করার অনুমতি দেয় যদিও এটি একটি অনন্য সেট।

function intersection (a, b) {
  var seen = a.reduce(function (h, k) {
    h[k] = true;
    return h;
  }, {});

  return b.filter(function (k) {
    var exists = seen[k];
    delete seen[k];
    return exists;
  });
}

আমি এই পদ্ধতির সম্পর্কে যুক্তিযুক্ত করা বেশ সহজ। এটি ধ্রুবক সময়ে পারফর্ম করে।

Answer 25

List1.filter (n => list2.includes (n)) ছাড়াও এটি সম্ভবত সবচেয়ে সহজ

var list1 = ['bread', 'ice cream', 'cereals', 'strawberry', 'chocolate']
var list2 = ['bread', 'cherry', 'ice cream', 'oats']

function check_common(list1, list2){
	
	list3 = []
	for (let i=0; i<list1.length; i++){
		
		for (let j=0; j<list2.length; j++){	
			if (list1[i] === list2[j]){
				list3.push(list1[i]);				
			}		
		}
		
	}
	return list3
	
}

check_common(list1, list2) // ["bread", "ice cream"]

Comments

— এটিতে

Answer 26

যদি আপনার এটির প্রয়োজন হয় তবে একাধিক অ্যারে ছেদ করে এটি পরিচালনা করতে হবে:

const intersect = (a, b, ...rest) => {
  if (rest.length === 0) return [...new Set(a)].filter(x => new Set(b).has(x));
  return intersect(a, intersect(b, ...rest));
};

console.log(intersect([1,2,3,4,5], [1,2], [1, 2, 3,4,5], [2, 10, 1])) // [1,2]

Comments

তবে 100 টি উপাদান সহ 30 টি অ্যারের জন্য এই দ্রবণটি কত দ্রুত?

— ons ই

এটি জাভাস্ক্রিপ্ট পদ্ধতিগুলির সাথে নেটিভ ব্যতীত আর কিছুই ব্যবহার করছে না এবং এর জন্য কোডটি যে ভিএম চালাবে সেটিকে যতদূর সম্ভব এটি অপ্টিমাইজ করতে বিনামূল্যে। আমি যথেষ্ট ইতিবাচক যে এই মন্তব্যটির বয়সের তুলনায় আপনি ভি 8 এর একটি আধুনিক সংস্করণে এটি চালিয়ে যাচ্ছেন তার চেয়ে দ্রুত কোনও সমাধান নেই।

— বেলফোর্ডজ

Answer 27

ES6 শৈলীর সহজ উপায়।

const intersection = (a, b) => {
  const s = new Set(b);
  return a.filter(x => s.has(x));
};

উদাহরণ:

intersection([1, 2, 3], [4, 3, 2]); // [2, 3]

Answer 28

আমি একটি আন্তঃসংশোধন ফাংশন লিখেছি যা এমনকি সেই বস্তুর নির্দিষ্ট সম্পত্তির উপর ভিত্তি করে অবজেক্টগুলির অ্যারের ছেদ সনাক্ত করতে পারে।

এই ক্ষেত্রে,

if arr1 = [{id: 10}, {id: 20}]
and arr2 =  [{id: 20}, {id: 25}]

এবং আমরা idসম্পত্তি ভিত্তিতে ছেদ চাই , তারপরে আউটপুটটি হওয়া উচিত:

[{id: 20}]

যেমন, একইটির জন্য ফাংশন (দ্রষ্টব্য: ES6 কোড) হ'ল:

const intersect = (arr1, arr2, accessors = [v => v, v => v]) => {
    const [fn1, fn2] = accessors;
    const set = new Set(arr2.map(v => fn2(v)));
    return arr1.filter(value => set.has(fn1(value)));
};

এবং আপনি ফাংশন হিসাবে কল করতে পারেন:

intersect(arr1, arr2, [elem => elem.id, elem => elem.id])

এছাড়াও দ্রষ্টব্য: এই ক্রিয়াটি প্রথম অ্যারেটিকে প্রাথমিক অ্যারে বিবেচনা করে ছেদটি খুঁজে পেয়েছে এবং এভাবে ছেদ করার ফলাফলটি প্রাথমিক অ্যারের মতো হবে।

Answer 29

ভাবেন এটি ও (অ্যারে 1 + অ্যারে 2) সময় ধরে মানচিত্র ধরে ধরে দ্রুত হবে। ও (1) হ'ল দয়া করে ভুল হলে আমাকে সংশোধন করুন।

const intersection = (a1, a2) => {
  let map = new Map();
  let result = []
  for (let i of a1) {
    if (!map.has(i)) map.set(i, true);
  }
  for (let i of a2) {
    if (map.has(i)) result.push(i)
  }
  return result;
}

Answer 30

এখানে আন্ডারস্কোর.জেএস বাস্তবায়ন রয়েছে:

_.intersection = function(array) {
  if (array == null) return [];
  var result = [];
  var argsLength = arguments.length;
  for (var i = 0, length = array.length; i < length; i++) {
    var item = array[i];
    if (_.contains(result, item)) continue;
    for (var j = 1; j < argsLength; j++) {
      if (!_.contains(arguments[j], item)) break;
    }
    if (j === argsLength) result.push(item);
  }
  return result;
};

সূত্র: http://underscorejs.org/docs/underscore.html#section-62

Comments

আন্ডারস্কোর উপলব্ধ থাকলে কোনও খারাপ রেফারেন্স নয়

— দিমিত্রিওস মিস্ট্রিওটিস