Bir dizi imzalı tamsayının benzersiz olmayan öğelerini bulan bir program yazın. Ortaya çıkan dizi herhangi bir sırayla olabilir.

Cevabınız, bir değişkenin ( dörneğin,) bir değişkende saklanacak olan girişi doğrulayan ve doğru sonucu değerlendiren bir pasaj olabilir .

Test Kılıfları

Her test durumu biçiminde tek bir satırdır input => output. Çıktının diğer permütasyonlarının da geçerli olduğunu unutmayın.

[]                        => []
[-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]

Elementlerin sırası önemli değil.

Bu kod golf, yani en kısa cevap (bayt cinsinden) kazanır.

K5 , 5 bayt

Girişin zaten bir değişkende olduğunu varsayarak d,

?d^?d

Farklı elemanları (al ?hariç d) ( d^d) 'ye ait farklı elementler ( ?d). Güzel simetrik, hayır? Bu, çünkü "hariç" işleci, sağ argümanın sadece ilk oluşumunu sol argümandan çıkardığı için çalışır.

Daha genel olarak,

nu: {?x^?x}

Eylemde:

  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)

Düzenle:

Benzersiz olmayan öğelerin ilk oluşumu sırasını korumak istiyorsak, 4 ekstra bayt ücreti hariç benzersiz öğeleri kaldırmadan önce ve sonra kaynak listesini tersine çevirebiliriz:

  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

Dizinin zaten D değişkeninde olduğunu varsayarak ( bu yoruma göre ):

