Bạn sẽ nhận được một mảng và phải trả về số nguyên xảy ra nhiều lần.

[234, 2, 12, 234, 5, 10, 1000, 2, 99, 234]

Điều này sẽ trả về 2, vì mỗi 234và 2xuất hiện nhiều hơn một lần.

[234, 2, 12, 234]
[2, 12, 234, 5, 10, 1000, 2]

Danh sách sẽ không bao giờ dài hơn 100k số nguyên và các số nguyên trong danh sách sẽ luôn nằm trong khoảng từ -100k đến 100k.

Số nguyên nên được tính nếu chúng xảy ra nhiều lần, vì vậy nếu một số nguyên xảy ra 3 lần thì nó vẫn sẽ chỉ được tính là một số nguyên lặp lại.

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

[1, 10, 16, 4, 8, 10, 9, 19, 2, 15, 18, 19, 10, 9, 17, 15, 19, 5, 13, 20]  = 4
[11, 8, 6, 15, 9, 19, 2, 2, 4, 19, 14, 19, 13, 12, 16, 13, 0, 5, 0, 8]     = 5
[9, 7, 8, 16, 3, 9, 20, 19, 15, 6, 8, 4, 18, 14, 19, 12, 12, 16, 11, 19]   = 5
[10, 17, 17, 7, 2, 18, 7, 13, 3, 10, 1, 5, 15, 4, 6, 0, 19, 4, 17, 0]      = 5
[12, 7, 17, 13, 5, 3, 4, 15, 20, 15, 5, 18, 18, 18, 4, 8, 15, 13, 11, 13]  = 5
[0, 3, 6, 1, 5, 2, 16, 1, 6, 3, 12, 1, 16, 5, 4, 5, 6, 17, 4, 8]           = 6
[11, 19, 2, 3, 11, 15, 19, 8, 2, 12, 12, 20, 13, 18, 1, 11, 19, 7, 11, 2]  = 4
[6, 4, 11, 14, 17, 3, 17, 11, 2, 16, 14, 1, 2, 1, 15, 15, 12, 10, 11, 13]  = 6
[0, 19, 2, 0, 10, 10, 16, 9, 19, 9, 15, 0, 10, 18, 0, 17, 18, 18, 0, 9]    = 5
[1, 19, 17, 17, 0, 2, 14, 10, 10, 12, 5, 14, 16, 7, 15, 15, 18, 11, 17, 7] = 5

R , 20 byte

Đây có phải là những gì bạn đang theo đuổi? Sử dụng tableđể đếm số lần xuất hiện của từng scangiá trị đầu vào. Kiểm tra nếu số lượng là> 1 và tổng hợp các dấu vết.

sum(table(scan())>1)

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

Haskell , 42 byte

f s=sum[1|x<-[-9^6..9^6],filter(==x)s>[x]]

Hãy thử trực tuyến! Lạm dụng thực tế các số nguyên trong danh sách được đảm bảo trong phạm vi -100k và 100k.

Bash + coreutils, 18

sort|uniq -d|wc -l

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

APL (Dyalog Unicode) , 9 8 byte ^SBCS

-1 cảm ơn

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

+/1<⊢∘≢⌸

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

+/ Tổng của

1< cho dù 1 ít hơn

... ⌸ cho mỗi phần tử độc đáo:

 ⊢∘ bỏ qua các yếu tố duy nhất thực tế,

 ≢ số lần xuất hiện của nó

C (tiếng kêu) 175 117 95 byte

c(*a,*b){return*a-*b;}r(*l,m){qsort(l,m,4,c);return((!m||l[1]-*l)&l[-1]==*l)+(m?r(l+1,m-1):0);}

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

Đây là lần đầu tiên tôi gửi một trong số này, vì vậy hãy cho tôi biết nếu có bất kỳ vấn đề nào với định dạng hoặc bất cứ điều gì.

Cập nhật từ các ý kiến:

• -58 đến 117 byte từ Jo King
• -80 đến 95 byte chỉ từ ASCII

nộp bản gốc

C # (Trình biên dịch tương tác Visual C #) , 40 byte

n=>n.GroupBy(c=>c).Count(c=>c.Count()>1)

Bản nháp đầu tiên của thông số kỹ thuật không rõ ràng và tôi nghĩ nó có nghĩa là trả lại tất cả các yếu tố xuất hiện nhiều hơn một lần. Đây là phiên bản cập nhật.

Bằng cách nào đó tôi đã không nhận thấy rằng mã của tôi đã trả về số lượng phần tử xuất hiện một lần. Cảm ơn Paul Karam đã bắt được điều đó!

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

Python 3 , 38 byte

lambda a:sum(a.count(x)>1for x in{*a})

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

J , 11 9 byte

