Dada uma lista finita não vazio de inteiros, a saída de um truthy valor se não são exatamente duas entradas iguais e todas as outras entradas são distintas, e uma Falsey valor de outra forma.

Exemplos

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)

Experimente online!

{*m}lança a lista em um setobjeto, uma lista não ordenada de itens sem duplicatas. Fazer isso sempre diminuirá o comprimento da lista pelo número de duplicatas nela. Ao calcular quanto o comprimento mudou, podemos facilmente saber se a lista teve uma única duplicata e retornar o resultado do teste.

^{-2 bytes graças a ovs.}

Casca , 4 bytes

εṠ-u

Experimente online!

Explicação

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

MATL , 7 , 6 bytes

&=sp4=

Experimente online!

Um byte salvo graças a @Guiseppe!

Explicação:

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

Experimente online! Baseado na resposta de H.PWiz .

Geléia , 8 5 bytes

QL‘=L

Experimente online!

Explicação

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

Se os valores de saída puderem ser consistentes, então QL_Lfunciona, que gera -1para verdade e qualquer outro número não positivo para falsey (obrigado @ JonathanAllan)

JavaScript (ES6), 30 bytes

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

Experimente online

Pushy , 8 bytes

Implementação simples de verificar se len(set(list)) == len(list)-1:

LtvuL^=#

Explicação:

       \ 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

Isso funciona, pois o comprimento só diminuirá em 1 se houver apenas exatamente 1 número inteiro não distinto na lista inicial.

Experimente online!

Oitava , 25 bytes

Isso não está usando uma abordagem groupou uniquecomo muitas das outras respostas, mas o "produto cartesiano" de todas as comparações possíveis.

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

Explicação

             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

Experimente online!

E porque nenhum programa estaria completo sem uma convolução (obrigado @LuisMendo por corrigir um erro):

Oitava , 40 bytes

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

Experimente online!

J , 7 6 bytes

=&#0,=

=verifique a igualdade de todos os elementos com cada elemento exclusivo, cria uma matriz com m linhas para  m  elementos únicos.
0,adicione uma linha vazia na parte superior.
=&#o número de linhas é igual ao comprimento da entrada?

Experimente online!

Retina , 15 12 11 bytes

Agradecemos a Neil por economizar 1 byte.

D`
Mm2`^$
1

Experimente online!

A entrada é separada pela alimentação de linha. (O conjunto de testes usa separação por vírgula por conveniência.)

Explicação

D`

Desduplicar as linhas na entrada, que remove qualquer número inteiro que apareceu antes (mas deixa os feeds de linha circundantes).

Mm2`^$

Conte o número de linhas vazias, que é igual ao número de duplicatas removidas, mas considere apenas as duas primeiras correspondências. Portanto, a saída será apenas 0(sem duplicatas), 1(uma duplicata), 2(duas ou mais duplicatas).

1

Verifique se exatamente uma duplicata foi removida.

05AB1E , 4 bytes

