অ্যারেতে সমস্ত অ-অনন্য মান (যেমন: সদৃশ / একাধিক সংখ্যার) পান

418

কোনও নকল মান আছে কিনা তা দেখতে আমার একটি জাভাস্ক্রিপ্ট অ্যারে চেক করতে হবে। এটি করার সবচেয়ে সহজ উপায় কী? আমাকে কেবল সদৃশ মানগুলি কী তা খুঁজে বের করতে হবে - আসলে আমার তাদের সূচকের প্রয়োজন হয় না বা সেগুলি কতবার নকল করা হয়।

আমি জানি যে আমি অ্যারের মধ্য দিয়ে লুপ করতে পারি এবং ম্যাচের জন্য অন্যান্য সমস্ত মান পরীক্ষা করতে পারি তবে মনে হয় এর চেয়ে সহজ উপায় থাকা উচিত।

অনুরূপ প্রশ্ন:

javascript  arrays 
— স্কট স্যান্ডার্স
সূত্র
22
এই প্রশ্নটি যা জিজ্ঞাসা করে তা নিয়ে বছরের পর বছর বিভ্রান্তি দেখা দেয়। অ্যারেতে থাকা উপাদানগুলি নকল করা হয়েছিল তা আমার জানতে হবে: "আমাকে কেবল সদৃশ মানগুলি কী তা খুঁজে বের করতে হবে"। সঠিক উত্তরটি অ্যারে থেকে সদৃশগুলি সরিয়ে ফেলবে না। এটি আমি যা চেয়েছিলাম তার বিপরীতে: অনুলিপিগুলির একটি তালিকা, অনন্য উপাদানের একটি তালিকা নয়।
— স্কট স্যান্ডার্স

উত্তর:

301

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

const findDuplicates = (arr) => {
  let sorted_arr = arr.slice().sort(); // You can define the comparing function here. 
  // JS by default uses a crappy string compare.
  // (we use slice to clone the array so the
  // original array won't be modified)
  let results = [];
  for (let i = 0; i < sorted_arr.length - 1; i++) {
    if (sorted_arr[i + 1] == sorted_arr[i]) {
      results.push(sorted_arr[i]);
    }
  }
  return results;
}

let duplicatedArray = [9, 9, 111, 2, 3, 4, 4, 5, 7];
console.log(`The duplicates in ${duplicatedArray} are ${findDuplicates(duplicatedArray)}`);
স্নিপেট প্রসারিত করুন

যদি আপনি ডুপ্লিকেটগুলির জন্য একটি ফাংশন হিসাবে ফিরে যান। এটি একই ধরণের মামলার জন্য।

তথ্যসূত্র: https://stackoverflow.com/a/57532964/8119511

— swilliams
সূত্র
10
"আপনার সাজানোর অ্যালগরিদম ধরে নেওয়া ভাল, এটি O ^ 2 এর চেয়ে কম হওয়া উচিত"। বিশেষত, এটি ও (এন * লগ (এন)) হতে পারে।
— ESRogs
83
2 টিরও বেশি অনুলিপি সহ এই স্ক্রিপ্টটি এত ভাল কাজ করে না (যেমনarr = [9, 9, 9, 111, 2, 3, 3, 3, 4, 4, 5, 7];
— মটিটি
7
@swilliams আমি মনে করি না এই নির্দেশিকাগুলি ব্যবহার না করার বিষয়ে কিছু বলেছে i++। পরিবর্তে, তারা লিখতে না বলে j = i + +j। দুটি ভিন্ন জিনিস আইএমএইচও। আমি মনে করি i += 1সহজ এবং সুন্দর তুলনায় আরও বিভ্রান্তিকর i++:)
— ড্যানিলো বার্জেন
34
-1 এই উত্তরটি অনেক স্তরে ভুল। প্রথমত var sorted_arr = arr.sort()অকেজো: arr.sort()মূল অ্যারেটি পরিবর্তিত করে (যা তার নিজস্ব ক্ষেত্রে একটি সমস্যা)। এটি একটি উপাদানকেও ছাড়ায়। (উপরে কোড রান 9 সেখানে কি ঘটছে।?) CC @dystroy একটি ক্লিনার সমাধান হবেresults = arr.filter(function(elem, pos) { return arr.indexOf(elem) == pos; })
— NullUserException
24
প্রত্যেকে: প্রশ্নটি সদৃশ মানগুলি প্রদর্শন করতে বলে, সেগুলি সরাতে নয়। কোডটি এটি করার চেষ্টা করছে না এমন কিছু করার চেষ্টা করার জন্য কোড সম্পাদনা / ভঙ্গ করবেন না। সতর্কতাটিতে ডুপ্লিকেটযুক্ত মানগুলি দেখানো উচিত।
— স্কট স্যান্ডার্স
205

আপনি যদি সদৃশগুলি নিখুঁত করতে চান তবে এই দুর্দান্ত সমাধানটি চেষ্টা করে দেখুন:

function eliminateDuplicates(arr) {
  var i,
      len = arr.length,
      out = [],
      obj = {};

  for (i = 0; i < len; i++) {
    obj[arr[i]] = 0;
  }
  for (i in obj) {
    out.push(i);
  }
  return out;
}

সূত্র: http://dreaminginjavascript.wordpress.com/2008/08/22/eliminating- সদৃশ /

