Dato un elenco finito non vuoto di numeri interi, emettere un valore di verità se ci sono esattamente due voci uguali e tutte le altre voci sono distinte e un valore di falsa altrimenti.

Esempi

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

Suppongo che non possiamo supporre che gli interi saranno sempre inferiori a 10?

— Martin Ender,

1

Sì, tranne se la tua lingua non supporta numeri interi più grandi.

— Flawr,

1

Puoi elaborare cosa intendi per coerente ?

— Flawr,

33

L'ho visto sulla cima di HNQ e ho pensato che avremmo raggiunto l'ultima domanda interpersonale.se

— gntskn,

3

@Walfrat Pubblicalo come la tua sfida. Anche tale feedback è di solito apprezzato nella sandbox.

— Flawr,

22

Python 3, 30 28 byte

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

Provalo online!

{*m}lancia l'elenco su un setoggetto, un elenco non ordinato di elementi senza duplicati. In questo modo si ridurrà sempre la lunghezza dell'elenco in base al numero di duplicati in essa contenuti. Calcolando quanto la lunghezza è cambiata, possiamo facilmente capire se l'elenco aveva un solo duplicato e restituire il risultato del test.

^{-2 byte grazie agli ovs.}

— LyricLy
fonte

Esattamente la soluzione che avevo, ma ho dimenticato la {*m}scorciatoia anziché set, ben giocata a golf!

— FlipTack,

27 byte per la negazione . (Falsey quando dovrebbe essere Truthy, ecc.)

— mbomb007,

3

Ecco un altro modo strano di farlo (anche negazione):lambda m:~-len(m[len({*m}):])

— mbomb007,

9

Buccia , 4 byte

εṠ-u

Provalo online!

Spiegazione

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

— Zgarb
fonte

7

MATL , 7 , 6 byte

&=sp4=

Provalo online!

Un byte salvato grazie a @Guiseppe!

Spiegazione:

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

1

Poiché sis sume sumsomma lungo la prima dimensione non-singleton (colonne) e la matrice è simmetrica, non potrebbe essere solo questa sinvece di Xs?

— Giuseppe,

1

@Giuseppe Ah, TIL. Grazie!

— DJMcMayhem

7

Haskell , 34 byte

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

Provalo online! Basato sulla risposta di H.PWiz .

— Laikoni
fonte

6

Gelatina , 8 5 byte

QL‘=L

Provalo online!

Spiegazione

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 i valori di output possono essere valori coerenti, allora QL_Lfunziona, quali output -1per verità e qualsiasi altro numero non positivo per falsità (grazie @JonathanAllan)

— caird coinheringaahing
fonte

QL_Lprodurrebbe -1per la verità e un numero inferiore -1o 0per la falsità (ad es. [1,6,3,4,4,7,9,9,9]ritornerebbe -3, mentre [1,6,3,4,7,9]ritornerebbe 0).

— Jonathan Allan,

@JonathanAllan Oh yeah. Immagino che gli esempi su cui l'ho provato siano tornati -2.

— caird coinheringaahing l'

5

JavaScript (ES6), 30 byte

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

Provalo online

— ispido
fonte

4

Pushy , 8 byte

Semplice implementazione del controllo se len(set(list)) == len(list)-1:

LtvuL^=#

Spiegazione:

       \ 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

Questo funziona in quanto la lunghezza diminuirà di 1 solo se nella lista iniziale era presente solo 1 intero non distinto.

Provalo online!

— FlipTack
fonte

1

Caspita, non vedo una risposta invadente da anni! +1

— caird coinheringaahing l'

1

@cairdcoinheringaahing Pushy non morirà mai. Tornerà solo più forte.

— FlipTack,

4

Ottava , 25 byte

Questo non sta usando un approccio groupo uniquecome molte delle altre risposte, ma piuttosto il "prodotto cartesiano" di tutte le possibili comparazioni.

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

Spiegazione

             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

Provalo online!

E poiché nessun programma sarebbe completo senza una convoluzione (grazie @LuisMendo per aver corretto un errore):

Ottava , 40 byte

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

Provalo online!

— flawr
fonte

Mi hai ispirato a elaborare questo approccio :)

— Stewie Griffin,

2

@StewieGriffin Penso che la risposta MATL abbia usato il tuo approccio esatto :)

