20
\$\begingroup\$

You will receive an array and must return the number of integers that occur more than once.

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

This will return 2, since each of 234 and 2 appear more than once.

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

The list will never be more than 100k integers long, and the integers inside the list will always be in between -100k and 100k.

Integers should be counted if they occur more than once, so if an integer occurs 3 times then it will still only count as one repeated integer.

Test cases

[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
\$\endgroup\$
  • \$\begingroup\$ What do you mean by Once it counts the repetition, don't count again? Also, since we want to find the repetition of a specific integer, how would we know which integer to search for if we are not given it? Lastly, the test cases are a bit confusing; which are output and which are input? \$\endgroup\$ – Embodiment of Ignorance Feb 24 '19 at 18:19
  • 4
    \$\begingroup\$ I've edited this to try to make it a bit clearer. Is this what you intended? Also, please put answers in for those test cases. \$\endgroup\$ – Rɪᴋᴇʀ Feb 24 '19 at 18:21
  • 1
    \$\begingroup\$ I have added some answers to the test cases, sorry if I go them wrong \$\endgroup\$ – MickyT Feb 24 '19 at 19:20
  • 1
    \$\begingroup\$ I've voted to close this question until you confirm this is what you intended. \$\endgroup\$ – Rɪᴋᴇʀ Feb 24 '19 at 21:01
  • 4
    \$\begingroup\$ Related (output the non-unique items, instead of the amount of non-unique items). \$\endgroup\$ – Kevin Cruijssen Feb 24 '19 at 21:38

45 Answers 45

15
\$\begingroup\$

R, 20 bytes

Is this what you are after? Uses table to count the occurrences of each of the scan input values. Tests if count is > 1 and sums the trues.

sum(table(scan())>1)

Try it online!

| improve this answer | |
\$\endgroup\$
  • \$\begingroup\$ my mind went to duplicated first -- the humble table is so useful for golfing! \$\endgroup\$ – Giuseppe Feb 25 '19 at 15:41
  • \$\begingroup\$ @giuseppe table is a favorite now :) \$\endgroup\$ – MickyT Feb 25 '19 at 17:17
9
\$\begingroup\$

Haskell, 42 bytes

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

Try it online! Abuses the fact the the integers in the list are guaranteed to be within -100k and 100k.

| improve this answer | |
\$\endgroup\$
8
\$\begingroup\$

Bash + coreutils, 18

sort|uniq -d|wc -l

Try it online!

| improve this answer | |
\$\endgroup\$
7
\$\begingroup\$

APL (Dyalog Unicode), 9 8 bytesSBCS

-1 thanks to ngn

Anonymous tacit prefix function.

+/1<⊢∘≢⌸

Try it online!

+/ sum of

1< whether 1 is less than

 for each unique element:

⊢∘ ignoring the actual unique element,

 the count of its occurrences

| improve this answer | |
\$\endgroup\$
  • \$\begingroup\$ {1<≢⍵}⌸ -> 1<⊢∘≢⌸ \$\endgroup\$ – ngn Mar 22 '19 at 16:13
  • \$\begingroup\$ @ngn Thanks. Incorporated. \$\endgroup\$ – Adám Mar 27 '19 at 14:11
5
\$\begingroup\$

C (clang) 175 117 95 bytes

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);}

Try it online!

This is the first time I've submitted one of these, so let me know if there are any issues with formatting or anything.

Updates from the comments:

  • -58 to 117 bytes from Jo King
  • -80 to 95 bytes from ASCII-only

original submission

| improve this answer | |
\$\endgroup\$
  • 5
    \$\begingroup\$ Welcome, nice start. I'm not a C person but here's a link to a tips for golfing C page \$\endgroup\$ – MickyT Feb 25 '19 at 0:27
  • 2
    \$\begingroup\$ 117 bytes => d,i;c(*a,*b){return*a-*b;}r(l[],m){qsort(l,m,4,c);for(i=d=0;++i<m;)d+=((l[i+1]-l[i]||i>m-2)&&l[i-1]==l[i]);return d;}. As @ASCII-only noted, the includes don't affect the compilation of your program \$\endgroup\$ – Jo King Feb 25 '19 at 0:38
  • 2
    \$\begingroup\$ @JoKing 100: d;c(*a,*b){return*a-*b;}r(*l,m){qsort(l,m,4,c);for(d=0;~m--;)d+=(!m||l[1]-*l)&l[-1]==*l++;return d;} \$\endgroup\$ – ASCII-only Feb 25 '19 at 0:41
  • 1
    \$\begingroup\$ @CollinPhillips yes. as you can see in the link i posted, it still compiles fine without the includes \$\endgroup\$ – ASCII-only Feb 25 '19 at 0:42
  • 2
    \$\begingroup\$ 95: 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);} \$\endgroup\$ – ASCII-only Feb 25 '19 at 1:12
