सभी गैर-विशिष्ट मान प्राप्त करें (जैसे: डुप्लिकेट / एक से अधिक घटनाएँ)

Question

मुझे यह देखने के लिए जावास्क्रिप्ट ऐरे की जाँच करनी होगी कि क्या कोई डुप्लिकेट मान हैं। ऐसा करने का सबसे आसान तरीका क्या है? मुझे केवल यह पता लगाने की आवश्यकता है कि डुप्लिकेट किए गए मान क्या हैं - मुझे वास्तव में उनके अनुक्रमित या कितनी बार उन्हें डुप्लिकेट करने की आवश्यकता नहीं है।

मुझे पता है कि मैं सरणी के माध्यम से लूप कर सकता हूं और एक मैच के लिए अन्य सभी मूल्यों की जांच कर सकता हूं, लेकिन ऐसा लगता है कि एक आसान तरीका होना चाहिए।

इसी तरह का सवाल:

• जावास्क्रिप्ट सरणी में सभी अद्वितीय मान प्राप्त करें (डुप्लिकेट निकालें)

Comments

यह प्रश्न क्या पूछता है, इसे लेकर वर्षों से भ्रम की स्थिति बनी हुई है। मुझे यह जानने की ज़रूरत है कि सरणी में कौन से तत्व डुप्लिकेट किए गए थे: "मुझे केवल यह पता लगाने की आवश्यकता है कि डुप्लिकेट किए गए मान क्या हैं"। सही उत्तर को सरणी से डुप्लिकेट को नहीं निकालना चाहिए। यही कारण है कि मैं क्या चाहता था: डुप्लिकेट की एक सूची, अद्वितीय तत्वों की सूची नहीं।

— स्कॉट Saunders

Answer 1

आप सरणी को सॉर्ट कर सकते हैं और फिर उसके माध्यम से चला सकते हैं और फिर देख सकते हैं कि अगला (या पिछला) सूचकांक वर्तमान के समान है या नहीं। अपने सॉर्ट एल्गोरिथ्म को अच्छा मानते हुए, यह O (n ² ) से कम होना चाहिए :

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

Comments

"आपके सॉर्ट एल्गोरिथ्म को अच्छा मानते हुए, यह ओ ^ 2 से कम होना चाहिए"। विशेष रूप से, यह O (n * log (n)) हो सकता है।

— ESRogs

यह स्क्रिप्ट 2 से अधिक डुप्लिकेट के साथ इतनी अच्छी तरह से काम नहीं करती है (जैसेarr = [9, 9, 9, 111, 2, 3, 3, 3, 4, 4, 5, 7];

— Mottie

मुझे लगता है कि उन दिशानिर्देशों का उपयोग न करने के बारे में कुछ भी कहना है i++। इसके बजाय, वे लिखने के लिए नहीं कहते हैं j = i + +j। दो अलग-अलग चीजें IMHO। मुझे लगता i += 1है कि सरल और सुंदर की तुलना में अधिक भ्रामक है i++:)

— डैनिलो बर्गन

-1 यह उत्तर कई स्तरों पर गलत है। सबसे पहले var sorted_arr = arr.sort()बेकार है: arr.sort()मूल सरणी को उत्परिवर्तित करता है (जो अपने आप में एक समस्या है)। यह भी एक तत्व को त्यागता है। (ऊपर दिए गए कोड को चलाएं। 9 का क्या होता है?) Cc @dystroy एक क्लीनर समाधान होगाresults = arr.filter(function(elem, pos) { return arr.indexOf(elem) == pos; })

— NullUserException

हर कोई: सवाल डुप्लिकेट मान प्रदर्शित करने के लिए कहता है, न कि उन्हें हटाने के लिए। कृपया कोड को संपादित करने / तोड़ने के लिए इसे बनाने की कोशिश न करें, ऐसा कुछ करने की कोशिश न करें। अलर्ट को उन मूल्यों को दिखाना चाहिए जो डुप्लिकेट हैं।

— स्कॉट Saunders

Answer 2