— rapfaria
সূত্র
18
এটি একটি ভাল কোড, তবে দুর্ভাগ্যক্রমে এটি যা করতে চাইছে তা করে না।
— স্কট সান্ডার্স
67
উপরের কোডটি (যা আমার - এটি আমার ব্লগ) আপনাকে খুব কাছে পেয়েছে। একটি ছোট ঝাঁকুনি এবং আপনি সেখানে আছেন। প্রথমত, আপনি দেখতে পাচ্ছেন arrlethight এবং out.length একই কিনা। যদি সেগুলি একই হয় তবে কোনও সদৃশ উপাদান নেই। তবে আপনি আরও কিছু চান। আপনি যদি ডুপসকে ঘটে যাওয়ার সাথে সাথে "ধরতে" চান তবে অ্যারেটির দৈর্ঘ্য [অ্যারে [i]] = 0 লাইনের পরে বাড়বে কিনা তা পরীক্ষা করে দেখুন। নিফটি, আহ? :-) সুন্দর কথার জন্য ধন্যবাদ, রাফেল মন্টনারো।
— নোসারেডা
6
@ মার্কোডেমিও: আহ, না, কোডটি স্পেস দিয়ে কাজ করবে না কেন? আপনি কোনও সম্পত্তি নামে যা খুশি রাখতে পারেন - স্পেস সহ অ্যাক্সেসের জন্য ডট সিনট্যাক্সটি ব্যবহার করতে পারবেন না (পার্সিংকে ভেঙে ফেলতে পারে এমন বিভিন্ন অক্ষরের প্রপসও নয়)।
— গিজ
4
@ জিজস: +1 আপনি ঠিক বলেছেন। আমি এটা জানতাম না। এটি এখনও অবজেক্টগুলির একটি অ্যারে হয়ে গেলে এটি কাজ করে না।
— মার্কো ডেমিও
3
এই অ্যালগরিদমের একটি বাছাই করা অ্যারে ফিরিয়ে দেওয়ার পার্শ্ব প্রতিক্রিয়াও রয়েছে, যা আপনি যা চান তা নাও হতে পারে।
— অসমমিতি
165

এটি সদৃশ থ্রেড (!) থেকে আমার উত্তর:

এই এন্ট্রি ২০১৪ লেখার সময় - সমস্ত উদাহরণ হ'ল লুপস বা জিকুয়েরি। জাভাস্ক্রিপ্ট এ জন্য উপযুক্ত সরঞ্জাম আছে: বাছাই, মানচিত্র এবং হ্রাস।

সদৃশ আইটেম সন্ধান করুন

var names = ['Mike', 'Matt', 'Nancy', 'Adam', 'Jenny', 'Nancy', 'Carl']

var uniq = names
  .map((name) => {
    return {
      count: 1,
      name: name
    }
  })
  .reduce((a, b) => {
    a[b.name] = (a[b.name] || 0) + b.count
    return a
  }, {})

var duplicates = Object.keys(uniq).filter((a) => uniq[a] > 1)

console.log(duplicates) // [ 'Nancy' ]
স্নিপেট প্রসারিত করুন

আরও কার্যকরী বাক্য গঠন:

@ ডাইমিট্রো-ল্যাপটিন কিছু কোড কোড অপসারণের নির্দেশ করেছেন। এটি একই কোডের আরও কমপ্যাক্ট সংস্করণ। কিছু ES6 কৌশল এবং উচ্চতর অর্ডার ফাংশন ব্যবহার করে:

const names = ['Mike', 'Matt', 'Nancy', 'Adam', 'Jenny', 'Nancy', 'Carl']

const count = names =>
  names.reduce((a, b) => ({ ...a,
    [b]: (a[b] || 0) + 1
  }), {}) // don't forget to initialize the accumulator

const duplicates = dict =>
  Object.keys(dict).filter((a) => dict[a] > 1)

console.log(count(names)) // { Mike: 1, Matt: 1, Nancy: 2, Adam: 1, Jenny: 1, Carl: 1 }
console.log(duplicates(count(names))) // [ 'Nancy' ]
স্নিপেট প্রসারিত করুন

— খ্রিস্টান ল্যান্ডগ্রেন
সূত্র
1
এই ধরণের সমাধানটি আমি সন্ধান করছি। আমি যদি কয়েক ডজন লুপ রাখতে চাইতাম তবে এটি লেখা সহজ। ওপিতে মূল শব্দটি ছিল "দক্ষ"।
— জোশ
@ খ্রিস্টিয়ান ল্যান্ডগ্রেন, 'ডিক' পরিবর্তনশীল কোথায় ঘোষণা করা হয়েছে? পরিবর্তে 'গণনা' ব্যবহার করা উচিত?
— Dmytro Laptin
4
দয়া করে নিজের জন্য নিজের বিভ্রান্তিমূলক মতামতটি রাখুন (-১ অহংকারী হওয়ার জন্য) আমি ব্যক্তিগতভাবে "সংক্ষিপ্ত" এবং "দক্ষ" লোককে বিভ্রান্ত করে এবং পারফরম্যান্স প্রশ্নবিদ্ধভাবে ওয়ান-লাইনার পোস্ট করে ক্লান্ত হয়ে পড়েছি। সংক্ষিপ্ত প্রোগ্রাম এবং আধুনিক জেএস প্রকৃতির দ্বারা ভাল নয়। এখানে "দক্ষ" শব্দের সাধারণ অপব্যবহার । সাধারণ নিরীহ বিশ্বাস এখানে (নিম্নলিখিত মন্তব্য পড়ুন)। এখানে ডেমো ।
— পাতা
1
@ লেফ - আপনার নিজের উত্তরগুলিতে আপনার পরামর্শগুলি রাখুন। আপনি যে সমাধানটি সম্পাদনা করেছেন তা পঠনযোগ্য নয়, এটি পারফরম্যান্ট হতে পারে (সম্ভবত না) তবে তবুও - পাঠ্যতা প্রায়শই আমার মতে সম্পাদনের চেয়ে গুরুত্বপূর্ণ। তবে সর্বাধিক গুরুত্বপূর্ণ - কারও কারও কোডটি কারণ ছাড়াই আপনার সাথে এটি প্রতিস্থাপনের জন্য সরাবেন না।
— খ্রিস্টান ল্যান্ডগ্রেন
1
বিভিন্ন উত্তর, হ্যাঁ, বিভিন্ন মতামত, আমি এটি মনে করি না।
— পাতা
64

