Недавно я увидел этот код Javascript в StackOverflow для объединения двух массивов и удаления дубликатов:

Array.prototype.unique = function() {
    var a = this.concat();
    for(var i=0; i<a.length; ++i) {
        for(var j=i+1; j<a.length; ++j) {
            if(a[i] === a[j])
                a.splice(j--, 1);
        }
    }
    return a;
};

var array1 = ["Vijendra","Singh"];
var array2 = ["Singh", "Shakya"];
var array3 = array1.concat(array2).unique(); 

Хотя этот код работает, он ужасно неэффективен ( O(n^2)). Ваша задача - создать алгоритм с меньшей сложностью.

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

Требования :

Упакуйте весь ваш код в функцию, которая отвечает следующим требованиям «правильности»:

• Вход: два массива
• Выход: один массив
• Объединяет элементы обоих массивов вместе. Любой элемент в любом входном массиве должен быть в выходном массиве.
• Выводимый массив не должен иметь дубликатов.
• Заказ не имеет значения (в отличие от оригинала)
• Любой язык имеет значение
• Не используйте функции массивов стандартной библиотеки для обнаружения уникальности или объединения наборов / массивов (хотя в стандартной библиотеке все в порядке). Позвольте мне сделать различие, что конкатенация массива - это хорошо, но функции, которые уже выполняют все вышеперечисленное, - нет.

Perl

27 персонажей

Простой Perl Hack

my @vals = ();
push @vals, @arr1, @arr2;
my %out;
map { $out{$_}++ } @vals;
my @unique = keys %out;

Я уверен, что кто-то мог бы это сделать одним ударом ... и, таким образом (спасибо Dom Hastings)

sub x{$_{$_}++for@_;keys%_}

JavaScript O (N) 131 124 116 92 (86?)

Гольф версия:

function m(i,x){h={};n=[];for(a=2;a--;i=x)i.map(function(b){h[b]=h[b]||n.push(b)});return n}

Читаемая человеком версия для гольфа:

function m(i,x) {
   h = {}
   n = []
   for (a = 2; a--; i=x)
      i.map(function(b){
        h[b] = h[b] || n.push(b)
      })
   return n
}

Я мог бы использовать concatтак и сделать это в 86 символов:

function m(i,x){h={};n=[];i.concat(x).map(function(b){h[b]=h[b]||n.push(b)});return n}

Но я не уверен, что это все еще O (N) на основе этого JsPerf: http://jsperf.com/unique-array-merging-concat-vs-looping, так как версия concat немного быстрее с меньшими массивами, но медленнее с большие массивы (Chrome 31 OSX).

На практике сделайте это (в гольфе полно плохих практик):

function merge(a1, a2) {
   var hash = {};
   var arr = [];
   for (var i = 0; i < a1.length; i++) {
      if (hash[a1[i]] !== true) {
        hash[a1[i]] = true;
        arr[arr.length] = a1[i];
      }
   }
   for (var i = 0; i < a2.length; i++) {
      if (hash[a2[i]] !== true) {
        hash[a2[i]] = true;
        arr[arr.length] = a2[i];
      }
   }
   return arr;
}
console.log(merge([1,2,3,4,5],[1,2,3,4,5,6]));

Я не очень хорош в вычислительной сложности, но я верю, что это так O(N). Хотелось бы, чтобы кто-то мог уточнить.

Редактировать: вот версия, которая принимает любое количество массивов и объединяет их.

function merge() {
   var args = arguments;
   var hash = {};
   var arr = [];
   for (var i = 0; i < args.length; i++) {
      for (var j = 0; j < args[i].length; j++) {
        if (hash[args[i][j]] !== true) {
          arr[arr.length] = args[i][j];
          hash[args[i][j]] = true;
        }
      }
    }
   return arr;
}
console.log(merge([1,2,3,4,5],[1,2,3,4,5,6],[1,2,3,4,5,6,7],[1,2,3,4,5,6,7,8]));

Python 2.7, 38 символов

F=lambda x,y:{c:1 for c in x+y}.keys()

Должно быть O (N) при условии хорошей хеш-функции.

setРеализация 8-ми символов в Wasi лучше, если вы не думаете, что это нарушает правила.

PHP, 69/42 68/41 символов

В том числе объявление функции составляет 68 символов:

function m($a,$b){return array_keys(array_flip($a)+array_flip($b));}