यदि आप डुप्लिकेट को समाप्त करना चाहते हैं, तो इस महान समाधान का प्रयास करें:

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-duplicates/

Comments

यह अच्छा कोड है, लेकिन दुर्भाग्य से यह वह नहीं करता है जो मैं पूछ रहा हूं।

— स्कॉट सॉन्डर्स

ऊपर दिया गया कोड (जो मेरा है - वह मेरा ब्लॉग है) आपको बहुत पास मिलता है। एक छोटा सा ट्वीक और आप वहां हैं। सबसे पहले, आप देख सकते हैं कि arr.length और out.length समान हैं। यदि वे समान हैं, तो कोई डुप्लिकेट तत्व नहीं हैं। लेकिन आप थोड़ा और चाहते हैं। यदि आप के रूप में वे होते हैं, तो "पकड़ने" चाहते हैं, यह देखने के लिए जांचें कि क्या obj [गिरफ्तार] [i] = 0 लाइन के बाद सरणी की लंबाई बढ़ जाती है। निफ्टी, एह? :-) अच्छे शब्दों के लिए धन्यवाद, राफेल मोंट्रो।

— नोसरेडना

@MarcoDemaio: उह, नहीं, कोड रिक्त स्थान के साथ काम क्यों नहीं करेगा? आप एक संपत्ति के नाम पर जो कुछ भी पसंद कर सकते हैं - बस डॉट सिंटैक्स का उपयोग रिक्त स्थान वाले लोगों तक पहुंचने के लिए नहीं कर सकते हैं (न ही विभिन्न अन्य वर्णों के साथ जो कि पार्सिंग को तोड़ देगा)।

— गीज

@ जीजस: +1 आप सही कह रहे हैं। मैं यह नहीं जानता था। लेकिन यह अभी भी काम नहीं करता है जब यह वस्तुओं की एक सरणी है।

— मार्को डेमायो

इस एल्गोरिथ्म में एक सॉर्ट किए गए सरणी को वापस करने का साइड इफेक्ट भी है, जो कि आप नहीं चाहते हैं।

— असममित

Answer 3

यह डुप्लिकेट थ्रेड (!) से मेरा उत्तर है:

2014 में इस प्रविष्टि को लिखते समय - सभी उदाहरण लूप या jQuery के लिए थे। जावास्क्रिप्ट में इसके लिए सही उपकरण हैं: सॉर्ट, मैप और कम करें।

डुप्लिकेट आइटम ढूंढें

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' ]

अधिक कार्यात्मक वाक्यविन्यास:

@ Dmytro-Alpin ने बताया कि कुछ कोड कोड हटाए जाएंगे। यह उसी कोड का अधिक कॉम्पैक्ट संस्करण है। कुछ 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' ]

Comments

यह एक ऐसा उपाय है जिसकी मुझे तलाश है। अगर मैं एक दर्जन से अधिक छोरों के लिए चाहता था, तो यह लिखना बहुत आसान है। ओपी में प्रमुख शब्द "कुशल" था।

— जोश

@ChristianLandgren, 'तानाशाह' चर कहाँ घोषित किया जाता है? हो सकता है कि इसके बजाय 'गिनती' का इस्तेमाल किया जाए?

— दिमित्रो रेप्लिन

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

— पत्ती

@leaf - कृपया अपने सुझाव अपने उत्तरों में रखें। आपके द्वारा संपादित किया गया समाधान पठनीय नहीं है, यह प्रदर्शनकारी हो सकता है (शायद नहीं) लेकिन फिर भी - पठनीयता अक्सर मेरी राय में प्रदर्शन से अधिक महत्वपूर्ण है। लेकिन सबसे महत्वपूर्ण बात - किसी और के कोड को बिना किसी कारण के इसे आपके पास से हटाने के लिए न निकालें।

— क्रिश्चियन लैंडग्रेन

अलग-अलग जवाब, हां, अलग-अलग राय, मुझे ऐसा नहीं लगता।

— पत्ती

Answer 4

किसी सरणी में डुप्लिकेट मान प्राप्त करें

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

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])

