Проверьте, содержит ли массив повторяющиеся значения

Ответ 1

Вы получили неправильные обратные значения:

• Как только вы найдете два значения, которые равны, вы можете сделать вывод, что массив не уникален и возвращает false.

• В самом конце, после того, как вы проверили все пары, вы можете вернуть true.

Если вы делаете это много, а массивы большие, вы можете изучить возможность сортировки массива, а затем только сравнение соседних элементов. Это будет иметь лучшую асимптотическую сложность, чем ваш текущий метод.

Ответ 2

Простое решение, если у вас есть ES6, использует Set:

function checkIfArrayIsUnique(myArray) {
  return myArray.length === new Set(myArray).size;
}

Ответ 3

Это должно работать только с одним циклом:

function checkIfArrayIsUnique(arr) {
    var map = {}, i, size;

    for (i = 0, size = arr.length; i < size; i++){
        if (map[arr[i]]){
            return false;
        }

        map[arr[i]] = true;
    }

    return true;
}

Ответ 4

Предполагая, что вы нацеливаете браузеры, которые не являются IE8,

это тоже сработает:

function checkIfArrayIsUnique(myArray) 
{
    for (var i = 0; i < myArray.length; i++) 
    {
        if (myArray.indexOf(myArray[i]) !== myArray.lastIndexOf(myArray[i])) { 
            return false; 
        } 
    } 
    return true;   // this means not unique
}

Ответ 5

Лучшее решение когда-либо.

 Array.prototype.checkIfArrayIsUnique = function() {
    this.sort();    
    for ( var i = 1; i < this.length; i++ ){
        if(this[i-1] == this[i])
            return false;
    }
    return true;
    }

Ответ 6

let a = [11,22,11,22];


let hasDup = a.some((val,i)=>{
  return a.indexOf(val)!=i
})
// hasDup = true

True → массив имеет дубликаты

False → uniqe array

Ответ 7

function hasNoDuplicates(arr) { return arr.every(num => arr.indexOf(num) === arr.lastIndexOf(num)); }

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

Ответ 8

Здесь O (n) решение:

function hasDupes(arr) {
  /* temporary object */
  var uniqOb = {};
  /* create object attribute with name=value in array, this will not keep dupes*/
  for (var i in arr)
    uniqOb[arr[i]] = "";
  /* if object attributes match array, then no dupes! */
  if (arr.length == Object.keys(uniqOb).length)
    alert('NO dupes');
  else
    alert('HAS dupes');


}
var arr = ["1/1/2016", "1/1/2016", "2/1/2016"];
hasDupes(arr);

https://jsfiddle.net/7kkgy1j3/

Ответ 9

Без for loop, только using Map().

Вы также можете вернуть дубликаты.

(function(a){
  let map = new Map();

  a.forEach(e => {
    if(map.has(e)) {
      let count = map.get(e);
      console.log(count)
      map.set(e, count + 1);
    } else {
      map.set(e, 1);
    }
  });

  let hasDup = false;
  let dups = [];
  map.forEach((value, key) => {
    if(value > 1) {
      hasDup = true;
      dups.push(key);
    }
  });
   console.log(dups);
   return hasDup;
 })([2,4,6,2,1,4]);

Ответ 10

Написал это для инициализации нового массива длины uniqueIndexCount. Здесь представлена минус несвязанная логика.

    public Vector3[] StandardizeVertices(Vector3[] dimensions, int standard)
    {
        //determine the number of unique dimension vectors
        int uniqueIndexCount = 0;
        for (int a=0; a < dimensions.Length; ++a)
        {
            int duplicateIndexCount = 0;
            for (int b = a; b < dimensions.Length; ++b)
            {
                if(a!=b && dimensions[a] == dimensions[b])
                {
                    duplicateIndexCount++;
                }
            }
            if (duplicateIndexCount == 0)
            {
                uniqueIndexCount++;
            }
        }
        Debug.Log("uniqueIndexCount: "+uniqueIndexCount);
        return dimensions;
    }

Ответ 11

function checkIfArrayIsUnique(myArray) 
    {
      isUnique=true

        for (var i = 0; i < myArray.length; i++) 
        {
            for (var j = 0; j < myArray.length; j++) 
            {
                if (i != j) 
                {
                    if (myArray[i] == myArray[j]) 
                    {
                        isUnique=false
                    }
                }
            }
        }
        return isUnique;
    }

Предположим, что массив уникален в начале.

Если найти два значения равно, измените на false

Ответ 12

Код, заданный в вопросе, может быть лучше написан следующим образом

function checkIfArrayIsUnique(myArray) 
    {
        for (var i = 0; i < myArray.length; i++) 
        {
            for (var j = i+1; j < myArray.length; j++) 
            {                  
                    if (myArray[i] == myArray[j]) 
                    {
                        return true; // means there are duplicate values
                    }

            }
        }
        return false; // means there are no duplicate values.
    }

Ответ 13

Возвращает повторяющийся элемент в массиве и создает новый массив без дубликатов:

 var a = ["hello", "hi", "hi", "juice", "juice", "test"];
    var b = ["ding", "dong", "hi", "juice", "juice", "test"];
    var c = a.concat(b);
    var dupClearArr = [];

    function dupArray(arr) {

        for (i = 0; i < arr.length; i++) {
            if (arr.indexOf(arr[i]) != i && arr.indexOf(arr[i]) != -1) {
                console.log('duplicate item ' + arr[i]);
            } else {
                dupClearArr.push(arr[i])
            }

        }
        console.log('actual array \n' + arr + ' \nno duplicate items array \n' + dupClearArr)
    }

    dupArray(c);

Ответ 14

Поздний ответ, но может быть полезным

function areThereDuplicates(args) {

    let count = {};
    for(let i = 0; i < args.length; i++){
         count[args[i]] = 1 + (count[args[i]] || 0);
    }
    let found = Object.keys(count).filter(function(key) {
        return count[key] > 1;
    });
    return found.length ? true : false; 
}

areThereDuplicates([1,2,5]);