22
\$\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\$
6
  • \$\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\$
    – Gymhgy
    Feb 24, 2019 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\$
    – Riker
    Feb 24, 2019 at 18:21
  • 1
    \$\begingroup\$ I have added some answers to the test cases, sorry if I go them wrong \$\endgroup\$
    – MickyT
    Feb 24, 2019 at 19:20
  • 1
    \$\begingroup\$ I've voted to close this question until you confirm this is what you intended. \$\endgroup\$
    – Riker
    Feb 24, 2019 at 21:01
  • 4
    \$\begingroup\$ Related (output the non-unique items, instead of the amount of non-unique items). \$\endgroup\$ Feb 24, 2019 at 21:38

50 Answers 50

16
\$\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!

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

Bash + coreutils, 18

sort|uniq -d|wc -l

Try it online!

\$\endgroup\$
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.

\$\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

\$\endgroup\$
2
  • \$\begingroup\$ {1<≢⍵}⌸ -> 1<⊢∘≢⌸ \$\endgroup\$
    – ngn
    Mar 22, 2019 at 16:13
  • \$\begingroup\$ @ngn Thanks. Incorporated. \$\endgroup\$
    – Adám
    Mar 27, 2019 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

\$\endgroup\$
8
  • 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, 2019 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, 2019 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, 2019 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, 2019 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, 2019 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!

\$\endgroup\$
3
  • 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, 2019 at 6:26
  • 1
    \$\begingroup\$ Or just >1 to keep the 40 bytes count \$\endgroup\$
    – Paul Karam
    Feb 25, 2019 at 7:13
  • \$\begingroup\$ @PaulKaram I didn't notice that, thanks! \$\endgroup\$
    – Gymhgy
    Feb 25, 2019 at 16:20
4
\$\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
\$\endgroup\$
2
  • \$\begingroup\$ So all values that are not 1 are false? \$\endgroup\$
    – Adám
    Feb 24, 2019 at 20:20
  • \$\begingroup\$ @Adám: Yes, that is correct. \$\endgroup\$
    – Emigna
    Feb 24, 2019 at 21:01
4
\$\begingroup\$

Python 3, 38 bytes

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

Try it online!

\$\endgroup\$
4
\$\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.

\$\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
\$\endgroup\$
4
  • \$\begingroup\$ Hey Galen. 1#.1<1#.= for 9 bytes + good ol' self-classify fun. \$\endgroup\$
    – Jonah
    Feb 24, 2019 at 23:15
  • 1
    \$\begingroup\$ @Jonah Thanks! Honestly, I wasn't aware of this. \$\endgroup\$ Feb 25, 2019 at 7:20
  • 1
    \$\begingroup\$ @Jonah Nice! \$\endgroup\$
    – Adám
    Feb 25, 2019 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, 2019 at 18:14
4
\$\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
\$\endgroup\$
4
\$\begingroup\$

Uiua, 7 bytes

/+>1⍘⊚⊛

Try it!

/+>1⍘⊚⊛
      ⊛  # classify (i.e. map integers -> naturals)
    ⍘⊚   # inverse where (occurrences)
  >1     # where are they greater than one?
/+       # sum
\$\endgroup\$
3
\$\begingroup\$

Ruby, 34 bytes

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

Try it online!

\$\endgroup\$
1
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.

\$\endgroup\$
3
\$\begingroup\$

Python 3, 63 bytes

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

Try it online!

\$\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

\$\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.

\$\endgroup\$
1
  • \$\begingroup\$ Dammit, we had the exact same answer \$\endgroup\$ Feb 28, 2019 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.

\$\endgroup\$
3
\$\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.

\$\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!

\$\endgroup\$
2
\$\begingroup\$

JavaScript (ES6), 40 bytes

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

Try it online!

\$\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.

\$\endgroup\$
1
  • 1
    \$\begingroup\$ Count[{_,__}]@*Gather \$\endgroup\$
    – alephalpha
    Feb 26, 2019 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!

\$\endgroup\$
9
  • \$\begingroup\$ 11 \$\endgroup\$
    – ASCII-only
    Feb 24, 2019 at 23:09
  • \$\begingroup\$ 9 9 9? \$\endgroup\$
    – ASCII-only
    Feb 24, 2019 at 23:19
  • \$\begingroup\$ 8 8 \$\endgroup\$
    – ASCII-only
    Feb 24, 2019 at 23:30
  • 2
    \$\begingroup\$ 6 \$\endgroup\$
    – ASCII-only
    Feb 24, 2019 at 23:45
  • 2
    \$\begingroup\$ 6 6 \$\endgroup\$
    – ASCII-only
    Feb 24, 2019 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.
\$\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.
\$\endgroup\$
2
\$\begingroup\$

Gaia, 6 bytes

e:uDul

Try it online!

e	| eval as a list
 :	| duplicate
  u	| uniquify
   D	| multiset difference; keep only repeated elements
    u	| uniquify
     l	| find length
\$\endgroup\$
2
\$\begingroup\$

Arturo, 49 31 bytes

$=>[tally&|enumerate[k,v]->v>1]

Try it

-18 bytes due to Arturo 0.9.83 providing tally and enumerate.

$ => [               ; a function
    tally &          ; create a dictionary of elements and their occurrences from the input
    |                ; then...
    enumerate[k,v]-> ; count the number of key-value pairs where...
    v>1              ; the value (occurrences) is greater than one
]                    ; end function
\$\endgroup\$
2
\$\begingroup\$

Pyt, 7 bytes

ĐỤ⇹ɔ⁻žŁ

Try it online!

Đ             implicit input; Đuplicate on the stack
 Ụ            get Ụnique elements
  ⇹ɔ          ɔount occurrences of each in original list
    ⁻žŁ       decrement; remove žeros; get Łength; implicit print
 
\$\endgroup\$
2
\$\begingroup\$

Thunno 2 L, 5 bytes

Uæc1Q

Try it online!

Explanation

Uæc1Q  # Implicit input
U      # Uniquify the input
 æ     # Filter it by:
  c    #  Count in the input
   1Q  #  Is not equal to 1
       # Push the length
       # Implicit output
\$\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
\$\endgroup\$

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

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