इसके लिए छँटाई या किसी तीसरे पक्ष के ढांचे की आवश्यकता नहीं है। यह भी मैनुअल छोरों की जरूरत नहीं है। यह हर मूल्य इंडेक्सऑफ () के साथ काम करता है (या स्पष्ट होने के लिए: सख्त तुलना ऑपरेटर ) का समर्थन करता है।

की वजह से कम हो () और indexOf () यह कम से कम आईई 9 की जरूरत है।

Comments

ES6 तीर / सरल / शुद्ध संस्करण:const dupes = items.reduce((acc, v, i, arr) => arr.indexOf(v) !== i && acc.indexOf(v) === -1 ? acc.concat(v) : acc, [])

— ZephDavies

Answer 5

आप इस फ़ंक्शन को जोड़ सकते हैं, या इसे घुमा सकते हैं और इसे जावास्क्रिप्ट के ऐरे प्रोटोटाइप में जोड़ सकते हैं:

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);

Comments

यह सबसे अच्छा समाधान है, लेकिन इसे सरणी प्रोटोटाइप में जोड़ने से सावधान रहें, क्योंकि यह आईई को गड़बड़ करेगा यदि मूल्यों के माध्यम से लूपिंग।

— सांपसा सुओनीन

@ रोयिन्कर पर्ल उन्हें भी समर्थन करता है, लेकिन मुझे नहीं पता था कि जावास्क्रिप्ट ने किया था

— ल्यूक एच

ओपी ने जो मांगा था, वह नहीं करता है, डुप्लिकेट वापस करें।

— RWC

Answer 6

अद्यतन: निम्नलिखित एक अनुकूलित संयुक्त रणनीति का उपयोग करता है। यह हैश ओ (1) लुकअप समय ( uniqueआदिम की एक सरणी पर चल रहा है ओ (एन)) से लाभ के लिए आदिम लुकअप को अनुकूलित करता है । ऑब्जेक्ट लुकअप को एक अद्वितीय आईडी के साथ ऑब्जेक्ट्स को टैग करके अनुकूलित किया जाता है, जबकि इसके माध्यम से पुनरावृति होती है ताकि डुप्लिकेट ऑब्जेक्ट की पहचान भी पूरी सूची के लिए O (1) प्रति आइटम और O (n) हो। एकमात्र अपवाद आइटम हैं जो जमे हुए हैं, लेकिन वे दुर्लभ हैं और एक सरणी और इंडेक्सऑफ का उपयोग करके एक कमबैक प्रदान किया जाता है।

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 संग्रह उपलब्ध हैं, तो एक बहुत सरल और काफी तेज संस्करण है। (यहाँ IE9 + और अन्य ब्राउज़रों के लिए शिम: https://github.com/Benvie/ES6-Harmony-Collections-Shim )

function unique(array){
  var seen = new Set;
  return array.filter(function(item){
    if (!seen.has(item)) {
      seen.add(item);
      return true;
    }
  });
}

Comments

वास्तव में? 2 साल पहले हल किए गए प्रश्न का उत्तर क्यों दें?

— रेने पॉट

मैं एक और सवाल का जवाब दे रहा था और जाहिरा तौर पर गलती से इस पर लिंक करने वाले किसी व्यक्ति पर क्लिक किया गया, इसे डुप्लिकेट कहा गया, और मेरे उत्तर का क्लोन बनाकर खुद को नरक से बाहर निकालने के लिए भ्रमित किया। मैं अपने सामान को बहुत संपादित करता हूं।

stackoverflow.com/questions/7683845/…

मुझे लगता है कि यह विभिन्न समाधानों के साथ अच्छा है। इससे कोई फर्क नहीं पड़ता कि विषय पुराना है और हल हो गया है क्योंकि ऐसा करने के विभिन्न तरीकों के साथ आना अभी भी संभव है। यह कंप्यूटर विज्ञान में एक विशिष्ट समस्या है।

— एमिल विकासस्ट्रम

आप यह उल्लेख करना चाहते हैं कि यह ES5 एरे तरीकों पर निर्भर करता है जो IE <9. में लागू नहीं होते हैं

— टिम डाउन

Answer 7

अपडेट: लघु डुप्लिकेट प्राप्त करने के लिए एक लाइनर:

[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 और नीचे के लिए काम नहीं करता है।

Comments

ओपी ने जो मांगा था, वह नहीं करता है, डुप्लिकेट वापस करें।

— RWC

सच है, मैंने अपने उत्तर को ठीक करने के लिए अद्यतन किया।

— लॉरेंट पायॉट

शाही हल! thnaks

— जेरेमी Piednoel

Answer 8

var a = ["a","a","b","c","c"];

a.filter(function(value,index,self){ return (self.indexOf(value) !== index )})

Comments

यह काम करने लगता है, लेकिन आपको संभवतः कुछ पाठों का वर्णन करना चाहिए कि यह कैसे काम करता है

— DIMM रीपर

डुप्लिकेट मान के 2 से अधिक होने पर काम नहीं करेंगे।

— वासा

यह सुरुचिपूर्ण और सरल है। मुझे यह पसंद है। यह जानने के लिए कि वे कैसे काम करते हैं, मैंने यह दिखाने के लिए एक डुप्लिकेट बनाया है कि कैसे डुप्लिकेट दिखाएं और डुप्लिकेट को समाप्त करें। यहां देखें: gist.github.com/jbcoder/f1c616a32ee4d642691792eebdc4257b

— Josh

@ TheDIMMR सस्ता दूसरे 'a'के लिए सरणी में, फिल्टर फ़ंक्शन के अंदर index == 1, जबकिself.indexOf('a') == 0

— सर्जियो ओस्ट्रोवस्की

Answer 9

यह आपको वही चाहिए जो आप चाहते हैं, बस डुप्लिकेट।

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.

Answer 10

अंडरस्कोर का उपयोग करना। js

function hasDuplicate(arr){
    return (arr.length != _.uniq(arr).length);
}

Answer 11

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;
  };
}

