Получить все неуникальные значения (т.е. дубликаты / более одного вхождения) в массиве

scanf не будет потреблять\n, поэтому он будет приниматься с помощью gets, следующего за scanf. запустите поток ввода после scanf, как это.

#include <stdlib.h>
#include <string.h>

int main(void) {
   int a;
   char b[20];

   printf("Input your ID: ");
   scanf("%d", &a);
   fflush(stdin);
   printf("Input your name: ");
   gets(b);   

   printf("---------");

   printf("Name: %s", b);   

   system("pause");
   return 0;
}
379
задан Samuel Liew 15 November 2017 в 10:35
поделиться

24 ответа

Вы можете отсортировать массив, а затем просмотреть его и посмотреть, совпадает ли следующий (или предыдущий) индекс с текущим. Если у вас хороший алгоритм сортировки, он должен быть меньше O (n 2 ):

 var arr = [9, 9, 111, 2, 3, 4, 4, 5, 7]; вар sorted_arr = arr.slice (). sort (); // Здесь вы можете определить функцию сравнения. // JS по умолчанию использует дерьмовое сравнение строк. // (мы используем срез для клонирования массива, чтобы // исходный массив не изменялся) var results = []; for (var i = 0; i 

На тот случай, если вы должны вернуть как функцию для дубликатов. Это для случая аналогичного типа.

Ссылка: https: // stackoverflow. com / a / 57532964/8119511

281
ответ дан 22 November 2019 в 23:43
поделиться

Вот небольшой простой фрагмент, чтобы найти уникальные и повторяющиеся значения без сортировки и двух циклов.

var _unique = function (arr) {
    var h = [], t = [];
    arr.forEach(function (n) {
        if (h.indexOf(n) == -1)
            h.push(n);
        else t.push(n);
    });
    return [h, t];
}
var result = _unique(["test",1,4,2,34,6,21,3,4,"test","prince","th",34]);
console.log("Has duplicate values : " + (result[1].length > 0))  //and you can check count of duplicate values
console.log(result[0]) //unique values
console.log(result[1]) //duplicate values
0
ответ дан A.T. 15 November 2017 в 10:35
поделиться

//find duplicates:
//sort, then reduce - concat values equal previous element, skip others

//input
var a = [1, 2, 3, 1, 2, 1, 2]

//short version:
var duplicates = a.sort().reduce((d, v, i, a) => i && v === a[i - 1] ? d.concat(v) : d, [])
console.log(duplicates); //[1, 1, 2, 2]

//readable version:
var duplicates = a.sort().reduce((output, element, index, input) => {
  if ((index > 0) && (element === input[index - 1]))
    return output.concat(element)
  return output
}, [])
console.log(duplicates); //[1, 1, 2, 2]
1
ответ дан Afanasii Kurakin 15 November 2017 в 10:35
поделиться

Это одно из простых решений ES5, о которых я мог подумать -

function duplicates(arr) {
  var duplicatesArr = [],
      uniqueObj = {};

  for (var i = 0; i < arr.length; i++) {
    if( uniqueObj.hasOwnProperty(arr[i]) && duplicatesArr.indexOf( arr[i] ) === -1) {
      duplicatesArr.push( arr[i] );
    }
    else {
      uniqueObj[ arr[i] ] = true;
    }
  }

  return duplicatesArr;
}
/* Input Arr: [1,1,2,2,2,1,3,4,5,3] */
/* OutPut Arr: [1,2,3] */
1
ответ дан Debajit Majumder 15 November 2017 в 10:35
поделиться
var a= [1, 2,2,3,3,4,4,4];
var m=[];
var n = [];
a.forEach(function(e) {
  if(m.indexOf(e)=== -1) {
    m.push(e);
}else if(n.indexOf(e)=== -1){
    n.push(e);
}

});
-1
ответ дан santhosh 15 November 2017 в 10:35
поделиться

Быстрый и элегантный способ с использованием деструктуризации и уменьшения объектов es6.