একটি অ্যারেতে সদৃশ মানগুলি সন্ধান করুন

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

var input = [1, 2, 3, 1, 3, 1];

var duplicates = input.reduce(function(acc, el, i, arr) {
  if (arr.indexOf(el) !== i && acc.indexOf(el) < 0) acc.push(el); return acc;
}, []);

document.write(duplicates); // = 1,3 (actual array == [1, 3])
স্নিপেট প্রসারিত করুন

এর জন্য বাছাই বা কোনও তৃতীয় পক্ষের কাঠামোর দরকার নেই। এটির জন্য ম্যানুয়াল লুপেরও দরকার নেই। এটি প্রতিটি মান সূচকের সাথে কাজ করে () (বা আরও পরিষ্কার হতে: কঠোর তুলনা অপারেটর ) সমর্থন করে।

() এবং সূচিপত্র () কমিয়ে আনার কারণে এর জন্য কমপক্ষে আইই 9 প্রয়োজন।

— ফ্লু
সূত্র
7
ES6 তীর / সরল / খাঁটি সংস্করণ:const dupes = items.reduce((acc, v, i, arr) => arr.indexOf(v) !== i && acc.indexOf(v) === -1 ? acc.concat(v) : acc, [])
— ZephDavies
30

আপনি এই ফাংশনটি যুক্ত করতে পারেন বা এটিকে সামঞ্জস্য করতে পারেন এবং এটি জাভাস্ক্রিপ্টের অ্যারে প্রোটোটাইপে যুক্ত করতে পারেন: 

Array.prototype.unique = function () {
    var r = new Array();
    o:for(var i = 0, n = this.length; i < n; i++)
    {
        for(var x = 0, y = r.length; x < y; x++)
        {
            if(r[x]==this[i])
            {
                alert('this is a DUPE!');
                continue o;
            }
        }
        r[r.length] = this[i];
    }
    return r;
}

var arr = [1,2,2,3,3,4,5,6,2,3,7,8,5,9];
var unique = arr.unique();
alert(unique);
— karim79
সূত্র
এটি সেরা সমাধান, তবে এটিকে অ্যারে প্রোটোটাইপে যুক্ত করার বিষয়ে সতর্কতা অবলম্বন করুন, যেহেতু এটি মানগুলির মধ্যে লুপিংয়ের ফলে IE কে জড়িয়ে দেবে।
— সাম্পসা সুনিনেন
@ রয়টাইঙ্কার পার্ল তাদেরও সমর্থন করে তবে আমার জাভাস্ক্রিপ্টের কোনও ধারণা ছিল না
— লুক এইচ
1
ওপি যা বলেছিল তা করে না, সদৃশগুলি ফেরত দিন।
— RWC
27

আপডেট করা: নিম্নলিখিতটি একটি অনুকূলিত সম্মিলিত কৌশল ব্যবহার করে। এটি হ্যাশ ও (1) দেখার সময় (আদিমদের uniqueএকটি অ্যারেতে চলছে হে (এন)) থেকে উপকার পাওয়ার জন্য আদিম অনুসন্ধানগুলি অনুকূল করে । অবজেক্টের অনুসন্ধানগুলি অনন্য আইডি দিয়ে অবজেক্টগুলিকে ট্যাগ করে অনুকূলিত করা হয় যাতে ডুপ্লিকেট অবজেক্টগুলি সনাক্তকরণে আইটেম প্রতি ও (1) এবং পুরো তালিকার জন্য ও (এন) হয়। একমাত্র ব্যতিক্রম হ'ল আইটেমগুলি হিমায়িত হয় তবে এগুলি বিরল এবং একটি অ্যারে এবং ইনডেক্সফ ব্যবহার করে একটি ফ্যালব্যাক সরবরাহ করা হয়।

var unique = function(){
  var hasOwn = {}.hasOwnProperty,
      toString = {}.toString,
      uids = {};

  function uid(){
    var key = Math.random().toString(36).slice(2);
    return key in uids ? uid() : uids[key] = key;
  }

  function unique(array){
    var strings = {}, numbers = {}, others = {},
        tagged = [], failed = [],
        count = 0, i = array.length,
        item, type;

    var id = uid();

    while (i--) {
      item = array[i];
      type = typeof item;
      if (item == null || type !== 'object' && type !== 'function') {
        // primitive
        switch (type) {
          case 'string': strings[item] = true; break;
          case 'number': numbers[item] = true; break;
          default: others[item] = item; break;
        }
      } else {
        // object
        if (!hasOwn.call(item, id)) {
          try {
            item[id] = true;
            tagged[count++] = item;
          } catch (e){
            if (failed.indexOf(item) === -1)
              failed[failed.length] = item;
          }
        }
      }
    }

    // remove the tags
    while (count--)
      delete tagged[count][id];

    tagged = tagged.concat(failed);
    count = tagged.length;

    // append primitives to results
    for (i in strings)
      if (hasOwn.call(strings, i))
        tagged[count++] = i;

    for (i in numbers)
      if (hasOwn.call(numbers, i))
        tagged[count++] = +i;

    for (i in others)
      if (hasOwn.call(others, i))
        tagged[count++] = others[i];

    return tagged;
  }

  return unique;
}();

