Испытание "Уникальные элементы"

ну типа k - это счетчик совпадений, если он равен 1, то текущее число попадает в “уникальность”. т.к. в цикле число само себя один раз прогоняет, то как минимум 1 точно будет.

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

спасибо)

Мне понравилось. Не додумался до сравнения первого и второго var. Гж

Мой вариантик. Просто что бы было))

var numbers = [1, 4, 5, 9, 2, 5, 1];
var uniqueNumbers = [];

for (var i = 0; i < numbers.length; i++) {
  var oops = 0;
  for (var j = 0; j < numbers.length; j++) {
    if (numbers[i] === numbers[j]) {oops++;}}    
  if (oops === 1) {uniqueNumbers.push(numbers[i]);}
}

Решила посредством отпиливания повторяющихся элементов. В консоли сработало, в минибраузере курса - выдаёт ошибку "Не удалось проинициализировать исходные переменные" (String). Что ему не нравится?

Сводка

var numbers = [1, 4, 5, 9, 2, 5, 1];

var findUnique = function (arr) {
var sorted = arr.sort();
for (var i = 0; i < sorted.length; i++) {
if (sorted[i] === sorted[i + 1]) {
delete sorted[i];
delete sorted[i + 1];
}
}
return sorted.filter(element => element !== null);
};

findUnique(numbers);

могу точно сказать, что из-за сортировки неверный порядок получился.
P.S. вкурил, я так понимаю у академии тут баг, uniqueNumbers должен всегда инициализироваться в начале в виде пустого массива. видимо по замыслу создателей нужно просто было push в него элементы.

вот так получше будет, но вариант не оптимальный через delete
let numbers = [1, 4, 5, 9, 2, 5, 1];
let uniqueNumbers = [];

const findUnique = arr => {
  let newArr = arr.slice();
  for (let i = 0; i < newArr.length; i++) {
    for (let j = i + 1; j < newArr.length; j++) {
      if (newArr[i] == newArr[j]) {
        delete newArr[i];
        delete newArr[j]
      }
    }
  }
  return newArr.filter(item => item != null);
};

uniqueNumbers = findUnique(numbers);
console.log(numbers);

У меня так получилось:

for (var i=0; i <= numbers.length-1; i++) {
  
 
    var swap = numbers[i];
    numbers[i] = '';

         if (numbers.indexOf(swap) === -1 ) {
           uniqueNumbers.push(swap);
 
   }
  numbers[i] = swap;
  
}

а вот мой вариант

var numbers = [1, 4, 5, 9, 2, 5, 1];
var uniqueNumbers = [];

var uniq = true;

for(var i = 0; i < numbers.length; i++) {
  
  for(var j = 0; j < numbers.length; j++) {
        if(i === j) {
            uniq = true;
          }
          else {
            if(numbers[i] === numbers[j]) {
              uniq = false;
              break
            } 
          }
    }
    
    if(uniq === true){  
      uniqueNumbers.push(numbers[i])
    }
}

Прямо как мой вариант. Только я не использовал лишнюю переменную number. Просто сравнивал numbers[i] c numbers[j].

var numbers = [1, 4, 5, 9, 2, 5, 1];
var uniqueNumbers = [];

for(var i=0; i<numbers.length; i++){
var n=0;
for(var j=0; j<numbers.length; j++){
if(numbers[i]===numbers[j]){
n++;
}
}
if(n===1){
uniqueNumbers.push(numbers[i]);
}
}
console.log(uniqueNumbers);

1 Симпатия

Мой вариант:

    var numbers = [1, 4, 5, 9, 2, 5, 1];
    var uniqueNumbers = [];
    var count = 0;

    for (var i = 0; i < numbers.length; i++) {
    for (var j = 0; j < numbers.length; j++) {
        if (numbers[j] == numbers[i]) {
            count += 1
        }
    }
    if (count == 1) {
        uniqueNumbers.push(numbers[i])
    }
    count = 0;
    }

У меня рабочий вариант вышел аналогичный, сначала пытался изобрести что то по аналогии с тем что было выше, но не получалось. В этом решении единственный вопрос относиться к эффективности, ведь если я не ошибаюсь indexOf работает как цикл, из за чего мы имеем решение через 3 цикла, что ресурсозатратнее чем через 2. (Возможно indexOf лучше оптимизирован, и тогда все мои рассуждения гроша ломанного не стоят, хз)

for(var i = 0; i <numbers.length; i++) { // перебираем массив
var unique = true; // cоздаем проверку уникальности
for (var j = 0; j <numbers.length ; j++) { //перебираем другие элементы
if (numbers[i] === numbers[j] && i != j) { // cравниваем на “неуникальность”
unique = false;}
}
if(unique) { // если уникально
uniqueNumbers.push(numbers[i]); // добавляем в массив
}
}

Мой вариант решения

uniqueNumbers = numbers.filter((a,_,arr)=>arr.indexOf(a)==arr.lastIndexOf(a));

Великолепно!

Вот такой вариант с indexOf

Сводка
var numbers = [1, 4, 5, 9, 2, 5, 1];
var uniqueNumbers = [];
var twinNumbersFirst = [];
var twinNumbersSecond = [];

for (var i = 0; i < numbers.length; i++) {
    if (twinNumbersFirst.indexOf(numbers[i]) == -1) {
      twinNumbersFirst.push(numbers[i]);
      console.log(twinNumbersFirst);
    } else {
      twinNumbersSecond.push(numbers[i]);
      console.log(twinNumbersSecond)
    } 
  } 
for (var j = 0; j < twinNumbersFirst.length; j++) {
  if (twinNumbersSecond.indexOf(twinNumbersFirst[j]) == -1) {
      uniqueNumbers.push(twinNumbersFirst[j]);
    } 
  } 
console.log(uniqueNumbers);

Кто может объяснить как работает этот вариант? Разве numbers[i] не будет всегда равен numbers[j]? Получается просто массив весь перепишется из одного в другой. Что я не понимаю?

Разобрался сам.
Но зачем таким образом код писать , не понимаю. Сразу не читабельно становится.

а если так?

Сводка

var numbers = [1, 4, 5, 9, 2, 5, 1];
var uniqueNumbers = [];

for (j = 0; j < numbers.length; j++) {
var count = 0;

for (var i = 0; i < numbers.length; i++) {
if (numbers[j] === numbers [i]) {
count++;
}
}

if (count === 1) uniqueNumbers.push(numbers[j]);

}

Отличное решение!