डुप्लिकेट के बिना ऐरे मर्ज

Question

मैंने हाल ही में इस जावास्क्रिप्ट कोड को 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)) है। आपकी चुनौती कम जटिलता के साथ एक एल्गोरिथ्म बनाने की है।

जीतने के मापदंड कम से कम जटिलता के साथ समाधान है , लेकिन पात्रों में सबसे कम लंबाई से संबंधों को तोड़ दिया जाएगा।

आवश्यकताएँ :

किसी फ़ंक्शन में अपने सभी कोड को एक साथ पैकेज करें जो "शुद्धता:" के लिए निम्नलिखित आवश्यकताओं को पूरा करता है।

• इनपुट: दो सरणियाँ
• आउटपुट: एक सरणी
• दोनों सरणियों के तत्वों को एक साथ जोड़ता है- इनपुट ऐरे में कोई भी तत्व आउटपुटेड ऐरे में होना चाहिए।
• आउटपुट सरणी में कोई डुप्लिकेट नहीं होना चाहिए।
• आदेश कोई फर्क नहीं पड़ता (मूल के विपरीत)
• कोई भी भाषा मायने रखती है
• विशिष्टता का पता लगाने या सेट / सरणियों का पता लगाने के लिए मानक लाइब्रेरी के सरणी फ़ंक्शंस का उपयोग न करें (हालांकि मानक लाइब्रेरी से अन्य चीजें ठीक हैं)। मुझे इस बात से अवगत कराएं कि ऐरे का कॉन्सेप्ट ठीक है, लेकिन फ़ंक्शंस जो पहले से ही उपरोक्त सभी करते हैं, वे नहीं हैं।

Comments

हम सरणी कार्यों का उपयोग किए बिना किसी सरणी में कैसे बना या जोड़ सकते हैं?

— एमिल विक्रोत्तम

@ EmilVikström मेरा संपादन देखें मेरा मतलब था कि आप सरणी विशिष्टता कार्यों का उपयोग नहीं कर सकते। अस्पष्ट होने के लिए क्षमा करें।

— 1

यदि इसमें से एक सरणियों में डुप्लिकेट हैं, तो क्या हम उन्हें भी हटा दें? उदाहरण के लिए, विलय [1, 2, 2, 3]और [2, 3, 4]वापस लौटना चाहिए [1, 2, 2, 3, 4]या [1, 2, 3, 4]?

— OI

@ ओआई, हाँ, यह बहुत आसान बना देगा।

— 1

क्या मैं पूछ सकता हूं: क्या है ? क्या हम केवल पूर्णांक या तार मान सकते हैं, या क्या हमें बहुस्तरीय वस्तुओं की तरह अधिक जटिल चीजों की अनुमति भी देनी होगी?

— jawns317

Answer 1

पर्ल

27 वर्ण

सरल पर्ल हैक

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

मुझे यकीन है कि कोई इसे एक-लाइनर कर सकता है .. और इस तरह (धन्यवाद डोम हेस्टिंग्स)

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

Comments

"अद्वितीयता का पता लगाने के लिए मानक पुस्तकालय के सरणी फ़ंक्शंस का उपयोग न करें (हालाँकि अन्य चीज़ें मानक लाइब्रेरी ठीक हैं)"

— जॉन ड्वोरक

मैं उस नियम का उल्लंघन कैसे कर रहा हूं? मैं अद्वितीय कार्यों का उपयोग नहीं कर रहा हूँ?

— ज़च लीटन

यह कैसे काम करता है, तब? क्षमा करें, मैं perl नहीं पढ़ सकता। यदि यह हैश मैप की कुंजियाँ पढ़ता है - क्या यह उस नियम के साथ ठीक है? मैं तब तक वोट नहीं दूंगा जब तक यह आश्वस्त न हो जाए कि यह है।

— जॉन ड्वोरक

यह सरणियों को जोड़ता है, दोनों पर लूप करता है और हैश को बढ़ाता है जो उस मूल्य को बढ़ाता है जो सरणी लूप में वर्तमान मान है। फिर यह उस हैश की कुंजी लेता है, मैंने अपने कुछ काम में इसका उपयोग किया है .. इसलिए [१,१,३,३,४,४]] {१ => २, २ => १, ३ => १ , 4 => 2}

— Zach Leighton

@ZachLeighton आप कोड को 27 वर्णों तक छोटा कर सकते हैं sub x{$_{$_}++for@_;keys%_}(यदि यह एक टाई के नीचे आता है!) और उपयोग के रूप में:z((1,2,3,4),(2,3,4,5,6))

— डोम हेस्टिंग्स

