鉴于整数的非空有限列表，输出truthy如果恰好有两个相等的条目和所有其他条目是不同的值，并且falsey否则值。

例子

truthy:
[1,1]
[1,2,1]
[1,6,3,4,4,7,9]

falsey:
[0]
[1,1,1]
[1,1,1,2]
[1,1,2,2]
[2,1,2,1,2]
[1,2,3,4,5]

Python 3中，30 28个字节

lambda m:len({*m})+1==len(m)

在线尝试！

{*m}将列表强制转换为set对象，即无重复项的无序列表。这样做将始终通过列表中重复项的数量来减少列表的长度。通过计算长度变化了多少，我们可以轻松判断列表是否有单个重复项，并返回测试结果。

^{-2个字节感谢ovs。}

外壳，4个字节

εṠ-u

在线尝试！

说明

εṠ-u  Implicit input.
   u  Unique elements.
 Ṡ-   Delete them from input, counting multiplicities.
ε     Is the result a singleton list?

MATL，7，6个字节

&=sp4=

在线尝试！

感谢@Guiseppe，节省了一个字节！

说明：

&=  % Table of pair-wise equality comparisons
    %
    % [1 0 0 0 0 0 0
    %  0 1 0 0 0 0 0
    %  0 0 1 0 0 0 0
    %  0 0 0 1 1 0 0
    %  0 0 0 1 1 0 0
    %  0 0 0 0 0 1 0
    %  0 0 0 0 0 0 1]
    %
s   % Sum each Column. Stack:
    %
    % [1 1 1 2 2 1 1]
    %
p   % Product of the array. Stack:
    %
    % [4]
    %
4=  % Compare the stack to '4'

Haskell，34个字节

f x=[1|a<-x,b<-x,a==b]==1:1:(1<$x)

在线尝试！基于H.PWiz的答案。

果冻，8 5字节

QL‘=L

在线尝试！

说明

QL‘=L  - Main link, argument L (a list)   e.g [1,6,3,4,4,7,9]
Q      - Deduplicated elements                [1,6,3,4,7,9]
 L     - Length                               6
  ‘    - Increment                            7
    L  - Length of the input                  7 ([1,6,3,4,4,7,9])
   =   - Are they equal?                      1

如果输出值可以是任何一致的值，则QL_L可以正常工作，该输出可以输出真值，而-1其他任何非正数都可以输出假值（感谢@JonathanAllan）

JavaScript（ES6），30个字节

a=>new Set(a).size==a.length-1

在线尝试

Pushy，8字节

简单执行检查是否len(set(list)) == len(list)-1：

LtvuL^=#

说明：

       \ Implicit: Put all input on stack
Ltv    \ Get the stack length - 1, save in auxiliary stack
u      \ Remove non-unique elements
L      \ Get the new length
^=     \ Compare with the previously saved length
#      \ Print result

这是因为如果在初始列表中仅恰好有1个非唯一整数，则长度只会减少1。

在线尝试！

八度，25字节

这不是使用a group或unique方法解决其他许多问题，而是使用所有可能比较的“笛卡尔积”。

