Dada una lista finita no vacía de enteros, arroje un valor verdadero si hay exactamente dos entradas iguales y todas las demás entradas son distintas, y un valor falso de lo contrario.

Ejemplos

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 bytes

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

Pruébalo en línea!

{*m}lanza la lista a un setobjeto, una lista desordenada de elementos sin duplicados. Hacer esto siempre disminuirá la longitud de la lista por el número de duplicados en ella. Al calcular cuánto ha cambiado la longitud, podemos determinar fácilmente si la lista tenía un solo duplicado y devolver el resultado de la prueba.

^{-2 bytes gracias a los ovs.}

Casco , 4 bytes

εṠ-u

Pruébalo en línea!

Explicación

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

MATL , 7 , 6 bytes

&=sp4=

Pruébalo en línea!

¡Un byte guardado gracias a @Guiseppe!

Explicación:

&=  % 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 bytes

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

Pruébalo en línea! Basado en la respuesta de H.PWiz .

Jalea , 8 5 bytes

QL‘=L

Pruébalo en línea!

Explicación

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

Si los valores de salida pueden ser valores consistentes, entonces QL_Lfunciona, lo que da como resultado -1verdadero y cualquier otro número no positivo para falsey (gracias @JonathanAllan)

JavaScript (ES6), 30 bytes

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

Pruébalo en línea

Pushy , 8 bytes

Implementación simple de verificar si len(set(list)) == len(list)-1:

LtvuL^=#

Explicación:

       \ 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

Esto funciona ya que la longitud solo disminuirá en 1 si solo había exactamente 1 entero no distinto en la lista inicial.

Pruébalo en línea!

Octava , 25 bytes

Esto no está utilizando un enfoque groupo un uniqueenfoque como muchas de las otras respuestas, sino más bien el "producto cartesiano" de todas las comparaciones posibles.

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

Explicación

             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

Pruébalo en línea!

Y debido a que ningún programa estaría completo sin una convolución (gracias @LuisMendo por corregir un error):

Octava , 40 bytes

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

Pruébalo en línea!

J , 7 6 bytes

=&#0,=

=compruebe la igualdad de cada elemento con cada elemento único, crea una matriz con m filas para  m  elementos únicos.
0,agregue una fila vacía en la parte superior.
=&#¿El número de filas es igual a la longitud de entrada?

Pruébalo en línea!

Retina , 15 12 11 bytes

Gracias a Neil por guardar 1 byte.

D`
Mm2`^$
1

Pruébalo en línea!

La entrada está separada por salto de línea. (El conjunto de pruebas utiliza la separación por comas por conveniencia).

Explicación

D`

Deduplicar las líneas en la entrada, lo que elimina cualquier número entero que haya aparecido antes (pero deja los saltos de línea circundantes).

Mm2`^$

Cuente la cantidad de líneas vacías, que es igual a la cantidad de duplicados que eliminamos, pero solo considere las dos primeras coincidencias. Por lo tanto, la salida solo será 0(sin duplicados), 1(un duplicado), 2(dos o más duplicados).

1

Asegúrese de eliminar exactamente un duplicado.

05AB1E, 4 bytes

{¥_O

Try it online!

Outputs 1 as truthy, any other non-negative integer as falsy. In 05AB1E, 1 is the only truthy number (thanks @Emigna for the insight!).

Explanation

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

Ruby, 32 bytes

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

C# (.NET Core), 35 + 18 bytes

+18 for using System.Linq.

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

Try it online!

67 byte alternative without Linq:

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

Try it online!

Excel, 42 bytes

Danish language version

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

Assumes each integer from the list in separate cell in column A.
If we were allowed for inconsistent falsey values, we could save 3 bytes:

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

English language version (44 bytes)

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

R, 32 31 bytes

-1 byte thanks to @JarkoDubbeldam

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

Try it online!

Reads from stdin, writes to stdout.

duplicated iterates through the list, replacing the values of l with TRUE if that value occurs earlier in the list, and FALSE otherwise. If there's a unique pair of soulmates, there should be exactly one TRUE value, so the sum should be 1.

PowerShell, 40 37 bytes

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

Try it online!

The Sort-Object command (alias sort) with the -unique flag pulls out only the unique components of the input. For example, for input @(1,3,3,2), this will result in @(1,2,3).

Thus, we just need to make sure that the .count of this object (i.e., how many elements it has) is -equal to the .count of our input array -1 (i.e., we have exactly one duplicate entry).

Saved 3 bytes thanks to Sinusoid.
Fixed bug thanks to TessellatingHeckler.

Perl 5, 36 + 1 (-a) = 37 bytes

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

Try it online!

Haskell, 37 bytes

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

Try it online!

Octave / MATLAB (with Statistics package / toolbox), 21 bytes

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

Anonymous function. Input is a column vector. Output is true (displayed as 1) or false (displayed as0).

Try it online!

Explanation

pdist(x) computes a vector of Euclidean distances between all pairs of rows from x. It considers each pair only once (order of the two rows doesn't matter), and doesn't consider pairs formed by the same row twice.

In our case x is a column vector, so Euclidean distance between two rows is just absolute difference between the two numbers.

~ is logical (Boolean) negation, nnz is number of nonzeros, and ==1 compares to 1. So the result is true if and only if there is only one pair that gives zero distance.

Jq 1.5, 53 25 bytes

length-(unique|length)==1

Inspired by Riley's answer and much shorter then my original solution.

Try it online!

Julia, 39 26 bytes

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

Explanation

The code generates a 2-dimensional table of booleans, which is then collected using the sum function, counting the number of same-element pairs in the cartesian square of A. Then this is compared to the length of the string plus two, and the quantities are equal only when there is exactly one repeat character.

This code redefines the NOT operator.

Pyth, 6 bytes

qtlQl{

Verify all the test cases.

• l{ - Gets the number of unique elements.

• tlQ - Gets the length of the input list, decremented.

• q - Checks equality.

7 bytes

q1l.-Q{

Verify all the test cases

Octave, 23 26 bytes

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

Try it online!

The x==x' part was inspired by flawr's answer. This is longer than Luis' answer, but it doesn't use any toolboxes.

Explanation:

This is an anonymous function that takes a vector x as input, and compares it to itself transposed. This will give a matrix where all diagonal elements are 1, and any off diagonal elements signals that there are duplicates elements.

The sum along any given column shows how many duplicates there are of that number. We want two of the numbers to have a duplicate, so we two values equal to two, and the rest unequal to two.

If we take the product of this matrix, we'll get 4 if there are only two equal elements (2*2*1*1*1*1*...), and something other than 4 if there are no duplicates, or more than two.

PHP, 46 bytes

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

Counts the number of entries in $argv and compares it to the number of unique entries. If the former is higher than the latter by 1 then truthy, else falsey.

Try it on eval.in!

05AB1E, 6 5 bytes

{¥>ΘO

Try it online!

{¥>Θ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 being the only truthy value in 05AB1E, we can stop here. (Thanks @Emigna for pointing that out.)

To get only two distinct values, we can optionally add:

     Θ  # equals 1?                 -> 1

APL (Dyalog Unicode), 7 bytes^SBCS

1=≢-≢∘∪

Try it online!

Explanation:

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

Jelly, 10 bytes

ċ@€`QṢ⁼1,2

Try it online!

a longer but different approach

Japt, 7 bytes

â ʶUÊÉ

Try it

Explanation

Remove duplicates (â), get length (Ê) and compare equality (¶) with the length (Ê) of the input (U) minus 1 (É).

Haskell, 37 bytes

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

Try it online!

05AB1E, 5 bytes

gIÙg-

Try it online!

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

In 05AB1E 1 is the only truthy value, so for a truthy result there must be exactly 1 duplicate element removed by the uniquify.