Viết chương trình sẽ lấy 2 mảng số nguyên đầu vào và trả về giá trị trung thực nếu tồn tại một phần tử có trong cả hai mảng hoặc một mảng giả. Giải pháp rõ ràng cho vấn đề này là lặp đi lặp lại qua từng phần tử trong mảng đầu tiên và so sánh nó với từng phần tử trong phần thứ hai, nhưng đây là nhược điểm: Chương trình của bạn phải có độ phức tạp thuật toán nhiều nhất, trong trường hợp xấu nhất là O ( NlogN), trong đó N là chiều dài của mảng dài hơn,

Các trường hợp thử nghiệm:

 {1,2,3,4,-5},{5,7,6,8} -> false
 {},{0}                 -> false
 {},{}                  -> false
 {1,2},{3,3}            -> false
 {3,2,1},{-4,3,5,6}     -> true
 {2,3},{2,2}            -> true

Đây là mã golf , vì vậy mã ngắn nhất tính bằng byte sẽ thắng.

Trên thực tế , 1 byte

∩

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

Đây chỉ đơn thuần là giao lộ được thiết lập sẵn. Giá trị kết quả là giao điểm của hai bộ - danh sách không trống (là giá trị trung thực) nếu có giao điểm và danh sách trống (là giá trị falsey) nếu không.

Phức tạp

Theo Python Wiki , giao điểm tập hợp có độ phức tạp thời gian trong trường hợp xấu nhất là O(N*M)(trong đó Nvà Mlà độ dài của hai bộ). Tuy nhiên, độ phức tạp thời gian chỉ xấu khi hai bộ chứa các đối tượng riêng biệt mà tất cả đều có cùng giá trị băm (ví dụ {"some string"} & {hash("some string")}:). Do các phần tử tập hợp chỉ là số nguyên trong trường hợp này (và không có hai số nguyên nào băm vào cùng một giá trị trừ khi chúng bằng nhau), nên độ phức tạp trong trường hợp xấu nhất thực tế là O(min(N, M))(tuyến tính theo độ dài nhỏ hơn của hai tập hợp). Cấu trúc của mỗi bộ là O(N)(tuyến tính theo số lượng phần tử), vì vậy độ phức tạp tổng thể là O(max(N, M))(độ phức tạp bị chi phối bởi việc xây dựng bộ lớn hơn).

TSQL, 40 37 36 byte

SQL không có mảng, nó đang sử dụng các bảng thay thế

Trả về -1 cho đúng hoặc 0 cho sai

DECLARE @ table(a INT)
DECLARE @2 table(b INT)

INSERT @ values(1),(2),(3),(4),(-5)
INSERT @2 values(5),(6),(7),(8)

SELECT~-sign(min(abs(a-b)))FROM @,@2

Dùng thử

Ruby, 37 byte:

exit ($*.map{|x|eval x}.reduce:&)!=[]

Như trong định nghĩa: "chương trình sẽ lấy 2 mảng số nguyên đầu vào và trả về giá trị trung thực nếu ...", đây là chương trình, chấp nhận 2 mảng dưới dạng chuỗi trong đầu vào, trả về đúng hoặc sai.

dưới dạng hàm - 14 byte:

->a,b{a&b!=[]}

Phức tạp:

Tài liệu ruby ​​của toán tử itnersection (&) cho biết "Nó so sánh các phần tử bằng cách sử dụng các phương thức băm và eql của chúng để đạt hiệu quả.", Mà tôi cho rằng chính xác là những gì chúng ta đang tìm kiếm.

Theo kinh nghiệm:

$ time ruby a.rb "[*1..1000001]" "[*1000001..2000000]"

real    0m0.375s
user    0m0.340s
sys 0m0.034s

$ time ruby a.rb "[*1..2000001]" "[*2000001..4000000]"

real    0m0.806s
user    0m0.772s
sys 0m0.032s