Не включая объявление функции 41 символа:

array_keys(array_flip($a)+array_flip($b))

Один путь в Руби

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

merged_arr = {}.tap { |hash| (arr1 + arr2).each { |el| hash[el] ||= el } }.keys

По сути, это шаги, которые я прохожу в строке выше.

1. Определите переменную, merged_arrкоторая будет содержать результат
2. Инициализируйте пустой неназванный хеш как посредника, чтобы поместить уникальные элементы в
3. Используется Object#tapдля заполнения хеша (на который ссылается как hashв tapблоке) и возврата его для последующего объединения методов
4. Объединить arr1и arr2в один необработанный массив
5. Для каждого элемента elв каскадном массиве, поместить значение elв , hash[el]если значения в hash[el]настоящее время не существует. Запоминание здесь ( hash[el] ||= el) - это то, что обеспечивает уникальность элементов.
6. Получите ключи (или значения, поскольку они одинаковы) для теперь заполненного хеша

Это должно бежать O(n)вовремя. Пожалуйста, дайте мне знать, если я сделал какие-либо неточные утверждения или смогу ли я улучшить ответ выше для эффективности или удобочитаемости.

Возможные улучшения

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

merged_arr = {}.tap { |hash| (arr1 + arr2).each { |el| hash[el] = 1 } }.keys

Я действительно люблю Object#tap, но мы можем достичь того же результата, используя Enumerable#reduce:

merged_arr = (arr1 + arr2).reduce({}) { |arr, val| arr[val] = 1; arr }.keys

Вы могли бы даже использовать Enumberable#map:

merged_arr = Hash[(arr1 + arr2).map { |val| [val, 1] }].keys

Как бы я это делал на практике

Сказав все это, если бы меня попросили объединить два массива arr1и arr2таким образом, что результат merged_arrимеет уникальные элементы и могут использовать любой метод Ruby , в моем распоряжении, я бы просто использовать оператор набора накидной , который предназначен для решения этой точной задачи:

merged_arr = arr1 | arr2

Быстрый взгляд на источник Array#|, тем не менее, подтверждает, что использование хэша в качестве посредника кажется приемлемым решением для выполнения уникального слияния двух массивов.

Array.prototype.unique = function()
{
  var o = {},i = this.length
  while(i--)o[this[i]]=true
  return Object.keys(o)
}

Функция, которая будет принимать n массивов, может быть следующей:

function m()
{
  var o={},a=arguments,c=a.length,i;
  while(c--){i=a[c].length;while(i--)o[a[c][i]] = true} 
  return Object.keys(o);
}

Гольф, я думаю, это должно работать (117 символов)

function m(){var o={},a=arguments,c=a.length,i;while(c--){i=a[c].length;while(i--)o[a[c][i]]=1}return Object.keys(o)}

Обновление Если вы хотите сохранить исходный тип, вы можете

function m()
{
  var o={},a=arguments,c=a.length,f=[],g=[];
  while(c--)g.concat(a[c])
  c = g.length      
  while(c--){if(!o[g[c]]){o[g[c]]=1;f.push(g[c])}}
  return f
}

или игра в гольф 149:

function m(){var o={},a=arguments,c=a.length,f=[],g=[];while(c--)g.concat(a[c]);c= g.length;while(c--){if(!o[g[c]]){o[g[c]]=1;f.push(g[c])}}return f}

Это все еще может вызвать некоторые сомнения, если вы хотите различить, 123и '123'это не будет работать ..

питон, 46

def A(a,b):print[i for i in b if i not in a]+a

Или просто используя операцию set

питона, 8

set(a+b)

Perl

23 байта, если мы только посчитаем кодовый блок внутри подпрограммы. Может быть 21, если разрешена перезапись глобальных значений (это приведет к удалению myиз кода). Он возвращает элементы в случайном порядке, потому что порядок не имеет значения. Что касается сложности, то в среднем это O (N) (зависит от количества коллизий хэшей, но они довольно редки - в худшем случае это может быть O (N ² ) (но этого не должно быть, потому что Perl может обнаруживать патологические хэши и изменяет начальное значение хэш-функции при обнаружении такого поведения)).

use 5.010;
sub unique{
    my%a=map{$_,1}@_;keys%a
}
my @a1 = (1, 2, 3, 4);
my @a2 = (3, 4, 5, 6);
say join " ", unique @a1, @a2;

