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!

APL (Dyalog Unicode), 9 bytes^SBCS

Anonymous tacit prefix function.

+/{1<≢⍵}⌸

Try it online!

+/ sum of

{…}⌸ for each unique element:

 1< whether 1 is less than

 ≢⍵ the count of occurrences

Bash + coreutils, 18

sort|uniq -d|wc -l

Try it online!

Python 3, 38 bytes

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

Try it online!

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.

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

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

Ruby, 34 bytes

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

Try it online!

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

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

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.

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

n=>n.GroupBy(c=>c).Count(c=>c.Count()<2)

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.

Try it online!

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

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

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!

APL (Dyalog Extended), 8 7 bytes^SBCS

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

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!

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

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.

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.

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.

JavaScript (ES6), 40 bytes

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

Try it online!

JavaScript (Node.js), 93 bytes

a=>Object.values(a.reduce((a,c)=>Object.assign(a,{[c]:(a[c]|0)+1}),{})).filter(i=>i>1).length

Try it online!

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.

Pyth, 10 bytes

lf<1/QT.{Q

Probably a way to golf it, I'm quite rusty with pyth...

Alternate 10 byte version...

lf>lT1.gSk

Try it online!

Python 3, 63 bytes

lambda l:len(C(l)-C({*l}))

from collections import Counter as C

Try it online!

PowerShell, 33 bytes

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

Try it online!

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

arr.GroupBy(x=>x).Where(y=>y.Count()>1).Select(y=>y.Key).Count()

Try it online!

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

Pyth, 8 bytes

lfthTr8S

Try it online here, or verify all the test cases at once here.

PHP (112 Bytes)

<?php $c=0;foreach(array_count_values(json_decode(file_get_contents('php://stdin'))) as $b)if($b>1)$c++;echo $c;

The assignment does not make it clear if the input is received via Stdin in exactly given format or as separate parameters in Argv, so here is a variant for argv, 91 Bytes:

<?php array_shift($argv);$c=0;foreach(array_count_values($argv) as $b)if($b>1)$c++;echo $c;