Mục tiêu của bạn là tính toán giao điểm đã đặt của hai danh sách số nguyên. Giao điểm được định nghĩa là nhóm số nguyên không theo thứ tự duy nhất được tìm thấy ít nhất một lần trong cả hai danh sách đầu vào.

Đầu vào

Đầu vào có thể ở bất kỳ định dạng nào mong muốn (tham số hàm, stdio, v.v.) và bao gồm hai danh sách các số nguyên. Bạn không giả định bất cứ điều gì về mỗi danh sách ngoài chúng có thể chứa bất kỳ số nguyên không âm nào (nghĩa là chúng không được sắp xếp, có thể chứa các bản sao, có thể có độ dài khác nhau và thậm chí có thể trống). Giả định rằng mỗi số nguyên sẽ phù hợp với loại số nguyên có chữ ký của ngôn ngữ của bạn, có thể dài hơn 1 chữ số thập phân và được ký.

Ví dụ đầu vào:

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

Đầu ra

Đầu ra là bất kỳ danh sách nào giống như số nguyên biểu thị giao điểm đã đặt của hai danh sách theo bất kỳ định dạng nào mong muốn (giá trị trả về, stdio, v.v.). Không có yêu cầu rằng đầu ra phải được sắp xếp, mặc dù bạn được hoan nghênh cung cấp một triển khai luôn luôn được sắp xếp. Đầu ra phải tạo thành một tập hợp không có thứ tự hợp lệ (ví dụ: nó không được chứa bất kỳ giá trị trùng lặp nào).

Các trường hợp thử nghiệm ví dụ (lưu ý rằng thứ tự của đầu ra không quan trọng):

Hai dòng đầu tiên là danh sách đầu vào, dòng thứ ba là đầu ra. (empty)biểu thị danh sách trống.

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

Chấm điểm

Đây là mã golf; câu trả lời ngắn nhất trong byte thắng.

Lỗ vòng tiêu chuẩn bị cấm. Bạn có thể sử dụng bất kỳ tính năng tích hợp nào không được thiết kế cho các hoạt động giống như thiết lập.

Các tính năng tích hợp bị cấm:

• thiết lập tạo / loại bỏ trùng lặp
• thiết lập sự khác biệt / giao lộ / liên minh
• Kiểm tra thành viên tổng quát (ví dụ: mọi thứ tương tự như intừ khóa trong Python, indexOfgiống như các hàm, v.v.). Lưu ý rằng việc sử dụng các cấu trúc "mục foreach trong danh sách" được cho phép (giả sử chúng không vi phạm bất kỳ hạn chế nào khác), mặc dù thực tế là Python sử dụng lại intừ khóa để tạo cấu trúc này.
• Các phần tử tích hợp bị cấm này là "vi-rút", nghĩa là nếu có phần tích hợp lớn hơn chứa bất kỳ tính năng phụ nào thì nó cũng bị cấm tương tự (ví dụ: lọc theo tư cách thành viên trong danh sách).

Bất kỳ tích hợp nào không có trong danh sách trên đều được cho phép (ví dụ: sắp xếp, kiểm tra đẳng thức nguyên, liệt kê thêm / xóa theo chỉ mục, lọc, v.v.).

Ví dụ: lấy hai đoạn ví dụ sau (mã giống như Python):

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

Bạn có thể tự mình thực hiện bất kỳ tính năng nào giống như tập hợp này và chúng sẽ được tính vào điểm số của bạn.

Giải pháp của bạn nên hoàn thành trong một khoảng thời gian hợp lý (giả sử, chưa đến một phút cho bất kỳ phần cứng nào bạn có cho hai danh sách ~ độ dài 1000 mỗi danh sách).

Haskell, 45 42 byte

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

Hãy thử trực tuyến!

Chỉnh sửa: -2 byte nhờ @ janrjan Johansen, -1 byte nhờ @dfeuer.

MATL , 18 byte

YY_iti!=Xa)hStdfQ)

Hãy thử trực tuyến!

Điều này hoạt động trong hai bước. Đầu tiên giao điểm được tính toán, có thể với các bản sao. Điều này dựa trên việc so sánh tất cả các phần tử của một mảng với tất cả các phần tử của mảng khác và giữ các phần tử của phần tử đầu tiên có mặt trong phần thứ hai.