আপনার যদি ES6 সংগ্রহ উপলব্ধ থাকে তবে তার চেয়ে অনেক সহজ এবং উল্লেখযোগ্যভাবে দ্রুত সংস্করণ পাওয়া যায়। (আইই 9 + এবং অন্যান্য ব্রাউজারগুলির জন্য এখানে ঝকঝকে: https://github.com/Benvie/ES6- হারমোনি- সংগ্রহগুলি- শিম )

function unique(array){
  var seen = new Set;
  return array.filter(function(item){
    if (!seen.has(item)) {
      seen.add(item);
      return true;
    }
  });
}
সত্যি? 2 বছর আগে সমাধান করা একটি প্রশ্নের উত্তর কেন দেবেন?
— রিনি পট
3
আমি অন্য প্রশ্নের জবাব দিচ্ছিলাম এবং ঘটনাক্রমে দুর্ঘটনাবশত এই ব্যক্তির সাথে লিঙ্ক করা কাউকে ক্লিক করে, এটি একটি সদৃশ বললাম, এবং আমার উত্তরটি ক্লোন করে শেষ করে দিয়েছি এবং নিজের থেকে নরককে বিভ্রান্ত করেছিলাম। আমি আমার স্টাফ অনেক সম্পাদনা করি।
16
আমি মনে করি এটি বিভিন্ন সমাধান সহ দুর্দান্ত। বিষয়টি পুরানো এবং সমাধান হওয়ার বিষয়টি গুরুত্বপূর্ণ নয় যেহেতু এটি করার বিভিন্ন উপায় নিয়ে এখনও আসা সম্ভব। এটি কম্পিউটার বিজ্ঞানের একটি সাধারণ সমস্যা।
— এমিল বিক্রষ্টম
আপনি উল্লেখ করতে চাইতে পারেন যে এটি ES5 অ্যারে পদ্ধতিগুলির উপর নির্ভর করে যা IE <9. এ কার্যকর করা হয়নি
— টিম ডাউন
24

আপডেট হয়েছে: নকল পেতে সংক্ষিপ্ত ওয়ান-লাইনার:

[1, 2, 2, 4, 3, 4].filter((e, i, a) => a.indexOf(e) !== i) // [2, 4]

ডুপ্লিকেট ছাড়াই অ্যারেটি পেতে কেবল শর্তটি উল্টে দিন: 

[1, 2, 2, 4, 3, 4].filter((e, i, a) => a.indexOf(e) === i) // [1, 2, 3, 4]

আমি কেবল filter()নীচে আমার পুরানো উত্তর সম্পর্কে ভাবি নি ;)

আপনার যখন যা দরকার তা হ'ল এই প্রশ্নে কোন ডুপ্লিকেট নেই বলে আপনি পরীক্ষাটি ব্যবহার করতে পারেন every():

[1, 2, 3].every((e, i, a) => a.indexOf(e) === i) // true

[1, 2, 1].every((e, i, a) => a.indexOf(e) === i) // false

নোট করুন যে every()IE 8 এবং নীচে জন্য কাজ করে না।

— লরেন্ট পাইওট
সূত্র
1
ওপি যা বলেছিল তা করে না, সদৃশগুলি ফেরত দিন।
— RWC
সত্য, আমি এটি ঠিক করতে আমার উত্তর আপডেট করেছি।
— লরেন্ট পাওট
রয়্যাল সলিউশন! থ্যাঙ্কস
— জেরেমি পিডনোয়েল
21 
var a = ["a","a","b","c","c"];

a.filter(function(value,index,self){ return (self.indexOf(value) !== index )})
— অ্যাঞ্জেল ডেভিড ক্যালডারো প্যাকিয়ট
সূত্র
এটি কাজ করে বলে মনে হচ্ছে তবে এটি কীভাবে কাজ করে তা বর্ণনা করে আপনার সম্ভবত কিছু পাঠ্য অন্তর্ভুক্ত করা উচিত।
— DIMM রিপার
1
সদৃশ মানের আরও 2 টি ঘটনা উপস্থিত থাকলে কাজ করবে না।
— ভাসা
1
এটি মার্জিত এবং সহজ। আমি এটা ভালোবাসি. তারা কীভাবে কাজ করে তা অনুধাবন করতে চায় তাদের জন্য, আমি নকলগুলি কীভাবে প্রদর্শন করতে এবং সদৃশগুলি বর্জন করতে হবে তা দেখিয়ে একটি বাক্য তৈরি করেছি। এখানে দেখুন: gist.github.com/jbcoder/f1c616a32ee4d642691792eebdc4257b
— জোশ
সেকেন্ডের জন্য @TheDIMMReaper 'a'অ্যারের মধ্যে, ভিতরে ফিল্টার ফাংশন index == 1, যেহেতুself.indexOf('a') == 0
— Sergiy Ostrovsky
19

এটি আপনার যা চান তা পাবেন, কেবল নকলগুলি।

function find_duplicates(arr) {
  var len=arr.length,
      out=[],
      counts={};

  for (var i=0;i<len;i++) {
    var item = arr[i];
    counts[item] = counts[item] >= 1 ? counts[item] + 1 : 1;
    if (counts[item] === 2) {
      out.push(item);
    }
  }

  return out;
}

find_duplicates(['one',2,3,4,4,4,5,6,7,7,7,'pig','one']); // -> ['one',4,7] in no particular order.
— ড্যানিয়েল বিয়ার্ডসলে
সূত্র
9

ES2015

//          🚩🚩   🚩                 🚩 
var arr =  [1,2,2,3,3,4,5,6,2,3,7,8,5,22],
    arr2 = [1,2,511,12,50],
    arr3 = [22],
    unique;

// Combine all the arrays to a single one
unique = arr.concat(arr2, arr3)

// create a new (dirty) Array with only the unique items
unique = unique.map((item,i) => unique.includes(item, i+1) ? item : '' )

// Cleanup - remove duplicate & empty items items 
unique = [...new Set(unique)].filter(n => n)

console.log(unique)
স্নিপেট প্রসারিত করুন

3 অ্যারে (বা আরও) থেকে অনন্য মানগুলি পান:

Array.prototype.unique = function () {
    var arr = this.sort(), i; // input must be sorted for this to work
    for( i=arr.length; i--; )
      arr[i] === arr[i-1] && arr.splice(i,1); // remove duplicate item

    return arr;
}

var arr =  [1,2,2,3,3,4,5,6,2,3,7,8,5,9],
    arr2 = [1,2,511,12,50],
    arr3 = [22],
    // merge arrays & call custom Array Prototype - "unique"
    unique = arr.concat(arr2, arr3).unique();