5
\$\begingroup\$

C# (Visual C# Interactive Compiler), 40 bytes

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

The first draft of the spec was unclear, and I thought it mean return all the elements that appear more than once. This is the updated version.

Somehow I didn't notice that my code returned the number of elements that appeared once. Thanks to Paul Karam for catching that!

Try it online!

| improve this answer | |
\$\endgroup\$
  • 1
    \$\begingroup\$ Your output is wrong, it needs to count the elements with 2 or more occurences. It should be n=>n.GroupBy(c=>c).Count(c=>c.Count()>=2). The OP says the answer of this list is 2. Your code returns 5. The change I gave you returns 2. \$\endgroup\$ – Paul Karam Feb 25 '19 at 6:26
  • 1
    \$\begingroup\$ Or just >1 to keep the 40 bytes count \$\endgroup\$ – Paul Karam Feb 25 '19 at 7:13
  • \$\begingroup\$ @PaulKaram I didn't notice that, thanks! \$\endgroup\$ – Embodiment of Ignorance Feb 25 '19 at 16:20
4
\$\begingroup\$

Python 3, 38 bytes

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

Try it online!

| improve this answer | |
\$\endgroup\$
4
\$\begingroup\$

J, 11 9 bytes

-2 bytes thanks to Jonah!

1#.1<1#.=

Try it online!

Original solution:

1#.(1<#)/.~

Try it online!

Explanation:

        /.~   group the list by itself
   (   )      for each group
    1<#       is the length greater than 1
1#.           sum by base-1 conversion
| improve this answer | |
\$\endgroup\$
  • \$\begingroup\$ Hey Galen. 1#.1<1#.= for 9 bytes + good ol' self-classify fun. \$\endgroup\$ – Jonah Feb 24 '19 at 23:15
  • 1
    \$\begingroup\$ @Jonah Thanks! Honestly, I wasn't aware of this. \$\endgroup\$ – Galen Ivanov Feb 25 '19 at 7:20
  • 1
    \$\begingroup\$ @Jonah Nice! \$\endgroup\$ – Adám Feb 25 '19 at 7:21
  • \$\begingroup\$ @Adám and here i was pleased that i'd gotten J to tie with APL. Foiled again :) \$\endgroup\$ – Jonah Feb 25 '19 at 18:14
3
\$\begingroup\$

Ruby, 34 bytes

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

Try it online!

| improve this answer | |
\$\endgroup\$
3
\$\begingroup\$

05AB1E, 4 bytes

Ù¢≠O

Try it online! or as a Test Suite

Explanation

   O  # sum
  ≠   # the false values
 ¢    # in the count
Ù     # of each unique digit in input
| improve this answer | |
\$\endgroup\$
  • \$\begingroup\$ So all values that are not 1 are false? \$\endgroup\$ – Adám Feb 24 '19 at 20:20
  • \$\begingroup\$ @Adám: Yes, that is correct. \$\endgroup\$ – Emigna Feb 24 '19 at 21:01
3
\$\begingroup\$

Jelly, 4 bytes

ĠITL

Try it online!

...Or ĠIƇL

How?

Ġ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

would filter to keep only truthy results of I ([[6],[3,6]]) which also has the desired length.

| improve this answer | |
\$\endgroup\$
3
\$\begingroup\$

Perl 6, 15 bytes

+*.repeated.Set

Try it online!

Pretty self explanatory. An anonymous code block that gets the count (+) of the Set of elements among the repeated elements of the input (*).

I've realised I've posted almost the exact same solution for a related question.

| improve this answer | |
\$\endgroup\$
3
\$\begingroup\$

Python 3, 63 bytes

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

Try it online!

| improve this answer | |
\$\endgroup\$
3
\$\begingroup\$

Java 8, 74 73 bytes

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

Try it online.

Explanation:

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
| improve this answer | |
\$\endgroup\$
3
\$\begingroup\$

APL (Dyalog Extended), 8 7 bytesSBCS

Anonymous tacit prefix function using Jonah's method.

+/1<∪⍧⊢

Try it online!

+/ the total number occurrences
  literally the sum of Truths

1< where one is less than

 the unique elements'

 count in

 the unmodified argument

| improve this answer | |
\$\endgroup\$
3
\$\begingroup\$

Haskell, 41 bytes

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

Try it online!

Count suffixes where the first element h appears exactly once in the part t that comes after.


Haskell, 40 bytes

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

Try it online!

Stealing the method from other answers.