-2 byte nhờ Jonah!

1#.1<1#.=

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

Giải pháp ban đầu:

1#.(1<#)/.~

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

Giải trình:

        /.~   group the list by itself
   (   )      for each group
    1<#       is the length greater than 1
1#.           sum by base-1 conversion

Ruby , 34 byte

->a{a.uniq.count{|x|a.count(x)>1}}

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

05AB1E , 4 byte

Ù¢≠O

Hãy thử trực tuyến! hoặc như một bộ thử nghiệm

Giải trình

   O  # sum
  ≠   # the false values
 ¢    # in the count
Ù     # of each unique digit in input

Thạch , 4 byte

ĠITL

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

...Hoặc là ĠIƇL

Làm sao?

ĠITL - Link: list of integers   e.g. [234, 2, 12, 234, 5, 10, 1000, 2, 99, 234]
Ġ    - group indices by value        [[2,8],5,6,3,9,[1,4,10],7]
 I   - incremental differences       [[6],[],[],[],[],[3,6],[]]
  T  - truthy indices                [1,6]
   L - length                        2

IƇsẽ lọc để chỉ giữ kết quả trung thực của I( [[6],[3,6]]) cũng có độ dài mong muốn.

Perl 6 , 15 byte

+*.repeated.Set

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

Khá tự giải thích. Một khối mã ẩn danh có số đếm ( +) của các Setphần tử trong sốrepeated phần tử của đầu vào (* ).

Tôi nhận ra rằng tôi đã đăng gần như cùng một giải pháp cho một câu hỏi liên quan.

Python 3 , 63 byte

lambda l:len(C(l)-C({*l}))
from collections import Counter as C

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

Java 8, 74 73 byte

L->L.stream().filter(i->L.indexOf(i)<L.lastIndexOf(i)).distinct().count()

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

Giải trình:

L->                      // Method with ArrayList parameter and integer return-type
  L.stream()             //  Create a stream of the input-list
   .filter(i->           //  Filter it by:
     L.indexOf(i)        //   Where the first index of a value
     <L.lastIndexOf(i))  //   is smaller than the last index of a value
   .distinct()           //  Deduplicate this filtered list
   .count()              //  And return the count of the remaining values

APL (Dyalog Extended) , 8 7 byte ^SBCS

Hàm tiền tố ẩn danh sử dụng phương thức của Jonah .

+/1<∪⍧⊢

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

+/ tổng số lần xuất hiện theo
  ^{nghĩa đen là tổng của Sự thật}

1< nơi một ít hơn

∪ các yếu tố độc đáo '

⍧ đếm trong

⊢ đối số không được sửa đổi

Haskell , 41 byte

f(h:t)=sum[1|filter(==h)t==[h]]+f t
f _=0

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

Đếm các hậu tố trong đó phần tử đầu tiên hxuất hiện chính xác một lần trong phần ttiếp theo.

Haskell , 40 byte

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

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

Ăn cắp phương pháp từ các câu trả lời khác.

Haskell, 41 byte

f[]=0
f(a:s)=sum[1|filter(==a)s==[a]]+f s

Giải pháp này về cơ bản tính có bao nhiêu phần tử của danh sách có cùng phần tử xuất hiện chính xác một lần sau đó trong danh sách.

Haskell , 47 byte

f[]=0
f(a:b)|x<-filter(/=a)b,x/=b=1+f x|1>0=f b

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

Đây là cách tiếp cận ngây thơ. Có khả năng một cái gì đó có thể được thực hiện để cải thiện điều này.

f[]=0

Chúng tôi trở lại 0cho danh sách trống

f(a:b)

Trong trường hợp danh sách không trống bắt đầu bằng avà sau đó b.

|x<-filter(/=a)b,x/=b=1+f x

Nếu lọc ara bkhác với b(đó là atrong b) thì chúng ta trả lại 1 nhiều hơn so với fáp dụng bvới as được lọc.

|1>0=f b

Nếu bộ lọc akhông thay đổi bthì chúng ta chỉ cần chạyf qua phần còn lại.

Đây là một cách tiếp cận tương tự khác có cùng độ dài:

f[]=0
f(a:b)|elem a b=1+f(filter(/=a)b)|1>0=f b

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

JavaScript (ES6), 40 byte

a=>a.map(o=x=>n+=(o[x]=-~o[x])==2,n=0)|n

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

