दो सूचियों का प्रतिच्छेदन सेट करें

Question

आपका लक्ष्य पूर्णांकों की दो सूचियों के सेट प्रतिच्छेदन की गणना करना है। चौराहे को अद्वितीय अन-ऑर्डर किए गए पूर्णांकों के समूह के रूप में परिभाषित किया गया है जो दोनों इनपुट सूची में कम से कम एक बार पाए जाते हैं।

इनपुट

इनपुट किसी भी प्रारूप में वांछित (फ़ंक्शन पैरामीटर, stdio, आदि) हो सकता है, और पूर्णांक की दो सूचियों में शामिल हो सकता है। आप बहुत से प्रत्येक सूची के बारे में कुछ भी नहीं मानते हैं, क्योंकि उनमें पूर्णांक संख्या में कोई भी गैर-ऋणात्मक संख्या हो सकती है (यानी वे अनसोल्ड हैं, संभवतः डुप्लिकेट हो सकते हैं, अलग-अलग लंबाई हो सकती है, और खाली भी हो सकती है)। यह माना जाता है कि प्रत्येक पूर्णांक आपकी भाषा के मूल हस्ताक्षरित पूर्णांक प्रकार में फिट होगा, 1 दशमलव से अधिक लंबा हो सकता है, और हस्ताक्षरित हैं।

उदाहरण इनपुट:

1 4 3 9 8 8 3 7 0
10 1 4 4 8 -1

उत्पादन

आउटपुट किसी भी सूची-पूर्णांक की तरह होता है जो दो सूचियों के सेट चौराहे का प्रतिनिधित्व किसी भी प्रारूप में वांछित (रिटर्न मान, stdio, आदि) करता है। कोई आवश्यकता नहीं है कि आउटपुट को क्रमबद्ध किया जाए, हालांकि एक कार्यान्वयन प्रदान करने के लिए आपका स्वागत है जो हमेशा सॉर्ट किया जाता है। आउटपुट के पास एक वैध संयुक्त राष्ट्र का सेट होना चाहिए (जैसे इसमें कोई डुप्लिकेट मान नहीं होना चाहिए)।

उदाहरण के परीक्षण के मामले (ध्यान दें कि आउटपुट का क्रम महत्वपूर्ण नहीं है):

पहली दो लाइनें इनपुट लिस्ट हैं, तीसरी लाइन आउटपुट है। (empty)रिक्त सूची को दर्शाता है।

(empty)
(empty)
(empty)

1000
(empty)
(empty)

3 1 2 4 3 1 1 1 1 3
3 1 -1 0 8 3 3 1
1 3

1 2 1
3 3 4
(empty)

स्कोरिंग

यह कोड गोल्फ है; बाइट्स जीत में सबसे कम जवाब।

मानक लूप-होल निषिद्ध हैं। आप किसी भी निर्मित सुविधाओं का उपयोग कर सकते हैं जो सेट-जैसे ऑपरेशन के लिए डिज़ाइन नहीं किए गए हैं।

निषिद्ध अंतर्निहित विशेषताएं:

• निर्माण / डुप्लिकेट को निकालना
• अंतर / अंतर / संघ सेट करें
• सामान्यीकृत सदस्यता परीक्षण (जैसे inपायथन में कीवर्ड के समान कुछ भी , indexOfजैसे-समान फ़ंक्शन, आदि)। ध्यान दें कि "लिस्ट में फ़ॉरवर्ड आइटम" के निर्माण की अनुमति है (यह मानते हुए कि वे किसी भी अन्य प्रतिबंधों का उल्लंघन नहीं करते हैं), इस तथ्य के बावजूद कि पायथन inइस निर्माण को बनाने के लिए कीवर्ड का फिर से उपयोग करता है ।
• ये निषिद्ध बिल्ट-इन "वायरल" हैं, अर्थात यदि इन उप-विशेषताओं में से कोई भी अंतर्निहित है, तो यह समान रूप से निषिद्ध है (जैसे किसी सूची में सदस्यता द्वारा फ़िल्टर करना)।

उपरोक्त सूची में किसी भी अंतर्निहित इन्स को अनुमति नहीं है (पूर्व छँटाई, पूर्णांक समानता परीक्षण, सूची परिशिष्ट / सूचकांक द्वारा हटा, फ़िल्टरिंग, आदि)।