Sau đó, các bản sao được loại bỏ. Đối với điều này, mảng từ bước trước được sắp xếp và các mục được giữ nếu khác với bước trước. Một -infgiá trị được đặt trước để giá trị đầu tiên (tức là thấp nhất) không bị mất.

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

Thạch, 13 byte

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

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

Ṃ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 ký tự

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

được gọi là

> 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

Trong Lua thường xuyên, điều này sẽ là

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

Vì vậy, về cơ bản, tôi đang lặp lại qua từng phần tử của hai bảng và chỉ lưu trữ các giá trị tương đương. Bằng cách sử dụng giá trị làm khóa ( k[w]=w), tôi sẽ loại bỏ tất cả các bản sao. Sau đó chúng tôi xuất bảng mới bằng cách lặp qua chỉ số & giá trị củapairs

JavaScript (ES6), 66 byte

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

Không sử dụng indexOf, vì tôi không tin rằng nó được cho phép.

Bình thường, 12 11 byte

eMrSsq#RQE8

Trình diễn

Giải trình:

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 + lõi core GNU, 184 byte

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

Cầu nguyện:

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

Đầu ra:

4
56
3

Không có đầu ra nếu giao lộ trống. Kịch bản này không sắp xếp và kiểm tra độ tỉnh táo nếu bộ đầu tiên trống. Giải trình:

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

Phần thưởng cần biết: Bạn có thể thay đổi grep -o .để làm điều này với các chuỗi ngẫu nhiên thay vì số.

Perl 6, 26 37 byte

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

sử dụng

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

Câu trả lời táo bạo không cạnh tranh

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

hoặc nếu bạn thích nó trong một fchức năng ol 'nhàm chán

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

Võng mạc , 63 byte

Hai dòng cuối cùng loại bỏ trùng lặp. Đầu vào là hai danh sách được phân tách bằng dấu cách được phân tách bằng dấu phẩy. Đầu ra được phân cách bằng khoảng trắng.

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

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

Dùng thử trực tuyến

Nếu các bản sao trong đầu ra được cho phép, chương trình của tôi sẽ là 42 byte.

Jq 1.5 , 99 byte

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

Mở rộng

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
;

Điều này tránh sử dụng {}các đối tượng và vì jq không có hoạt động bit nên điều này mô phỏng chúng với một mảng.

Hãy thử trực tuyến!

Tiên đề, 411 byte

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 và kiểm tra

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

Tiên đề, 257 byte

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)

Điều này mà không cần sử dụng binsearch ... Nhưng tôi không biết O lớn ... Kết quả và kết quả:

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

Không thực hiện nhiều bài kiểm tra nên có thể bị lỗi ...

Thạch , 12 byte

pEÐfḢ€ĠḢ€$ị$

Hãy thử trực tuyến!

Husk , 9 byte

mo←←kIfE*

Hãy thử trực tuyến!

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.

Tìm kiếm mã nguồn của Husk trên GitHub, k("keyon") được triển khai như là thành phần sắp xếp danh sách và nhóm các giá trị liền kề, vì vậy mặc dù tôi thực sự không thể tìm thấy việc triển khai "groupOn" có thể an toàn khi cho rằng nó không ' Không làm bất cứ điều gì nhỏ nhặt, vì Haskell là một ngôn ngữ chức năng và việc nhóm các giá trị bằng nhau liền kề là một hoạt động giảm danh sách liên kết khá đơn giản. (Tôi có thể tìm thấy việc triển khai kchữ ký loại "keyby" khác, mà tôi có thể sử dụng ở đây bằng cách thay đổiI thành =, nhưng tôi không biết Haskell vì vậy tôi không thể biết chính xác nó hoạt động như thế nào.)

Ngoài ra, một câu trả lời Brachylog nhỏ mà tôi đã đưa ra trước khi tôi nhận ra các hoạt động của tất cả các loại đều không được phép: ⟨∋∈⟩ᵘ

R. 141 83 byte

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

Được cải thiện bởi Giuseppe

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

Thử trực tuyến đây đây

Python3, 51 byte

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

Nếu danh sách đầu vào có thể chứa các bản sao:

Python3, 67 byte

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

PHP ,78, 77 byte

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

Hãy thử trực tuyến!

Không rườm rà, nhưng tuân thủ quy tắc (tôi nghĩ).

Đầu ra

[], []
[]

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