$ time ruby a.rb "[*1..4000001]" "[*4000001..8000000]"

real    0m1.932s
user    0m1.857s
sys 0m0.073s

$ time ruby a.rb "[*1..8000001]" "[*8000001..16000000]"

real    0m4.464s
user    0m4.336s
sys 0m0.119s

Mà dường như để xác nhận nó.

Perl, 25 + 1 = 26 byte phối hợp với Dada

print 2<($a{$_}|=$.)for@F

Chạy với -a(1 byte hình phạt).

Một phiên bản cải tiến của chương trình bên dưới (được lưu giữ để xem lịch sử của giải pháp và để hiển thị giải pháp mà tôi tự tìm thấy; nó cũng có nhiều lời giải thích hơn). Các -atùy chọn đọc các mảng không gian tách biệt như đầu vào, lưu trữ chúng trong @F. Chúng tôi sử dụng %atừ điển (được truy cập dưới dạng $a{$_}) để lưu trữ một bitmask trong đó mảng đầu vào nằm trong và in 1mỗi khi chúng ta thấy một phần tử trong cả hai mảng, nghĩa là giá trị cao hơn 2 bên trong bitmask kết quả (may mắn thay, một sự so sánh không trả về chuỗi null, vì vậy printkhông có gì). Chúng tôi không thể sử dụng sayvì một dòng mới là sự thật trong Perl. Hiệu suất không giống như phiên bản cũ của chương trình (nhưng nhanh hơn về các yếu tố không đổi).

Perl, 44 + 1 = 45 byte