console.log(unique);  // [22, 50, 12, 511, 2, 1, 9, 5, 8, 7, 3, 6, 4]

পুরানো ব্রাউজারগুলির জন্য অ্যারে ইনডেক্সের জন্য কেবল একটি পলিফিল:

if (!Array.prototype.indexOf){
   Array.prototype.indexOf = function(elt /*, from*/){
     var len = this.length >>> 0;

     var from = Number(arguments[1]) || 0;
     from = (from < 0) ? Math.ceil(from) : Math.floor(from);
     if (from < 0)
        from += len;

     for (; from < len; from++){
        if (from in this && this[from] === elt)
           return from;
     }
     return -1;
  };
}

"ইনআরে" ব্যবহার করে jQuery সমাধান:

if( $.inArray(this[i], arr) == -1 )

পরিবর্তে যোগ করার Array.prototype.indexOf

— VSync
সূত্র
+1 কারণ এটি অ্যারে.ইন্ডেক্সঅফ ব্যবহার করে অবশ্যই কোডটি আরও পঠনযোগ্য, তবে দুর্ভাগ্যক্রমে এটি সাধারণ নেস্টেড লুপটি ব্যবহার করার চেয়ে ধীর বলে মনে হচ্ছে। এমনকি ব্রাউজারগুলিতে যে অ্যারে.আইনডেফকে কার্যকরভাবে এফএফের মতো প্রয়োগ করে। প্লিজ, আমি এখানে এই পরীক্ষাগুলি একবার দেখুন: jsperf.com/array-unique2 এবং আমাকে আপনার মতামত জানাতে দিন।
— মার্কো ডেমাইও
@ শেখারডিজাইনার - আপডেট হওয়া উত্তর। "r" হ'ল অ্যারেটি আপনি অনুসন্ধান করেছেন
— vsync
@vsync var r = [];আপনার কোডটি কাজ করতে আমাকে শুরু করতে হয়েছিল। এবং মোহন মত কাজ।
— শেখর কে শর্মা
@ শেখারডিজাইনার - এই মিশ্রণের জন্য আমি দুঃখিত, অ্যারে প্রোটোটাইপ সমাধানের জন্য আপনার কোনও rভেরিয়েবলের দরকার নেই
— vsync
2
ওপি যা বলেছিল তা করে না, সদৃশগুলি ফেরত দিন।
— RWC
8

এখানে আমার সহজ এবং এক লাইন সমাধান।

এটি প্রথমে অনন্য উপাদান অনুসন্ধান করে না, তারপরে সেট ব্যবহারের সাথে অ্যারেটিকে অনন্য করে তোলে।

সুতরাং আমরা শেষে নকল এর অ্যারে আছে।

var array = [1, 2, 2, 3, 3, 4, 5, 6, 2, 3, 7, 8, 5, 22, 1, 2, 511, 12, 50, 22];

console.log([...new Set(
  array.filter((value, index, self) => self.indexOf(value) !== index))]
);
স্নিপেট প্রসারিত করুন

— ওলেগ আবরাজায়েভ
সূত্র
7

এটি আমার প্রস্তাব (ES6):

let a = [1, 2, 3, 4, 2, 2, 4, 1, 5, 6]
let b = [...new Set(a.sort().filter((o, i) => o !== undefined && a[i + 1] !== undefined && o === a[i + 1]))]

// b is now [1, 2, 4]
— lukaszkups
সূত্র
1
এটি প্রতিবেদন করবে যে এর একক ঘটনাটি undefinedহ'ল সদৃশ।
— ডেম পিলাফিয়ান
1
@ ডেমপিলাফিয়ান আপনাকে ধন্যবাদ জানায়, আপডেট হয়েছে
— লুকাশজকুপস
6 
var a = [324,3,32,5,52,2100,1,20,2,3,3,2,2,2,1,1,1].sort();
a.filter(function(v,i,o){return i&&v!==o[i-1]?v:0;});

বা অ্যারের প্রোটোটাইপ.কাইন যোগ করার পরে

//copy and paste: without error handling
Array.prototype.unique = 
   function(){return this.sort().filter(function(v,i,o){return i&&v!==o[i-1]?v:0;});}

এখানে দেখুন: https://gist.github.com/1305056

— লরেঞ্জ লো সৌর
সূত্র
1
ফিল্টার ফাংশনটি সত্য বা মিথ্যা প্রত্যাবর্তন করতে হবে, উপাদানটি নয়। 0 এর সমন্বিত একটি অ্যারে ফিল্টার করা তাদের ফিরিয়ে দেয় না।
— এমফ্লডিন
এছাড়াও, আমি ধরে নিই যে i&&এটি অ্যারের সীমানার বাইরে যাওয়া এড়ানোর জন্য, তবে এর অর্থ এটিও রয়েছে যে সাজানো অ্যারেতে প্রথম উপাদানটি অন্তর্ভুক্ত করা হবে না। আপনার উদাহরণে 1ফলাফল অ্যারে তেমন নেই । অর্থাত return i&&v!==o[i-1]?v:0;হওয়া উচিতreturn v!==o[i-1];
— mflodin
6

Es6 অবজেক্টের ডেস্ট্রাকচারিং এবং হ্রাস করে দ্রুত এবং মার্জিত উপায়ে

এটি ও (এন) এ চলেছে (অ্যারের উপরে 1 পুনরাবৃত্তি) এবং 2 বারের বেশি প্রদর্শিত মানগুলি পুনরাবৃত্তি করে না

const arr = ['hi', 'hi', 'hi', 'bye', 'bye', 'asd']
const {
  dup
} = arr.reduce(
  (acc, curr) => {
    acc.items[curr] = acc.items[curr] ? acc.items[curr] += 1 : 1
    if (acc.items[curr] === 2) acc.dup.push(curr)
    return acc
  }, {
    items: {},
    dup: []
  },
)

