您将获得两个非负整数A和B的数组/列表/向量。您的任务是输出出现在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、9]，[8、7、6、3、4、3]-> 4 [2，2，2，6，3，5，8，8]，[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
Answers:
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.
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），并且仅打印每行的第一次重复。
虽然手册页说它将打印所有重复，但增加的-u原因-D仅打印第一次出现的重复行。通常使用来实现此行为uniq -d。
最后，sed q立即退出，将其输入（两个数组的唯一元素）减少到第一行。由于输出按降序排序，因此这是最大值。
eS@Fm.m/d
多亏了Xcoder先生，节省了3个字节。
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.
eS@Fm.m/d），然后将输入作为两个列表的列表。
@ Mr.Xcoder，@ pizzapants184和@ovs节省了7个字节
lambda a,b:max(f*(a.count(f)==b.count(f)<2)for f in a)-1个字节感谢外长者埃里克（Erik the Outgolfer）
εТÏ}`Ãà
ε } # For each input
Ð¢Ï # Get the unique elements
`Ã # Keep only the elements that appear in both lists
à # Keep the greatest element
# Implicit print
→►≠OfEΠ
将输入作为两个列表的列表，也可用于任意数量的列表（如果可能，返回每个正好出现一次的最高数字）。 在线尝试！
这是Husk对（ab）使用新的“ maximum by”函数的第一个答案►。
→►≠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
f()(sort -rn<<<"$1"|uniq -u);grep -m1 -wf<(f "$1") <(f "$2")
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
sort -rnwith sed q而不是tail -1剃除1个字节。grep -wf顺便说一句很棒的发现。+1
param($a,$b)filter f($x){$x|group|?{$_.count-eq1}}
(f($a|sort|?{$_-in((f $b).Name)}))[-1].Name接受输入$a并$b作为数组。构造一个将输入数组元素在一起的a filter，group并仅拉出具有count -equal的元素1（即，仅输入数组中唯一的元素）。
然后，下一行构造算法。首先我们sort $a，然后取出那些是-in独特的项目$b。然后将它们自身唯一化，[-1]选择最大的，然后我们选择.Name它们。剩下的就在管道上，输出是隐式的。
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
e仅在a和中显示一次b。
(g=x=>x.filter(y=>y==e).length==1)更短。
f为infix运算符并编写[1|...]==[1]而不是sum[1|...]==1保存一些字节。
Max@Cases[Tally@#⋂Tally@#2,{x_,1}:>x]&
Tally@#给出了第一个输入的唯一元素及其计数的列表：例如Tally[{2,2,2,6,3,5,8,2}]yields {{2,4},{6,1},{3,1},{5,1},{8,1}}。
Tally@#2对第二个列表执行相同操作，并⋂找到两个列表中都存在的对。然后，我们选择以Cases结尾的（对）对1，并获取每个结果的第一个元素，从而为我们提供了所有唯一双胞胎的列表。最后，Max返回最大的唯一双胞胎。
{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 */
}
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.maxlet 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.max100％F＃！欢迎任何帮助！
前缀表示法赢得了6个字节！
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使用此算法。
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！我忘了！
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
完整的程序主体。提示输入来自STDIN的列表。适用于任意数量的列表。输出到STDOUT。
⌈/∊∩/{⊂⍺⍴⍨1=≢⍵}⌸¨⎕⎕ 提示输入来自STDIN的评估输入
{… }⌸¨ 对于每个列表，使用该唯一元素作为左参数（⍺），并将其出现的索引列表作为右参数（），对该列表中的每个唯一元素调用以下函数⍵：
≢⍵ 索引总计（即出现次数）
1= 等于1
⍺⍴⍨ 使用它来重塑特定元素（即，如果不唯一，则给出空列表）
现在，对于每个输入列表，我们都有两个唯一元素列表（尽管每个元素都是一个列表，并且有空列表作为非唯一元素的残差）。
∩/ 交集（减少）
∊ ε NLIST（扁平化）
⌈/ 最大（减少）
*经典，计数⌸的⎕U2338。
,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
<?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。
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;}Explanation:
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 methodfunction(A,B)max(setdiff(intersect(A,B),c(A[(d=duplicated)(A)],B[d(B)])))Computes A intersect B, then the maximum of the difference between that and the duplicated elements of A and B.
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]}I'm new here, so I don't really know if I can remove the function definition and just put its contents (which would save me 17 bytes)
Here's the working example: 122 121 114
122 to 121 bytes: Wrapping initialization in a for
121 to 114 bytes: b has to be a string
b and save b=''+b,?
f=(a,b)=>{for(b=''+b,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]}.
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)
First time in SQL, any help is welcome!
def m(n):[.[indices(.[])|select(length==n)[]]]|unique[];[map(m(1))|m(2)]|max
Expanded
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
Here is another solution which is the same length:
def u:[keys[]as$k|[.[$k]]-(.[:$k]+.[$k+1:])]|add;map(u)|.[0]-(.[0]-.[1])|max
Expanded
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
{1↑R[⍒R←((1={+/⍵=A}¨A)/A←⍺)∩(1={+/⍵=B}¨B)/B←⍵]}
Declares an anonymous function that takes two vectors, eliminates duplicate elements, then finds the biggest element in the intersection of the results.
A←⍺ and B←⍵ store the arguments passed to the function in A and B.
a=b returns a vector with 1 in each index in which a is equal to b. If a is a scalar (i.e. single quantity and not a vector) this returns a vector with 1 wherever the element in b is a and 0 when it is not. For example:
Input: 1=1 2 3
Output: 1 0 0
{+/⍵=A}: nested anonymous function; find the occurrences of the argument in vector A and add them up i.e. find the number of occurrences of the argument in A
1={+/⍵=A}¨A: apply the nested anonymous function to each element in A and find the ones that equal 1 i.e. unique elements
((1={+/⍵=A}¨A)/A←⍺): having found the location of the unique elements, select just these elements in the original vector (/ selects from the right argument elements whose locations correspond to 1 in the left argument)
R←((1={+/⍵=A}¨A)/A←⍺)∩(1={+/⍵=B}¨B)/B←⍵: repeat the process for the second argument; now that we have just the unique elements, find the intersection i.e. common elements and store this in vector R
R[⍒R]: access the elements of R in decreasing order
1↑R[⍒R]: take the first element of R when it's sorted in decreasing order
Test case:
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
[:>./@,[*([*+/"1(1=*/)+/)@(=/)
How it works:
I start with testing where the two list overlap by =/ (inserts equality test between all the members of the lists:
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
More than one 1 in the same column means that the number is not unique for the left argument (6 in this case); in the row - for the right argument (3)
Then I sum up all rows and all columns to find where are the duplicates:
+/ c
0 0 2 1 1 1
+/"1 c
0 2 1 1 1 0
I find the cartesian product of the above lists and set the members greater than 1 to 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
I mask the equality matrix c with m to find the unique elements that are common to both lists and multiply the left argument by this.
]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
Then I flatten the list and find the max element:
>./,l
4
a=>b=>a.Intersect(b).Where(x=>a.Concat(b).Count(y=>y==x)<3).Max()+31 bytes for using System;using System.Linq;
I took inspiration from @aloisdg's answer. However, instead of searching for unique values in both arrays, I inverted the order of operations so that intersect is first, and then find the max value of the items that occur twice when the arrays are concatenated and are in their intersect. I can use <3 as Count will be at least 2 for any value, as it will be in both arrays.
-1 byte thanks to @aloisdg and his suggestion to use Func currying.
@(x)max(intersect(cellfun(@(x){x(sum(x'==x)==1)},x){:}))Anonymous function that takes as input a cell array of two numerical arrays.
For each (cellfun(@(x)...)) of the two input arrays, this creates a matrix of pairwise equality comparisons between its entries (x.'==x); keeps (x(...)) only the entries for which the column sum is 1 (sum(...)==1); and packs the result in a cell ({...}). The intersection (intersect) of the two results ({:}) is computed, and the maximum (max(...)) is taken.
Last@Select[a=Join@##;Sort[#⋂#2],a~Count~#<3&]&