Anda akan diberikan dua Array / Daftar / Vektor bilangan bulat non-negatif A dan B . Tugas Anda adalah untuk output tertinggi bilangan bulat N yang muncul di kedua A dan B , dan juga unik di kedua A dan B .

• Anda dapat berasumsi bahwa setidaknya ada satu nomor seperti itu.

• Setiap Masukan wajar dan Output metode / format yang diperbolehkan.

• Celah ini dilarang.

• Ini adalah kode-golf , jadi kode terpendek di setiap bahasa pemrograman menang!

Kasus uji:

A, B -> Output

[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

Jelly , 7 byte

fċ@ÐṂ;Ṁ

Cobalah online!

Bagaimana itu bekerja

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

Terima kasih kepada @seshoumara karena bermain golf 1 byte!

Cobalah online!

Bagaimana itu bekerja

uniq mengambil input yang diurutkan dan melakukan satu atau beberapa tindakan, tergantung pada flag-command-line.

U<<<$1dan U<<<$2panggil fungsi Udengan argumen baris perintah pertama dan kedua sebagai input. Untuk masing-masing, sort -rn|uniq -udijalankan, mengurutkan input secara numerik ( -n) dan dalam urutan menurun ( -r) untuk uniq , yang hanya akan mencetak baris unik ( -u).

Output dari keduanya (elemen unik dari setiap array) disatukan dan disalurkan ke U D, yaitu
sort -rn|uniq -uD,. Kali ini, uniq hanya akan mencetak garis duplikat ( -D), dan hanya pengulangan pertama dari masing-masing.

Sementara halaman manual mengatakan itu akan mencetak semua pengulangan, -upenyebab yang ditambahkan -Duntuk mencetak hanya kemunculan pertama dari garis duplikat. Perilaku ini biasanya dicapai dengan uniq -d.

Akhirnya, sed qsegera berhenti, mengurangi inputnya (elemen unik dari kedua array) ke baris pertama. Karena output diurutkan dalam urutan menurun, ini adalah maksimum.

Pyth, 12 9 byte

Cobalah

[email protected]/d

Disimpan 3 byte berkat Tn. Xcoder.

Penjelasan

[email protected]/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

Disimpan 7 byte berkat @ Mr.Xcoder , @ pizzapants184 dan @ovs

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

Cobalah online!

05AB1E , 9 8 byte

-1 byte terima kasih Erik the Outgolfer

εТÏ}`Ãà

Cobalah online!

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

Sekam , 7 byte

→►≠OfEΠ

Mengambil input sebagai daftar dua daftar, juga berfungsi untuk sejumlah daftar (mengembalikan angka tertinggi yang terjadi tepat satu kali dalam masing-masing, jika memungkinkan). Cobalah online!

Penjelasan

Ini adalah jawaban Sekam pertama untuk (ab) menggunakan fungsi "maksimum oleh" yang baru ►.

→►≠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")

Cobalah secara Online

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

Jelly , 11 byte

ċ@Ị¥Ðf`€f/Ṁ

Cobalah online!

J, 23 byte

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