उदाहरण के लिए, निम्नलिखित दो उदाहरण स्निपेट्स (पायथन-जैसे कोड) लें:

# prohibited: filters by testing if each value in tmpList is a member of listA
result = tmpList.filter(listA)

# ok: filtering by a lambda which manually iterates over listA and checks for equality
def my_in_func(val, slist):
    for a in slist:
        if(val == a):
            return True
    return False
result = filter(lambda v: my_in_func(val, listA), tmpList)

आप इनमें से किसी भी सेट-जैसी विशेषताओं को लागू करने का स्वागत करते हैं और वे आपके स्कोर की ओर गिनेंगे।

आपका समाधान समय की एक उचित मात्रा में पूरा होना चाहिए (कहते हैं, दो सूचियों के लिए आपके पास जो भी हार्डवेयर है उस पर एक मिनट से कम ~ लंबाई 1000 प्रत्येक)।

Comments

वैसे, एक्स एक्स के बिना वाई में भ्रम और गलतफहमी आम है , यही कारण है कि वे लेखन चुनौतियों से बचने के लिए आधिकारिक तौर पर एक चीज हैं ।

— डेनिस

@ डेनिस हाँ, मुझे लगता है कि यह समस्या वास्तव में उनमें से एक बन गई है :( जब मैंने पहली बार इसे लिखा था, तो मैं उम्मीद कर रहा था कि यह एक दिलचस्प समस्या हो सकती है, लेकिन जैसे ही मैंने एक नियम को काम करना शुरू कर दिया, मुझे सिर्फ चुनौती को मारना चाहिए था।

— helloworld922

क्या एक बिलिन है जो लंबाई की एन्कोडिंग चलाने की अनुमति देता है?

— इसहाक

उसे ठीक होना चाहिए।

— helloworld922 20

क्या आउटपुट में डुप्लिकेट हो सकते हैं?

— आदम

Answer 1

हास्केल, 45 42 बाइट्स

y#(e:s)=[e|any(==e)y,all(/=e)s]++y#s
_#x=x

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

संपादित करें: -2 बाइट्स @ अर्जन जोहान्सन की बदौलत, -1 बाइट @ फादर को धन्यवाद।

Comments

यह स्पष्ट पुनरावृत्ति के साथ 2 बाइट्स छोटा है ।

— अर्जन जोहानसन

@ ØrjanJohansen, 1 अधिक ।

— dfeuer

Answer 2

MATL , 18 बाइट्स

YY_iti!=Xa)hStdfQ)

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

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

फिर डुप्लिकेट हटा दिए जाते हैं। इसके लिए, पिछले चरण से सरणी को क्रमबद्ध किया जाता है, और प्रविष्टियां पूर्ववर्ती से अलग होने पर रखी जाती हैं। एक -infमान पूर्व निर्धारित किया गया है ताकि पहला (सबसे कम) मान खो न जाए।

YY_                 % push -infinity
   it               % take first input. Duplicate
     i!             % take second input. Transpose
        =           % test all combinations of elements of the two inputs for equality
        Xa          % row vector that contains true for elements of first array that 
                    % are present in the second, possibly duplicated
          )         % index into first array to keep only those elements. Now we need
                    % to remove duplicates
           h        % append -infinity
            S       % sort
             tdf    % duplicate. Find entries that differ from the preceding
                Q)  % add 1 and index into array to keep only non-duplicates

Answer 3

जेली, 13 बाइट्स

