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]

code-golf array-manipulation decision-problem

— flawr
fonte

Suponho que não podemos assumir que os números inteiros sempre serão menores que 10?

— Martin Ender

11

Sim, exceto se o seu idioma não suportar números inteiros maiores.

— flawr

11

Você pode elaborar o que você quer dizer com consistente ?

— flawr

33

Viu esta no topo da HNQ & pensei que tinha chegado a questão interpersonal.se finais

— gntskn

3

@ Walfrat Publique como seu próprio desafio. Além disso, esse feedback geralmente é apreciado na caixa de areia.

— flawr

22

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

— LyricLy
fonte

Exatamente a solução que eu tinha, mas esqueci o {*m}atalho em vez de set, bem jogado!

— FlipTack 11/10

27 bytes para a negação . (Falsey quando deveria ser Truthy, etc)

— mbomb007

3

Aqui está outra maneira estranha para fazê-lo (também negação):lambda m:~-len(m[len({*m}):])

— mbomb007

9

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?

— Zgarb
fonte

7

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'

— DJMcMayhem
fonte

11

Como sis sume sumsomas ao longo da primeira dimensão não singleton (colunas) e a matriz são simétricas, isso não poderia ser apenas em svez de Xs?

— Giuseppe

11

@ Giuseppe Ah, TIL. Obrigado!

— DJMcMayhem

7

Haskell , 34 bytes

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

Experimente online! Baseado na resposta de H.PWiz .

— Laikoni
fonte

6

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)

— caird coinheringaahing
fonte

QL_Lproduziria -1para verdade e algum número menor que -1ou 0para falsey (por exemplo [1,6,3,4,4,7,9,9,9], retornaria -3, enquanto [1,6,3,4,7,9]retornaria 0).

— Jonathan Allan

@JonathanAllan Oh yeah. Eu acho que os exemplos que eu testei em tudo aconteceram -2.

— caird coinheringaahing

5

JavaScript (ES6), 30 bytes

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

Experimente online

— Shaggy
fonte

4

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!

— FlipTack
fonte

11

Uau, não vejo uma resposta agressiva há anos! +1

— caird coinheringaahing

11

@cairdcoinheringaahing Pushy nunca vai morrer. Só voltará mais forte.

— FlipTack 11/11

4

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!

— flawr
fonte

Você me inspirou a vir para cima com esta abordagem :)

— Stewie Griffin

2

@StewieGriffin Eu acho que o MATL resposta usado sua abordagem exata :)

— flawr

4

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!

— FrownyFrog
fonte

Eu acho que você pode substituir .~com=

— H.PWiz

@ H.PWiz Nice, editado.

— FrownyFrog

4

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).

Verifique se exatamente uma duplicata foi removida.

— Martin Ender
fonte