(-.-.@~:#]) menghapus dari daftar elemen yang berulang

& lakukan ini untuk kedua argumen

([-.-.) Kami ingin A intersect B. Ini adalah ungkapan yang setara: "A minus (A minus B)"

>./ Ambil maks

Cobalah online!

PowerShell , 94 byte

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

Cobalah online!

Mengambil input $adan $bsebagai array. Buat a filteryang groupmenggabungkan elemen-elemen array input dan menarik hanya elemen-elemen dengan count -equal ke 1(yaitu, hanya elemen-elemen yang unik dalam array input).

Baris berikutnya kemudian membangun algoritma. Pertama sort $a, kita tarik -inbenda-benda unik itu $b. Itu sendiri unik-ified, yang terbesar [-1]dipilih, dan kami mengambilnya .Name. Yang tersisa pada pipa dan output tersirat.

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

Terima kasih @justinMariner untuk mendapatkan dari 102 hingga 86

Terima kasih @tsh untuk mendapatkan dari 86 hingga 75

Terima kasih @Arnauld dari 75 hingga 71

Cobalah online!

Haskell , 57 53 byte

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

Cobalah online!

UPD: Terima kasih @Laikoni

Bahasa Wolfram (Mathematica) , 40 byte

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

Cobalah online!

Bagaimana itu bekerja

Tally@#memberikan daftar elemen unik dari input pertama, bersama-sama dengan jumlah mereka: misalnya, Tally[{2,2,2,6,3,5,8,2}]hasil {{2,4},{6,1},{3,1},{5,1},{8,1}}.

Tally@#2melakukan hal yang sama untuk daftar kedua, dan ⋂menemukan pasangan hadir di keduanya. Lalu kami memilih (dengan Cases) pasangan yang berakhir dengan 1, mengambil elemen pertama dari setiap hasil, yang memberi kami daftar semua kembar yang unik. Akhirnya, Maxmengembalikan kembar unik terbesar.

Röda , 48 byte

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

Cobalah online!

Terinspirasi oleh jawaban jq170727 .

Penjelasan:

{ /* 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 # (.NET Core) , 117 115 114 111 108 byte

115 114 byte

Solusi lain dengan countBywaktu ini:

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

Cobalah online!

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

Cobalah online!

100% F #! Setiap bantuan dipersilahkan!

6 byte menang berkat notasi awalan!

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

@adalah fungsi concat! Terima kasih @ Ayb4btu untuk algoritme ini.

Cobalah online!

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

Cobalah online!

Solusi naif dengan LINQ ( using System;using System.Linq;+ 31chars jadi 116 byte dengan header)

84! Saya lupa kari!

Pip , 17 16 byte

MX{_Na=_Nb=1FIa}

Ini adalah fungsi yang mengambil dua daftar sebagai argumen. Cobalah online!

Penjelasan

  {            }  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 karakter = 23 byte *

Badan program penuh. Meminta daftar daftar dari STDIN. Bekerja dengan sejumlah daftar. Output ke STDOUT.

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

Cobalah online!

⎕ meminta input yang dievaluasi dari STDIN

{... }⌸¨ untuk setiap daftar, panggil fungsi berikut untuk setiap elemen unik dalam daftar itu, menggunakan elemen unik sebagai argumen kiri ( ⍺) dan daftar indeks kemunculannya sebagai argumen kanan ( ⍵):

 ≢⍵ penghitungan indeks (yaitu jumlah kejadian)

 1= sama dengan 1

 ⍺⍴⍨ menggunakannya untuk membentuk kembali elemen spesifik (mis. berikan daftar kosong jika tidak unik)

Sekarang kami memiliki dua daftar elemen unik untuk setiap daftar input (meskipun setiap elemen adalah daftar, dan ada daftar kosong sebagai residu dari elemen non-unik).

∩/ persimpangan (reduksi)

∊ ϵ daftar (ratakan)

⌈/ maks (reduksi)

* dalam Classic, menghitung ⌸sebagai ⎕U2338.

MATL , 13 byte

,iSY'1=)]X&X>

Cobalah online! Atau Verifikasi semua kasus uji .

Penjelasan

,      % 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;

Berikan array sebagai parameter GET adan 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;}

Penjelasan:

Coba di sini.

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

Cobalah online!

Menghitung Aberpotongan B, maka maksimum perbedaan antara itu dan elemen yang diduplikasi dari Adan 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]}

Saya baru di sini, jadi saya tidak benar-benar tahu apakah saya dapat menghapus definisi fungsi dan hanya memasukkan isinya (yang akan menyelamatkan saya 17 byte)

Ini contoh kerjanya: 122 121 114

122 hingga 121 byte: Membungkus inisialisasi dalam untuk

121 hingga 114 byte: bharus berupa string

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)

Cobalah online!

Pertama kali dalam SQL, bantuan apa pun diterima!

Jq 1,5 , 76 byte

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

Diperluas

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

Cobalah online!

Berikut adalah solusi lain yang memiliki panjang yang sama:

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

Diperluas

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

Cobalah online!

APL, 47 byte

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

Menyatakan fungsi anonim yang mengambil dua vektor, menghilangkan elemen duplikat, lalu menemukan elemen terbesar di persimpangan hasil.

A←⍺dan B←⍵menyimpan argumen yang diteruskan ke fungsi di Adan B.

a=bmengembalikan vektor dengan 1 di setiap indeks yang asama dengan b. Jika askalar (yaitu kuantitas tunggal dan bukan vektor) ini mengembalikan vektor dengan 1 di mana pun elemen dalam badalah adan 0 ketika tidak. Sebagai contoh:

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

{+/⍵=A}: fungsi anonim bersarang; menemukan kemunculan argumen dalam vektor Adan menambahkannya yaitu menemukan jumlah kemunculan argumen diA

1={+/⍵=A}¨A: terapkan fungsi anonim bersarang untuk setiap elemen dalam A dan temukan elemen yang sama dengan 1 yaitu elemen unik

((1={+/⍵=A}¨A)/A←⍺): setelah menemukan lokasi elemen unik, pilih saja elemen-elemen ini dalam vektor asli (/ pilih dari elemen argumen kanan yang lokasinya sesuai dengan 1 pada argumen kiri)

R←((1={+/⍵=A}¨A)/A←⍺)∩(1={+/⍵=B}¨B)/B←⍵: ulangi proses untuk argumen kedua; sekarang kita hanya memiliki elemen unik, temukan persimpangan yaitu elemen umum dan simpan dalam vektorR

R[⍒R]: mengakses elemen Rdalam urutan menurun

1↑R[⍒R]: ambil elemen pertama Rsaat diurutkan dalam urutan menurun

Kasus cobaan:

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=*/)+/)@(=/)

Bagaimana itu bekerja:

Saya mulai dengan pengujian di mana kedua daftar tumpang tindih oleh =/(memasukkan uji kesetaraan antara semua anggota daftar:

   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

Lebih dari satu 1 di kolom yang sama berarti bahwa angka tersebut tidak unik untuk argumen kiri (6 dalam kasus ini); di baris - untuk argumen yang benar (3)

Lalu saya meringkas semua baris dan semua kolom untuk menemukan di mana duplikatnya:

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

Saya menemukan produk kartesius dari daftar di atas dan mengatur anggota lebih besar dari 1 menjadi 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

Saya menutupi matriks kesetaraan c dengan m untuk menemukan elemen unik yang umum untuk kedua daftar dan mengalikan argumen kiri dengan ini.

]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

Lalu saya meratakan daftar dan menemukan elemen maks:

 >./,l 
4

Cobalah online!

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

Cobalah online!

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

Saya mengambil inspirasi dari jawaban @ aloisdg. Namun, alih-alih mencari nilai unik di kedua array, saya membalikkan urutan operasi sehingga yang intersectpertama, dan kemudian menemukan nilai maksimum item yang terjadi dua kali ketika array digabungkan dan berada di berpotongan. Saya bisa menggunakan <3sebagai Countakan setidaknya 2 untuk nilai apapun, karena akan berada di kedua array.

Ucapan Terima Kasih

-1 byte terima kasih kepada @aloisdg dan sarannya untuk menggunakan Funccurrying.

Oktaf , 57 56 byte

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

Fungsi anonim yang mengambil input sel array dari dua array numerik.

Cobalah online!

Penjelasan

Untuk setiap ( cellfun(@(x)...)) dari dua array input, ini membuat matriks perbandingan kesetaraan berpasangan antara entri ( x.'==x); menyimpan ( x(...)) hanya entri yang jumlah kolomnya 1( sum(...)==1); dan mengemas hasilnya dalam sel ( {...}). Perpotongan ( intersect) dari dua hasil ( {:}) dihitung, dan maksimum ( max(...)) diambil.

Bahasa Wolfram (Mathematica) , 49 byte

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

Cobalah online!