console.log(dup)
// ['hi', 'bye']
স্নিপেট প্রসারিত করুন

— লুকাস জ্যানন
সূত্র
5

আমি ভাবতে পারি এমন সহজ সমাধানটি এখানে:

    const arr = [-1, 2, 2, 2, 0, 0, 0, 500, -1, 'a', 'a', 'a']

    const filtered = arr.filter((el, index) => arr.indexOf(el) !== index)
    // => filtered = [ 2, 2, 0, 0, -1, 'a', 'a' ]

    const duplicates = [...new Set(filtered)]

    console.log(duplicates)
    // => [ 2, 0, -1, 'a' ]

এটাই.

বিঃদ্রঃ:

  1. এটি 0স্ট্রিং এবং নেতিবাচক সংখ্যাগুলি সহ যে কোনও সংখ্যার সাথে কাজ করে যেমন -1- সম্পর্কিত প্রশ্ন: একটি জাভাস্ক্রিপ্ট অ্যারেতে সমস্ত অনন্য মান পান (ডুপ্লিকেটগুলি সরান)

  2. আসল অ্যারে arrসংরক্ষণ করা হয়েছে ( filterআসলটি পরিবর্তনের পরিবর্তে নতুন অ্যারে প্রদান করে)

  3. filteredঅ্যারে রয়েছে সব সদৃশ; এটা করতে পারেন এছাড়াও (এখানে আমাদের ফিল্টার অ্যারে যেমন চেয়ে বেশি 1 একই মান ধারণ করে [ 2, 2, 0, 0, -1, 'a', 'a' ])

  4. আপনি যদি ডুপ্লিকেটযুক্ত কেবল মানগুলি (একই মান সহ একাধিক নকল পেতে চান না) পেতে চান তবে আপনি ব্যবহার করতে পারেন [...new Set(filtered)](ES6 এর একটি অবজেক্ট সেট রয়েছে যা কেবলমাত্র অনন্য মান সংরক্ষণ করতে পারে)

আশাকরি এটা সাহায্য করবে.

— নিকোলা জোভানোভিচ
সূত্র
5

সংক্ষিপ্ততম ভ্যানিলা জেএস :

[1,1,2,2,2,3].filter((v,i,a) => a.indexOf(v) !== i) // [1, 2, 2]
— মুরগি
সূত্র
4

এখানে একটি খুব হালকা এবং সহজ উপায়:

var codes = dc_1.split(',');
var i = codes.length;
while (i--) {
  if (codes.indexOf(codes[i]) != i) {
    codes.splice(i,1);
  }
}
— ব্র্যান্ডন ফেরারা
সূত্র
সেরা উত্তর. এবং যদি ব্যবহারকারী সদৃশ উপাদানগুলিকে অ্যারে চান তবে এর জন্য আমি @ ব্র্যান্ডন কোড var i = কোড। দৈর্ঘ্য আপডেট করেছি; var সদৃশ = []; যখন (i--) {যদি (কোড .indexOf (কোডগুলি [i])! = i) {যদি (সদৃশ.ইন্ডেক্সফ (কোডগুলি [i]) === -1) uplic সদৃশ। পুশ (আরআর [i]) ; } কোড.স্প্লাইস (আই, ১); }}
— হিমাংশু শেখর
4

ES6 এর মাধ্যমে (বা ব্যাবেল বা টাইপসিসিপ্ট ব্যবহার করে) আপনি কেবল পারেন:

var duplicates = myArray.filter(i => myArray.filter(ii => ii === i).length > 1);

https://es6console.com/j58euhbt/

— tocqueville
সূত্র
আমি স্বতন্ত্রভাবে একই বাক্য গঠনতে এসেছি এবং যখন আমি এটি পেয়েছি তখন সমাধান হিসাবে এটি যুক্ত করতে চলেছিলাম। এটি সম্ভবত সবচেয়ে অর্থনৈতিক নয়, তবে এটি সহজ।
— nize
4

ES6 সিনট্যাক্স সহ সাধারণ কোড (নকলের সাজানো অ্যারে ফেরত):

let duplicates = a => {d=[]; a.sort((a,b) => a-b).reduce((a,b)=>{a==b&&!d.includes(a)&&d.push(a); return b}); return d};

ব্যবহারবিধি:

duplicates([1,2,3,10,10,2,3,3,10]);
— অতিথি
সূত্র
1
.filter () অনেক সহজ হবে
— tocqueville
4

এক রৈখিক

var arr = [9,1,2,4,3,4,9]
console.log(arr.filter((ele,indx)=>indx!==arr.indexOf(ele))) //get the duplicates
console.log(arr.filter((ele,indx)=>indx===arr.indexOf(ele))) //remove the duplicates
স্নিপেট প্রসারিত করুন

— শ্রাবণ গাঞ্জি
সূত্র
indx!প্রথম উদাহরণের জন্য কি করতে পারে ?
— বলেস্টাইলার
1
@ সেলেস্টাইলার হহে, এর অর্থ indx !== ...- কঠোর বৈষম্য।
— দারিয়া
কেবলমাত্র অবজেক্টগুলির অ্যারে যুক্ত করা হচ্ছেresult.filter((ele,indx) => indx !== result.map(e => e.name).indexOf(ele.name));
— এক্স-ম্যাজিক্স
4

এই উত্তরটি সহায়ক হতে পারে, এটি অ্যারে থেকে সদৃশগুলি অপসারণের জন্য জেএস reduce অপারেটর / পদ্ধতির ক্ষতি করে ।

const result = [1, 2, 2, 3, 3, 3, 3].reduce((x, y) => x.includes(y) ? x : [...x, y], []);

console.log(result);
স্নিপেট প্রসারিত করুন

— দিব্যংশু রাওয়াত
সূত্র
3
আমরা এখন কেবল new Set([1, 2, 2, 3, 3, 3, 3])
— নকলগুলি
3

