최근에 두 배열 을 병합 하고 중복을 제거하는 StackOverflow 에서이 Javascript 코드를 보았습니다 .

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)). 복잡성이 적은 알고리즘을 만드는 것이 과제입니다.

당첨 기준은 복잡성 이 가장 적은 솔루션 이지만 문자의 길이가 가장 짧아서 관련성이 떨어집니다.

요구 사항 :

다음 "정확성"요구 사항을 충족하는 함수로 모든 코드를 함께 패키지하십시오.

• 입력 : 2 개의 배열
• 출력 : 하나의 배열
• 두 배열의 요소를 함께 병합-입력 배열의 모든 요소는 출력 배열에 있어야합니다.
• 출력 된 배열에는 중복이 없어야합니다.
• 순서는 중요하지 않습니다 (원래와 달리)
• 모든 언어 수
• 고유성을 감지하거나 세트 / 배열을 병합하기 위해 표준 라이브러리의 배열 함수를 사용하지 마십시오 (표준 라이브러리의 다른 항목은 괜찮음). 배열 연결은 훌륭하지만 위의 모든 기능을 수행하는 기능은 그렇지 않다는 점을 구별하겠습니다.

펄

27 자

간단한 펄 해킹

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

누군가가 이것을 한 줄로 확신 할 수 있다고 확신합니다. 따라서 (Dom Hastings에게 감사드립니다)

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

자바 스크립트 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}

:이 JsPerf에 따라 여전히 O (N) 인 경우 그러나 나는 확실하지 않다 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]));

파이썬 2.7, 38 자

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

좋은 해시 함수를 가정하면 O (N)이어야합니다.

set규칙을 위반한다고 생각하지 않으면 Wasi의 8 자 구현이 더 좋습니다.

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독특한 요소를 가지고 내 처분에 어떤 루비 방법을 사용할 수 있습니다, 나는 단순히이 정확한 문제를 해결하기위한 것입니다 합집합 연산자를 사용합니다 :

merged_arr = arr1 | arr2

Array#|그러나 의 소스를 빠르게 살펴보면 해시를 중개자로 사용하는 것이 2 개의 배열 사이에서 고유 한 병합을 수행하는 데 적합한 솔루션 인 것으로 보입니다.

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)

펄

서브 루틴 내부의 코드 블록 만 계산하는 경우 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는 초기화되지 않았으므로 포함될 가비지를 제거하는 것입니다.

매스 매 티카 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}

자바 스크립트 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;
  });
}

자바 스크립트 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 개체는 본질적으로 일종의 이진 검색 인덱싱을 사용하여 삽입하는 동안 고유 한 개체를 처리합니다. 나는 자바에서 그것을 알고있다.log(n) 단일 객체를 두 번 이상 포함 할 수 없다는 사실에 따라 이진 검색을 사용하여 검색 있습니다.

Javascript에서도 이것이 사실인지는 모르겠지만 다음 스 니펫과 같은 간단한 것이 n*log(n)구현에 충분할 수 있습니다 .

자바 스크립트 , 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)자바 스크립트의 기능을 알려, 이러한 복잡성은 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)

자바 스크립트, 131 자

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

배열 변수와 결과 변수 예제를 제외한 PHP 약 28 자.

$ array1 = 배열 ​​(1, 2, 3); $ array2 = 배열 ​​(3, 4, 5);

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