Вам буде надано два масивів / списків / вектори невід'ємних цілих чисел A і B . Ваше завдання полягає в тому, щоб вивести ціле число N , яке з'являється в обох A і B , а також є унікальним в обох A і B .

• Ви можете припустити, що існує хоча б одне таке число.

• Дозволено будь-який розумний метод / формат введення та виводу .

• Ці Лазівки заборонені.

• Це код-гольф , тому найкоротший код у кожній мові програмування виграє!

Випробування:

А, В -> Вихід

[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

Желе , 7 байт

fċ@ÐṂ;Ṁ

Спробуйте в Інтернеті!

Як це працює

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 байт

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

Дякуємо @seshoumara за те, що гольф на 1 байт!

Спробуйте в Інтернеті!

Як це працює

uniq приймає впорядковані дані та виконує одну чи кілька дій, залежно від прапорів командного рядка.

U<<<$1і U<<<$2викликати функцію Uз першого та другого аргументу командного рядка як вхід. Для кожного з них sort -rn|uniq -uвиконується, сортуючи вхід чисельно ( -n) та у порядку зменшення ( -r) для uniq , який буде друкувати лише унікальні рядки ( -u).

Вихід обох (унікальних елементів кожного масиву) об'єднується та передається U D, тобто
sort -rn|uniq -uD. Цього разу uniq друкує лише повторювані рядки ( -D) та лише перше повторення кожного.

Незважаючи на те, що сторінка man каже, що вона буде надрукована всіма повторами, додані -uприводить -Dдо друку лише першого появи дублюваних рядків. Така поведінка зазвичай досягається за допомогою uniq -d.

Нарешті, sed qмиттєво завершує роботу, зводячи її вхід (унікальні елементи обох масивів) до першого рядка. Оскільки вихід сортувався у порядку зменшення, це максимум.

Pyth, 12 9 байт

Спробуй це

eS@Fm.m/d

Збережено 3 байти завдяки панові Xcoder.

Пояснення

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 байт

Збережено 7 байт завдяки @ Mr.Xcoder , @ pizzapants184 та @ovs

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

Спробуйте в Інтернеті!

05AB1E , 9 8 байт

-1 байт завдяки Еріку Переможнику

εТÏ}`Ãà

Спробуйте в Інтернеті!

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

Лушпиння , 7 байт

→►≠OfEΠ

Приймає введення як список двох списків, працює і для будь-якої кількості списків (повертаючи найвищу кількість, яка трапляється рівно один раз у кожному, якщо можливо). Спробуйте в Інтернеті!

Пояснення

Це перша відповідь Хука на (ab) використання нової функції "максимум за" ►.

→►≠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 байт

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

Спробуйте це в Інтернеті

Баш, 89 байт

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

ТІО

Желе , 11 байт

ċ@Ị¥Ðf`€f/Ṁ

Спробуйте в Інтернеті!

J, 23 байти

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