D{De=(},_&

Çevrimiçi deneyin

Açıklama:

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

Not: pgüzel bir baskı istiyorsanız bir tane ekleyin , aksi halde sonuçta elde edilen dizi varsayılan olarak sınırlayıcı olmadan yazdırılır. Soru, snippet'in yalnızca "doğru sonucu değerlendirmek" gerektiğini belirttiğinden, bu kabul edilebilir.

Standart giriş / çıkış versiyonu, 13:

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

Çevrimiçi deneyin

Açıklama:

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

İthalatta bile oldukça kısa. a \\ bher bir elemanının ilk geçtiği kaldırır bgelen ave nubbir liste tüm elemanları tek hale getirir.

Pyth, 7 bayt

S{.-Q{Q

Çevrimiçi deneyin.

Nasıl çalışır

Pyth değerlendirilen girişi otomatik olarak kaydeder Qve kullanılmayan tüm dönüş değerlerini yazdırır.

     {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 bayt

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

Umarım, tamsayıların D tablosunda depolandığını varsaymak iyidir. Bu, SQLServer, PostgreSQL ve muhtemelen başkalarında çalışacaktır. 2 bayttan @manatwork sayesinde.

Mathematica, 29 26 bayt

Bu girişin saklandığı varsayılarak d:

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

Aksi takdirde, adsız bir işlev olarak 29 bayttır:

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

Burada, d⋃d(veya #⋃#) kopyaları çıkarmak için bir golf oyunu - set birliğini kendisiyle alarak Mathematica, bir takım olarak yorumluyor, kopyaları otomatik olarak kaldırırken, asıl birlik hiçbir şey yapmıyor.

Daha sonra, her iki yöntem de orijinal listede görünen öğeleri en az iki kez filtrelemeyi sağlar.

JavaScript (ES6), 37 bayt

Bunu JavaScript konsolunda çalıştırın:

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

Matlab / Octave, 40

Girdi değerlerinin gerçek olduğunu varsayıyorum (karmaşık değil). Giriş bir değişkende d.

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

Octave'da çevrimiçi olarak deneyin .

Python 3.5, 30

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

Python 3.5'in paket açma paketini kullanır. ~-Falsy 1 0 arasında bir sayı alır çıkarır 1,.

Bu bir liste verir. Bir set vermek tamamsa, o zaman 1 karakter tasarruf eden ve 3.5 sürümüne ihtiyaç duymayan bir set anlayışı kullanırız:

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

PowerShell, 31 29 Bayt

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

$dZaten doldurulmuş olduğunu varsayar (verildiği gibi) - örneğin $d=@(-34,0,1,-34,4,8,4),.

Diziyi Group-Object, benzer öğeleri bir araya toplayan ve esas olarak bir dizi dizisi olan bir nesneyi yayan cmdlet'e boruları yerleştirir . Biz boru bir karşı Where-Object( ?vardır operatör) Countbirden büyük (yani çiftleri vardır) ve çıkış .Namebu öğelerin. Ayrıca ilk sıralamayı korumanın da bir yan bonusu var.

_{Düzenleme - Danko Durbić sayesinde iki bayt kaydedildi}

APL (Dyalog Unicode) , 13 9 bayt ^SBCS

Anonim zımni önek işlevi.

∊(⊂1↓⊣¨)⌸

Çevrimiçi deneyin!

(… )⌸ Her benzersiz öğe (sol argüman) ve gerçekleştiği endeksler (sağ argüman) için, aşağıdaki tacit işlevini uygulayın:

 ⊣¨ sağdaki her biri için soldan biri (benzersiz öğe) (dizinler)

 1↓ bir tane bırak

 ⊂ enclose (düzensiz bir matris oluşturmak için sıfırlarla doldurmayı önler)

∊ ε nlist (düzleştirmek)

Julia, 30 29 bayt

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

d.==d'Aksi takdirde i,jtrue d[i]==d[j]ve false değeri olan simetrik bir matris yaratır . sumBir boyutta ming yapmak ve sonra 1'i çıkarmak, eğer elemanlardan sadece biri varsa sıfır, eğer birden fazla ise sıfırdan farklı olacaktır.findSıfır olmayan elemanların indekslerini elde eder, bu daha sonra dizinin dkendisini indekslemek için kullanılır . ∪(sendika) uniquebu şekilde kullanıldığında olduğu gibi davranır , tekrarları kaldırır.

Eski çözüm:

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

Basit - her giriş için dizide birden fazla olup olmadığını kontrol eder. Birden fazla olanlar "süzgeç" tarafından döndürülür, sonra∪ (sendika) gibi davranırunique bu şekilde kullanıldığında tekrar eder, böylece tekrar eder.

Not: başlangıçta bir işlev olarak kullanıyordu, ancak soru dizinin d, soruda önerildiği gibi seçtiğim bir değişkende saklanmasına izin veriyor .

Python 2.7, 36 42

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

edit : soruda istenen formata uymak için ifadeyi listeyle (..) çevreledi

Octave, 22 bayt

Luis Medo'nun cevabına dayanarak .

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

R, 31 24 bayt

7 bayt için flodel sayesinde .

Girdi zaten varsayalım d.

kod:

unique(d[duplicated(d)])

düzenleme: şimdi aditsu tarafından belirtildiği gibi 2'den fazla kopya varsa, doğru çıktı .

Python 3 - 33 30 bayt

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

dGiriş olarak repl çıkışı .

Mathematica, 31 29

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

Pyth, 7 bayt

ft/QT{Q

Açıklama:

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.

Filtre, öğeler kümesinden bir kez beliren tüm öğeleri kaldırır.

LINQ, 62 54 bayt

Biraz yeni, ama işte hiçbir şey yok.

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

K (oK) , 7 bayt

Çözüm:

&1<#:'=

Çevrimiçi deneyin!

Açıklama:

&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

Test çıkışı:

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

Mathematica, 23 bayt

Giriş saklanırken d:

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

Bir fonksiyon olarak, 24 bayt:

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

örneğin

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

bunu döndürür:

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

(her alt listenin birinci elemanı, ikinci ise oluşum sıklığıdır). Bu listeye uygulamak Pick[#,#2>1]&@@@onu dönüştürür

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

Ve ikinci Pickdeğerlendirme Trueargümanının ilk argümana dönüştüğü yerde .

K (K5 değil), 10 bayt

x@&1<#:'=x

Girişin var olduğunu varsayar x. K5 olmayan bir cevap vermenin eğlenceli olacağını düşündüm!

Perl 6, 16 bayt

Listede kayıtlı $_olduğunu varsayalım, aşağıdaki snippet'lerden herhangi birini kullanabilirsiniz.
_{^{(özellikle izin verildi)}}

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

keys .Bag (-) .Set # 18 bytes

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

Bir çantanızın olmasına aldırış etmiyorsanız, bırakabilirsiniz keys .

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

Bunların hiçbiri yalnızca imzalı tamsayılar üzerinde çalışmayı, hatta bu konuda sadece rakamları sınırlamaz.

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

Ruby, 30 28 bayt

Gelen Etkileşimli Yakut Shell :

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

^{Kirill L. sayesinde 2 bayt kaydedildi}

JavaScript, 35 28 bayt

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

Çevrimiçi Deneyin!

Bunu gönderdikten sonra, w0lf'in çözümüne çok benzer olduğunu anladım .

Ortak Lisp, 57 bayt

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

Octave, 33 bayt

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

• Her bir tamsayının ilk oluşumunun indekslerini bulur,
• bu oluşumları kaldırır ve
• Kalan dizinin benzersiz elemanlarını bulur.

İşte ideone üzerinde . Snippet'i bir fonksiyona sardım, böylece tüm örnek girişlerini kullanarak arayabilirim.

Java 8, 80 Bayt

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

X'in varsayalım sayılar listesi.

PHP, 35 37 bayt

Oldukça yalındır:

array_diff_key($a,array_unique($a))

Not olarak: Sorulardan da belirtildiği ;gibi, satırın sonuna şunu eklemedim :

Cevabınız, bir değişkenin (d, say) bir değişkende saklanacak olan girdiyi varsayan ve doğru sonucu değerlendiren bir pasaj olabilir

Böylece bu snippet bu şekilde kullanılabilir ve doğru sonucu değerlendirir:

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

Başka bir not

Yukarıdaki kod, mücadelede verilen tüm test durumları için geçerlidir. Bunların hepsinde benzersiz olmayan karakterler en fazla yinelenir. Bir eleman iki kereden fazla meydana gelebilirse array_unique(), uzunluğu 49 bayta yükselten bir tane daha gerekli olacaktır :

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

Düzenlemeler

• Kaydedilen 2 bayt yerine array_diff_associle array_diff_key. Jörg Hülsermann'a teşekkürler .