@(x)nnz(triu(x==x',1))==1

说明

             x==x'        %create a matrix where the entry at (i,j) compares whether x(i) == x(ju)
        triu(x==x',1)     %only consider the strict upper triangular matrix
    nnz(triu(x==x',1))    %count the number of nonzero entries
@(x)nnz(triu(x==x',1))==1 %check whether this number is actually 1

在线尝试！

并且因为没有卷积就没有完整的程序（感谢@LuisMendo纠正错误）：

八度，40字节

@(x)nnz(~conv(sort(x),-1:2:1,'same'))==1

在线尝试！

J，7 6字节

=&#0,=

=检查每个元素是否与每个唯一元素相等，并为m个  唯一元素创建一个包含m行  的矩阵。在顶部添加一个空行。行数等于输入的长度吗？
0,
=&#

在线尝试！

视网膜，15 12 11字节

感谢Neil节省了1个字节。

D`
Mm2`^$
1

在线尝试！

输入以换行分隔。（为了方便起见，测试套件使用逗号分隔。）

说明

D`

对输入中的行进行重复数据删除，从而删除之前出现的所有整数（但保留周围的换行符）。

Mm2`^$

计算空行的数量，该数量等于我们删除的重复行的数量，但仅考虑前两个匹配项。因此，输出将仅为0（无重复），1（一个重复），2（两个或更多重复）。

1

确保仅删除了一个重复项。

05AB1E，4个字节

{¥_O

在线尝试！

输出1为真，其他任何非负整数为假。在05AB1E中，1是唯一真实的数字（感谢@Emigna！）。

说明

{       Implicit input. Sort
 ¥      Consecutive differences
  _     Boolean negate
   O    Sum. Implicit display

Ruby，32个字节

->(s){s.uniq.length==s.length-1}

C＃（.NET Core），35 + 18字节

+18使用System.Linq。

n=>n.Distinct().Count()==n.Length-1

在线尝试！

不带Linq的67字节替代：

n=>new System.Collections.Generic.HashSet<int>(n).Count==n.Length-1

在线尝试！

Excel，42个字节

丹麦语版本

=TÆLV(A:A)=SUM(--(FREKVENS(A:A,A:A)>0))+1

假定列中的单独单元格中列表中的每个整数A。
如果允许我们使用不一致的false值，则可以节省3个字节：

=TÆLV(A:A)+SUM(-(FREKVENS(A:A,A:A)>0))

英文版（44字节）

=COUNTA(A:A)=SUM(--(FREQUENCY(A:A,A:A)>0))+1

R，32 31字节

-1字节感谢@JarkoDubbeldam

cat(sum(duplicated(scan()))==1)

在线尝试！

从stdin读取，写入stdout。

duplicated遍历列表，如果该值出现在列表中的较早位置l，TRUE则将其替换为，FALSE否则使用。如果有一对唯一的灵魂伴侣，则应该恰好有一个TRUE值，因此总和应为1。

PowerShell，40 37字节

($args|sort -u).count-eq$args.count-1

在线尝试！

带有nique标志的Sort-Object命令（别名sort）-u仅提取输入的唯一组成部分。例如，对于输入@(1,3,3,2)，结果为@(1,2,3)。

因此，我们只需要确保在.count该对象（即有多少元素它）是-eqUAL到.count我们的输入数组-1（即我们恰好有一个重复的条目）。

由于正弦曲线，节省了3个字节。
修复了由于TessellatingHeckler而导致的错误。

Perl 5，36 +1（-a）= 37字节

map$k{$_}++,@F;@a=keys%k;say@a+1==@F

在线尝试！

Haskell，37个字节

f x=sum[1|a<-x,b<-x,a==b]==2+length x

在线尝试！

八度 / MATLAB（带有统计信息包/工具箱），21字节

@(x)nnz(~pdist(x))==1

匿名函数。输入是列向量。输出为true（显示为1）或false（显示为0）。

在线尝试！

说明

pdist(x)计算来自的所有行对之间的欧式距离矢量x。它只考虑每个对一次（两行的顺序无关紧要），并且不考虑同一行两次形成的对。

在我们的例子中x是列向量，因此两行之间的欧几里得距离只是两个数字之间的绝对差。

~是逻辑（布尔）取反，nnz是非零数，并且与==1进行比较1。因此结果是，true当且仅当只有一对给出零距离时。

JQ 1.5，53 25个字节

length-(unique|length)==1

受到赖利的回答的启发，比我原来的解决方案要短得多。

在线尝试！

朱莉娅，39 26字节

!a=sum(a.==a')==endof(a)+2

说明

该代码生成一个二维布尔值表，然后使用sum函数收集该表，计算A的笛卡尔平方中相同元素对的数量。然后将其与字符串的长度加2进行比较，仅当有一个重复字符时，数量相等。

此代码重新定义了NOT运算符。

Pyth，6个字节

qtlQl{

验证所有测试用例。

• l{ -获取唯一元素的数量。

• tlQ -获取输入列表的长度，并递减。

• q -检查是否相等。

7字节

q1l.-Q{

验证所有测试用例

八度，23 26字节

@(x)prod(sum(x==x'))==4

在线尝试！

这x==x'部分是受骗子的回答启发的。这比Luis的回答要长，但是它不使用任何工具箱。

说明：

这是一个匿名函数，将向量x作为输入，并将其与转置后的自身进行比较。这将给出一个矩阵，其中所有对角线元素均为1，任何不对角线元素都表示存在重复元素。

任何给定列的总和显示该数目有多少个重复项。我们希望其中两个数字重复，因此我们两个等于2的值，其余不等于2。

如果取这个矩阵的乘积，4则将得到只有两个相等的元素（2*2*1*1*1*1*...），以及除4没有重复项或两个以上之外的其他值。

PHP，46字节

<?=count(array_unique($argv))==count($argv)-1;

计算其中的条目数，$argv并将其与唯一条目数进行比较。如果前者比后者高1，则为真，否则为假。

在eval.in上尝试！

05AB1E，6 5字节

{¥>ΘO

在线尝试！

{¥>ΘO   # example input:               [1, 6, 3, 4, 4, 7, 9]
{       # sort                      -> [1, 3, 4, 4, 6, 7, 9]
 ¥      # get deltas                -> [  2, 1, 0, 2, 1, 2 ]
  >     # increment                 -> [  3, 2, 1, 3, 2, 3 ]
   Θ    # truthify (only 1 gives 1) -> [  0, 0, 1, 0, 0, 0 ]
    O   # sum                       -> 1

1作为05AB1E中唯一的真实值，我们可以在这里停止。（感谢@Emigna指出这一点。）

要仅获取两个不同的值，我们可以选择添加：

     Θ  # equals 1?                 -> 1

APL（Dyalog Unicode），7 字节^SBCS

1=≢-≢∘∪

在线尝试！

说明：

1=≢-≢∘∪  ⍝ Monadic function train
    ≢∘∪  ⍝ Generate a list of unique items in the input,
         ⍝ and return the length of that list
  ≢-     ⍝ Take the length of the input and subtract the above
1=       ⍝ If the difference is 1, true, otherwise false

果冻，10字节

ċ@€`QṢ⁼1,2

在线尝试！

更长但又不同的方法

Japt，7个字节

â ʶUÊÉ

试试吧

说明

删除重复项（â），获取长度（Ê），并将等于（¶）与Ê输入（U）的长度（）减去1（É）进行比较。

Haskell，37个字节

f x=sum[1|0<-(-)<$>x<*>x]==2+length x

在线尝试！

05AB1E，5个字节

gIÙg-

在线尝试！

g     # Get number of elements in input
 IÙg  # Get number of unique elements in input
    - # Subtract

在05AB1E中，1是唯一的真实值，因此对于真实结果，必须通过uniquify删除正好1个重复元素。