入力2の整数配列を受け取り、両方の配列に存在する要素が存在する場合は真の値を返し、そうでない場合は偽の要素を返すプログラムを記述します。この問題の明らかな解決策は、最初の配列の各要素を反復処理し、2番目の配列の各要素と比較することですが、ここで問題があります。プログラムには、最悪の場合、O（ NlogN）、Nはより長い配列の長さ、

テストケース：

 {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

これはcode-golfなので、バイト単位の最も短いコードが優先されます。

実際には、1バイト

∩

オンラインでお試しください！

これは単に組み込みの交差点セットです。結果の値は、2つのセットの共通部分です。共通部分がある場合は空ではないリスト（真の値）、それ以外の場合は空のリスト（誤った値）です。

複雑

Python Wikiによると、セットの交差は最悪の場合の時間の複雑さを持っていますO(N*M)（NとMは2つのセットの長さです）。ただし、時間の複雑さは、2つのセットにすべて同じハッシュ値を持つ個別のオブジェクト（たとえば、{"some string"} & {hash("some string")}）が含まれている場合にのみ悪くなります。この場合、セットの要素は整数のみであり（2つの整数が等しくない限り、同じ値にハッシュされない）、実際の最悪の場合の複雑さはO(min(N, M))（2つのセットのうち小さい方の長さで線形）です。各セットの構造はO(N)（要素数で線形）であるため、全体的な複雑さはO(max(N, M))（複雑さはより大きなセットの構造によって支配されます）。

TSQL、40 37 36バイト

SQLには配列がありません。代わりにテーブルを使用しています

trueの場合は-1、falseの場合は0を返します

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

やってみて

Ruby、37バイト：

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

定義のように：「入力2の整数配列を受け取り、真の値を返す場合...」の場合、これはプログラムであり、入力で2つの配列を文字列として受け入れ、trueまたはfalseを返します。

関数として-14バイト：

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

複雑：

itnersection（＆）演算子のルビのドキュメントには、「効率のためにハッシュとeql？メソッドを使用して要素を比較する」とあります。これはまさに私たちが探しているものだと思います。

経験的に：

$ 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

それはそれを確認しているようです。

Perl、25 + 1 = Dadaと共同で26バイト

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

-a（1バイトのペナルティ）で実行します。

以下のプログラムの改善されたバージョン（これは、ソリューションの履歴を確認したり、自分で見つけたソリューションを表示したりするために残されています。さらに説明があります）。この-aオプションは、スペースで区切られた配列を入力として読み取り、それらをに格納します@F。%a辞書（としてアクセス$a{$_}）を使用して、入力が含まれている入力配列のビットマスクを格納し、1両方の配列に要素が見つかるたびに出力します。 null文字列なので、print何も行いません）。sayPerlでは改行が真実であるため使用できません。パフォーマンスは、プログラムの古いバージョンと漸近的に同じです（ただし、一定の要素に関しては高速です）。

Perl、44 + 1 = 45バイト

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

-p（1バイトのペナルティ）で実行します。要素をスペースで区切って、1行に1つの配列を入力します。

これ%aは、値が表示された入力配列のビットマスクを格納するハッシュテーブルを作成することで機能します。1行目と2行目の両方の配列に表示された場合、ビットマスクは値3を格納します。ハッシュし、3に対応するキーがあるかどうかを確認すると、共通の値があるかどうかがわかります。

このアルゴリズムの複雑さは、ハッシュの作成を一定の時間と見なす場合（つまり、Perlのように整数に制限がある場合）はO（n）です。bignum整数（入力を文字列として残すため、このプログラムに入力できる）を使用する場合、アルゴリズム自体の複雑さは、名目上、ハッシュ作成ごとにO（n log n）であり、ハッシュ逆転、つまりO（n log n）になります。ただし、Perlのハッシュアルゴリズムは、悪意を持って選択された入力での潜在的なO（n²）パフォーマンスの影響を受けます。ただし、アルゴリズムはランダム化されているため、その入力が何であるかを判別することはできません（整数で単純にトリガーできない可能性もあります）。そのため、「道徳的に」カウントする複雑さのクラスについては議論の余地があります。幸いなことに、これは問題ではありません

このコードは整数以外の入力に対しては3機能しますが、3 つ以上の配列に対しては機能しません（これはハードコードされているため、3行目の入力は2の累乗ではないため、ビットマスクが正しくないためです）。むしろ面倒なことに、コードは自然に重複要素の1つを返します。これはほとんどすべての場合において"0"真実ですが、Perlでは誤っており、配列では有効な重複要素です。その+ため、出力の前にa を付加して3バイトを無駄にする必要がありました。これは、で重複する配列のエッジケースで真の出力を提供するために見つけた最も安い方法0です。Perl以外の言語（空でない文字列が真実である）から真実と偽の概念を使用することが許可されている場合は、3バイトを節約"+$_"する$_ように変更できます。

Python2 - 41の 30バイト

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

セットの交差：O（min（N、M））ここで、NとMはセットの長さです。

リストからセットへの変換：O（max（N、M））

• 9バイト節約してくれたJakubeに感謝！set(a).intersection(b)->set(a)&set(b)
• 2バイトを節約してくれたKadeに感謝！->削除f=

公理、439バイト

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、1]、[i、2] ...]として変換します。リストの2番目のリストを[[1、i]、[0、i] ...]として変換します。ここで、i 2のリストをマージするよりも虚数の変数であり、リスト2にリスト1の要素が1つある場合に1つの並べ替えを行うので、最後にO（N log N）になります。ここで、N = lenght list 1 + lenght list 2