Ngôn ngữ Wolfram 34 byte

 Length@DeleteCases[Gather@#,{x_}]&

Gathercác nhóm số nguyên giống hệt nhau vào danh sách. DeleteCases[...{x_}]loại bỏ danh sách chứa một số duy nhất. Lengthtrả về số lượng danh sách còn lại (mỗi danh sách chứa hai hoặc nhiều số nguyên giống nhau.

Japt , 12 11 9 8 6 byte

ü èÈÊÉ

Với rất nhiều sự giúp đỡ từ @ ASCII-Only và các đề xuất từ ​​@Shaggy và @Luis felipe De jesus Munoz.

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

Bình thường, 6 byte

l{.-Q{

Hãy thử nó ở đây

Giải trình

l{.-Q{
     {Q   Deduplicate the (implicit) input.
  .-Q     Remove the first instance of each from the input.
l{        Count unique.

Brachylog , 7 byte

ọzt;1xl

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

Giải trình:

ọ          For every unique element E of the input, [E, how many times E occurs]
 zt        The last elements of the previous value.
   ;1x     With every 1 removed,
      l    how many there are.

PHP, 39 byte

một dịp tốt đẹp để sử dụng các biến số :

foreach($argv as$v)$r+=++$$v==2;echo$r;

lấy đầu vào từ các đối số dòng lệnh. Chạy với -nrhoặc thử trực tuyến .

$argv[0]là -và đó xuất hiện một lần duy nhất trong các đối số, vì vậy nó không ảnh hưởng đến kết quả.

Phần tử , 40 byte

_(#'{"2:0+4:'~1+";~2=[''1+""]$2+'[(#]'}`

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

Điều này đòi hỏi đầu vào phải ở định dạng chính xác như [234, 2, 1000, 2, 99, 234](kèm theo []dấu phẩy và khoảng trắng giữa các số nguyên).

Giải trình:

_                                        input
 (#                                      delete the [ at start of input
   '{"                               '}  WHILE the string is non-empty
   '{"2:                             '}    duplicate it
   '{"  0+                           '}    add 0 to coerce to integer (gets next number in array)
   '{"    4:                         '}    make 3 additional copies
   '{"      '                        '}    temporarily move 1 copy to control stack
   '{"       ~                       '}    fetch the current map value for given integer
   '{"        1+                     '}    increment map value
   '{"          "                    '}    retrieve temporary copy of integer (the key for the map)
   '{"           ;                   '}    store updated map value
   '{"            ~                  '}    fetch map value again (1 if 1st instance, 2 if 2nd, etc.)
   '{"             2=                '}    test for map value = 2, this is the first duplication
   '{"               [      ]        '}    IF
   '{"               [''    ]        '}      move stuff from main stack to control stack
   '{"               [  1+  ]        '}      increment the counter of duplicate (bottom of stack)
   '{"               [    ""]        '}      move stuff back to main stack
   '{"                       $       '}    take length of current integer
   '{"                        2+     '}    add 2 (for the comma and space)
   '{"                          '[  ]'}    FOR loop with that number
   '{"                          '[(#]'}      trim those many characters from front of input string
                                       ` output result

Võng mạc 0.8.2 , 19 byte

O`.+
m`^(.+)(¶\1)+$

Hãy thử trực tuyến! Liên kết bao gồm bộ kiểm tra phân tách từng dòng trên dấu phẩy. Giải trình:

O`.+

Sắp xếp các giá trị bằng nhau.

m`^(.+)(¶\1)+$

Đếm số lần chạy của ít nhất hai giá trị.

Sạch , 59 54 byte

import StdEnv,StdLib
$l=sum[1\\[_,_:_]<-group(sort l)]

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

Sắp xếp danh sách, các nhóm liền kề các phần tử bằng nhau và đếm số lượng có nhiều hơn 1 mục.

Rust, 126 byte

let f=|v:Vec<i32>|{let mut u=v.clone();u.sort();u.dedup();u.iter().filter(|i|v.iter().filter(|n|**n==**i).count()>1).count()};

Tôi từ bỏ. Điều này về cơ bản giống như Ruby. Có "cách khác" tạo một mảng và lập chỉ mục vào nó bằng cách sử dụng các giá trị trong vectơ đầu vào, +100000, tuy nhiên, các chuyển đổi loại (như usize / as i32) chiếm quá nhiều không gian.

MATL , 5 byte

8#uqz

Hãy thử trực tuyến! Hoặc xác minh tất cả các trường hợp thử nghiệm .

Giải trình

8#u   % Number of ocurrences of each unique value
q     % Subtract 1
z     % Number of nonzeros

k, 8 byte

+/1<#:'=

đọc là: sum (độ dài mỗi nhóm)> 1

+/ is sum (plus over)

#:' is length each

= is group (ex. =1 2 1 6 7 2 generates 1 2 6 7!(0 2;1 5;,3;,4) (dictionary of unique value and its positions)

Sử dụng ví dụ (trường hợp thử nghiệm đầu tiên)

+/1<#:'=1 10 16 4 8 10 9 19 2 15 18 19 10 9 17 15 19 5 13 20

viết 4