Amacınız iki tamsayı listesinin kesişme noktasını hesaplamaktır. Kavşak, her iki giriş listesinde en az bir kez bulunan benzersiz sıralanmamış tamsayı grubu olarak tanımlanır.

Giriş

Giriş istenen herhangi bir formatta (fonksiyon parametresi, stdio, vb.) Olabilir ve iki tamsayı listesinden oluşur. Birçoğunuz, negatif olmayan tamsayılar içerebilmeleri dışında her liste hakkında hiçbir şey varsaymazsınız (yani ayrıştırılmaz, muhtemelen yinelenebilir, farklı uzunluklara sahip olabilir ve hatta boş olabilir). Her bir tamsayının dilinizin yerel imzalı tamsayı türüne sığacağı, 1 ondalık basamak uzunluğunda olabileceği ve imzalandığı varsayılmaktadır.

Örnek girdi:

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

Çıktı

Çıktı, iki listenin istenen herhangi bir formata (dönüş değeri, stdio, vb.) Ayarlanmış kesişimini temsil eden tamsayıların liste benzeri bir şeklidir. Çıktının sıralanması gerekmez, ancak her zaman sıralanacak bir uygulama sağlayabilirsiniz. Çıktı geçerli bir sıralanmamış küme oluşturmalıdır (örn. Yinelenen değerler içermemelidir).

Örnek test senaryoları (çıktı sırasının önemli olmadığını unutmayın):

İlk iki satır girdi listeleridir, üçüncü satır çıktıdır. (empty)boş listeyi gösterir.

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

puanlama

Bu kod golf; baytlarda en kısa cevap kazanır.

Standart halka delikleri yasaktır. Set benzeri işlemler için tasarlanmamış yerleşik özellikleri kullanabilirsiniz.

Yerleşik yasaklanmış özellikler:

• oluşturma / kopyaları kaldırma
• fark / kavşak / birleşim ayarlama
• Genel üyelik testi (örneğin in, Python'daki anahtar kelimeye benzer indexOfişlevler, benzeri işlevler vb.). Python'un inbu yapıyı oluşturmak için anahtar kelimeyi yeniden kullansa da, "listedeki her öğeyi önbelleğe al" yapılarının kullanımına izin verildiğini (diğer kısıtlamaların hiçbirini ihlal etmediği varsayılarak) unutmayın .
• Bu yasaklanmış yerleşik "viral" dir, yani bu alt özelliklerden herhangi birini içeren daha büyük bir yerleşik varsa benzer şekilde yasaklanmıştır (örneğin bir listeye üyeliğe göre filtreleme).

Yukarıdaki listede bulunmayan tüm yerleşik öğelere izin verilir (ör. Sıralama, tamsayı eşitlik testi, listeye göre ekleme / kaldırma, filtreleme vb.).

Örneğin, aşağıdaki iki örnek parçacığı (Python benzeri kod) alın:

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

Bu set benzeri özelliklerden herhangi birini kendiniz uygulayabilirsiniz ve puanınıza göre sayılırlar.

Çözümünüz makul bir sürede tamamlanmalıdır (mesela, iki liste için her bir donanımda bir dakikadan az bir süre var ~ her biri uzunluk 1000).

Haskell, 45 42 bayt

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

Çevrimiçi deneyin!

Düzenleme: @ Ørjan Johansen sayesinde -2 bayt, @dfeuer sayesinde -1 bayt.

MATL , 18 bayt

YY_iti!=Xa)hStdfQ)

Çevrimiçi deneyin!

Bu iki adımda çalışır. İlk olarak kesişme, muhtemelen kopyalarla hesaplanır. Bu, bir dizinin tüm öğelerini diğerinin tüm öğeleriyle karşılaştırmaya ve birincinin ikinci öğesinde bulunan öğelerini tutmaya dayanır.