| improve this answer | |
\$\endgroup\$
  • \$\begingroup\$ Dammit, we had the exact same answer \$\endgroup\$ – proud haskeller Feb 28 '19 at 16:29
3
\$\begingroup\$

Haskell, 41 bytes

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

This solution basically counts how many elements of the list have the same element appear exactly once later in the list.

| improve this answer | |
\$\endgroup\$
2
\$\begingroup\$

Haskell, 47 bytes

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

Try it online!

This is the naïve approach. There is likely something that could be done to improve this.

f[]=0

We return 0 for the empty list

f(a:b)

In the case of a non-empty list starting with a and then b.

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

If filtering a out of b is different from b (that is a is in b) then we return 1 more than f applied to b with the as filtered out.

|1>0=f b

If filtering as doesn't change b then we just run f across the rest.

Here is another similar approach that has the same length:

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

Try it online!

| improve this answer | |
\$\endgroup\$
2
\$\begingroup\$

JavaScript (ES6), 40 bytes

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

Try it online!

| improve this answer | |
\$\endgroup\$
2
\$\begingroup\$

Wolfram Language 34 bytes

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

Gather groups identical integers into lists. DeleteCases[...{x_}] eliminates lists containing a single number. Length returns the number of remaining lists (each containing two or more identical integers.

| improve this answer | |
\$\endgroup\$
  • 1
    \$\begingroup\$ Count[{_,__}]@*Gather \$\endgroup\$ – alephalpha Feb 26 '19 at 3:10
2
\$\begingroup\$

Japt, 12 11 9 8 6 bytes

ü èÈÊÉ

With lots of help from @ASCII-Only, and suggestions from @Shaggy and @Luis felipe De jesus Munoz.

Try it online!

| improve this answer | |
\$\endgroup\$
  • \$\begingroup\$ 11 \$\endgroup\$ – ASCII-only Feb 24 '19 at 23:09
  • \$\begingroup\$ 9 9 9? \$\endgroup\$ – ASCII-only Feb 24 '19 at 23:19
  • \$\begingroup\$ 8 8 \$\endgroup\$ – ASCII-only Feb 24 '19 at 23:30
  • 2
    \$\begingroup\$ 6 \$\endgroup\$ – ASCII-only Feb 24 '19 at 23:45
  • 2
    \$\begingroup\$ 6 6 \$\endgroup\$ – ASCII-only Feb 24 '19 at 23:51
2
\$\begingroup\$

Pyth, 6 bytes

l{.-Q{

Try it here

Explanation

l{.-Q{
     {Q   Deduplicate the (implicit) input.
  .-Q     Remove the first instance of each from the input.
l{        Count unique.
| improve this answer | |
\$\endgroup\$
2
\$\begingroup\$

Brachylog, 7 bytes

ọzt;1xl

Try it online!

Explanation:

ọ          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.
| improve this answer | |
\$\endgroup\$
2
\$\begingroup\$

PHP, 39 bytes

a nice occasion to use variable variables:

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

takes input from command line arguments. Run with -nr or try it online.


$argv[0] is - and that appears only once in the arguments, so it does not affect the result.

| improve this answer | |
\$\endgroup\$
1
\$\begingroup\$

Element, 40 bytes

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

Try it online!

This requires input to be in a precise format like [234, 2, 1000, 2, 99, 234] (enclosed with [] with a comma and space between integers).

Explanation:

_                                        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
| improve this answer | |
\$\endgroup\$
1
\$\begingroup\$

Retina 0.8.2, 19 bytes

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

Try it online! Link includes test suite which splits each line on commas. Explanation:

O`.+

Sort equal values together.

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

Count the number of runs of at least two values.

| improve this answer | |
\$\endgroup\$
1
\$\begingroup\$

Clean, 59 54 bytes

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

Try it online!

Sorts the list, groups adjacent equal elements, and counts the number with more than 1 item.

| improve this answer | |
\$\endgroup\$
1
\$\begingroup\$

Rust, 126 bytes

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()};

I give up. This is basically the same as Ruby. There is "another way" creating an array and indexing into it using the values in the input vector, +100000, however the type conversions (as usize / as i32) take up too much space.

| improve this answer | |
\$\endgroup\$
1
\$\begingroup\$

MATL, 5 bytes

8#uqz

Try it online! Or verify all test cases.

Explanation

8#u   % Number of ocurrences of each unique value
q     % Subtract 1
z     % Number of nonzeros
| improve this answer | |
\$\endgroup\$
1
\$\begingroup\$

k, 8 bytes

+/1<#:'=

reads as: sum (length each group) > 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)

Use example (first test case)

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

writes 4

| improve this answer | |
\$\endgroup\$

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.