Scrivi un programma che trova gli elementi non univoci di una matrice di numeri interi con segno. L'array risultante può essere in qualsiasi ordine.

La tua risposta potrebbe essere uno snippet che presuppone che l'input sia archiviato in una variabile ( ddiciamo) e valuta il risultato corretto.

Casi test

Ogni caso di test è una singola riga nel formato input => output. Si noti che sono valide anche altre permutazioni dell'output.

[]                        => []
[-1, 0, 1]                => []
[1, 1]                    => [1]
[3, 0, 0, 1, 1, 0, 5, 3]  => [3, 0, 1]
[-34, 0, 1, -34, 4, 8, 4] => [-34, 4]

L'ordine degli elementi non ha importanza.

Questo è il golf del codice, quindi vince la risposta più breve (in byte).

K5 , 5 byte

Supponendo che l'input sia già in una variabile chiamata d,

?d^?d

Prendi gli elementi distinti ( ?) di d tranne ( d^) gli elementi distinti di d ( ?d). Piacevolmente simmetrico, no? Questo funziona perché l'operatore "tranne" rimuove solo la prima occorrenza dell'argomento destro dall'argomento sinistro.

Più generalmente,

nu: {?x^?x}

In azione:

  nu'(();-1 0 1;1 1;3 0 0 1 1 0 5 3;-34 0 1 -34 4 8 4)
(()
 ()
 ,1
 0 1 3
 -34 4)

Modificare:

Se volessimo preservare l'ordine della prima occorrenza di elementi non univoci, potremmo invertire l'elenco di sorgenti prima e dopo aver rimosso gli elementi univoci tramite, tranne al costo di 4 byte extra:

  nu: {?|(|x)^?x}
  nu'(();-1 0 1;1 1;3 0 0 1 1 0 5 3;-34 0 1 -34 4 8 4)
(()
 ()
 ,1
 3 0 1
 -34 4)

CJam, 10

Supponendo che l'array sia già nella variabile D (sulla base di questo commento ):