নিম্নলিখিত ফাংশন (ইতিমধ্যে উল্লিখিত ডিলিপিকেটস ফাংশনটির একটি প্রকরণ) এর কৌশলটি মনে হচ্ছে ইনপুট ["পরীক্ষা", "টেস্ট 2", "টেস্ট 2", 1, 1, 1, 2 এর জন্য পরীক্ষা 2,1,7,5 ফেরত , 3, 4, 5, 6, 7, 7, 10, 22, 43, 1, 5, 8]

নোট করুন যে সমস্যাটি বেশিরভাগ অন্যান্য ভাষার চেয়ে জাভাস্ক্রিপ্টে অপরিচিত, কারণ একটি জাভাস্ক্রিপ্ট অ্যারে ঠিক যে কোনও কিছু রাখতে পারে। নোট করুন যে সলিউশনগুলি ব্যবহার করে এমন সমাধানগুলিতে একটি উপযুক্ত বাছাইকরণ ফাংশন সরবরাহ করার প্রয়োজন হতে পারে - আমি এখনও সেই রুটটি চেষ্টা করি নি।

এই নির্দিষ্ট প্রয়োগটি (কমপক্ষে) স্ট্রিং এবং সংখ্যার জন্য কাজ করে।

function findDuplicates(arr) {
    var i,
        len=arr.length,
        out=[],
        obj={};

    for (i=0;i<len;i++) {
        if (obj[arr[i]] != null) {
            if (!obj[arr[i]]) {
                out.push(arr[i]);
                obj[arr[i]] = 1;
            }
        } else {
            obj[arr[i]] = 0;            
        }
    }
    return out;
}
— Nosredna
সূত্র
3

কেবল ইএস 5 এর (যেমন, এটি আইই 8 এবং নীচের জন্য একটি ফিল্টার () পলিফিলের প্রয়োজন):

var arrayToFilter = [ 4, 5, 5, 5, 2, 1, 3, 1, 1, 2, 1, 3 ];

arrayToFilter.
    sort().
    filter( function(me,i,arr){
       return (i===0) || ( me !== arr[i-1] );
    });
— gotofritz
সূত্র
আমি এই সহজ সমাধান পছন্দ। আপনি যদি সদৃশগুলি চান তবে আপনাকে প্রথমে সেই নকলগুলি সন্ধান করতে হবে এবং তারপরে সদৃশ তালিকাটিকে অনন্য করে তুলতে হবে। [0, 4, 5, 5, 5, 2, 1, 3, 1, 1, 2, 1, 3]। বাছাই করুন ()। ফিল্টার (ফাংশন (আমি, আমি, আর)) {ফিরে (আমি! == 0) ) && (me == arr [i-1]);})। ফিল্টার (ফাংশন (আমি, আমি, এআর) {রিটার্ন (i === 0) || (আমাকে! == আর [i-1]) ;});
— গ্রেগ
3 

var arr = [2, 1, 2, 2, 4, 4, 2, 5];

function returnDuplicates(arr) {
  return arr.reduce(function(dupes, val, i) {
    if (arr.indexOf(val) !== i && dupes.indexOf(val) === -1) {
      dupes.push(val);
    }
    return dupes;
  }, []);
}

alert(returnDuplicates(arr));
স্নিপেট প্রসারিত করুন

এই ফাংশনটি বাছাইয়ের পদক্ষেপ এড়িয়ে চলে এবং নতুন অ্যারিতে সদৃশটি উপস্থিত না থাকলে হ্রাস () পদ্ধতিটি ব্যবহার করে uplic

— Vasa
সূত্র
3

এখানে সর্বাধিক কার্যকারিতার চেয়ে 10x গুণ দ্রুত অ্যারে থেকে স্থায়ীভাবে সদৃশগুলি মুছে ফেলার এটি সম্ভবত দ্রুততম উপায় way

function toUnique(a,b,c){//array,placeholder,placeholder
 b=a.length;
 while(c=--b)while(c--)a[b]!==a[c]||a.splice(c,1)
}
var array=[1,2,3,4,5,6,7,8,9,0,1,2,1];
toUnique(array);
console.log(array);
  1. পরীক্ষা: http://jsperf.com/wgu
  2. ডেমো: http://jsfiddle.net/46S7g/
  3. আরও: https://stackoverflow.com/a/25082874/2450730

যদি আপনি উপরের কোডটি জিজ্ঞাসা করতে না পারেন, একটি জাভাস্ক্রিপ্ট বই পড়তে পারেন বা এখানে সংক্ষিপ্ত কোড সম্পর্কে কিছু ব্যাখ্যা রয়েছে। https://stackoverflow.com/a/21353032/2450730

সম্পাদনা মন্তব্য মতামত হিসাবে বলা হয়েছে এই ফাংশনটি অজ্ঞাতসারে একটি অ্যারে ফিরিয়ে দেয়, প্রশ্নটি তবে সদৃশগুলি সন্ধান করতে বলে asks সেক্ষেত্রে এই ফাংশনটিতে একটি সাধারণ পরিবর্তন ডুপ্লিকেটগুলিকে একটি অ্যারেতে ঠেকাতে দেয়, তারপরে পূর্ববর্তী ফাংশনটি ব্যবহার করে সদৃশদের নকলকে toUniqueসরিয়ে দেয়।

function theDuplicates(a,b,c,d){//array,placeholder,placeholder
 b=a.length,d=[];
 while(c=--b)while(c--)a[b]!==a[c]||d.push(a.splice(c,1))
}
var array=[1,2,3,4,5,6,7,8,9,0,1,2,1];