{¥_O

Experimente online!

Saídas 1como verdade, qualquer outro número inteiro não negativo como falso. Em 05AB1E, 1é o único número de verdade (obrigado @Emigna pelo insight!).

Explicação

{       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 para usar System.Linq.

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

Experimente online!

Alternativa de 67 bytes sem Linq:

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

Experimente online!

Excel, 42 bytes

Versão em língua dinamarquesa

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

Assume cada número inteiro da lista em célula separada na coluna A.
Se nos permitissem valores inconsistentes de falsey , poderíamos salvar 3 bytes:

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

Versão em inglês (44 bytes)

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

R , 32 31 bytes

-1 byte graças a @JarkoDubbeldam

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

Experimente online!

Lê de stdin, escreve para stdout.

duplicateditera pela lista, substituindo os valores de lpor TRUEse esse valor ocorrer anteriormente na lista e FALSEcaso contrário. Se houver um único par de almas gêmeas, deve haver exatamente um TRUEvalor, portanto a soma deve ser 1.

PowerShell , 40 37 bytes

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

Experimente online!

O Sort-Objectcomando (alias sort) com o -usinalizador nique extrai apenas os componentes exclusivos da entrada. Por exemplo, para entrada @(1,3,3,2), isso resultará em @(1,2,3).

Portanto, precisamos apenas garantir que o .countobjeto desse objeto (ou seja, quantos elementos ele possui) seja -eqigual ao .countda nossa matriz de entrada -1(ou seja, temos exatamente uma entrada duplicada).

Economizou 3 bytes graças ao Sinusoid.
Corrigido o erro graças ao TessellatingHeckler.

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

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

Experimente online!

Haskell , 37 bytes

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

Experimente online!

Octave / MATLAB (com pacote / caixa de ferramentas Statistics), 21 bytes

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

Função anônima. Entrada é um vetor de coluna. A saída é true(exibida como 1) ou false(exibida como 0).

Experimente online!

Explicação

pdist(x)calcula um vetor de distâncias euclidianas entre todos os pares de linhas de x. Ele considera cada par apenas uma vez (a ordem das duas linhas não importa) e não considera os pares formados pela mesma linha duas vezes.

No nosso caso, xé um vetor de coluna; portanto, a distância euclidiana entre duas linhas é apenas uma diferença absoluta entre os dois números.

~é uma negação lógica (booleana), nnzé o número de nonzeros e se ==1compara a 1. Portanto, o resultado é truese e somente se houver apenas um par que dê distância zero.

Jq 1.5 , 53 25 bytes

length-(unique|length)==1

Inspirado pela resposta de Riley e muito mais curto que minha solução original.

Experimente online!

Julia, 39 26 bytes

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

Explicação

O código gera uma tabela bidimensional de booleanos, que é então coletada usando a função sum, contando o número de pares do mesmo elemento no quadrado cartesiano de A. Então, isso é comparado ao comprimento da string mais dois, e o quantidades são iguais apenas quando há exatamente um caractere de repetição.

Este código redefine o operador NOT.

Pitão , 6 bytes

qtlQl{

Verifique todos os casos de teste.

• l{ - Obtém o número de elementos exclusivos.

• tlQ - Obtém o comprimento da lista de entrada, decrementado.

• q - Verifica a igualdade.

7 bytes

q1l.-Q{

Verifique todos os casos de teste

Oitava , 23 26 bytes

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

Experimente online!

A x==x'parte foi inspirada na resposta de flawr . Isso é mais longo que a resposta de Luis, mas não usa nenhuma caixa de ferramentas.

Explicação:

Esta é uma função anônima que pega um vetor xcomo entrada e o compara a si próprio transposto. Isso fornecerá uma matriz onde estão todos os elementos diagonais 1e quaisquer elementos fora da diagonal sinalizam que há elementos duplicados.

A soma ao longo de qualquer coluna mostra quantas duplicatas existem desse número. Queremos que dois dos números tenham uma duplicata; portanto, dois valores são iguais a dois e o restante é desigual a dois.

Se pegarmos o produto dessa matriz, descobriremos 4se existem apenas dois elementos iguais ( 2*2*1*1*1*1*...) e algo diferente de 4se não houver duplicatas ou mais de dois.

PHP, 46 bytes

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

Conta o número de entradas $argve o compara com o número de entradas exclusivas. Se o primeiro é mais alto que o último em 1, então é verdade, senão falsey.

Experimente no eval.in!

05AB1E , 6 5 bytes

{¥>ΘO

Experimente 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

1sendo o único valor verdadeiro em 05AB1E, podemos parar por aqui. (Obrigado @ Emigna por apontar isso.)

Para obter apenas dois valores distintos, podemos adicionar opcionalmente:

     Θ  # equals 1?                 -> 1

APL (Dyalog Unicode) , ^{SBCS de} 7 bytes

1=≢-≢∘∪

Experimente online!

Explicação:

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

Gelatina , 10 bytes

ċ@€`QṢ⁼1,2

Experimente online!

uma abordagem mais longa, mas diferente

Japonês, 7 bytes

â ʶUÊÉ

Tente

Explicação

Remova duplicatas ( â), obtenha comprimento ( Ê) e compare a igualdade ( ¶) com o comprimento ( Ê) da entrada ( U) menos 1 ( É).

Haskell , 37 bytes

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

Experimente online!

05AB1E , 5 bytes

gIÙg-

Experimente online!

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

Em 05AB1E 1 é o único valor de verdade, portanto, para um resultado de verdade, deve haver exatamente 1 elemento duplicado removido pela unificação.