jAr समाधान "inArray" का उपयोग कर:

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

जोड़ने के बजाय Array.prototype.indexOf

Comments

+1 क्योंकि यह निश्चित रूप से Array.indexOf का उपयोग करके कोड अधिक पठनीय है, लेकिन दुर्भाग्य से यह एक साधारण नेस्टेड लूप का उपयोग करने की तुलना में धीमा लगता है। यहां तक ​​कि उन ब्राउज़रों पर भी, जो FF की तरह Array.indexOf को लागू करते हैं। Plz, इन परीक्षणों को मैंने यहाँ देखा है: jsperf.com/array-unique2 और मुझे अपने विचारों से अवगत कराएँ ।

— मार्को डेमायो

@shekhardesigner - अद्यतन उत्तर। "r" वह सरणी है जिसे आप खोजते हैं

— vsync

@vsync मुझे var r = [];आपका कोड काम करने के लिए इनिशियलाइज़ करना था। और आकर्षण की तरह काम किया।

— शेखर के। शर्मा

@ शेखरडिजाइनर - मुझे मिश्रण के लिए खेद है, ऐरे प्रोटोटाइप प्रोटोटाइप समाधान के लिए आपको एक rचर की आवश्यकता नहीं है

— vsync

ओपी ने जो मांगा था, वह नहीं करता है, डुप्लिकेट वापस करें।

— RWC

Answer 12

यहाँ मेरा सरल और एक लाइन समाधान है।

यह पहले अद्वितीय तत्वों को नहीं खोजता है, फिर सेट के उपयोग के साथ पाया गया सरणी को अद्वितीय बनाता है।

तो हम अंत में डुप्लिकेट की सरणी है।

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))]
);

Answer 13

यह मेरा प्रस्ताव (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]

Comments

यह रिपोर्ट करेगा कि एक एकल घटना undefinedएक डुप्लिकेट है।

— डेम पिलाफियन

@DemPilafian धन्यवाद, अद्यतन

— lukaszkups

Answer 14

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

Comments

फ़िल्टर फ़ंक्शन को सही या गलत लौटना चाहिए, न कि तत्व को। 0 वाले सरणी को फ़िल्टर करने से उन्हें वापस नहीं किया जाता।