— flawr

4

J , 7 6 byte

=&#0,=

=controlla la parità di ogni elemento con ogni elemento univoco, crea una matrice con m righe per m elementi unici.
0,aggiungi una riga vuota in cima.
=&#il numero di righe equivale alla lunghezza dell'input?

Provalo online!

— FrownyFrog
fonte

Penso che tu possa sostituire .~con=

— H.Pwiz l'

@ H.PWiz Nice, modificato.

— FrownyFrog,

4

Retina , 15 12 11 byte

Grazie a Neil per aver salvato 1 byte.

D`
Mm2`^$
1

Provalo online!

L'ingresso è separato dall'alimentazione di linea. (La suite di test utilizza la separazione virgola per comodità.)

Spiegazione

D`

Deduplica le linee nell'input, che rimuove qualsiasi numero intero apparso prima (ma lascia gli avanzamenti riga circostanti).

Mm2`^$

Conta il numero di righe vuote, che è uguale al numero di duplicati che abbiamo rimosso, ma considera solo le prime due corrispondenze. Quindi l'output sarà solo 0(nessun duplicato), 1(un duplicato), 2(due o più duplicati).

Assicurarsi che sia stato rimosso esattamente un duplicato.

— Martin Ender
fonte

Salvare un byte limitando la corrispondenza della nuova riga a 2, in modo che l'ingresso alla terza riga sia sempre 0, 1 o 2, semplificando il test. (Stranamente non puoi usare A`.per contare le nuove linee, perché lascia cadere l'ultima.)

— Neil,

@Neil Grazie, il limite è un'idea chiara. Ho anche provato a usare A`., ma il problema è piuttosto che non puoi distinguere una singola riga vuota dal non avere alcuna linea. Forse dovrei considerare la conclusione Ae l' Goutput con un avanzamento riga se ci sono righe. Anche se probabilmente dovrebbe essere un'opzione dal momento che posso immaginare che il linefeed sia fastidioso in altri scenari.

— Martin Ender,

Abbinare una singola riga vuota è facile - questo è solo ^$¶.

— Neil,

@Neil No, intendo che l'output di Aè identico indipendentemente dal fatto che mantenga una singola riga vuota o scarti tutte le righe.

— Martin Ender,

Siamo spiacenti, questo è ciò che intendevo per "elimina l'ultimo": restituisce una riga in meno, ma non puoi distinguere tra 0 e 1.

— Neil,

3

05AB1E , 4 byte

{¥_O

Provalo online!

Produce 1come verità, qualsiasi altro numero intero non negativo come falsa. In 05AB1E, 1è l'unico numero vero (grazie @Emigna per l'intuizione!).

Spiegazione

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

— Luis Mendo
fonte

3

Rubino, 32 byte

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

— parenparen
fonte

Benvenuti in PPCG! Poiché si tratta di code golf, è necessario includere il conteggio dei byte del programma. Mi sono preso la libertà di farlo per te questa volta.

— Pavel,

Che ne dici Array#size?

— Travis,

Puoi scendere a 26 byte usando->s{s.uniq.size==s.size-1}

— Conor O'Brien

3

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

+18 per l'utilizzo System.Linq.

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

Provalo online!

Alternativa a 67 byte senza Linq:

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

Provalo online!

— Ian H.
fonte

3

Excel, 42 byte

Versione in lingua danese

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

Presuppone ogni numero intero dall'elenco in una cella separata nella colonna A.
Se ci fossero consentiti valori errati di falsità , potremmo salvare 3 byte:

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

Versione in lingua inglese (44 byte)

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

— Pajonk
fonte

3

R , 32 31 byte

-1 byte grazie a @JarkoDubbeldam

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

Provalo online!

Legge da stdin, scrive su stdout.

duplicatedscorre l'elenco, sostituendo i valori di lcon TRUEse tale valore si verifica prima nell'elenco e in caso FALSEcontrario. Se c'è una coppia unica di anime gemelle, dovrebbe esserci esattamente un TRUEvalore, quindi la somma dovrebbe essere 1.

— Giuseppe
fonte

1

31 byte

— JAD

1

@JarkoDubbeldam ah, ovviamente. È bello vederti di nuovo! È passato un po 'di tempo.

— Giuseppe,