ない

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

結果

(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

なぜrとsのコードを「クリア」するのか理解できません...

PowerShell、88 78 77 23バイト

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

私の元からなんと54のバイトオフシェービング用@briantistのおかげで、より短くすることで答え冗長-IncludeEqual、-ExcludeDifferentと-Not！

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

Compare-Object（diffのエイリアスCompare-Object）のソースが見つからないため、時間の複雑さはわかりません。

PHP、15バイト

array_intersect

オンラインでお試しください！

呼び出し可能な / lambda関数としてのPHP組み込み。戻り値はPHP truthy/ falseyテスト可能な値です。また、他のPHP提出に従って、この実装はチャレンジの複雑さの要件を満たす必要があります（StackExchange）。

R、23バイト

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

一致する要素が常に1つだけ存在し、それ1が真の値（これはRにある）であると仮定すると、次のように記述できます。

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

これは21バイトです。

PHP、55 51バイト

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

使用法：ファイルに保存して、ブラウザーから呼び出します。

intersect.php?a[]=1&a[]=2&a[]=3&b[]=0&b[]=4&b[]=5出力0のためにfalse。

intersect.php?a[]=1&a[]=2&a[]=3&b[]=0&b[]=4&b[]=1出力1のためにtrue。

複雑さについては、参照を見つけることができませんでしたが、このStackOverflowの投稿によると、スクリプトは問題ありません

GolfScript、1バイト

スタック上の配列として入力を直接受け取ることが許可されている場合、この1バイトのGolfScriptソリューションは次の仕様を満たす必要があります。

&

テキストベースのI / Oが必要な場合は、まず入力を評価して、長さを最大2バイトにプッシュする必要があります。

~&

これらのソリューションはどちらも、Rubyの対応する演算子を使用して実装されるGolfScript配列交差演算子を使用します。配列に一致する要素が含まれていない場合は空の配列（偽）を返し、そうでない場合はすべての一致する要素を含む空でない配列（真実）を返します。

これまでのところ、Ruby配列交差演算子の内部実装または漸近的な複雑さに関するドキュメントは、「効率のためにハッシュとeql？メソッドを使用して要素を比較します」という簡単な説明を超えて見つけることができませんでした。ただし、ハッシュテーブルを使用した妥当な実装はO（n）時間で実行され（ハッシュと比較がO（1）であると想定）、いくつかの簡単なパフォーマンステストでこれが実際に当てはまることが示されています。

これらの試験はGolfScriptプログラムを用いて行った~2?.2*,/&整数かかり、kは、2×2つの演算シーケンス生成する^k個の 2つの二つの配列に分割し、要素^k個の要素とその（明らかに空の）交点を計算します。赤い星は、測定された実行時間を示しTを種々の値に対して（対数スケールで）秒K、機能緑色ラインプロットながらT = C ×2 ^kのスケーリング定数が、C ≈2 ^-17.075を最良に選択しました測定データに適合します。

（注：このような対数プロット上で、その任意の形式の多項式関数T = C ×（2 ^kは）直線を生じるであろう。しかしながら、線の傾きは、指数に依存A、およびデータ上の緑色の線で示されているように、a = 1 と確かに一致します。FWIW 、このデータセットの数値の最適指数は≈1.00789でした​​。）

JavaScript（ES6）、39バイト

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

O（n + m）より悪くなりますが、うまくいけばO（n * m）ほど悪くありません。

Rust、103バイト

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

2つの配列スライス（または完全な配列への参照、スライスへの参照解除を自動的に行う）を取得し、それらをセットにバンドルして、非素性をチェックします。Rust標準ライブラリでセットユニオンがどのように実装されているかはよくわかりませんが、最低でもO（n + m）である必要があります。

コレクションを使用しない場合、私が目にする最も簡単な方法は、両方の配列を並べ替え、それらを注意深くステップオーバーして重複を探すことです。このようなもの

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
}

しかし、Rust IMOでゴルフを楽しむには突然変異が多すぎる必要があります。

Python、11バイト

set.__and__

2つのセットを取り、それらを交差させる組み込み

公理、50 221バイト

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)

ない

--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）は、より大きな配列beetwin aおよびbを取得します。N個の要素があるとします。その配列を並べ替え、他の配列の要素を使用してバイナリ検索を実行します。これはO（Nlog（N））になります。bのaの要素がない場合は0を返し、それ以外の場合は1を返します。

結果

(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

ゼリー、2バイト

œ&

オンラインでお試しください！

説明

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