— मफलोडिन

इसके अलावा, मुझे लगता i&&है कि यह सरणी की सीमा से बाहर जाने से बचने के लिए है, लेकिन इसका मतलब यह भी है कि सॉर्ट किए गए सरणी में पहला तत्व शामिल नहीं होगा। आपके उदाहरण 1में परिणामी सरणी में कोई नहीं है। Ie return i&&v!==o[i-1]?v:0;होना चाहिएreturn v!==o[i-1];

— mflodin

Answer 15

एस 6 ऑब्जेक्ट को नष्ट करने और कम करने का उपयोग करके तेज और सुरुचिपूर्ण तरीका

यह O (n) (सरणी पर 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']

Answer 16

यहाँ सबसे सरल उपाय है जिसके बारे में मैं सोच सकता हूँ:

    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 में एक ऑब्जेक्ट सेट है जो केवल अनन्य मान स्टोर कर सकता है)

उम्मीद है की यह मदद करेगा।

Answer 17

सबसे छोटा वेनिला JS :

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

Answer 18

यहाँ एक बहुत ही हल्का और आसान तरीका है:

var codes = dc_1.split(',');
var i = codes.length;
while (i--) {
  if (codes.indexOf(codes[i]) != i) {
    codes.splice(i,1);
  }
}

Comments

सबसे बढ़िया उत्तर। और अगर उपयोगकर्ता डुप्लिकेट तत्वों की सरणी चाहते हैं, तो इसके लिए मैंने @brandon कोड var i = code .length अपडेट किया है; var डुप्लिकेट = []; जबकि (i--) {if (कोड .indexOf (कोड [i]! = i)!} {अगर (डुप्लिकेट .indexOf (कोड [i]) === -1) {डुप्लिकेट। push (गिरफ्तार [i]) ; } कोड.प्लिसिस (i, 1); }}

— हिमांशु शेखर

Answer 19

ES6 के साथ (या बैबल या टाइप्सप्लेट का उपयोग करके) आप बस कर सकते हैं:

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

https://es6console.com/j58euhbt/

Comments

मैं स्वतंत्र रूप से एक ही वाक्यविन्यास पर आया था, और जब मुझे यह मिला तो समाधान के रूप में जोड़ना था। यह शायद सबसे किफायती नहीं है, लेकिन यह सरल है।

— Nize

Answer 20

ईएस 6 सिंटैक्स के साथ सरल कोड (डुप्लिकेट के क्रमबद्ध सरणी):

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]);

Comments

.filter () बहुत सरल होगा

— टोकेविले

Answer 21

एक लाइन

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

Comments

indx!पहले उदाहरण के लिए क्या करता है?

— Saylestyler

@ सयैस्टाइलर हे, इसका मतलब है indx !== ...- सख्त असमानता।

— डारिया

केवल वस्तुओं की सरणी के लिए जोड़नाresult.filter((ele,indx) => indx !== result.map(e => e.name).indexOf(ele.name));

— x-magix

Answer 22

यह उत्तर भी सहायक हो सकता है, यह सरणी से डुप्लिकेट को निकालने के लिए js reduce ऑपरेटर / विधि का लाभ उठाता है ।

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

console.log(result);

Comments

अब हम केवल new Set([1, 2, 2, 3, 3, 3, 3])डुप्लिकेट को हटाने के लिए कर सकते हैं

— किंबाउदी

Answer 23

निम्न कार्य (पहले से बताए गए कार्य को खत्म करने का कार्य भिन्नता) लगता है कि इनपुट के लिए टेस्ट 2,1,7,5 लौट रहा है ["टेस्ट", "टेस्ट 2", "टेस्ट 2", 1, 1, 1, 2 , 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;
}

Answer 24

ईएस 5 केवल (यानी, इसे IE8 और उससे नीचे के लिए एक फिल्टर () पॉलीफिल की आवश्यकता है):

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] );
    });

Comments

मुझे यह सरल उपाय पसंद है। यदि आप डुप्लिकेट चाहते हैं, हालांकि, आपको पहले उन डुप्लिकेट को खोजने की आवश्यकता है, और फिर डुप्लिकेट सूची को अद्वितीय बनाएं। [०, ४, ५, ५, ५, २, १, ३, १, १, २, १, ३] () () फिल्टर (फ़ंक्शन (मुझे, मैं, गिरफ्तार) {वापसी (आई! = ०) ) && (me == गिरफ्तारी [i-1]);})। फ़िल्टर (फ़ंक्शन (मुझे, i, गिरफ्तार) {वापसी (i === 0) || || (me! == arr [i-1] || ;});

— ग्रेग

Answer 25

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));

यह फ़ंक्शन सॉर्टिंग चरण से बचता है और डुप्लिकेट को नए सरणी में धकेलने के लिए कम () पद्धति का उपयोग करता है यदि यह पहले से मौजूद नहीं है।

Answer 26

यह संभवतः यहां सबसे अधिक कार्यों की तुलना में किसी सरणी से 10x गुना तेजी से डुप्लिकेट को स्थायी रूप से हटाने का सबसे तेज़ तरीका है। और सफारी में 78x तेज़ी से।

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

संपादित करें जैसा कि टिप्पणियों में कहा गया है कि यह फ़ंक्शन एक सरणी को uniques के साथ लौटाता है, सवाल हालांकि डुप्लिकेट खोजने के लिए कहता है। उस स्थिति में इस फ़ंक्शन के लिए एक सरल संशोधन डुप्लिकेट को एक सरणी में धकेलने की अनुमति देता है, फिर पिछले फ़ंक्शन का उपयोग करके 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));

Comments

"यदि आप ऊपर दिए गए कोड को नहीं पूछ सकते हैं, तो एक जावास्क्रिप्ट पुस्तक पढ़ें" इस उत्तर में पूरी तरह से बहुत कोड गोल्फ है। एक, बी, सी जैसी चर चीजों का नामकरण कोड को पढ़ना मुश्किल बनाता है। घुंघराले ब्रेसिज़ के लिए यह और भी बदतर बना देता है।

— नदी विलियमसन

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

— cocco

आपके कोड में तकनीकी रूप से कुछ भी गलत नहीं है। उस ने कहा, चर, ए, बी, सी, डी, आदि का नामकरण और लूपिंग करते समय कोड को पढ़ना मुश्किल बना देता है। इसलिए, कोड कुछ भी सिखाने में विफल रहता है।

— नदी विलियमसन

Answer 27

यदि तत्व पहले से मौजूद है, तो परीक्षण के लिए "शामिल" का उपयोग करना।

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>

Comments

कोड अलग-अलग तत्व देता है, लेकिन दिए गए परिणाम की ओर नहीं जाता है। कृपया पूर्ण सही कोड प्रदान करें।

— RWC

Answer 28

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;
}

Answer 29

मैंने अभी एक ऐरे फिल्टर का उपयोग करके इसे प्राप्त करने का एक सरल तरीका निकाला है

    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);

Answer 30

निम्नलिखित तर्क आसान और तेज होगा

// @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. सिंगल लाइन :-P
2. दक्षता को बेहतर बनाने में मदद करने वाली सभी इनबिल्ट डेटा संरचना
3. और तेज

तर्क का विवरण:

1. सभी डुप्लिकेट को निकालने के लिए सेट करने के लिए परिवर्तित
2. निर्धारित मूल्यों के माध्यम से परिवर्तन
3. शर्त के लिए स्रोत सरणी में प्रत्येक सेट मान चेक के साथ "मान पहले सूचकांक पिछले सूचकांक के बराबर नहीं है" ==> फिर डुप्लिकेट के रूप में अनुमान लगाया गया कि यह 'अद्वितीय' है

नोट: मानचित्र () और फ़िल्टर () विधियाँ कुशल और तेज़ हैं।

Comments

यह परीक्षण किया ... बहुत तेज। और यह समझ में आता है .. काश मैं इसके बारे में सोचा

— माइकल Rhema