Bạn sẽ được cung cấp hai Mảng / Danh sách / Vectors các số nguyên không âm A và B . Nhiệm vụ của bạn là để sản lượng cao nhất số nguyên N mà xuất hiện trong cả hai Một và B , và cũng là duy nhất trong cả hai Một và B .

• Bạn có thể cho rằng có ít nhất một số như vậy.

• Bất kỳ phương thức / định dạng đầu vào và đầu ra hợp lý đều được cho phép.

• Những sơ hở này bị cấm.

• Đây là môn đánh gôn , vì vậy mã ngắn nhất trong mọi ngôn ngữ lập trình sẽ thắng!

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

A, B -> Đầu ra

[6], [1, 6] -> 6
[1, 2, 3, 4], [4, 5, 6, 7] -> 4
[0, 73, 38, 29], [38, 29, 73, 0] -> 73
[1, 3, 4, 6, 6, 9], [8, 7, 6, 3, 4, 3] -> 4
[2, 2, 2, 6, 3, 5, 8, 2], [8, 7, 5, 8] -> 5
[12, 19, 18, 289, 19, 17], [12, 19, 18, 17, 17, 289] -> 289
[17, 29, 39, 29, 29, 39, 18], [19, 19, 18, 20, 17, 18] -> 17
[17, 29, 39, 29, 29, 39, 18, 18], [19, 19, 18, 20, 17, 18] -> 17

Thạch , 7 byte

fċ@ÐṂ;Ṁ

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

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

fċ@ÐṂ;Ṁ  Main link. Left argument: A. Right argument: B

f        Filter; keep those elements of A that appear in B.
   ÐṂ    Yield all elements of the result for which the link to left yields a
         minimal value (2).
 ċ@        Count the occurrences of the element...
     ;     in the concatenation of A and B.
      Ṁ  Take the maximum.

Bash + coreutils, 49 byte

U()(sort -rn|uniq -u$1)
(U<<<$1;U<<<$2)|U D|sed q

Cảm ơn @seshoumara vì đã chơi golf 1 byte!

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

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

uniq nhận đầu vào được sắp xếp và thực hiện một hoặc một số hành động, tùy thuộc vào các cờ dòng lệnh.

U<<<$1và U<<<$2gọi hàm Uvới đối số dòng lệnh thứ nhất và thứ hai làm đầu vào. Đối với mỗi một, sort -rn|uniq -uđược thực thi, sắp xếp đầu vào số ( -n) và theo thứ tự giảm dần ( -r) cho uniq , sẽ chỉ in các dòng duy nhất ( -u).

Đầu ra của cả hai (các phần tử duy nhất của mỗi mảng) được nối và được dẫn đến U D, nghĩa là ,
sort -rn|uniq -uD. Lần này, uniq sẽ chỉ in các dòng trùng lặp ( -D) và chỉ lặp lại lần đầu tiên của mỗi dòng.

Trong khi trang man cho biết nó sẽ in tất cả các lần lặp lại, các -unguyên nhân được thêm vào -Dchỉ in lần xuất hiện đầu tiên của các dòng trùng lặp. Hành vi này thường đạt được với uniq -d.

Cuối cùng, sed qthoát ngay lập tức, giảm đầu vào của nó (các phần tử duy nhất của cả hai mảng) xuống dòng đầu tiên. Vì đầu ra được sắp xếp theo thứ tự giảm dần, đây là mức tối đa.

Bình thường, 12 9 byte

Thử nó

eS@Fm.m/d

Đã lưu 3 byte nhờ ông Xcoder.

Giải trình

eS@Fm.m/d
    m  /d   Count the occurrences of each element.
     .m     Take only those that appear the minimum number of times.
  @F        Apply the above to A and B and take the intersection.
eS          Take the largest.

Python 3 , 61 56 54 byte

Đã lưu 7 byte nhờ @ Mr.Xcoder , @ pizzapants184 và @ovs

lambda a,b:max(f*(a.count(f)==b.count(f)<2)for f in a)

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

05AB1E , 9 8 byte

-1 byte nhờ Erik the Outgolfer

εТÏ}`Ãà

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

ε   }    # For each input
 Ð¢Ï     #   Get the unique elements
     `Ã  # Keep only the elements that appear in both lists
       à # Keep the greatest element
         # Implicit print

Husk , 7 byte

→►≠OfEΠ

Lấy đầu vào là một danh sách gồm hai danh sách, cũng hoạt động với bất kỳ số lượng danh sách nào (trả về số cao nhất xảy ra chính xác một lần trong mỗi danh sách, nếu có thể). Hãy thử trực tuyến!