Salve um byte limitando a correspondência da nova linha para 2, para que a entrada para a terceira linha seja sempre 0, 1 ou 2, simplificando o teste. (Irritantemente você não pode usar A`.para contar novas linhas, porque cai o último.)

— Neil

@ Neil Obrigado, o limite é uma boa idéia. Também tentei usar A`., mas o problema é que você não consegue distinguir uma única linha vazia de não ter nenhuma linha. Talvez eu deva considerar terminar Ae Genviar com um avanço de linha, se houver alguma linha. Embora isso provavelmente deva ser uma opção, já que posso imaginar que o feed de linha seja irritante em outros cenários.

— Martin Ender

Combinar uma única linha vazia é fácil - isso é justo ^$¶.

— Neil

@ Neil Não, quero dizer que a saída de Aé idêntica, independentemente de manter uma única linha vazia ou descartar todas as linhas.

— Martin Ender

Desculpe, isso é o que eu quis dizer com "deixa cair o último" - ele retorna um a menos linha vazia, mas então você não pode distinguir entre 0 e 1.

— Neil

3

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

— Luis Mendo
fonte

3

Ruby, 32 bytes

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

— parenparen
fonte

Bem-vindo ao PPCG! Como esse é um código de golfe, você precisa incluir a contagem de bytes do seu programa. Tomei a liberdade de fazer isso por você neste momento.

— Pavel

Que tal Array#size?

— Travis

Você pode obter até 26 bytes usando->s{s.uniq.size==s.size-1}

— Conor O'Brien

3

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!

— Ian H.
fonte

3

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

— pajonk
fonte

3

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.

— Giuseppe
fonte

11

31 bytes

— JAD

11

@JarkoDubbeldam ah, é claro. Bom te ver de novo! Faz algum tempo.

— Giuseppe

Estive ocupado com outras coisas, não tenho certeza se ainda estou de volta.

— JAD

@ Giuseppe, acabei de ler esta pergunta e imediatamente pensei em sua abordagem original .... Muito bom! Eu nunca teria pensado na scan()abordagem.

— Joseph Wood

3

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.

— AdmBorkBork
fonte

Você pode usar o alias get-exclusivo 'gu' em vez de grupo para alcançar o mesmo resultado?

— Sinusoid

@ Sinusoid Sim, nós podemos. Obrigado!

— AdmBorkBork

Isso não funciona no segundo caso de teste 1,2,1- get-uniqueapenas funciona na entrada pré-classificada. Que tal ($args|sort -u).count-eq$args.count-1também tem 37, mas funciona para todos os casos de teste, se você chamar assim como em f 1 2 1vez de f 1,2,1?

— TessellatingHeckler

@TessellatingHeckler Ah, boa captura. Todo o teste que fiz foi com entrada pré-classificada. Obrigado!

— AdmBorkBork

2

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

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

Experimente online!

— Xcali
fonte

11

pode ser @k{@F}++;say@F==1+keys%k

— jogado golfe

2

Haskell , 37 bytes

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

Experimente online!

— H.PWiz
fonte

2

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.

— Luis Mendo
fonte

2

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!

— jq170727
fonte

2

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.

— eaglgenes101
fonte

!a=sum(a.==a')==endof(a)+2salva alguns bytes. Experimente online!

— Dennis

2

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

— Mr. Xcoder
fonte

2

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.

— Stewie Griffin
fonte

2

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!

— roberto06
fonte

Você precisa usar o nome da variável $ argv, não pode usar apenas $ a?

— dading84

3

@ dading84 $argvé a lista de parâmetros da linha de comando. Então: não, ele não pode simplesmente usar $a.

— Titus

2

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

— Arnauld
fonte

11

Se estiver correto retornar qualquer valor falsey para os casos falsey, você pode pular o Θ, como 1é o único valor verdadeiro em 05AB1E.

— Emigna

@Emigna Thanks! Eu não tinha certeza se foi aprovado pelo OP, mas acho que é.

— Arnauld 11/10

Receio que você precise reverter para a solução anterior, pois ¢não funcionará. Contaria [19,4,4,9]como falso e [19,9]verdadeiro, uma vez que encontra o 0in 10.

— Emigna

@ Emigna Obrigado por descobrir isso. Eu acho que está consertado.

— Arnauld 12/10

{¥_Odeve ficar bem também.

— Emigna

2

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

— voidhawk
fonte

1

Gelatina , 10 bytes

ċ@€`QṢ⁼1,2

Experimente online!

uma abordagem mais longa, mas diferente

— HyperNeutrino
fonte

1

Japonês, 7 bytes

â Ê¶UÊÉ

Tente

Explicação

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

— Shaggy
fonte

Não são 12 bytes? Não são âÊÉ¶caracteres multibyte?

— RedClover 13/10

1

Haskell , 37 bytes

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

Experimente online!

— flawr
fonte

1

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.

— Riley
fonte

À procura de uma alma gêmea

Exemplos

Python 3, 30 28 bytes

Casca , 4 bytes

Explicação

MATL , 7 , 6 bytes

Haskell , 34 bytes

Geléia , 8 5 bytes

Explicação

JavaScript (ES6), 30 bytes

Pushy , 8 bytes

Oitava , 25 bytes

Explicação

Oitava , 40 bytes

J , 7 6 bytes

Retina , 15 12 11 bytes

Explicação

05AB1E , 4 bytes

Explicação

Ruby, 32 bytes

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

Excel, 42 bytes

R , 32 31 bytes

PowerShell , 40 37 bytes

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

Haskell , 37 bytes

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

Explicação

Jq 1.5 , 53 25 bytes

Julia, 39 26 bytes

Explicação

Pitão , 6 bytes

7 bytes

Oitava , 23 26 bytes

Explicação:

PHP, 46 bytes

05AB1E , 6 5 bytes

APL (Dyalog Unicode) , SBCS de 7 bytes

Gelatina , 10 bytes

Japonês, 7 bytes

Explicação

Haskell , 37 bytes

05AB1E , 5 bytes

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

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