Answer 2

जावास्क्रिप्ट ओ (एन) 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 क्योंकि संक्षिप्त संस्करण के रूप में छोटे सरणियों से थोड़ा तेज है, लेकिन इसके साथ धीमा है बड़ी सरणियाँ (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]));

Comments

यह लगभग वही है जो मैं सेकंड के एक जोड़े में पोस्ट करने वाला था :-( हाँ, यह amortized रैखिक समय है अगर hash तालिकाओं को सम्मिलन और खोज के लिए amortized निरंतर समय के साथ लागू किया जाता है (जो कई भाषाओं में आम है, विशेष रूप से नहीं जानते हैं जेएस के बारे में)।

— एमिल विक्रोत्तम

@ EmilVikström इसके लिए धन्यवाद कि मुझे विश्वास है कि जावास्क्रिप्ट करता है, लेकिन इस पर सबूत नहीं है। तेज़ उंगलियाँ करने के लिए क्षमा याचना, अपने आप को टिप्पणियों से धीमा कर दिया: पी

— जॉर्ज रीथ

यह एक महान दृष्टिकोण है। हालाँकि, क्या आप अपने अच्छी तरह से स्वरूपित संस्करण के अलावा एक "कोड-गोल्फ" शैली समाधान भी प्रदान कर सकते हैं? यह देखते हुए कि कई लोगों ने इसे सही दृष्टिकोण के रूप में सोचा है, संभवतः एक टाई होने जा रहा है O(N)।

— 1

@ Cloudcoder2000 ठीक है, मैं एक पूर्ण संस्करण प्रिंट करना चाहता था क्योंकि कोड-गोल्फ संस्करण व्यवहार में कम कुशल होने की संभावना है।

— जॉर्ज रीथ

@ Cloudcoder2000 वे पूरी तरह से स्वतंत्र नहीं हैं इसलिए सबसे खराब स्थिति नहीं है O(A*B)( Nइसका उपयोग नहीं कर रहे हैं क्योंकि यह भ्रामक है)। यह होगा कि यदि हर इनपुट ऐरे (हर A) में समान मात्रा में तत्व ( B) हों, जैसा कि वास्तव में है O(SUM(B) FOR ALL A), जिसे सभी एरे इनपुट्स के तत्वों की गिनती के रूप में O(N)परिभाषित करते हुए फिर से लिखा जा सकता Nहै।

— मेयोनेज़ोम

Answer 3

पायथन 2.7, 38 वर्ण

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

एक अच्छा हैश फ़ंक्शन मानते हुए O (N) होना चाहिए।

वसी के 8 चरित्र setकार्यान्वयन बेहतर है, अगर आपको नहीं लगता कि यह नियमों का उल्लंघन करता है।

Comments

अच्छा! अजगर में समझ इतनी सुरुचिपूर्ण और शक्तिशाली हो सकती है।

— OI

Answer 4

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

Answer 5

रूबी में एक तरीका

ऊपर उल्लिखित नियमों के भीतर रखने के लिए, मैं जावास्क्रिप्ट समाधान के रूप में एक समान रणनीति का उपयोग करूंगा और एक मध्यस्थ के रूप में हैश का उपयोग करूंगा।

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

अनिवार्य रूप से, ये वे चरण हैं जो मैं ऊपर की रेखा से गुजर रहा हूं।

1. एक चर को परिभाषित करें merged_arrजिसमें परिणाम होगा
2. अद्वितीय तत्वों को रखने के लिए मध्यस्थ के रूप में एक खाली, अनाम हैश को प्रारंभ करें
3. का प्रयोग करें Object#tapहैश (के रूप में संदर्भित पॉप्युलेट करने के लिए hashमें tapब्लॉक) और इसे बाद में विधि श्रृंखलन के लिए वापस
4. CONCATENATE 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 सरणियों के बीच एक अद्वितीय मर्ज प्रदर्शन करने के लिए स्वीकार्य समाधान प्रतीत होता है।

Comments

"अद्वितीयता का पता लगाने के लिए मानक पुस्तकालय के सरणी फ़ंक्शंस का उपयोग न करें (हालाँकि अन्य चीज़ें मानक लाइब्रेरी ठीक हैं)"

— जॉन ड्वोरक

मैं दूसरे उदाहरण में उस नियम का उल्लंघन कैसे कर रहा हूँ? हैश पर मेमोशन किया जा रहा है। कि अनुमति नहीं है?

— OI

Answer 6

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', तो यह काम नहीं करेगा ।।

Comments

जवाब के लिए धन्यवाद। यह प्रभावशाली रूप से छोटा है, हालांकि यह केवल आधी समस्या करता है। आपको समाधान को वास्तविक विलय वाले भाग में शामिल करने की भी आवश्यकता है (भले ही इसका मूल उदाहरण में जैसा हो) और सभी को एक फ़ंक्शन में एक साथ रखें। इसके अलावा, क्या आप इसके अलावा (जैसा है O(N)) इसके अलावा "गोल्फ" संस्करण प्रदान कर सकते हैं ?

— hkk

यह सभी सदस्यों को तार में रखता है। जैसे m([1,2,3,4,5],[2,3,4,5,6],[2,3,4,5,6,7])बन जाता है["1", "2", "3", "4", "5", "6", "7"]

— जॉर्ज रीथ

Answer 7

अजगर, 46

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

या, सेट ऑपरेशन का उपयोग करके

अजगर, 8

set(a+b)

Comments

क्षमा करें यह स्पष्ट नहीं था, सेट ऑपरेशन का उपयोग करना भी धोखा है।

— 19

यदि आपका डुप्लिकेट b या डुप्लिकेट में है और उस तत्व में नहीं है तो आपके पहले कोड में डुप्लिकेट होंगे।

— वेदांत कंडोई

Answer 8

पर्ल

23 बाइट्स, यदि हम केवल सबरूटीन के अंदर कोड ब्लॉक की गिनती करते हैं। 21 हो सकता है, अगर वैश्विक मूल्यों को अधिलेखित करने की अनुमति है (यह myकोड से हटा देगा )। यह तत्वों को यादृच्छिक क्रम में लौटाता है, क्योंकि आदेश कोई फर्क नहीं पड़ता। जटिलता के लिए, औसतन यह हे (एन) है (हैश टकराव की संख्या पर निर्भर करता है, लेकिन वे दुर्लभ हैं - सबसे खराब स्थिति में यह ओ (एन ² ) हो सकता है (लेकिन ऐसा नहीं होना चाहिए, क्योंकि पर्ल रोग संबंधी हैश का पता लगा सकता है। , और हैश फ़ंक्शन बीज को बदलता है जब यह इस तरह के व्यवहार का पता लगाता है))।

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

Answer 9

फोरट्रान: 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, जिसमें असंगठित है।

Answer 10

गणितज्ञ १० चर

Union[a,b]

उदाहरण:

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

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

Mathematica2 43 चार्ज

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

Comments

मुझे लगता है कि यह मानक पुस्तकालय सरणी विधियों का उपयोग करने की श्रेणी में जाएगा।

— एचके

हाय @ Cloudcoder2000। Mathematica में Union का उपयोग करने के लिए कुछ विशिष्ट लाइब्रेरी को कॉल करने की आवश्यकता नहीं है।

— मुरता

मेरी राय में, बिल्टिन फ़ंक्शन का उपयोग करना वास्तव में जो सवाल करने के लिए पूछ रहा है वह धोखा देना है।

— कोनराड बोरोस्की

ठीक है ठीक है .. दूसरा कोड संघ का उपयोग नहीं करता है।

— Murta

मुझे लगता है कि Tally[Join[a, b]][[;; , 1]]यह भी धोखा होगा;;

— यवेस केलेट

Answer 11

जावास्क्रिप्ट 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;
  });
}