Giải trình

Đây là câu trả lời Husk đầu tiên cho (ab) sử dụng chức năng "max by" mới ►.

→►≠OfEΠ  Implicit input, say [[3,2,1,3],[1,2,3,4]]
      Π  Cartesian product: [[3,1],[2,1],[3,2],[2,2],[1,1],[3,3],[1,2],[3,1],[3,4],[2,3],[1,3],[3,2],[2,4],[3,3],[1,4],[3,4]]
    fE   Keep those that have equal elements: [[2,2],[1,1],[3,3],[3,3]]
   O     Sort: [[1,1],[2,2],[3,3],[3,3]]
 ►≠      Find rightmost element that maximizes number of other elements that are not equal to it: [2,2]
→        Take last element: 2

Bash + coreutils, 60 byte

f()(sort -rn<<<"$1"|uniq -u);grep -m1 -wf<(f "$1") <(f "$2")

Dùng thử trực tuyến

Bash, 89 byte

c()(for e;{((e^$1||r++,2^r));});for x in $1 $2;{((x<r))||c $x $1||c $x $2||r=$x;};echo $r

TIO

Thạch , 11 byte

ċ@Ị¥Ðf`€f/Ṁ

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

J, 23 byte

>./@([-.-.)&(-.-.@~:#])

(-.-.@~:#]) xóa khỏi danh sách mọi yếu tố lặp lại

& làm điều này cho cả hai

([-.-.) Chúng tôi muốn A giao nhau B. Đây là cụm từ tương đương: "A trừ (A trừ B)"

>./ Lấy tối đa

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

PowerShell , 94 byte

param($a,$b)filter f($x){$x|group|?{$_.count-eq1}}
(f($a|sort|?{$_-in((f $b).Name)}))[-1].Name

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

Đưa đầu vào $avà $bnhư mảng. Xây dựng một filtermà grouplà các phần tử mảng đầu vào với nhau và rút ra chỉ những người có một count -equal đến 1(ví dụ, chỉ có những người là duy nhất trong mảng đầu vào).

Dòng tiếp theo sau đó xây dựng thuật toán. Đầu tiên sort $a, chúng tôi , sau đó lấy ra những -inthứ duy nhất $b. Những cái đó sau đó là độc nhất vô nhị, lớn nhất [-1]được chọn, và chúng tôi lấy .Namechúng. Đó là còn lại trên đường ống và đầu ra là ẩn.

Javascript (ES6), 102 86 75 71 byte

a=>b=>Math.max(...a.map(e=>(g=x=>x.map(y=>y-e||x--,x=1)|!x)(a)*g(b)*e))

Cảm ơn @justinMariner vì đã nhận được từ 102 đến 86

Cảm ơn @tsh vì đã nhận được từ 86 đến 75

Cảm ơn @Arnauld vì đã nhận được từ 75 đến 71

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

Haskell , 57 53 byte

x?y|let v!x=filter(==v)x==[v]=maximum[a|a<-x,a!x,a!y]

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

CẬP NHẬT : Cảm ơn @Laikoni

Ngôn ngữ Wolfram (Mathicala) , 40 byte

Max@Cases[Tally@#⋂Tally@#2,{x_,1}:>x]&

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

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

Tally@#đưa ra một danh sách các yếu tố duy nhất của đầu vào đầu tiên, cùng với số lượng của chúng: ví dụ: Tally[{2,2,2,6,3,5,8,2}]sản lượng {{2,4},{6,1},{3,1},{5,1},{8,1}}.

Tally@#2thực hiện tương tự cho danh sách thứ hai và ⋂tìm thấy các cặp có trong cả hai. Sau đó, chúng tôi chọn ra (với Cases) các cặp kết thúc bằng 1, lấy phần tử đầu tiên của mỗi kết quả, cung cấp cho chúng tôi danh sách tất cả các cặp song sinh độc đáo. Cuối cùng, Maxtrả về cặp sinh đôi độc đáo lớn nhất.

Röda , 48 byte

{m={|n|sort|count|[_]if[_=n]};[_()|m 1]|m 2|max}

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

Lấy cảm hứng từ câu trả lời jq của jq170727 .

Giải trình:

{ /* Anonymous function, takes input from the stream */
  m={|n|        /* Local function m with parameter n: */
    sort|count| /*   Count unique values in the stream */
    [_]if[_=n]  /*   For each value, push it to the stream if its count is n */
  };
  [      /* For each list in the stream: */
    _()| /*   Flat it (push its values to the stream) */
    m 1  /*   Push values that appear only once to the stream */
  ]|
  m 2|   /* Push values that appear twice to the stream */
  max    /* Find the max value in the stream */
}

F # (Lõi .NET) , 117 115 114 111 108 byte

115 114 byte

Một giải pháp khác với countBythời gian này:

let u x=x|>Seq.countBy id|>Seq.filter(fun a->snd a=1)|>Seq.map fst|>set
let f x y=Set.intersect(u x)(u y)|>Seq.max

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

117 111 byte

let u x=x|>Seq.filter(fun a->x|>Seq.filter((=)a)|>Seq.length=1)|>set
let f x y=Set.intersect(u x)(u y)|>Seq.max

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

100% F #! Bất kỳ trợ giúp đều được chào đón!

6 byte giành được nhờ ký hiệu tiền tố!

108 byte

let f a b=Set.intersect(set a)(set b)|>Seq.filter(fun x->a@b|>Seq.filter(fun y->y=x)|>Seq.length<3)|>Seq.max

@là hàm concat! Cảm ơn bạn @ Ayb4btu cho thuật toán này.

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

C # (.NET Core) , 85 84 byte

x=>y=>x.Where(a=>x.Count(b=>b==a)<2).Intersect(y.Where(a=>y.Count(b=>b==a)<2)).Max()

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

Giải pháp ngây thơ với LINQ (using System;using System.Linq; + 31chars nên có 116 byte với tiêu đề)

84! Tôi quên cà ri!

Pip , 17 16 byte

MX{_Na=_Nb=1FIa}

Đây là một hàm lấy hai danh sách làm đối số. Hãy thử trực tuyến!

Giải trình

  {            }  Define function, args are a & b:
            FIa    Filter elements of a on this function:
   _Na              Count of element in a
      =_Nb          equals count of element in b
          =1        equals 1
                  This gives a function that returns a list of unique twins
MX                Modify it to take the max and return that instead

APL (Dyalog) , 18 ký tự = 23 byte *

Một chương trình đầy đủ cơ thể. Nhắc nhở danh sách các danh sách từ STDIN. Hoạt động với bất kỳ số lượng danh sách. Đầu ra cho STDOUT.

⌈/∊∩/{⊂⍺⍴⍨1=≢⍵}⌸¨⎕

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

⎕ lời nhắc cho đánh giá đầu vào từ STDIN

{... }⌸¨ cho mỗi danh sách, gọi hàm sau cho mỗi yếu tố duy nhất trong danh sách đó, sử dụng các yếu tố độc đáo như là đối số còn lại ( ⍺) và danh sách các chỉ số lần xuất hiện của nó như là đối số bên phải ( ⍵):

 ≢⍵ kiểm đếm các chỉ số (tức là số lần xuất hiện)

 1= bằng 1

 ⍺⍴⍨ sử dụng điều đó để định hình lại thành phần cụ thể (nghĩa là đưa ra danh sách trống nếu không phải là duy nhất)

Bây giờ chúng tôi có hai danh sách các phần tử duy nhất cho mỗi danh sách đầu vào (mặc dù mỗi phần tử là một danh sách và có các danh sách trống dưới dạng dư lượng từ các phần tử không duy nhất).

∩/ ngã tư (giảm)

∊ ε nlist (flatten)

⌈/ tối đa (giảm)

* trong Cổ điển, tính ⌸như ⎕U2338.

MATL , 13 byte

,iSY'1=)]X&X>

Hãy thử trực tuyến! Hoặc Xác minh tất cả các trường hợp thử nghiệm .

Giải trình

,      % Do twice
  i    %   Take input: array
  S    %   Sort array
  Y'   %   Run-length encode: pushes array of values and array of run lengths
  1=   %   Compare each run length with 1
  )    %   Use as logical index. This keeps only values that have appeared once
]      % End
X&     % Intersection of the two arrays
X>     % Maximum of array. Implicitly display

PHP, 98 byte

<?foreach(($c=array_count_values)($_GET[a])as$a=>$n)$n-1||$c($_GET[b])[$a]-1||$a<$r||$r=$a;echo$r;

Cung cấp mảng dưới dạng tham số GET avà b.

Java 8, 133 byte

a->b->{long r;for(java.util.Collections c=null;;a.remove(r))if(b.contains(r=c.max(a))&c.frequency(a,r)*c.frequency(b,r)==1)return r;}

Giải trình:

Hãy thử nó ở đây.

a->b->{                  // Method with two ArrayList<Long> parameters and long return-type
  long r;                //  Result-long
  for(java.util.Collections c=null; 
                         //  Create a java.util.Collections to save bytes
      ;                  //  Loop indefinitely
       a.remove(r))      //    After every iteration, remove the current item
    if(b.contains(r=c.max(a)) 
                         //   If the maximum value in `a` is present in `b`,
       &c.frequency(a,r)*c.frequency(b,r)==1)
                         //   and this maximum value is unique in both Lists:
      return r;          //    Return this value
                         //  End of loop (implicit / single-line body)
}                        // End of method

R , 73 byte

function(A,B)max(setdiff(intersect(A,B),c(A[(d=duplicated)(A)],B[d(B)])))

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

Tính toán Agiao nhau B, sau đó tối đa của sự khác biệt giữa đó và các yếu tố trùng lặp của Avà B.

JavaScript ES5, 122 121 114 byte

function f(a,b){for(i=a.sort().length;--i+1;)if(a[i]!=a[i+1]&&a[i]!=a[i-1]&&!(b.split(a[i]).length-2))return a[i]}

Tôi mới ở đây, vì vậy tôi thực sự không biết liệu tôi có thể xóa định nghĩa hàm hay không và chỉ cần đặt nội dung của nó (sẽ giúp tôi tiết kiệm 17 byte)

Đây là ví dụ hoạt động: 122 121 114

122 đến 121 byte: Đóng gói khởi tạo trong một cho

121 đến 114 byte: bphải là một chuỗi

SQLite , 118 byte

SELECT MAX(x)FROM(SELECT X FROM A GROUP BY X HAVING COUNT(X)=1
INTERSECT
SELECT X FROM B GROUP BY X HAVING COUNT(X)=1)

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

Lần đầu tiên trong SQL, bất kỳ trợ giúp đều được chào đón!

Jq 1.5 , 76 byte

def m(n):[.[indices(.[])|select(length==n)[]]]|unique[];[map(m(1))|m(2)]|max

Mở rộng

def m(n): # function to emit elements of multiplicity n
  [
    .[                         # select elements with
         indices(.[])          # number of indices in the array
       | select(length==n)[]   # equal to specified multiplicity
    ]
  ] | unique[]                 # emit deduped values
;

[
    map(m(1))   # collect multiplicity 1 elements from each array
  | m(2)        # collect multiplicity 2 elements
] | max         # choose largest of these elements

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

Đây là một giải pháp khác có cùng độ dài:

def u:[keys[]as$k|[.[$k]]-(.[:$k]+.[$k+1:])]|add;map(u)|.[0]-(.[0]-.[1])|max

Mở rộng

def u: # compute unique elements of input array
  [
      keys[] as $k                   # for each index k
    | [.[$k]] - (.[:$k]+.[$k+1:])    # subtract other elements from [ .[k] ]
  ]                                  # resulting in [] if .[k] is a duplicate
  | add                              # collect remaining [ .[k] ] arrays
;
  map(u)                             # discard duplicates from each input array
| .[0]-(.[0]-.[1])                   # find common elements using set difference
| max                                # kepp largest element

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

APL, 47 byte

{1↑R[⍒R←((1={+/⍵=A}¨A)/A←⍺)∩(1={+/⍵=B}¨B)/B←⍵]}

Khai báo một hàm ẩn danh có hai vectơ, loại bỏ các phần tử trùng lặp, sau đó tìm phần tử lớn nhất trong giao điểm của kết quả.

A←⍺và B←⍵lưu trữ các đối số được truyền cho hàm trong Avà B.

a=btrả về một vectơ có 1 trong mỗi chỉ số trong đó abằng b. Nếu alà một đại lượng vô hướng (tức là số lượng đơn và không phải là một vector) này trả về một vector với 1 bất cứ nơi nào các yếu tố trong blà avà 0 khi nó không phải là. Ví dụ:

Input: 1=1 2 3
Output: 1 0 0

{+/⍵=A}: hàm ẩn danh lồng nhau; tìm sự xuất hiện của đối số trong vectơ Avà thêm chúng lên, tức là tìm số lần xuất hiện của đối số trongA

1={+/⍵=A}¨A: áp dụng hàm ẩn danh lồng nhau cho từng phần tử trong A và tìm các phần tử bằng 1 tức là các phần tử duy nhất

((1={+/⍵=A}¨A)/A←⍺): đã tìm thấy vị trí của các phần tử duy nhất, chỉ chọn các phần tử này trong vectơ gốc ( /chọn từ các phần tử đối số bên phải có vị trí tương ứng với 1 trong đối số bên trái)

R←((1={+/⍵=A}¨A)/A←⍺)∩(1={+/⍵=B}¨B)/B←⍵: lặp lại quy trình cho đối số thứ hai; bây giờ chúng ta chỉ có các phần tử duy nhất, tìm giao điểm tức là các phần tử phổ biến và lưu trữ phần tử này trong vectơR

R[⍒R]: truy cập các phần tử Rtheo thứ tự giảm dần

1↑R[⍒R]: lấy phần tử đầu tiên Rkhi nó được sắp xếp theo thứ tự giảm dần

Trường hợp thử nghiệm:

Input: 17 29 39 29 29 39 18 18 {1↑R[⍒R←((1={+/⍵=A}¨A)/A←⍺)∩(1={+/⍵=B}¨B)/B←⍵]} 19 19 18 20 17 18
Output: 17

J , 30 byte

[:>./@,[*([*+/"1(1=*/)+/)@(=/)

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

Tôi bắt đầu với thử nghiệm trong đó hai danh sách trùng nhau bởi =/(chèn kiểm tra đẳng thức giữa tất cả các thành viên của danh sách:

   a =. 1 3 4 6 6 9
   b =. 8 7 6 3 4 3
   ]c=. a =/ b 
0 0 0 0 0 0
0 0 0 1 0 1
0 0 0 0 1 0
0 0 1 0 0 0
0 0 1 0 0 0
0 0 0 0 0 0

Nhiều hơn 1 trong cùng một cột có nghĩa là số này không phải là duy nhất cho đối số bên trái (6 trong trường hợp này); trong hàng - cho đối số đúng (3)

Sau đó, tôi tổng hợp tất cả các hàng và tất cả các cột để tìm các bản sao:

   +/ c
0 0 2 1 1 1
   +/"1 c
0 2 1 1 1 0

Tôi tìm thấy sản phẩm cartesian của các danh sách trên và đặt các thành viên lớn hơn 1 đến 0.

    m =. (+/"1 c) (1=*/) +/c
0 0 0 0 0 0
0 0 0 0 0 0
0 0 0 1 1 1
0 0 0 1 1 1
0 0 0 1 1 1
0 0 0 0 0 0

Tôi che dấu ma trận đẳng thức c với m để tìm các phần tử duy nhất phổ biến cho cả hai danh sách và nhân đối số bên trái với điều này.

]l =. a * m * c
0 0 0 0 0 0
0 0 0 0 0 0
0 0 0 0 4 0
0 0 0 0 0 0
0 0 0 0 0 0
0 0 0 0 0 0

Sau đó, tôi làm phẳng danh sách và tìm phần tử max:

 >./,l 
4

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

C # (.NET Core) , 66 + 31 = 97 65 + 31 = 96 byte

a=>b=>a.Intersect(b).Where(x=>a.Concat(b).Count(y=>y==x)<3).Max()

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

+31 byte cho using System;using System.Linq;

Tôi lấy cảm hứng từ câu trả lời của @ aloisdg. Tuy nhiên, thay vì tìm kiếm các giá trị duy nhất trong cả hai mảng, tôi đã đảo ngược thứ tự các thao tác sao cho intersecttrước tiên và sau đó tìm giá trị tối đa của các mục xảy ra hai lần khi các mảng được nối và nằm trong giao điểm của chúng. Tôi có thể sử dụng <3như Countsẽ có ít nhất 2 đối với bất kỳ giá trị, vì nó sẽ được ở cả hai mảng.

Lời cảm ơn

-1 byte nhờ vào @aloitorg và đề xuất của anh ấy để sử dụng Funccurrying.

Octave , 57 56 byte

@(x)max(intersect(cellfun(@(x){x(sum(x'==x)==1)},x){:}))

Hàm ẩn danh nhận đầu vào là một mảng ô gồm hai mảng số.

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

Giải trình

Đối với mỗi ( cellfun(@(x)...)) của hai mảng đầu vào, điều này tạo ra một ma trận so sánh đẳng thức theo cặp giữa các mục của nó ( x.'==x); chỉ giữ ( x(...)) các mục mà tổng cột là 1( sum(...)==1); và gói kết quả trong một ô ( {...}). Giao điểm ( intersect) của hai kết quả ( {:}) được tính toán và tối đa ( max(...)) được lấy.

Ngôn ngữ Wolfram (Mathicala) , 49 byte

Last@Select[a=Join@##;Sort[#⋂#2],a~Count~#<3&]&

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