ฉันเพิ่งเห็นรหัส 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 ง่าย

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

รุ่น Golfed:

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}

รุ่น golfed ที่มนุษย์อ่านได้:

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#|ดูเหมือนว่าจะยืนยันว่าการใช้แฮชเป็นตัวกลางดูเหมือนจะเป็นวิธีการแก้ปัญหาที่ยอมรับได้ในการดำเนินการผสานที่ไม่ซ้ำกันระหว่าง 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
}

หรือ golfed 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

หรือใช้การตั้งค่าแบบง่ายๆ

หลาม 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

Fortran: 282 252 233 213

รุ่น Golfed:

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 Chars

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

Javascript 86

รุ่น Golfed:

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
ต่อไปนี้คือทดสอบโดยใช้Traceur REPL

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

หากคุณกำลังมองหาการติดตั้งบนจาวาสคริปต์ที่อาศัยออบเจ็กต์ต้นแบบที่อยู่เบื้องหลังกรอบการทำงานที่มีประสิทธิภาพฉันจะใช้ 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)

   ⍳⍨ ดัชนี selfie (ดัชนีของการเกิดขึ้นครั้งแรกของแต่ละองค์ประกอบในอาร์เรย์ทั้งหมด); บน)

  = เปรียบเทียบองค์ประกอบตามองค์ประกอบกับ; บน):

   ⍳∘≢ ดัชนีของความยาวของอาร์เรย์ บน)

 (/⍨) ใช้สิ่งนั้นเพื่อกรอง บน):

  ⊢ อาร์กิวเมนต์ที่ไม่ได้แก้ไข 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 = อาร์เรย์ (1, 2, 3); $ array2 = อาร์เรย์ (3, 4, 5);

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