Daha sonra kopyalar kaldırılır. Bunun için, önceki adımdaki dizi sıralanır ve öncekinden farklıysa girişler tutulur. -infİlk (yani en düşük) değerin kaybolmaması için bir değer eklenir.

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

Jöle, 13 bayt

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

Çevrimiçi deneyin!

Nasıl çalışı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.

golflua , 68 karakter

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

hangisi denir

> 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

Düzenli Lua'da, bu

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

Yani temelde iki tablonun her elemanı üzerinde yineleme ve sadece eşdeğer değerleri depolamak. Değeri key ( k[w]=w) olarak kullanarak, tüm kopyaları kaldırıyorum. Daha sonra, yeni tabloyu ,pairs

JavaScript (ES6), 66 bayt

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

Kullanmadan indexOf, izin verildiğine ikna olmadığım için.

Pyth, 12 11 bayt

eMrSsq#RQE8

gösteri

Açıklama:

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.

bash + GNU coreutils, 184 Bayt

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

çağırma:

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

Çıktı:

4
56
3

Kavşak boşsa çıktı yok. Bu komut dosyası sıralanmaz ve ilk kümenin boş olup olmadığını kontrol eder. Açıklama:

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

Bilmeniz gereken bonus: Bunu grep -o .sayılar yerine rastgele dizelerle yapmak için değiştirebilirsiniz .

Perl 6, 26 37 bayt

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

kullanım

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

Arsız rakipsiz cevap

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

ya da sıkıcı ol fişlevinde isterseniz

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

Retina , 63 bayt

Son iki satır kopyaları kaldırır. Giriş, virgülle ayrılmış iki boşlukla ayrılmış listedir. Çıktı boşlukla sınırlandırılmıştır.

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

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

Çevrimiçi deneyin

Çıktıda kopyalara izin verilirse, programım 42 bayt olur.

Jq 1,5 , 99 bayt

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

Expanded

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
;

Bu, {}nesnelerin kullanılmasını önler ve jq'nin bit işlemleri olmadığından, bunlar bir dizi ile öykünür.

Çevrimiçi deneyin!

Aksiyom, 411 bayt

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 ve testi

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

Aksiyom, 257 bayt

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)

Bu binsearch kullanmadan ... Ama büyük O bilmiyorum ... Unglofed ve sonuçları:

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

Birçok test yürütülmedi bu yüzden hata olabilir ...

Jöle , 12 bayt

pEÐfḢ€ĠḢ€$ị$

Çevrimiçi deneyin!

Kabuk , 9 bayt

mo←←kIfE*

Çevrimiçi deneyin!

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.

GitHub'da kHusk'un kaynak koduna bakıldığında, ("keyon") listeyi sıralama ve bitişik değerleri gruplama bileşimi olarak uygulanır, bu yüzden aslında "groupOn" uygulamasını bulamasam da muhtemelen t Haskell işlevsel bir dil olduğundan ve bitişik eşit değerleri gruplandırmak oldukça basit bir şekilde bağlantılı bir liste üzerinde azaltma işlemidir. (I yapabilirsiniz uygulanmasını bulmak kBen değiştirerek burada kullanabilirsiniz bireyin diğer tip imza 'keyby', Iiçin =, fakat nasıl çalıştığını tam olarak söyleyemem bu yüzden Haskell bilmiyorum.)

Ayrıca, her türlü set işlemine izin verilmediğini fark etmeden önce bulduğum güzel bir Brachylog cevabı: ⟨∋∈⟩ᵘ

R ', 141 83 bayt

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 tarafından geliştirildi

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

Çevrimiçi deneyin buraya buraya

Python3, 51 bayt

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

Giriş listeleri kopyalar içeriyorsa:

Python3, 67 bayt

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

PHP ,78, 77 bayt

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

Çevrimiçi deneyin!

Hayır fırfırlar, ama kural uyumlu (sanırım).

Çıktı

[], []
[]

[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]
[]