(-.-.@~:#]) видаляє зі списку будь-які повторювані елементи

& зробіть це для обох аргументів

([-.-.) Ми хочемо, що перетинається B. Це еквівалентна фраза: "A мінус (A мінус B)"

>./ Візьміть макс

Спробуйте в Інтернеті!

PowerShell , 94 байти

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

Спробуйте в Інтернеті!

Приймає вхід $aі $bяк масиви. Створює , filterщо groupїв елементи вхідного масиву разом і витягує тільки ті , з count -eqUAL до 1(тобто, тільки ті , які є унікальними у вхідному масиві).

Потім наступний рядок будує алгоритм. Спочатку ми sort $aвитягуємо ті, що є -inунікальними предметами $b. Тоді вони самі є унікальними, [-1]вибирається найбільший , і ми беремо .Nameйого. Це залишилося на конвеєрі, і вихід неявний.

Javascript (ES6), 102 86 75 71 байт

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

Дякуємо @justinMariner за те, що отримав від 102 до 86

Дякуємо @tsh за те, що отримав від 86 до 75

Дякуємо @Arnauld за те, що отримав від 75 до 71

Спробуйте в Інтернеті!

Haskell , 57 53 байти

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

Спробуйте в Інтернеті!

UPD: Спасибі @Laikoni

Мова Вольфрама (Mathematica) , 40 байт

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

Спробуйте в Інтернеті!

Як це працює

Tally@#наводить перелік унікальних елементів першого введення разом з їх кількістю: наприклад, Tally[{2,2,2,6,3,5,8,2}]вихід {{2,4},{6,1},{3,1},{5,1},{8,1}}.

Tally@#2робить те ж саме для другого списку і ⋂знаходить пари, присутні в обох. Потім ми вибираємо (з Cases) пари, що закінчуються 1, беручи перший елемент кожного результату, який дає нам список всіх унікальних близнюків. Нарешті, Maxповертає найбільшого унікального близнюка.

Рода , 48 байт

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

Спробуйте в Інтернеті!

Натхненний відповіддю jq170727 jq .

Пояснення:

{ /* 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 байт

115 114 байт

Ще одне рішення з countByцього часу:

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

Спробуйте в Інтернеті!

117 111 байт

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

Спробуйте в Інтернеті!

100% F #! Будь-яка допомога вітається!

6 байт виграно завдяки префіксації!

108 байт

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

@це функція concat! Дякую @ Ayb4btu за цей алгоритм.

Спробуйте в Інтернеті!

C # (.NET Core) , 85 84 байт

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

Спробуйте в Інтернеті!

Наївне рішення з LINQ ( using System;using System.Linq;+ 31часа, тому 116 байт із заголовком)

84! Я забула завивати!

Піп , 17 16 байт

MX{_Na=_Nb=1FIa}

Це функція, яка бере два списки як аргументи. Спробуйте в Інтернеті!

Пояснення

  {            }  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 (Діалог) , 18 символів = 23 байти *

Повний орган програми. Підказки для переліку списків від STDIN. Працює з будь-якою кількістю списків. Виводи в STDOUT.

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

Спробуйте в Інтернеті!

⎕ запит на оцінений вхід від STDIN

{… }⌸¨ Для кожного списку викличте наступну функцію для кожного унікального елемента у цьому списку, використовуючи унікальний елемент як аргумент ліворуч ( ⍺) та список індексів його появи як правий аргумент ( ⍵):

 ≢⍵ підрахунок індексів (тобто кількість подій)

 1= дорівнює 1

 ⍺⍴⍨ використовувати це, щоб змінити конкретний елемент (тобто дає порожній список, якщо він не є унікальним)

Зараз у нас є два списки унікальних елементів для кожного списку вхідних даних (хоча кожен елемент є списком, і є порожні списки як залишки від не унікальних елементів).

∩/ перетин (зменшення)

∊ ϵ список (згладити)

⌈/ макс (зменшення)

* у Класичному, рахуючи ⌸як ⎕U2338.

MATL , 13 байт

,iSY'1=)]X&X>

Спробуйте в Інтернеті! Або Перевірте всі тестові випадки .

Пояснення

,      % 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 байт

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

Надайте масиви як параметри GET aі b.

Java 8, 133 байти

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

Пояснення:

Спробуйте тут.

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 байти

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

Спробуйте в Інтернеті!

Обчислення Aперетинаються B, то максимум різниці між цим і дублюється елементами Aта B.

JavaScript ES5, 122 121 114 байт

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

Я тут новачок, тому я не знаю, чи зможу я видалити визначення функції та просто поставити її вміст (це врятує мене 17 байт)

Ось робочий приклад: 122 121 114

122 - 121 байт: загортання ініціалізації в а

121 - 114 байт: bмає бути рядком

SQLite , 118 байт

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)

Спробуйте в Інтернеті!

Перший раз у SQL будь-яка допомога вітається!

Jq 1,5 , 76 байт

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

Розширено

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

Спробуйте в Інтернеті!

Ось ще одне рішення такої ж довжини:

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

Розширено

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

Спробуйте в Інтернеті!

APL, 47 байт

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

Оголошує анонімну функцію, яка займає два вектори, усуває повторювані елементи, потім знаходить найбільший елемент у перетині результатів.

A←⍺і B←⍵зберігати аргументи, передані функції в Aі B.

a=bповертає вектор з 1 у кожному індексі, в якому aдорівнює b. Якщо aскалярний (тобто одинична кількість, а не вектор), він повертає вектор з 1, де б не знаходився елемент b, aі 0, коли він не є. Наприклад:

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

{+/⍵=A}: вкладена анонімна функція; знайти вхід аргументу у векторному Aі додати їх, тобто знайти кількість входжень аргументу вA

1={+/⍵=A}¨A: застосуйте вкладену анонімну функцію до кожного елемента в А та знайдіть ті, що дорівнюють 1, тобто унікальні елементи

((1={+/⍵=A}¨A)/A←⍺): знайшовши розташування унікальних елементів, виберіть саме ці елементи в початковому векторі ( /вибирає з правого елемента аргументу, розташування якого відповідає 1 у лівому аргументі)

R←((1={+/⍵=A}¨A)/A←⍺)∩(1={+/⍵=B}¨B)/B←⍵: повторити процес для другого аргументу; тепер, коли у нас є просто унікальні елементи, знайдіть перетин, тобто загальні елементи, і збережіть це у векторномуR

R[⍒R]: доступ до елементів Rу зменшеному порядку

1↑R[⍒R]: взяти перший елемент, Rколи він сортується у порядку зменшення

Тестовий випадок:

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 байт

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

Як це працює:

Почну з тестування, де два списки перекриваються =/(вставляє тест на рівність між усіма членами списків:

   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

Більше одного 1 в тому ж стовпчику означає, що число не є унікальним для лівого аргументу (6 у цьому випадку); у рядку - за правильний аргумент (3)

Потім я підбиваю підсумки всіх рядків і всіх стовпців, щоб знайти, де є дублікати:

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

Я знаходжу декартовий добуток із зазначених вище списків і встановлюю члени більше 1 до 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

Я маскую матрицю рівності c з m, щоб знайти унікальні елементи, спільні для обох списків, і помножую лівий аргумент на це.

]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

Потім я розгладжую список і знаходжу максимальний елемент:

 >./,l 
4

Спробуйте в Інтернеті!

C # (.NET Core) , 66 + 31 = 97 65 + 31 = 96 байт

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

Спробуйте в Інтернеті!

+31 байт для using System;using System.Linq;

Я взяв натхнення у відповіді @ aloisdg. Однак замість пошуку унікальних значень в обох масивах я перевернув порядок операцій таким чином, що intersectспочатку, а потім знайшов максимальне значення елементів, що виникають двічі, коли масиви є об'єднаними і перебувають у їх перетині. Я можу використовувати <3як Countбуде принаймні 2 для будь-якого значення, як це буде в обох масивах.

Подяка

-1 байт завдяки @aloisdg та його пропозиції використовувати Funcкаррі.

Октава , 57 56 байт

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

Анонімна функція, яка приймає вхідний масив комірок з двох числових масивів.

Спробуйте в Інтернеті!

Пояснення

Для кожного ( cellfun(@(x)...)) двох вхідних масивів це створює матрицю попарних порівнянь рівності між його записами ( x.'==x); зберігає ( x(...)) тільки записи, для яких сума стовпців 1( sum(...)==1); і пакує результат у комірку ( {...}). Обчислюється перетин ( intersect) двох результатів ( {:}), і max(...)береться максимум ( ).

Мова Вольфрама (Mathematica) , 49 байт

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

Спробуйте в Інтернеті!