. Он работает в 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']
5
ответ дан Javascript Lover - SKT 15 November 2017 в 10:35
поделиться
var input = ['a', 'b', 'a', 'c', 'c'],
    duplicates = [],
    i, j;
for (i = 0, j = input.length; i < j; i++) {
  if (duplicates.indexOf(input[i]) === -1 && input.indexOf(input[i], i+1) !== -1) {
    duplicates.push(input[i]);
  }
}

console.log(duplicates);
2
ответ дан Gajus 15 November 2017 в 10:35
поделиться

Следовать логике будет проще и быстрее

// @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. При каждой проверке заданного значения в исходном массиве выполняется условие «значения первого индекса не равны последнему индексу» ==> Затем выводится как дубликат, он является «уникальным»

Примечание: методы map () и filter () эффективны и быстрее.

3
ответ дан PranavKAndro 15 November 2017 в 10:35
поделиться

Использование «include» для проверки, если элемент уже существует.

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>
3
ответ дан Srichakradhar 15 November 2017 в 10:35
поделиться

Существует действительно простой способ решить это. Если Вы используете довольно новый 'Набор' команда JavaScript. Набор может взять массив в качестве ввода и вывода новый 'Набор', который только содержит уникальные значения. Тогда путем сравнения длины массива и свойства 'размера' набора Вы видите, отличаются ли они. Если они отличаются, это должно произойти из-за дублирующейся записи.

var array1 = ['value1','value2','value3','value1']; // contains duplicates
var array2 = ['value1','value2','value3','value4']; // unique values

console.log('array1 contains duplicates = ' + containsDuplicates(array1));
console.log('array2 contains duplicates = ' + containsDuplicates(array2));


function containsDuplicates(passedArray) {
  let mySet = new Set(passedArray);
  if (mySet.size !== passedArray.length) {
    return true;
  }
  return false;
}

при выполнении вышеупомянутого отрывка, Вы получите этот вывод.

array1 содержит дубликаты = верный

, array2 содержит дубликаты = ложь

0
ответ дан user3094826 4 November 2019 в 09:27
поделиться

Вот простое решение, о котором я мог думать:

    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 - Связанный вопрос: Добираются, все уникальные значения в массиве JavaScript (удалите дубликаты)

  2. , исходный массив arr сохраняется (filter возвраты новый массив вместо того, чтобы изменить оригинал)

  3. Эти filtered, массив содержит весь дубликаты; это может также содержать больше чем 1 то же значение (например, наш фильтрованный массив здесь [ 2, 2, 0, 0, -1, 'a', 'a' ])

  4. , Если Вы хотите добраться только [1 126] значения, которые дублированы (Вы не хотите иметь несколько дубликатов с тем же значением), можно использовать [...new Set(filtered)] (ES6 имеет объект Набор , который может сохранить только уникальные значения)

Hope, которой это помогает.

4
ответ дан 22 November 2019 в 23:43
поделиться

Этот ответ мог бы также быть полезным, он усиливает оператор/метод js reduce для удаления дубликаты от массива.

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

console.log(result);
3
ответ дан 22 November 2019 в 23:43
поделиться

Вы можете добавить эту функцию или настроить ее и добавить в прототип массива Javascript:

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);
30
ответ дан 22 November 2019 в 23:43
поделиться

Если вы хотите удалить дубликаты, попробуйте этот отличный решение:

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/

204
ответ дан 22 November 2019 в 23:43
поделиться

Следующая функция (вариант уже упомянутой функции excluDuplicates), похоже, помогает добиться цели, возвращая test2,1,7,5 для входных данных ["test", "test2", " test2 ", 1, 1, 1, 2, 3, 4, 5, 6, 7, 7, 10, 22, 43, 1, 5, 8]

Обратите внимание, что проблема в JavaScript более странная, чем в большинстве других языков, потому что массив JavaScript может содержать что угодно. Обратите внимание, что решениям, использующим сортировку, может потребоваться соответствующая функция сортировки - я еще не пробовал этот маршрут.