Sono stato impegnato con alcune altre cose, non sono sicuro di essere ancora completamente tornato.

— JAD,

@Giuseppe, ho appena letto questa domanda e ho pensato subito al tuo approccio originale .... Molto bello! Non avrei mai pensato scan()all'approccio.

— Joseph Wood,

3

PowerShell , 40 37 byte

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

Provalo online!

Il Sort-Objectcomando (alias sort) con il -uflag nique estrae solo i componenti univoci dell'input. Ad esempio, per l'input @(1,3,3,2), ciò comporterà @(1,2,3).

Quindi, dobbiamo solo assicurarci che l' .countoggetto di questo (cioè quanti elementi ha) sia -equguale al .countnostro array di input -1(cioè abbiamo esattamente una voce duplicata).

Salvato 3 byte grazie a Sinusoid.
Bug risolto grazie a TessellatingHeckler.

— AdmBorkBork
fonte

Puoi usare l'alias get-unique 'gu' invece del gruppo per raggiungere lo stesso risultato?

— Sinusoide,

@Sinusoid Sì, possiamo. Grazie!

— AdmBorkBork,

Questo non funziona sul secondo caso di test 1,2,1- get-uniquefunziona solo su input preordinati. Che ne dici di ($args|sort -u).count-eq$args.count-1quale è anche 37 ma funziona per tutti i casi di test, se lo chiami come f 1 2 1invece di f 1,2,1?

— TessellatingHeckler,

@TessellatingHeckler Ah, buona cattura. Tutti i test che ho fatto sono stati con input preordinati. Grazie!

— AdmBorkBork,

2

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

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

Provalo online!

— Xcali
fonte

1

può essere giocato a golf@k{@F}++;say@F==1+keys%k

— Nahuel Fouilleul,

2

Haskell , 37 byte

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

Provalo online!

— H.PWiz
fonte

2

Octave / MATLAB (con pacchetto / toolbox Statistics), 21 byte

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

Funzione anonima. L'input è un vettore di colonna. L'output è true(visualizzato come 1) o false(visualizzato come 0).

Provalo online!

Spiegazione

pdist(x)calcola un vettore di distanze euclidee tra tutte le coppie di file da x. Considera ogni coppia una sola volta (l'ordine delle due righe non ha importanza) e non considera le coppie formate dalla stessa riga due volte.

Nel nostro caso xè un vettore di colonna, quindi la distanza euclidea tra due file è solo la differenza assoluta tra i due numeri.

~è la negazione logica (booleana), nnzè il numero di nonzeros e si ==1confronta con 1. Quindi il risultato è truese e solo se c'è solo una coppia che dà zero distanza.

— Luis Mendo
fonte

2

Jq 1,5 , 53 25 byte

length-(unique|length)==1

Ispirato dalla risposta di Riley e molto più breve della mia soluzione originale.

Provalo online!

— jq170727
fonte

2

Julia, 39 26 byte

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

Spiegazione

Il codice genera una tabella bidimensionale di booleani, che viene quindi raccolta utilizzando la funzione somma, contando il numero di coppie dello stesso elemento nel quadrato cartesiano di A. Quindi questo viene confrontato con la lunghezza della stringa più due, e il le quantità sono uguali solo quando esiste esattamente un carattere di ripetizione.

Questo codice ridefinisce l'operatore NOT.

— eaglgenes101
fonte

!a=sum(a.==a')==endof(a)+2salva qualche byte. Provalo online!

— Dennis,

2

Pyth , 6 byte

qtlQl{

Verifica tutti i casi di test.

l{ - Ottiene il numero di elementi univoci.
tlQ - Ottiene la lunghezza della lista di input, diminuita.
q - Verifica l'uguaglianza.

7 byte

q1l.-Q{

Verifica tutti i casi di test

— Mr. Xcoder
fonte

2

Ottava , 23 26 byte

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

Provalo online!

La x==x'parte è stata ispirata dalla risposta di Flawr . Questo è più lungo della risposta di Luis, ma non utilizza alcun toolbox.

Spiegazione:

Questa è una funzione anonima che accetta un vettore xcome input e lo confronta con se stesso trasposto. Questo darà una matrice in cui si trovano tutti gli elementi diagonali1 e qualsiasi elemento fuori diagonale segnala che ci sono elementi duplicati.

La somma lungo una data colonna mostra quanti duplicati ci sono di quel numero. Vogliamo che due dei numeri abbiano un duplicato, quindi abbiamo due valori uguali a due e il resto è diverso da due.

Se prendiamo il prodotto di questa matrice, otterremo 4se ci sono solo due elementi uguali ( 2*2*1*1*1*1*...) e qualcosa di diverso da 4se non ci sono duplicati, o più di due.

— Stewie Griffin
fonte

2

PHP, 46 byte

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

Conta il numero di voci in $argve lo confronta con il numero di voci univoche. Se il primo è superiore al secondo di 1, allora verità, altrimenti falsità.

Provalo su eval.in!

— Roberto06
fonte

Devi usare il nome della variabile $ argv, non puoi semplicemente usare $ a invece?

— dading84,

3

@ dading84 $argvè l'elenco dei parametri della riga di comando. Quindi: no, non può semplicemente usare $a.

— Tito,

2

05AB1E , 6 5 byte

{¥>ΘO

Provalo 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

1essendo l'unico valore vero in 05AB1E, possiamo fermarci qui. (Grazie @Emigna per averlo sottolineato.)

Per ottenere solo due valori distinti, possiamo aggiungere facoltativamente:

     Θ  # equals 1?                 -> 1

— Arnauld
fonte

1

Se è possibile restituire un valore di falsità per i casi di falsità, è possibile saltare il valore Θ, poiché 1è l'unico valore di verità in 05AB1E.

— Emigna,

@Emigna Grazie! Non ero sicuro che fosse stato approvato dall'OP, ma credo che lo sia.

— Arnauld,

Temo che sia necessario tornare alla soluzione precedente poiché ¢non funzionerà. Conterebbe [19,4,4,9]come falso e [19,9]vero dal momento che trova 0in 10.

— Emigna,

@Emigna Grazie per averlo individuato. Penso che sia risolto.

— Arnauld,

{¥_Odovrebbe anche essere a posto.

— Emigna,

2

APL (Dyalog Unicode) , 7 byte ^SBCS

1=≢-≢∘∪

Provalo online!

Spiegazione:

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 byte

ċ@€`QṢ⁼1,2

Provalo online!

un approccio più lungo ma diverso

— HyperNeutrino
fonte

1

Japt, 7 byte

â Ê¶UÊÉ

Provalo

Spiegazione

Rimuovi duplicati ( â), ottieni lunghezza ( Ê) e confronta l'uguaglianza ( ¶) con la lunghezza ( Ê) dell'input ( U) meno 1 ( É).

— ispido
fonte

Non sono 12 byte? I âÊÉ¶personaggi multibyte non sono ?

— RedClover,

1

Haskell , 37 byte

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

Provalo online!

— flawr
fonte

1

05AB1E , 5 byte

gIÙg-

Provalo online!

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

In 05AB1E 1 è l'unico valore di verità, quindi per un risultato di verità deve esserci esattamente 1 elemento duplicato rimosso da uniquify.

— Riley
fonte

Alla ricerca di un'anima gemella

Esempi

Python 3, 30 28 byte

Buccia , 4 byte

Spiegazione

MATL , 7 , 6 byte

Haskell , 34 byte

Gelatina , 8 5 byte

Spiegazione

JavaScript (ES6), 30 byte

Pushy , 8 byte

Ottava , 25 byte

Spiegazione

Ottava , 40 byte

J , 7 6 byte

Retina , 15 12 11 byte

Spiegazione

05AB1E , 4 byte

Spiegazione

Rubino, 32 byte

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

Excel, 42 byte

R , 32 31 byte

PowerShell , 40 37 byte

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

Haskell , 37 byte

Octave / MATLAB (con pacchetto / toolbox Statistics), 21 byte

Spiegazione

Jq 1,5 , 53 25 byte

Julia, 39 26 byte

Spiegazione

Pyth , 6 byte

7 byte

Ottava , 23 26 byte

Spiegazione:

PHP, 46 byte

05AB1E , 6 5 byte

APL (Dyalog Unicode) , 7 byte SBCS

Gelatina , 10 byte

Japt, 7 byte

Spiegazione

Haskell , 37 byte

05AB1E , 5 byte

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

APL (Dyalog Unicode) , 7 byte ^SBCS