D{De=(},_&

Provalo online

Spiegazione:

D{…},   filter items of D based on the block
  De=   count occurrences in D
  (     decrement (resulting in true/false for duplicate/unique)
_&      remove duplicates from the results

Nota: aggiungere a pse si desidera una stampa carina, altrimenti la matrice risultante viene stampata senza delimitatori per impostazione predefinita. Ciò è accettabile poiché la domanda specifica che lo snippet deve solo "valutare il risultato corretto".

Versione input / output standard, 13:

q~_{1$e=(},&p

Provalo online

Spiegazione:

q~      read and evaluate the input array
_       duplicate the array
{…},    filter items based on the block
  1$    copy the array
  e=    count occurrences
  (     decrement (resulting in true/false for duplicate/unique)
&       set intersection with the initial array (removes duplicates)
p       pretty print

Haskell - 32

import Data.List;f l=nub$l\\nub l

Abbastanza corto, anche con l'importazione. a \\ brimuove la prima occorrenza di ogni elemento di bda ae nubrende unici tutti gli elementi di un elenco.

Pyth, 7 byte

S{.-Q{Q

Provalo online.

Come funziona

Pyth memorizza automaticamente l'input valutato Qe stampa tutti i valori di ritorno inutilizzati.

     {Q  Convert Q into a set. This removes duplicates.
  .-Q    Perform "bagwise" difference of Q and set(Q).
         This removes the first occurrence of all elements in Q.
 {       Convert to set to deduplicate.
S        Sort. Returns a list.

SQL, 44 42 byte

SELECT*FROM D GROUP BY I HAVING COUNT(*)>1

Spero sia OK supporre che i numeri interi siano memorizzati nella tabella D? Questo funzionerà sia in SQL Server, PostgreSQL e possibilmente in altri. Grazie a @manatwork dai 2 byte.

Mathematica, 29 26 byte

Supponendo che l'input sia archiviato in d:

Select[d⋃d,d~Count~#>1&]

Altrimenti, è 29 byte come una funzione senza nome:

Cases[#⋃#,n_/;#~Count~n>1]&

Qui, d⋃d(o #⋃#) è un trucco da golf per rimuovere i duplicati: prendendo l'unione dell'insieme con se stesso, Mathematica interpreta l'elenco come un insieme, rimuovendo automaticamente i duplicati, mentre l'unione effettiva non fa nulla.

Successivamente, entrambi i metodi filtrano semplicemente quegli elementi che compaiono nell'elenco originale almeno due volte.

JavaScript (ES6), 37 byte

Esegui questo nella console JavaScript:

e={};d.filter(x=>(e[x]=1+e[x]||0)==1)

Matlab / Octave, 40

Suppongo che i valori di input siano reali (non complessi). L'input è in una variabile d.

unique(d(sum(triu(bsxfun(@eq,d,d')))>1))

Provalo online in Octave.

Python 3.5, 30

[x for x in{*d}if~-d.count(x)]

Utilizza il disimballaggio impostato di Python 3.5. I ~-sottrae 1, che prende un conteggio di 1 a 0 che è Falsy.

Questo dà un elenco. Se dare un set è OK, allora usiamo una comprensione di set, salvando 1 carattere e senza la versione 3.5:

{x for x in d if~-d.count(x)}

PowerShell, 31 29 byte

($d|group|?{$_.Count-1}).Name

Presuppone che $dsia già popolato (come indicato), ad esempio $d=@(-34,0,1,-34,4,8,4).

Instrada l'array nel Group-Objectcmdlet, che raggruppa elementi simili e sputa fuori un oggetto che è essenzialmente un array di array. Lo instradiamo a un Where-Object(l' ?operatore) che ha Countpiù di uno (cioè, ci sono duplicati) e produciamo l'output .Namedi quegli elementi. Ha anche un vantaggio secondario nel preservare l'ordinamento iniziale.

_{Modifica: salvato due byte grazie a Danko Durbić}

APL (Dyalog Unicode) , 13 9 byte ^SBCS

Funzione prefisso tacito anonimo.

∊(⊂1↓⊣¨)⌸

Provalo online!

(... )⌸ per ciascun elemento univoco (argomento sinistro) e gli indici in cui si verifica (argomento destro), applica la seguente funzione tacita:

 ⊣¨ uno a sinistra (l'elemento unico) per ciascuno a destra (gli indici)

 1↓ rilasciarne uno

 ⊂ racchiudi (impedisce al riempimento con zeri di creare una matrice non sfilacciata)

∊ ϵ nlist (appiattisci)

Julia, 30 29 byte

∪(d[find(sum(d.==d',1)-1)])

d.==d'crea una matrice simmetrica con il valore di i,jessere vero se d[i]==d[j]e falso altrimenti. summing in una dimensione e quindi sottraendo 1 produrrà zero se c'è solo uno dell'elemento e diverso da zero se ce n'è più di uno. findotterrà gli indici degli elementi diversi da zero, che verranno quindi utilizzati per indicizzare l'array dstesso. ∪(unione) si comporta come uniquese usato in questo modo, rimuovendo le ripetizioni.

Vecchia soluzione:

∪(filter(i->sum(d.==i)>1,d))

Semplice: per ogni voce controlla se ce ne sono più di una nell'array. Quelli per i quali ce ne sono più di uno vengono restituiti da "filtro", e quindi ∪(unione) si comporta come uniquese usato in questo modo, rimuovendo le ripetizioni.

Nota: originariamente lo aveva come funzione, ma la domanda consente all'array di essere memorizzato in una variabile, per la quale ho scelto dcome suggerito nella domanda.

Python 2.7, 36 42

list(set(filter(lambda x:d.count(x)>1,d)))

modifica : racchiude l'espressione con la lista (..) per conformarsi al formato richiesto nella domanda

Ottava, 22 byte

Basato sulla risposta di Luis Mendo .

d(sum(triu(d==d'))==2)

R, 31 24 byte

Grazie a flodel per i 7 byte.

Supponendo che l'ingresso sia già in d.

codice:

unique(d[duplicated(d)])

modifica: ora emette correttamente se ci sono più di 2 duplicati come indicato da aditsu .

Python 3 - 33 30 byte

{_ for _ in d if d.count(_)>1}

Uscita Repl, d come input.

Mathematica, 31 29

Cases[{s_,t_/;t>1}:>s]@*Tally

Pyth, 7 byte

ft/QT{Q

Spiegazione:

ft/QT{Q
           Q = eval(input())
     {Q    set(Q) - deduplicate
f          filter - with T as the filter variable.
  /QT      count in Q of T
 t         minus 1.

Il filtro rimuove tutti gli elementi che appaiono esattamente una volta dal set di elementi.

LINQ, 62 54 byte

Un po 'nuovo qui, ma qui non va niente.

d.GroupBy(c=>c).Where(g=>g.Count()>1).Select(g=>g.Key)

K (oK) , 7 byte

Soluzione:

&1<#:'=

Provalo online!

Spiegazione:

&1<#:'= / the solution
      = / group, key => value (index)
   #:'  / count length of each group
 1<     / 1 less than 
&       / keys where true

Shell + GNU coreutils, 12

sort|uniq -d

Uscita di prova:

$ printf "%s\n" -34 0 1 -34 4 8 4 | ./nonuniq.sh 
-34
4
$ 

Mathematica, 23 byte

Con input archiviato in d:

Pick[#,#2>1]&@@@Tally@d

Come funzione, 24 byte:

Pick[#,#2>1]&@@@Tally@#&

per esempio, con

d = {3, 0, 0, 1, 1, 0, 5, 3}
Tally@d

restituisce questo:

   {{3, 2},
    {0, 3},
    {1, 2},
    {5, 1}}

(il primo elemento di ciascun elenco secondario è l'elemento, il secondo è la frequenza di occorrenza). L'applicazione a questo elenco lo Pick[#,#2>1]&@@@trasforma in

{Pick[3,2>1], Pick[0,3>1], Pick[1,2>1], Pick[5,1>1]}

E dove il secondo argomento di Pickrestituisce Trueviene restituito il primo argomento.

K (non K5), 10 byte

x@&1<#:'=x

Presuppone che sia inserito x. Ho pensato che sarebbe stato divertente dare una risposta diversa da K5!

Perl 6, 16 byte

Supponendo che l'elenco sia archiviato, $_è possibile utilizzare uno dei seguenti frammenti.
_{^{(che è stato specificamente consentito)}}

(--«.BagHash).Set.keys # 23 bytes

keys .Bag (-) .Set # 18 bytes

# U+2216 SET MINUS
keys .Bag∖.Set # 16 bytes in utf8

Se non ti importa di ottenere una borsa, potresti lasciarla keys .

$_ = [3, 0, 0, 1, 1, 0, 5, 3];
.Bag∖.Set ∋ 3 # True
.Bag∖.Set ∋ 5 # False

Nessuno di questi ha il limite di lavorare solo su numeri interi con segno, o anche solo numeri per quella materia.

say keys .Bag∖.Set given |(<a b c d a a c>), 1/3, 2/3 - 1/3;
# (a c 0.333333)

Ruby, 30 anni 28 byte

In Interactive Ruby Shell :

d.select{|x|d.count(x>1)}|[]

^{Salvato 2 byte grazie a Kirill L.}

JavaScript, 35 28 byte

a=>a.filter(o=x=>!(o[x]^=1))

Provalo online!

Dopo aver pubblicato questo, mi sono reso conto che era molto simile alla soluzione di w0lf .

Lisp comune, 57 byte

(remove-duplicates(remove-if(lambda(x)(<(count x d)2))d))

Ottava, 33 byte

[~,a]=unique(d);d(a)=[];unique(d)

• Trova gli indici della prima occorrenza di ogni intero univoco,
• rimuove tali occorrenze e
• trova gli elementi univoci dell'array rimanente.

Eccolo su ideone . Ho racchiuso lo snippet in una funzione in modo da poterlo chiamare usando tutti gli input di esempio.

Java 8, 80 byte

x.stream().filter(i->x.indexOf(i)!=x.lastIndexOf(i)).collect(Collectors.toSet())

Supponendo che x contenga l'input Elenco di numeri.

PHP, 35 37 byte

Abbastanza diretto:

array_diff_key($a,array_unique($a))

Come nota: non ho aggiunto il ;alla fine della riga, come afferma la domanda:

La tua risposta potrebbe essere uno snippet che presuppone che l'input sia archiviato in una variabile (d, diciamo) e valuta il risultato corretto

Quindi questo frammento può essere utilizzato in questo modo e valuta il risultato corretto:

print implode(' ', array_diff_key($a,array_unique($a)));

Un'altra nota

Il codice sopra riportato funziona per tutti i casi di test forniti nella sfida. In quelli tutti i personaggi non unici sono al massimo duplicati. Se un elemento può verificarsi più di due volte, ne array_unique()sarebbe necessario un altro , che aumenta la lunghezza a 49 byte :

array_unique(array_diff_key($a,array_unique($a)))

Le modifiche

• Salvato 2 byte sostituendo array_diff_assoccon array_diff_key. Grazie a Jörg Hülsermann .