Эта конкретная реализация работает (по крайней мере) для строк и чисел.

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;
}
3
ответ дан 22 November 2019 в 23:43
поделиться

Просто чтобы добавить немного теории к вышесказанному.

Поиск дубликатов имеет нижнюю границу O (n * log (n) в модели сравнения. Итак, теоретически вы не можете сделать ничего лучше, чем сначала отсортировать, а затем пройти через список, последовательно удаляя любые найденные дубли.

Если вы хотите найти дубликаты за линейное (O (n)) ожидаемое время, вы можете хешировать каждый элемент списка; если есть столкновение, удалите / пометьте его как дубликат, и продолжаем.

2
ответ дан 22 November 2019 в 23:43
поделиться

Это должно дать вам то, что вы хотите, только дубликаты.

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.
17
ответ дан 22 November 2019 в 23:43
поделиться

Find unique values from 3 arrays (or more):

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],
    unique = arr.concat(arr2, arr3).unique();

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

Just a polyfill for array indexOf for old browsers:

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 solution using "inArray":

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

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

instead of adding the 'Array.prototype.indexOf'

6
ответ дан 22 November 2019 в 23:43
поделиться

В библиотеке Prototype есть функция uniq , которая возвращает массив без дубликатов. Но это только половина работы.

0
ответ дан 22 November 2019 в 23:43
поделиться

/ * Метод indexOf объекта Array полезен для сравнения элементов массива. IE - единственный крупный браузер, который изначально не поддерживает его, но его легко реализовать: * /

Array.prototype.indexOf= Array.prototype.indexOf || function(what, i){
    i= i || 0;
    var L= this.length;
    while(i<L){
        if(this[i]=== what) return i;
        ++i;
    }
    return -1;
}

function getarrayduplicates(arg){
    var itm, A= arg.slice(0, arg.length), dups= [];
    while(A.length){
        itm= A.shift();
        if(A.indexOf(itm)!= -1 && dups.indexOf(itm)== -1){
            dups[dups.length]= itm;
        }
    }
    return dups;
}

var a1 = [1, 22, 3, 2, 2, 3, 3, 4, 1, 22, 7, 8, 9];

alert (getarrayduplicates (a1));

Для очень больших массивов может быть быстрее удалять дубликаты из массива по мере их обнаружения, чтобы они больше не просматривались:

function getarrayduplicates(arg){
    var itm, A= arg.slice(0, arg.length), dups= [];
    while(A.length){
        itm= A.shift();
        if(A.indexOf(itm)!= -1){
            dups[dups.length]= itm;
            while(A.indexOf(itm)!= -1){
                A.splice(A.indexOf(itm), 1);
            }
        }
    }
    return dups;
}
0
ответ дан 22 November 2019 в 23:43
поделиться
var arr = ['a','b','c','a'];

arr.filter( (item , index ) => {  
console.log(item , index , arr.indexOf(item) , arr.indexOf( item ) == index);
return index == arr.indexOf(item)
 } );

enter image description here

-1
ответ дан 22 November 2019 в 23:43
поделиться

Можно использовать sort, filter и sets, чтобы сделать это.

var numbers = [1,2,3,4,5,6,7,8,1,2,3,4,5,3,3,4];
var numbersSorted = numbers.sort();
let result = numbers.filter((e, i) => numbers[i] == numbers[i+1]);
result = [...new Set(result)];
console.log(result);
0
ответ дан 22 November 2019 в 23:43
поделиться

Самый Короткий ванильный JS:

arr.filter((v,i,a) => a.indexOf(v) !== i) // [9, 4]
0
ответ дан 22 November 2019 в 23:43
поделиться
var array = ['a', 'b', 'c', 'a'];

function unique(array) {
    var unique_arr = [];
    array.forEach(function(i, e) {
        if (unique_arr.indexOf(i)===-1) unique_arr.push(i);
    });
    return unique_arr;
}
console.log(unique(array));
-1
ответ дан 22 November 2019 в 23:43
поделиться
Другие вопросы по тегам:

Похожие вопросы: