Recibirá una matriz y deberá devolver el número de enteros que se producen más de una vez.

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

Esto devolverá 2, ya que cada uno de 234y 2aparecerá más de una vez.

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

La lista nunca tendrá más de 100k enteros de largo, y los enteros dentro de la lista siempre estarán entre -100k y 100k.

Los enteros deben contarse si ocurren más de una vez, por lo que si un entero ocurre 3 veces, solo contará como un entero repetido.

Casos de prueba

[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 bytes

¿Es esto lo que buscas? Se utiliza tablepara contar las ocurrencias de cada uno de los scanvalores de entrada. Comprueba si el recuento es> 1 y suma las verdaderas.

sum(table(scan())>1)

Pruébalo en línea!

Haskell , 42 bytes

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

Pruébalo en línea! Abusa del hecho de que los enteros de la lista están garantizados dentro de -100k y 100k.

Bash + coreutils, 18

sort|uniq -d|wc -l

Pruébalo en línea!

APL (Dyalog Unicode) , ^{SBCS de} 9 8 bytes

-1 gracias a ngn

Función de prefijo tácito anónimo.

+/1<⊢∘≢⌸

Pruébalo en línea!

+/ la suma de

1< si 1 es menor que

... ⌸ para cada elemento único:

 ⊢∘ ignorando el elemento único real,

 ≢ el recuento de sus ocurrencias

C (sonido metálico) 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);}

Pruébalo en línea!

Esta es la primera vez que envío uno de estos, así que avíseme si hay algún problema con el formato o algo.

Actualizaciones de los comentarios:

• -58 a 117 bytes de Jo King
• -80 a 95 bytes de solo ASCII

presentación original

C # (compilador interactivo de Visual C #) , 40 bytes

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

El primer borrador de la especificación no estaba claro, y pensé que significaba devolver todos los elementos que aparecen más de una vez. Esta es la versión actualizada.

De alguna manera no me di cuenta de que mi código devolvió la cantidad de elementos que aparecieron una vez. ¡Gracias a Paul Karam por atrapar eso!

Pruébalo en línea!

Python 3 , 38 bytes

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

Pruébalo en línea!

J , 11 9 bytes

-2 bytes gracias a Jonah!

1#.1<1#.=

Pruébalo en línea!

Solución original:

1#.(1<#)/.~

Pruébalo en línea!

Explicación:

        /.~   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}}

Pruébalo en línea!

05AB1E , 4 bytes

Ù¢≠O

Pruébalo en línea! o como un conjunto de pruebas

Explicación

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

Jalea , 4 bytes

ĠITL

Pruébalo en línea!

...O ĠIƇL

¿Cómo?

Ġ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Ƈse filtraría para mantener solo resultados verdaderos de I( [[6],[3,6]]) que también tiene la longitud deseada.

Perl 6 , 15 bytes

+*.repeated.Set

Pruébalo en línea!

Bastante autoexplicativo. Un bloque de código anónimo que obtiene el conteo ( +) de los Setelementos entre los repeatedelementos de la entrada ( *).

Me di cuenta de que publiqué casi la misma solución para una pregunta relacionada.

Python 3 , 63 bytes

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

Pruébalo en línea!

Java 8, 74 73 bytes

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

Pruébalo en línea.

Explicación:

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 bytes ^SBCS

Función de prefijo tácito anónimo utilizando el método de Jonah .

+/1<∪⍧⊢

Pruébalo en línea!

+/ el número total de ocurrencias
  ^{literalmente la suma de verdades}

1< donde uno es menor que

∪ los elementos únicos

⍧ Cuéntalo

⊢ el argumento no modificado

Haskell , 41 bytes

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

Pruébalo en línea!

Cuente los sufijos donde el primer elemento haparece exactamente una vez en la parte tque viene después.

Haskell , 40 bytes

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

Pruébalo en línea!

Robar el método de otras respuestas.

Haskell, 41 bytes

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

Esta solución básicamente cuenta cuántos elementos de la lista tienen el mismo elemento que aparece exactamente una vez más tarde en la lista.

Haskell , 47 bytes

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

Pruébalo en línea!

Este es el enfoque ingenuo. Es probable que se pueda hacer algo para mejorar esto.

f[]=0

Volvemos 0por la lista vacía

f(a:b)

En el caso de una lista no vacía que comienza con ay luego b.

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

Si el filtrado ade bes diferente de b(es decir, aestá dentro b), entonces devolvemos 1 más de lo faplicado bcon los as filtrados.

|1>0=f b

Si el filtrado de as no cambia b, simplemente nos encontramos fcon el resto.

Aquí hay otro enfoque similar que tiene la misma longitud:

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

Pruébalo en línea!

JavaScript (ES6), 40 bytes

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

Pruébalo en línea!

Wolfram Language 34 bytes

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

Gatheragrupa enteros idénticos en listas. DeleteCases[...{x_}]elimina listas que contienen un solo número. Lengthdevuelve el número de listas restantes (cada una con dos o más enteros idénticos).

Japt , 12 11 9 8 6 bytes

ü èÈÊÉ

Con mucha ayuda de @ ASCII-Only, y sugerencias de @Shaggy y @Luis felipe De jesus Munoz.

Pruébalo en línea!

Pyth, 6 bytes

l{.-Q{

Pruébalo aquí

Explicación

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

Brachylog , 7 bytes

ọzt;1xl

Pruébalo en línea!

Explicación:

ọ          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 bytes

Una buena ocasión para usar variables variables :

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

toma datos de los argumentos de la línea de comandos. Ejecutar -nro probarlo en línea .

$argv[0]es -y eso aparece solo una vez en los argumentos, por lo que no afecta el resultado.

Elemento , 40 bytes.

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

Pruébalo en línea!

Esto requiere que la entrada esté en un formato preciso como [234, 2, 1000, 2, 99, 234](encerrado []con una coma y espacio entre enteros).

Explicación:

_                                        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)+$

Pruébalo en línea! Link incluye un conjunto de pruebas que divide cada línea en comas. Explicación:

O`.+

Ordenar valores iguales juntos.

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

Cuente el número de corridas de al menos dos valores.

Limpio , 59 54 bytes

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

Pruébalo en línea!

Ordena la lista, agrupa elementos iguales adyacentes y cuenta el número con más de 1 elemento.

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

Me rindo. Esto es básicamente lo mismo que Ruby. Hay "otra forma" de crear una matriz e indexarla utilizando los valores en el vector de entrada, +100000, sin embargo, las conversiones de tipo (como usize / as i32) ocupan demasiado espacio.

MATL , 5 bytes

8#uqz

Pruébalo en línea! O verificar todos los casos de prueba .

Explicación

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

k, 8 bytes

+/1<#:'=

se lee como: suma (longitud de cada grupo)> 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)

Ejemplo de uso (primer caso de prueba)

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

escribe 4