Viết chương trình tìm các phần tử không duy nhất của một mảng các số nguyên đã ký. Mảng kết quả có thể theo thứ tự bất kỳ.

Câu trả lời của bạn có thể là một đoạn mã giả định đầu vào được lưu trữ trong một biến ( d, giả sử) và đánh giá kết quả chính xác.

Các trường hợp thử nghiệm

Mỗi trường hợp thử nghiệm là một dòng duy nhất trong định dạng input => output. Lưu ý rằng các hoán vị khác của đầu ra là hợp lệ.

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

Thứ tự của các yếu tố không quan trọng.

Đây là mã golf, vì vậy câu trả lời ngắn nhất (tính bằng byte) sẽ thắng.

K5 , 5 byte

Giả sử đầu vào đã có trong một biến được gọi là d,

?d^?d

Lấy các phần tử riêng biệt ( ?) của d trừ ( d^) các phần tử riêng biệt của d ( ?d). Đối xứng hoàn toàn, không? Điều này hoạt động vì toán tử "ngoại trừ" chỉ loại bỏ lần xuất hiện đầu tiên của đối số bên phải khỏi đối số bên trái.

Tổng quát hơn

nu: {?x^?x}

Trong hành động:

  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)

Chỉnh sửa:

Nếu chúng tôi muốn duy trì thứ tự xuất hiện đầu tiên của các phần tử không phải là duy nhất, chúng tôi có thể đảo ngược danh sách nguồn trước và sau khi chúng tôi xóa các phần tử duy nhất thông qua ngoại trừ chi phí thêm 4 byte:

  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

Giả sử mảng đã có trong biến D (dựa trên nhận xét này ):