$a{"+$_"}|=$.for split}{$_={reverse%a}->{3}

Chạy với -p(1 byte hình phạt). Nhập một mảng trên mỗi dòng, tách các phần tử bằng khoảng trắng.

Điều này hoạt động thông qua việc tạo bảng băm %alưu trữ bitmask của mảng đầu vào mà giá trị đã được nhìn thấy. Nếu nó được nhìn thấy trong cả mảng trên dòng 1 và dòng 2, bitmask sẽ lưu trữ giá trị 3. Đảo ngược giá trị băm và xem nếu 3 có một khóa tương ứng cho chúng tôi biết nếu có bất kỳ giá trị chung nào.

Độ phức tạp của thuật toán này là O (n) nếu bạn coi việc tạo hàm băm là thời gian không đổi (nghĩa là, nếu bạn có các số nguyên bị ràng buộc, giống như Perl). Nếu sử dụng số nguyên bignum (có thể được nhập vào chương trình này, vì nó để lại đầu vào dưới dạng chuỗi), thì độ phức tạp của thuật toán sẽ là O (n log n) cho mỗi lần tạo băm và O (n) cho mỗi lần tạo băm và O (n) cho hàm băm đảo ngược, cộng vào O (n log n). Tuy nhiên, thuật toán băm của Perl chịu hiệu suất O (n²) tiềm năng với đầu vào được chọn độc hại; Tuy nhiên, thuật toán được chọn ngẫu nhiên để không thể xác định đầu vào đó là gì (và có thể nó không thể được kích hoạt đơn giản với các số nguyên), do đó, nó gây tranh cãi về mức độ phức tạp mà nó "tính" về mặt đạo đức. May mắn thay, điều này không thành vấn đề trong trường hợp có '

Mã này sẽ hoạt động cho đầu vào không phải là số nguyên, nhưng nó sẽ không hoạt động trong hơn hai mảng (vì 3mã hóa cứng và vì đầu vào trên dòng thứ ba sẽ không bitmask chính xác, vì nó không phải là lũy thừa 2). Khá khó chịu, mã tự nhiên trả về một trong các phần tử trùng lặp, đó là sự thật trong hầu hết các trường hợp, nhưng "0"là falsey trong Perl và một phần tử trùng lặp hợp lệ trong mảng. Như vậy, tôi đã phải lãng phí ba byte +chuẩn bị cho đầu ra, đây là cách rẻ nhất mà tôi tìm thấy để đưa ra một đầu ra trung thực trong trường hợp cạnh của các mảng chồng chéo tại 0. Nếu tôi được phép sử dụng khái niệm về truthy và falsey từ một ngôn ngữ khác ngoài Perl (trong đó bất kỳ chuỗi rỗng là truthy), bạn có thể thay đổi "+$_"để $_cứu ba byte.

Python2 - 41 30 byte

lambda a,b:bool(set(a)&set(b))

Đặt giao điểm: O (min (N, M)) trong đó N và M là chiều dài của các tập hợp.

Chuyển đổi từ danh sách thành tập hợp: O (max (N, M))

• Cảm ơn Jakube vì đã tiết kiệm 9 byte! set(a).intersection(b)->set(a)&set(b)
• Cảm ơn Kade vì đã tiết kiệm 2 byte! -> đã xóaf=

Tiên đề, 439 byte

c:=0;s(x,y)==(free c;if x.1=%i and y.2=%i then(x.2<y.1=>return true;x.2>y.1=>return false;c:=1;return false);if x.2=%i and y.1=%i then(x.1<y.2=>return true;x.1>y.2=>return false;c:=1;return false);if x.1=%i and y.1=%i then(x.2<y.2=>return true;x.2>=y.2=>return false);if x.2=%i and y.2=%i then(x.1<y.1=>return true;x.1>=y.1=>return false);false);r(a,b)==(free c;c:=0;m:=[[%i,j] for j in a];n:=[[i,%i] for i in b];r:=merge(m,n);sort(s,r);c)

điều này chuyển đổi danh sách đầu tiên trong danh sách dưới dạng [[i, 1], [i, 2] ...] danh sách thứ hai trong danh sách là [[1, i], [0, i] ...] trong đó tôi là biến số tưởng tượng hơn là hợp nhất danh sách 2 và tạo một loại sẽ tìm thấy nếu có một phần tử của danh sách 1 trong danh sách 2, vì vậy nó nằm ở cuối O (N log N) trong đó danh sách N = lenght 1 + danh sách chiều dài 2

vô dụng

-- i get [0,0,1,2,3] and [0,4,6,7]  and build [[%i,0],[%i,0],[%i,1],[%i,2] [%i,3],[0,%i],..[7,%i]]
c:=0
s(x:List Complex INT,y:List Complex INT):Boolean==
  free c  -- [%i,n]<[n,%i]
  if x.1=%i and y.2=%i then
    x.2<y.1=> return true 
    x.2>y.1=> return false
    c:=1
    return false
  if x.2=%i and y.1=%i then
    x.1<y.2=>return true
    x.1>y.2=>return false
    c:=1
    return false
  if x.1=%i and y.1=%i then
    x.2< y.2=>return true
    x.2>=y.2=>return false
  if x.2=%i and y.2=%i then
    x.1< y.1=>return true
    x.1>=y.1=>return false
  false


r(a,b)==
  free c
  c:=0
  m:=[[%i, j]  for j in a]
  n:=[[ i,%i]  for i in b]
  r:=merge(m,n)
  sort(s, r)
  c

các kết quả

(12) -> r([1,2,3,4,-5], [5,7,6,8]), r([],[0]), r([],[]), r([1,2],[3,3]), r([3,2,1],[-4,3,5,6]), r([2,3],[2,2])
   Compiling function r with type (List PositiveInteger,List Integer)
       -> NonNegativeInteger
   Compiled code for r has been cleared.
   Compiled code for s has been cleared.
   Compiling function r with type (List PositiveInteger,List
  PositiveInteger) -> NonNegativeInteger
   Compiled code for r has been cleared.
   Compiling function s with type (List Complex Integer,List Complex
      Integer) -> Boolean
   Compiled code for s has been cleared.

   (12)  [0,0,0,0,1,1]
                                           Type: Tuple NonNegativeInteger

tôi không hiểu tại sao nó "xóa" mã cho r và s ...

PowerShell, 88 78 77 23 byte

!!(diff -Inc -Ex $A $B)

Nhờ @briantist cho cạo ra khỏi một con số khổng lồ 54 byte từ ban đầu của tôi, nhiều tiết câu trả lời bằng cách rút ngắn -IncludeEqual, -ExcludeDifferentvà -Not!

if(-Not(diff -IncludeEqual -ExcludeDifferent $A $B)){("false")}else{("true")}

Tôi không thể tìm thấy nguồn cho Compare-Object ( difflà bí danh cho Compare-Object), vì vậy tôi không chắc chắn về độ phức tạp thời gian.

PHP , 15 byte

array_intersect

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

Một PHP tích hợp, như là một hàm có thể gọi / lambda. Trả về là một giá trị PHP truthy/ falseycó thể kiểm tra. Ngoài ra, theo trình đệ trình PHP khác, việc triển khai này phải đáp ứng các yêu cầu về độ phức tạp thách thức ( StackExchange ).

R, 23 byte

sum(scan()%in%scan())>0

Nếu chúng ta giả sử rằng sẽ luôn có một và chỉ một yếu tố khớp với nhau và đó 1là một giá trị trung thực (có trong R ), thì chúng ta có thể viết:

sum(scan()%in%scan())

đó là 21 byte.

PHP, 55 51 byte

<?=count(array_intersect($_GET[a],$_GET[b]))<1?0:1;

Cách sử dụng: lưu trong tệp và gọi từ trình duyệt:

intersect.php?a[]=1&a[]=2&a[]=3&b[]=0&b[]=4&b[]=5đầu ra 0cho false.

intersect.php?a[]=1&a[]=2&a[]=3&b[]=0&b[]=4&b[]=1đầu ra 1cho true.

Về độ phức tạp, tôi không thể tìm thấy tài liệu tham khảo nhưng theo bài đăng của StackOverflow này , kịch bản sẽ ổn

GolfScript, 1 byte

Nếu lấy đầu vào trực tiếp làm mảng trên ngăn xếp được cho phép, giải pháp GolfScript một byte này sẽ đáp ứng thông số kỹ thuật:

&

Nếu I / O dựa trên văn bản là bắt buộc, đầu vào cần được đánh giá trước, đẩy độ dài lên đến hai byte:

~&

Cả hai giải pháp này đều sử dụng toán tử giao điểm mảng GolfScript, được triển khai bằng toán tử tương ứng trong Ruby . Chúng trả về một mảng trống (là sai) nếu các mảng không chứa các phần tử phù hợp hoặc một mảng không trống (đó là sự thật) có chứa tất cả các phần tử phù hợp khác.

Cho đến nay tôi không thể tìm thấy bất kỳ tài liệu nào về việc triển khai nội bộ hoặc độ phức tạp tiệm cận của toán tử giao điểm mảng Ruby, ngoài tuyên bố ngắn gọn rằng "Nó so sánh các phần tử bằng cách sử dụng phương pháp băm và eql?" Cho hiệu quả. " Tuy nhiên, việc triển khai hợp lý bằng cách sử dụng bảng băm sẽ chạy trong thời gian O ( n ) (giả sử rằng băm và so sánh là O (1)) và một số thử nghiệm hiệu suất nhanh cho thấy đây thực sự là trường hợp:

Các xét nghiệm được thực hiện bằng cách sử dụng chương trình GolfScript ~2?.2*,/&, trong đó có một số nguyên k , tạo ra một chuỗi số học của 2 × 2 ^k yếu tố, chia nó thành hai mảng của 2 ^k yếu tố và tính (rõ ràng trống) ngã tư của họ. Các ngôi sao màu đỏ hiển thị thời gian thực hiện đo t trong vài giây (trên thang điểm từ logarit) cho các giá trị khác nhau của k , trong khi lô đường màu xanh chức năng t = c × 2 ^k , nơi rộng liên tục c ≈ 2 ^-17,075 được chọn để tốt nhất phù hợp với dữ liệu đo được.

(Lưu ý rằng, trên biểu đồ log-log như thế này, bất kỳ hàm đa thức nào có dạng t = c × (2 ^k ) ^a sẽ tạo ra một đường thẳng. Tuy nhiên, độ dốc của đường phụ thuộc vào số mũ a và dữ liệu chắc chắn là phù hợp với một = 1 như thể hiện bằng đường màu xanh lá cây ở trên. FWIW, các số tốt nhất điều chỉnh kích thước mũ cho tập dữ liệu này là một ≈ 1,00789.)

JavaScript (ES6), 39 byte

(a,b,c=new Set(b))=>a.some(e=>c.has(e))

Sẽ tệ hơn O (n + m) nhưng hy vọng không tệ như O (n * m).

Rust, 103 byte

|a:&[i32],b:&[i32]|!b.iter().collect::<std::collections::HashSet<_>>().is_disjoint(&a.iter().collect())

Đưa hai lát mảng (hoặc tham chiếu đến các mảng đầy đủ, chúng tự động chuyển sang các lát), bó chúng thành các bộ và kiểm tra sự không phân biệt. Tôi không chắc chắn cách tập hợp được triển khai trong thư viện tiêu chuẩn Rust, nhưng nó phải là O (n + m) tồi tệ nhất.

Không sử dụng các bộ sưu tập, cách thay thế dễ nhất tôi thấy là sắp xếp cả hai mảng, sau đó bước qua chúng một cách cẩn thận để tìm kiếm các bản sao. Một cái gì đó như thế này

fn overlapping(a: &Vec<i32>, b: &Vec<i32>) -> bool{
    let mut sa = a.clone();
    sa.sort();
    let mut sb = b.clone();
    sb.sort();
    let mut ai = 0;
    let mut bi = 0;
    while ai < a.len() && bi < b.len() {
        if sa[ai] < sb[bi] {
            ai += 1;
        } else if sa[ai] > sb[bi] {
            bi += 1;
        } else{
            return true;
        }
    }
    false
}

Nhưng điều đó đòi hỏi quá nhiều đột biến để trở thành niềm vui khi chơi golf trong Rust IMO :)