toUnique(theDuplicates(array));
— cocco
সূত্র
7
"যদি আপনি উপরের কোডটি জিজ্ঞাসা করতে না পারেন তবে একটি জাভাস্ক্রিপ্ট বইটি পড়ুন" এই উত্তরে পুরোপুরি অনেক বেশি কোড গল্ফ রয়েছে। A, b, c এর মতো ভেরিয়েবলের নামকরণ কোড পড়তে অসুবিধে করে। কোঁকড়া ধনুর্বন্ধনী বন্ধন এড়ানো আরও খারাপ করে তোলে।
— নদী উইলিয়ামসন
আমার বেশিরভাগ উত্তরগুলি পারফরম্যান্স এবং স্পেস সাশ্রয়ের উপর ভিত্তি করে (অন্যান্য সমাধান ইতিমধ্যে পোস্ট করা হয়) ... যদি আপনি এটি ডাউনওোট পছন্দ করেন না ... অন্যথায় জাভাস্ক্রিপ্ট শিখুন, একটি জেএস বই পড়ুন ... বা জ্যাকুরি ব্যবহার করুন ... তারা আপনি যদি একটি সহজ সমাধান অনুসন্ধান করেন তবে আরও অনেক উত্তর আছে। আপনি যদি সত্যিই কিছু শিখতে চান তবে আমি চিঠি অনুসারে কোড লেটারটি ব্যাখ্যা করে খুশি। যেহেতু আমি আপনার মন্তব্যে আসল প্রশ্নটি দেখতে পাচ্ছি না আমি অনুমান করি আপনি আমার উত্তরকে নীচে নামানোর উদ্দেশ্যটি অনুসন্ধান করছেন .... চালিয়ে যান ... এতে আমার কোনও সমস্যা নেই। একটি বাস্তব প্রশ্ন জিজ্ঞাসা করুন বা এমন কিছু আমাকে বলুন যা আমার কোডের সাথে কাজ করে না।
— কোকো
9
আপনার কোডটিতে প্রযুক্তিগতভাবে কোনও ভুল নেই। এটি বলেছিল, এ, বি, সি, ডি ইত্যাদি ভেরিয়েবলের নামকরণ এবং লুপগুলি শৃঙ্খলাবদ্ধকরণ কোড পড়তে অসুবিধাজনক করে তোলে। সুতরাং কোডটি কিছু শেখাতে ব্যর্থ।
— নদী উইলিয়ামসন
3

উপাদানটি ইতিমধ্যে বিদ্যমান কিনা তা পরীক্ষা করতে "অন্তর্ভুক্ত" ব্যবহার করে।

var arr = [1, 1, 4, 5, 5], darr = [], duplicates = [];

for(var i = 0; i < arr.length; i++){
  if(darr.includes(arr[i]) && !duplicates.includes(arr[i]))
    duplicates.push(arr[i])
  else
    darr.push(arr[i]);
}

console.log(duplicates);
<h3>Array with duplicates</h3>
<p>[1, 1, 4, 5, 5]</p>
<h3>Array with distinct elements</h3>
<p>[1, 4, 5]</p>
<h3>duplicate values are</h3>
<p>[1, 5]</p>
স্নিপেট প্রসারিত করুন

— Srichakradhar
সূত্র
কোডটি স্বতন্ত্র উপাদানগুলি ফিরিয়ে দেয় তবে প্রদত্ত ফলাফলের দিকে নিয়ে যায় না। সম্পূর্ণ সঠিক কোড সরবরাহ করুন।
— আরডাব্লুসি
3

ES6 সেট ডেটা স্ট্রাকচার অফার করে যা মূলত এমন অ্যারে যা নকলগুলি গ্রহণ করে না। সেট ডেটা কাঠামোর সাথে একটি অ্যারেতে সদৃশগুলি খুঁজে পাওয়ার খুব সহজ উপায় রয়েছে (কেবলমাত্র একটি লুপ ব্যবহার করে)।

আমার কোড এখানে

function findDuplicate(arr) {
var set = new Set();
var duplicates = new Set();
  for (let i = 0; i< arr.length; i++) {
     var size = set.size;
     set.add(arr[i]);
     if (set.size === size) {
         duplicates.add(arr[i]);
     }
  }
 return duplicates;
}
— Roysh
সূত্র
3

আমি অ্যারে ফিল্টার ব্যবহার করে এটি অর্জনের একটি সহজ উপায় সন্ধান করেছি

    var list = [9, 9, 111, 2, 3, 4, 4, 5, 7];
    
    // Filter 1: to find all duplicates elements
    var duplicates = list.filter(function(value,index,self) {
       return self.indexOf(value) !== self.lastIndexOf(value) && self.indexOf(value) === index;
    });
    
    console.log(duplicates);
স্নিপেট প্রসারিত করুন

— alaahd
সূত্র
3

নিম্নলিখিত যুক্তি সহজ এবং দ্রুত হবে

// @Param:data:Array that is the source 
// @Return : Array that have the duplicate entries
findDuplicates(data: Array<any>): Array<any> {
        return Array.from(new Set(data)).filter((value) => data.indexOf(value) !== data.lastIndexOf(value));
      }

সুবিধাদি :

  1. একক লাইন :- পি
  2. দক্ষতার উন্নতিতে সমস্ত ইনবিল্ট ডেটা কাঠামো সহায়তা করে
  3. দ্রুত

যুক্তির বর্ণনা:

  1. সমস্ত সদৃশ অপসারণ করতে সেট এ রূপান্তর করা
  2. সেট মানগুলির মাধ্যমে আইট্রেট করা
  3. শর্তের জন্য উত্স অ্যারেতে প্রতিটি সেট মান চেক সহ "মানগুলি প্রথম সূচক শেষ সূচকের সমান নয়" ==> তারপরে নকল হিসাবে অনুমান করা হয় এটি 'অনন্য'

দ্রষ্টব্য: মানচিত্র () এবং ফিল্টার () পদ্ধতিগুলি দক্ষ এবং দ্রুত।

— PranavKAndro
সূত্র
1
এটি পরীক্ষা করা হয়েছে ... খুব দ্রুত। এবং এটি বোধগম্য হয় .. আশা করি আমি এটি সম্পর্কে চিন্তাভাবনা করেছি
— মাইকেল রেহমা
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.