D{De=(},_&

Dùng thử trực tuyến

Giải trình:

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

Lưu ý: nối thêm pnếu bạn muốn in đẹp, nếu không thì mảng kết quả chỉ được in ra mà không có dấu phân cách theo mặc định. Điều đó được chấp nhận vì câu hỏi chỉ định đoạn trích chỉ cần "đánh giá kết quả chính xác".

Phiên bản đầu vào / đầu ra tiêu chuẩn, 13:

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

Dùng thử trực tuyến

Giải trình:

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

Khá ngắn, ngay cả với việc nhập khẩu. a \\ bloại bỏ sự xuất hiện đầu tiên của mỗi thành phần btừ avà nublàm cho tất cả các thành phần của danh sách là duy nhất.

Bình thường, 7 byte

S{.-Q{Q

Hãy thử trực tuyến.

Làm thế nào nó hoạt động

Pyth tự động lưu trữ đầu vào được đánh giá trong Qvà in tất cả các giá trị trả về không sử dụng.

     {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

Tôi hy vọng có thể giả sử các số nguyên được lưu trong bảng D không? Điều này sẽ hoạt động trong cả SQLServer, PostgreSQL và có thể cả những người khác. Nhờ @manatwork từ 2 byte.

Toán học, 29 26 byte

Giả sử rằng đầu vào được lưu trữ trong d:

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

Mặt khác, nó là 29 byte dưới dạng hàm không tên:

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

Đây, d⋃d (hoặc #⋃#) là một mẹo chơi gôn để loại bỏ các bản sao - bằng cách lấy liên kết tập hợp với chính nó, Mathicala diễn giải danh sách thành một tập hợp, tự động loại bỏ các bản sao, trong khi liên minh thực tế không làm gì cả.

Sau đó, cả hai phương pháp chỉ cần lọc các phần tử xuất hiện trong danh sách gốc ít nhất hai lần.

JavaScript (ES6), 37 byte

Chạy cái này trong bảng điều khiển JavaScript:

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

Matlab / Octave, 40

Tôi giả sử giá trị đầu vào là có thật (không phức tạp). Đầu vào là trong một biến d.

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

Hãy thử trực tuyến trong Octave.

Trăn 3,5, 30

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

Sử dụng bộ giải nén của Python 3.5. Các~- trừ 1, trong đó có một đếm 1-0 mà là Falsy.

Điều này đưa ra một danh sách. Nếu đưa ra một bộ là OK, thì chúng tôi sử dụng một bộ hiểu, lưu 1 char và không cần phiên bản 3.5:

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

PowerShell, 31 29 byte

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

Giả sử $dđã được điền (như đã cho) - ví dụ:$d=@(-34,0,1,-34,4,8,4) .

Đưa mảng vào Group-Objectcmdlet, nhóm các mục giống nhau lại với nhau và tạo ra một đối tượng thực chất là một mảng các mảng. Chúng tôi dẫn đến một Where-Object( ?toán tử) có Countlớn hơn một (nghĩa là có các bản sao) và xuất ra các .Namemục đó. Có một phần thưởng phụ của việc duy trì thứ tự ban đầu, quá.

_{Chỉnh sửa - đã lưu hai byte nhờ Danko Durbić}

APL (Dyalog Unicode) , 13 9 byte ^SBCS

Chức năng tiền tố ẩn danh.

∊(⊂1↓⊣¨)⌸

Hãy thử trực tuyến!

(Giáo dục)⌸  cho mỗi phần tử duy nhất (lập luận trái) và các chỉ số mà nó xảy ra (lập luận đúng), áp dụng các chức năng ngầm như sau:

 ⊣¨ một trong các bên trái (yếu tố duy nhất) cho mỗi bên phải (các chỉ số)

 1↓ thả một cái

 ⊂ bao vây (ngăn chặn đệm với số không để tạo ma trận không bị rách)

∊ ε nlist (flatten)

Julia, 30 29 byte

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

d.==d'tạo ra một ma trận đối xứng với giá trị i,jlà đúng nếu d[i]==d[j]và sai khác. summing trong một chiều và sau đó trừ đi 1 sẽ tạo ra số 0 nếu chỉ có một phần tử và khác không nếu có nhiều hơn một. findsẽ có được các chỉ mục của các phần tử khác không, sau đó được sử dụng để lập chỉ mục cho dchính mảng đó.∪(union) hoạt động như uniquekhi được sử dụng theo cách này, loại bỏ các lần lặp lại.

Giải pháp cũ:

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

Đơn giản - đối với mỗi mục, nó sẽ kiểm tra xem có nhiều mục trong mảng không. Những cái có nhiều hơn một được trả về bởi "bộ lọc" và sau đó ∪(union) hoạt động nhưunique khi được sử dụng theo cách này, loại bỏ các lần lặp lại.

Lưu ý: ban đầu có nó như là một hàm, nhưng câu hỏi cho phép mảng được lưu trữ trong một biến, mà tôi đã chọn dnhư được đề xuất trong câu hỏi.

Con trăn 2.7, 36 42

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

chỉnh sửa : bao quanh biểu thức với danh sách (..) để tuân thủ định dạng được yêu cầu trong câu hỏi

Octave, 22 byte

Dựa trên câu trả lời của Luis Mendo .

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

R, 31 24 byte

Nhờ flodel cho 7 byte.

Giả sử đầu vào đã có d.

mã:

unique(d[duplicated(d)])

chỉnh sửa: bây giờ nó xuất ra chính xác nếu có nhiều hơn 2 bản sao được chỉ ra bởi aditsu .

Python 3 - 33 30 byte

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

Thay thế đầu ra, dnhư đầu vào.

Toán học, 31 29

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

Bình thường, 7 byte

ft/QT{Q

Giải trình:

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.

Bộ lọc loại bỏ tất cả các thành phần xuất hiện chính xác một lần khỏi bộ phần tử.

LINQ, 62 54 byte

Kinda mới ở đây, nhưng ở đây không có gì.

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

K (oK) , 7 byte

Dung dịch:

&1<#:'=

Hãy thử trực tuyến!

Giải trình:

&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

Đầu ra thử nghiệm:

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

Toán học, 23 byte

Với đầu vào được lưu trữ trong d:

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

Là một hàm, 24 byte:

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

ví dụ với

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

trả lại cái này

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

(phần tử đầu tiên của mỗi danh sách con là phần tử, phần thứ hai là tần suất xuất hiện). Áp dụng vào danh sách này Pick[#,#2>1]&@@@biến nó thành

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

Và trong đó đối số thứ hai của Pickđánh giá cho Trueđối số thứ nhất được trả về.

K (không phải K5), 10 byte

x@&1<#:'=x

Giả sử đầu vào là trong x. Tôi nghĩ thật vui khi trả lời không phải K5!

Perl 6, 16 byte

Giả sử danh sách được lưu trữ trong $_bạn có thể sử dụng bất kỳ đoạn mã nào sau đây.
_{^{(được cho phép cụ thể)}}

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

keys .Bag (-) .Set # 18 bytes

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

Nếu bạn không quan tâm rằng bạn nhận được một túi, bạn có thể rời đi keys .

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

Không ai trong số này có giới hạn chỉ làm việc trên các số nguyên đã ký, hoặc thậm chí chỉ là số cho vấn đề đó.

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 byte

Trong Shell Ruby tương tác :

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

^{Đã lưu 2 byte nhờ Kirill L.}

JavaScript, 35 28 byte

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

Dùng thử trực tuyến!

Sau khi đăng bài này, tôi nhận ra rằng nó rất giống với giải pháp của w0lf .

Lisp thông thường, 57 byte

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

Octave, 33 byte

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

• Tìm các chỉ số xuất hiện đầu tiên của mỗi số nguyên duy nhất,
• loại bỏ những sự cố đó và
• tìm các phần tử duy nhất của mảng còn lại.

Đây là trên ideone . Tôi đã gói đoạn mã trong một hàm để tôi có thể gọi nó bằng cách sử dụng tất cả các đầu vào mẫu.

Java 8, 80 byte

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

Giả sử x chứa danh sách đầu vào của các số.

PHP, 35 37 byte

Khá thẳng về phía trước:

array_diff_key($a,array_unique($a))

Lưu ý: Tôi đã không thêm ;vào cuối dòng, như các câu hỏi nêu:

Câu trả lời của bạn có thể là một đoạn mã giả định đầu vào được lưu trữ trong một biến (d, giả sử) và đánh giá kết quả chính xác

Vì vậy, đoạn mã này có thể được sử dụng như thế này và đánh giá kết quả chính xác:

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

Một lưu ý khác

Mã ở trên hoạt động cho tất cả các trường hợp thử nghiệm được cung cấp trong thử thách. Trong đó tất cả các nhân vật không phải là duy nhất là nhiều nhất. Nếu một phần tử có thể xảy ra nhiều hơn hai lần, một phần tử khác array_unique()sẽ là cần thiết, làm tăng độ dài lên 49 byte :

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

Chỉnh sửa

• Đã lưu 2 byte bằng cách thay thế array_diff_assocbằng array_diff_key. Cảm ơn Jorg Hülsermann .