Python, 11 byte

set.__and__

Nội dung có 2 bộ và giao nhau trên chúng

Tiên đề, 50 221 byte

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

vô dụng

--suppose v.1<=v.2<=....<=v.#v
--   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  --1  4
    repeat
       l>h=>break
       m:=(l+h)quo 2   --m=(4+1)/2=5/2=2
                       --output [l,m,h]
       x<v.m=>(h:=m-1) --l x m  h =>  
       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)
  --output c
  for x in w repeat(if binSearch(x,c)~=0 then return 1)
  0

g (a, b) nhận được mảng lớn hơn beetwin a và b; giả sử nó có N phần tử: sắp xếp mảng đó, thực hiện tìm kiếm nhị phân với các phần tử mà mảng khác. Đây sẽ là O (Nlog (N)). Nó trả về 0 cho không có phần tử nào của a trong b, 1 nếu không.

các kết quả

(6) ->  g([1,2,3,4,-5], [5,7,6,8]), g([],[0]), g([],[]), g([1,2],[3,3]), g([3,2,1],[-4,3,5,6]), g([2,3],[2,2])
   Compiling function binSearch with type (PositiveInteger,List Integer
      ) -> NonNegativeInteger

   (6)  [0,0,0,0,1,1]
                                           Type: Tuple NonNegativeInteger

Thạch , 2 byte

œ&

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

Giải trình

 œ&  Main link. Arguments: x y
⁸    (implicit) x
   ⁹ (implicit) y
 œ&  Intersection of x and y