Comments

यह गलत मूल्यों को अनदेखा करता है ... m([1,0,0,0,0],[0,1,0])रिटर्न [1]।

— जॉर्ज रीथ

बदलें h[v]=vकरने के लिए h[v]=1।

— जॉर्ज रीथ

अच्छी तरह से देखा @GeorgeReith! हम 86 से 84 :)

— बर्ट्रेंड

यह अभी भी 86 है, मुझे लगता है कि आप भ्रमित हो गए क्योंकि आपने 2 संस्करणों को पठनीय संस्करण से हटा दिया है न कि गोल्फ वाले।

— जॉर्ज रीथ

Answer 12

जावास्क्रिप्ट 60

मैं ES6 जनरेटर का उपयोग कर रहा हूं। Google के Traceur REPL का
उपयोग करके निम्नलिखित परीक्षण योग्य है ।

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

Answer 13

यदि आप एक जावास्क्रिप्ट-आधारित कार्यान्वयन की तलाश कर रहे हैं जो कि फ्रेमवर्क के पीछे अंतर्निहित वस्तुओं पर निर्भर करता है, तो मैं कुशल हो सकता हूं। आमतौर पर एक कार्यान्वयन में, सेट ऑब्जेक्ट स्वाभाविक रूप से किसी भी तरह के द्विआधारी खोज अनुक्रमण के साथ सम्मिलन के दौरान अद्वितीय वस्तुओं को संभालता है। मुझे पता है कि यह जावा में हैlog(n) खोज है, इस तथ्य के आधार पर द्विआधारी खोज का उपयोग करके कि किसी भी सेट में एक से अधिक बार एक ही वस्तु नहीं हो सकती है।

---

हालांकि मुझे यह पता नहीं है कि क्या यह जावास्क्रिप्ट के लिए भी सही है, निम्नलिखित स्निपेट के रूप में कुछ सरल एक 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)।

Answer 14

एपीएल (डायलॉग यूनिकोड) , ओ (एन), 28 बाइट्स

बेनामी tacit infix फ़ंक्शन।

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

इसे ऑनलाइन आज़माएं!

, तर्कों को संक्षिप्त करें; पर)

(… ) उस पर निम्नलिखित अनाम tacit फ़ंक्शन लागू करें; हे (1)

   ⍳⍨ सूचकांक सेल्फी (पूरे सरणी में प्रत्येक तत्व की पहली घटना के संकेत); पर)

  = तत्व की तुलना तत्व से करें; पर):

   ⍳∘≢ सरणी की लंबाई के सूचकांक; पर)

 (/⍨) फ़िल्टर करने के लिए उपयोग करें; पर):

  ⊢ असम्बद्ध तर्क; हे (1)

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

Answer 15

जावास्क्रिप्ट, 131 वर्ण

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

Comments

PPCG में आपका स्वागत है! कृपया हमें बताएं कि यह कौन सी भाषा है और इसे बेहतर पठनीयता के लिए कोड के रूप में प्रारूपित करें। (यह चार स्थानों के साथ कोड लाइनों को इंडेंट करके काम करता है)। इसके अलावा आपके दृष्टिकोण की व्याख्या की सराहना की जाएगी।

— लकोनी

यह सिर्फ एक जावास्क्रिप्ट कोड है।

— deepak_pal

@techdeepak आप अपनी पोस्ट में ऐसी महत्वपूर्ण जानकारी जोड़ सकते हैं, इसे ठीक से प्रारूपित कर सकते हैं, वाक्य रचना हाइलाइटिंग जोड़ सकते हैं और अपने एल्गोरिथ्म की जटिलता के बारे में थोड़ा और लिख सकते हैं, क्योंकि यह सबसे तेज़-एल्गोरिथ्म है । जैसा कि यह खड़ा है, यह पोस्ट काफी निम्न गुणवत्ता का है।

— जोनाथन फ्रेच

Answer 16

28 वर्णों के आसपास PHP [उदाहरण सरणी चर और परिणाम चर को छोड़कर]।

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

$ परिणाम = array_merge ($ array1, $ array2);

Comments

इस प्रश्न से: विशिष्ट पुस्तकालय की सरणी कार्यों का उपयोग विशिष्टता या विलय सेट / सरणियों का पता लगाने के लिए न करें । इसके अतिरिक्त यह वास्तव में सरणी से डुप्लिकेट को दूर नहीं करता है

— जो राजा

मुझे लगता है कि आपने इस महत्वपूर्ण पंक्ति को इस प्रश्न से अनदेखा कर दिया है: " विशिष्टता का पता लगाने या सेट / सरणियों के लिए मानक पुस्तकालय के सरणी फ़ंक्शंस का उपयोग न करें "

— पीटर टेलर

हाँ। यह सही है। आप लोगों को धन्यवाद कि बाहर बताया। आलोचकों ने विनम्रतापूर्वक स्वीकार किया।

— एंड्री

@मजाक कर रहा है। आप "मानक पुस्तकालय का उपयोग न करें ..." के बारे में बिल्कुल सही हैं। बाकी गलत है। यह डुप्लिकेट को निकालता है।php.net/manual/en/function.array-merge.php । मैं आपको PHP के प्रलेखन को पूरी तरह से पढ़ने की सलाह देता हूं। मुझे 100% यकीन है कि यह काम करता है। बस आपको सावधानी बरतने की आवश्यकता है कि आप कौन से सरणियों को डुप्लिकेट मानते हैं। चीयर्स।

— 8

मैंने सचमुच आपके कोड में बिना किसी बदलाव के भाग लिया और आउटपुट में डुप्लिकेट है। ऐसा लगता है कि आपको दस्तावेज़ीकरण पढ़ना चाहिए, अर्थात् यदि, हालांकि, सरणियों में संख्यात्मक कुंजियाँ हैं, तो बाद में मान मूल मान को अधिलेखित नहीं करेगा, लेकिन जोड़ा जाएगा

— Jo King