=S¥Ðf
ṂrṀ{ç³ç

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

यह काम किस प्रकार करता है

ṂrṀ{ç³ç  Main link. Arguments: A (list 1), B (list 2)

Ṃ        Yield m, the minimum of A.
  Ṁ{     Yield M, the maxmimum of A.
 r       Create an inclusive range from m to M.
    f³   Apply the helper link with right argument A.
      f  Apply the helper link with right argument B.


=S¥Ðf    Helper link. Arguments: n (integer in range), L (list, A or B)

=        Test all elements of L for equality with n.
 S       Add the results.
  ¥      Combine the two previous links into a dyadic chain.
   Ðf    Filter by the result of the sums.

Comments

@isaacg अभी फिक्स्ड है।

— डेनिस

Answer 4

गोल्फलुआ , 68 वर्ण

\f(a,b)k={}~@_,v p(a)~@_,w p(b)?w==v k[w]=w$$$~@_,v p(k)I.w(v," ")$$

जिसे कहा जाता है

> f({1,2,3,4},{3,4,5})
3 4
> f({3,1,2,4,3,1,1,1,1,3},{3,1,-1,0,8,3,3,1})
3 1

नियमित लुआ में, यह होगा

function foo(a,b)
   local k={}
   for i,v in pairs(a)
      for j,w in pairs(b)
         if v==w then
            k[v] = v
         end
      end
   end
   for i,v in pairs(k)
      print(v," ")
   end
end

इसलिए मूल रूप से मैं दो तालिकाओं के प्रत्येक तत्व पर पुनरावृत्ति कर रहा हूं और केवल समान मूल्यों को संग्रहीत कर रहा हूं। मान को कुंजी ( k[w]=w) के रूप में उपयोग करके , मैं सभी डुप्लिकेट को समाप्त कर रहा हूं। फिर हम सूचकांक और मूल्य पर पुनरावृत्ति करके नई तालिका का उत्पादन करते हैंpairs

Answer 5

जावास्क्रिप्ट (ईएस 6), 66 बाइट्स

(a,b)=>a.filter((e,i)=>b.some(f=>e==f)&a.slice(0,i).every(f=>e-f))

उपयोग किए बिना indexOf, जैसा कि मुझे यकीन नहीं है कि इसकी अनुमति है।

Answer 6

पायथ, 12 11 बाइट्स

eMrSsq#RQE8

प्रदर्शन

स्पष्टीकरण:

eMrSsq#RQE8
               Implicit: Q is one of the lists.
     q#RQE     For every element in the first list, filter the second list on
               equality with that element.
    s          Concatenate. We now have the intersection, with duplicates.
  rS      8    Sort and run length encode, giving counts and elements.
eM             Take just the elements.

Comments

सॉर्टिंग और रैल एक बाइट बचाता है।

— जकुबे

@ जाकुब मैं कहूंगा कि आरईएल एक बिलिन है जो डुप्लिकेट को हटाता है।

— इसहाक

यह केवल डुप्लिकेट को हटाता है यदि आप इसे पहले सॉर्ट करते हैं और बाद में आरईएल की गिनती को हटाते हैं। यह एक ग्रे क्षेत्र में थोड़ा सा है, लेकिन मुझे लगता है कि एक शब्दकोश का उपयोग कर रहा है। यह मूल रूप से एक सेट है जो प्रत्येक तत्व के लिए अतिरिक्त डेटा संग्रहीत करता है।

— जकुबे

@ जाकुब ओपी का कहना है कि यह ठीक है। धन्यवाद!

— 20

Answer 7

बैश + GNU कोरुटिल्स, 184 बाइट्स

[ -z "$1" ] && exit
p='{if(a[$0]++==0)print $0}'
while read A; do
while read B; do
[ $A = $B ] && echo $A
done < <(grep -oP '\d*'<<<$1|awk "$p")
done < <(grep -oP '\d*'<<<$2|awk "$p")

मंगलाचरण:

./codegolf.sh '12 4 654 12 3 56' '4 4 56 33 3 3 3'

आउटपुट:

4
56
3

यदि चौराहा खाली है तो कोई आउटपुट नहीं। यह स्क्रिप्ट सॉर्ट नहीं करता है और अगर पहला सेट खाली है तो यह स्वच्छता जांच करता है। स्पष्टीकरण:

[ -z "$1" ] && exit  # Exit if first set is empty
p='{if(a[$0]++==0)print $0}' # The AWK program we will use
while read A; do   # read the list with two
while read B; do   # encapsulated loops
[ $A = $B ] && echo $A   # if they match, then print
done < <(grep -oP '\d*'<<<$1|awk "$p")
done < <(grep -oP '\d*'<<<$2|awk "$p")
# the process substitution greps the numbers and pipes them to awk. Our awk program makes them unique without sorting; it uses associative arrays with index names same as lines (our numbers here).

पता करने के लिए बोनस: आप grep -o .संख्याओं के बजाय यादृच्छिक स्ट्रिंग्स के साथ ऐसा करने के लिए बदल सकते हैं ।

Answer 8

पर्ल 6, 26 37 बाइट्स

{%(@^a.grep(any(@^b)):p.invert).keys}

प्रयोग

> my &f = {%(@^a.grep(any(@^b)):p.invert).keys}
-> @a, @b { #`(Block|559823336) ... }
> f([3,1,2,4,3,1,1,1,1,3], [3,1,-1,0,8,3,3,1])
(1 3)

चुटीले गैर-प्रतिस्पर्धी जवाब

> [3,1,2,4,3,1,1,1,1,3] ∩ [3,1,-1,0,8,3,3,1]
set(3, 1)

या यदि आप एक उबाऊ राजभाषा fसमारोह में इसे पसंद करते हैं

> my &f = &infix:<∩>
sub infix:<∩> (|p is raw) { #`(Sub+{<anon|130874592>}+{Precedence}|102325600) ... }
> f([3,1,2,4,3,1,1,1,1,3], [3,1,-1,0,8,3,3,1])
set(3, 1)

Comments

मैंने अपने उत्तर का उपयोग न करने के लिए अपडेट किया है .unique

— Hotkeys

आप वास्तव में जरूरत नहीं है invertअगर आप इसके बजाय मान लेते हैं। 24 बाइट्स

— जो किंग

Answer 9

रेटिना , 63 बाइट्स

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

+`( -?\d+)\b(.*,.*)\1\b
$1_$2
-?\d+\b|_|,

+`(-?\d+)(.*)\1
$1$2

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

यदि आउटपुट में डुप्लिकेट की अनुमति है, तो मेरा कार्यक्रम 42 बाइट्स होगा।

Answer 10

Jq 1.5 , 99 बाइट्स

def f(a;b):(a+b|min)as$m|[range($m;a+b|max)|[]]|.[a[]-$m][0]=1|.[b[]-$m][1]=1|.[[[1,1]]]|map(.+$m);

विस्तारित

def f(a;b):
     (a+b|min) as $m         # find smallest value in either array
   | [range($m;a+b|max)|[]]  # create array of [] for indices [min,max]
   | .[ a[]-$m ][0]=1        # store 1 in [0] at corresponding indices of a
   | .[ b[]-$m ][1]=1        # store 1 in [1] at corresponding indices of b
   | .[[[1,1]]]              # find all the indices where we stored a 1 for a and b
   | map(.+$m)               # convert back from indices to values
;

यह {}ऑब्जेक्ट का उपयोग करने से बचता है और चूंकि jq में बिट ऑपरेशंस नहीं होते हैं इसलिए यह एक एरे के साथ इनका अनुकरण करता है।

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

Answer 11

Axiom, 411 बाइट्स

b(x,v)==(l:=1;h:=#v;repeat(l>h=>break;m:=(l+h)quo 2;x<v.m=>(h:=m-1);x>v.m=>(l:=m+1);return m);0);g(a,b)==(if #a>#b then(v:=a;w:=b)else(v:=b;w:=a);c:=sort(v);for x in w repeat(if binSearch(x,c)~=0 then return 1);0)
f(a:List INT,b:List INT):List INT==(r:List INT:=[];#a*#b=0=>r;x:=sort(a);y:=sort(b);i:=1;repeat(i>#x=>break;v:=x.i;binSearch(v,y)=0=>(i:=i+1);r:=concat(r,v);while i<=#x and x.i=v repeat i:=i+1);r)

ungolf and test

--suppose v.1<=v.2<=....<=v.#v as the default function sort() produce
--   binary serch of x in v, return the index i with v.i==x
--   return 0 if that index not exist
--traslated in Axiom from C  book
--Il Linguaggio C, II Edizione 
--Brian W.Kerninghan, Dennis M.Ritchie
binSearch(x,v)==
    l:=1;h:=#v
    repeat
       l>h=>break
       m:=(l+h)quo 2
       x<v.m=>(h:=m-1) 
       x>v.m=>(l:=m+1)
       return m
    0

--N*log(N)+n*log(n)+N*n*log(n) so it is N*n*log(n) or n*N*log(N)
ListIntersection(a:List INT,b:List INT):List INT==
    r:List INT:=[];#a*#b=0=>r
    x:=sort(a);y:=sort(b)
    i:=1
    repeat
        i>#x=>break
        v:=x.i
        binSearch(v,y)=0=>(i:=i+1)
        r:=concat(r,v)
        while i<=#x and x.i=v repeat i:=i+1
    r

(5) -> f([],[])
   (5)  []
                                                       Type: List Integer
(6) -> f([1000],[])
   (6)  []
                                                       Type: List Integer
(7) -> f([3,1,2,4,3,1,1,1,1,3],[3,1,-1,0,8,3,3,1])
   (7)  [1,3]
                                                       Type: List Integer
(8) -> f([1,2,1],[3,3,4])
   (8)  []
                                                       Type: List Integer

Answer 12

Axiom, 257 बाइट्स

W(x,y)==>while x repeat y;f(a,b)==(r:List INT:=[];#a*#b=0=>r;x:=sort(a);y:=sort(b);i:=1;j:=1;repeat(j>#y=>break;W(i<=#x and x.i<y.j,i:=i+1);i>#x=>break;W(j<=#y and y.j<x.i,j:=j+1);j>#y=>break;v:=y.j;if x.i=v then(r:=concat(r,v);W(j<=#y and y.j=v,j:=j+1)));r)

यह बिन खोज के उपयोग के बिना ... लेकिन मुझे बड़ा O पता नहीं है ... बिना परिणाम और परिणाम:

--N*log(N)+n*log(n)+???
ListIntersection(a:List INT,b:List INT):List INT==
    r:List INT:=[];#a*#b=0=>r
    x:=sort(a);y:=sort(b)
    i:=1;j:=1
    repeat
        j>#y=>break
        while i<=#x and x.i<y.j repeat i:=i+1
        i>#x=>break
        while j<=#y and y.j<x.i repeat j:=j+1
        j>#y=>break
        v:=y.j;if x.i=v then 
                        r:=concat(r,v)
                        while j<=#y and y.j=v repeat j:=j+1
    r

(3) -> f([3,1,2,4,3,1,1,1,1,3],[3,1,-1,0,8,3,3,1])
   (3)  [1,3]
                                                       Type: List Integer
(4) -> f([],[])
   (4)  []
                                                       Type: List Integer
(5) -> f([1,2,1],[3,3,4])
   (5)  []
                                                       Type: List Integer

कई परीक्षणों को अंजाम नहीं दिया जा सका है इसलिए बग़ावत की जा सकती है ...

Answer 13

जेली , 12 बाइट्स

pEÐfḢ€ĠḢ€$ị$

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

Comments

Tio में 3,1,2,4,3,1,1,1,1,3 इनपुट और 3 इनपुट आउटपुट [1,2,3] के बदले [3]

— RosLuP

@RosLuP के [3]बजाय की कोशिश करें3

— हायपरनेट्यूटिनो

मेरी राय में यह ठीक होगा, यदि 2 सूचियों के प्रतिच्छेदन का परिणाम वापस (अन्य मामलों के रूप में) [] यदि परिणाम शून्य है, तो [1] यदि 2 सूचियों में 1 सामान्य है

— RosLuP

@RosLuP मैं इसकी मदद नहीं कर सकता, कि जेली आउटपुट कैसे करती है। []सिंगलटन सूचियों के लिए और तत्व के लिए खाली है । आप विकी पेज (परमाणु) पर जा सकते हैं और पायथन स्ट्रिंजिंग बिलिन को जोड़ सकते हैं, लेकिन इससे मेरा जवाब लंबा और सख्त हो जाता है I / O गूंगा है

— हाइपरएन्यूट्रीनो

यह मेरे लिए ठीक होगा यदि यह केवल इनपुट सूची को स्वीकार करता है [] तरीके से (उदाहरण [1], [1,2,3] [], [], [] आदि] और सूची का उत्पादन सूची [] तरीके से ही करता है (इसके इनपुट के रूप में)। यदि सूची के लिए कोष्ठक {} या () दाईं ओर के भाषण से ऊपर हैं। यह केवल मुझे लगता है कि के लिए है, सवाल संभवतः अन्यथा कहते हैं और सभी ठीक है

— RosLuP

Answer 14

भूसी , 9 बाइट्स

mo←←kIfE*

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

m            Map
 o←←         taking the first element from the first element
    kI       over lists of identical values from
        *    the Cartesian product of the two input lists
      f      filtered by
       E     both elements of a pair being equal.

kगीथहब पर हस्क के स्रोत कोड में खोज, ("कीन") को सूची को क्रमबद्ध करने और आसन्न मूल्यों को समूहीकृत करने की रचना के रूप में लागू किया गया है, हालांकि मुझे वास्तव में "समूह" का कार्यान्वयन नहीं मिल रहा है, यह संभवतः यह मानना ​​सुरक्षित है कि यह नहीं है ' टी कुछ भी करना नहीं है, क्योंकि हास्केल एक कार्यात्मक भाषा है और आसन्न समान मूल्यों को समूहीकृत करना एक सीधा-सीधा कम-से-जुड़ा-सूची ऑपरेशन है। (मैं कर सकते हैं के कार्यान्वयन को खोजने के kजो मैं यहाँ बदलकर इस्तेमाल कर सकते हैं के अन्य प्रकार हस्ताक्षर "keyby", Iकरने के लिए= है, लेकिन मैं हास्केल पता नहीं है तो मैं नहीं बता सकता वास्तव में यह कैसे काम करता है।)

इसके अलावा, एक अच्छा सा Brachylog उत्तर, जिसके साथ मैं आने से पहले ही महसूस कर चुका था कि सभी तरह के सेट ऑपरेशन बंद कर दिए गए थे: ⟨∋∈⟩ᵘ

Answer 15

आर, 141 83 बाइट्स

l=sapply(strsplit(readLines(file("stdin"))," "),as.numeric)
r=rle(sort(unlist(l)))[[2]]
r[sapply(r,function(x)any(x==l[[1]])&any(x==l[[2]]))]

Giuseppe द्वारा सुधार किया गया

function(a,b){r=rle(sort(c(a,b)))[[2]];r[sapply(r,function(x)any(x==a)&any(x==b))]}

ऑनलाइन कोशिश करें यहाँ यहाँ

Comments

यह काम नहीं लगता है। मैं शायद इसे गलत उपयोग करने की कोशिश कर रहा हूं, हालांकि, शायद आपको इसे ऑनलाइन प्रयास करने के लिए लिंक की आपूर्ति करनी चाहिए ! यह दिखाते हैं कि इसका उपयोग कैसे करना है और यह प्रदर्शित करना है कि यह चुनौती की आवश्यकताओं को पूरा करता है। (जवाब पर एक स्पष्टीकरण या तो चोट नहीं होगा।)

— असंबंधित स्ट्रिंग

आप इनपुट को मान नहीं सकते हैं aऔर bपूर्व-परिभाषित हैं, आपको इनपुट को स्वीकार करना होगा, या तो उन्हें फ़ंक्शन तर्क के रूप में या एसटीडीआईएन से लिया जाएगा।

— ग्यूसेप

मुझे लगता है कि गोल्फ खिलाड़ी सिर्फ एक समारोह बनाने के लिए होगा, जैसे

— Giuseppe

@db "हेडर" "कोड" खंड में परिभाषित अनाम फ़ंक्शन को नाम देता है (अनाम फ़ंक्शन पूरी तरह से स्वीकार्य हैं), और पाद लेख इसे कॉल करता है। हेडर, कोड, और पाद अनुभाग सभी कोड का एक टुकड़ा है, लेकिन "कोड" अनुभाग में केवल भाग बाइट्स के लिए मायने रखता है :-)

— Giuseppe

Answer 16

पायथन 3, 51 बाइट्स

lambda a,b:[v for v in a if{n:1 for n in b}.get(v)]

यदि इनपुट सूचियों में डुप्लिकेट हो सकते हैं:

पायथन 3, 67 बाइट्स

lambda a,b:list({v:1 for v in a if {n:1 for n in b}.get(v)}.keys())

Answer 17

पीएचपी ,78, 77 बाइट्स

function($a,$b){foreach($a as$x)foreach($b as$y)$x==$y?$c[$x]=$x:0;return$c;}

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

कोई तामझाम नहीं, लेकिन नियम-संगत (मुझे लगता है)।

उत्पादन

[], []
[]

[1000], []
[]

[3,1,2,4,3,1,1,1,1,3], [3,1,-1,0,8,3,3,1]
[3,1]

[1,2,1], [3,3,4]
[]