Вывод (также показывает случайность):

/tmp $ perl unique.pl 
2 3 4 6 1 5
/tmp $ perl unique.pl 
5 4 6 2 1 3

Фортран: 282 252 233 213

Гольф версия:

function f(a,b,m,n) result(d);integer::m,n,a(m),b(n),c(m+n);integer,allocatable::d(:);j=m+1;c(1:m)=a(1:m);do i=1,n;if(.not.any(b(i)==c(1:m)))then;c(j)=b(i);j=j+1;endif;enddo;allocate(d(j-1));d=c(1:j-1);endfunction

Который не только выглядит бесконечно лучше, но и на самом деле будет компилировать (слишком длинная строка в форме для гольфа) с удобочитаемой формой:

function f(a,b,m,n) result(d)
  integer::m,n,a(m),b(n),c(m+n)
  integer,allocatable::d(:)
  j=m+1;c(1:m)=a(1:m)
  do i=1,n
     if(.not.any(b(i)==c(1:m)))then
        c(j)=b(i);j=j+1
     endif
  enddo
  allocate(d(j-1))
  d=c(1:j-1)
end function

Это должно быть , O(n)как я копирую aв , cа затем проверить каждый bпротив всех c. Последний шаг - удалить мусор, который cбудет содержаться, поскольку он не инициализирован.

Mathematica 10 символов

Union[a,b]

Пример:

a={1,2,3,4,5};
b={1,2,3,4,5,6};
Union[a,b]

{1, 2, 3, 4, 5, 6}

Mathematica2 43 символа

Sort@Join[a, b] //. {a___, b_, b_, c___} :> {a, b, c}

Javascript 86

Гольф версия:

function m(a,b){var h={};return a.concat(b).filter(function(v){return h[v]?0:h[v]=1})}

Читаемая версия:

function merge(a, b) {
  var hash = {};
  return a.concat(b).filter(function (val) {
    return hash[val] ? 0 : hash[val] = 1;
  });
}

JavaScript 60

Я использую генератор ES6.
Следующее можно проверить с помощью Google Traceur REPL .

m=(i,j)=>{h={};return[for(x of i.concat(j))if(!h[x])h[x]=x]}

Если вы ищете эффективную реализацию на основе JavaScript, основанную на базовых объектах, лежащих в основе фреймворка, я бы просто использовал Set. Обычно в реализации объект Set по своей сути обрабатывает уникальные объекты во время вставки с помощью своего рода индексации двоичного поиска. Я знаю, что в Java это log(n)поиск, использующий бинарный поиск, основанный на том факте, что ни один набор не может содержать один объект более одного раза.

Хотя я понятия не имею, верно ли это и для Javascript, для n*log(n)реализации может быть достаточно чего-то простого, например, следующего фрагмента :

JavaScript , 61 байт

var s = new Set(a);      // Complexity O(a.length)
b.forEach(function(e) {  // Complexity O(b.length) * O(s.add())
  s.add(e);
}); 

Попробуйте онлайн!

Если приведенный выше фрагмент использует a = [1,2,3]и b = [1,2,3,4,5,6]затем s=[1,2,3,4,5,6].

Если вы знаете , сложность Set.add(Object)функции в JavaScript , дайте мне знать, сложность этого , n + n * f(O)где f(O)есть сложность s.add(O).

APL (Dyalog Unicode) , O (N), 28 байт

Анонимная функция молчаливого инфикса.

(⊢(/⍨)⍳∘≢=⍳⍨),

Попробуйте онлайн!

, объединить аргументы; НА)

(… ) Примените к нему следующую анонимную молчаливую функцию; O (1)

   ⍳⍨ индексы селфи (индексы первого появления каждого элемента во всем массиве); НА)

  = сравнить элемент за элементом с; НА):

   ⍳∘≢ индексы длины массива; НА)

 (/⍨) используйте это для фильтрации; НА):

  ⊢ неизмененный аргумент; O (1)

O (N + 1 + N + N + N + N + 1) = O (N)

JavaScript, 131 символ

var array1 = ["Vijendra","Singh"];   
var array2 = ["Singh", "Shakya"];     
result = Array.from(new Set([...array1, ...array2]))

PHP около 28 символов [исключая переменные массива и переменную результата].

$ array1 = array (1, 2, 3); $ array2 = array (3, 4, 5);

$ result = array_merge ($ array1, $ array2);