Otrzymasz tablicę i musisz zwrócić liczbę całkowitą, która występuje więcej niż jeden raz.

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

Będzie to powrót 2, ponieważ każdy 234i 2pojawić się więcej niż jeden raz.

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

Lista nigdy nie będzie dłuższa niż 100 000 liczb całkowitych, a liczby całkowite na liście zawsze będą zawierać się w przedziale od -100 000 do 100 000.

Liczby całkowite należy liczyć, jeśli występują więcej niż jeden raz, więc jeśli liczba całkowita wystąpi 3 razy, nadal będzie liczona jako jedna powtórzona liczba całkowita.

Przypadki testowe

[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 bajtów

Czy o to ci chodzi? Używa tabledo zliczania wystąpień każdej z scanwartości wejściowych. Sprawdza, czy liczba wynosi> 1 i sumuje wartości rzeczywiste.

sum(table(scan())>1)

Wypróbuj online!

Haskell , 42 bajty

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

Wypróbuj online! Nadużywa faktu, że liczby całkowite na liście mają gwarantowane wartości w zakresie od -100 do 100 000.

Bash + coreutils, 18

sort|uniq -d|wc -l

Wypróbuj online!

APL (Dyalog Unicode) , 9 8 bajtów ^SBCS

-1 dzięki ngn

Anonimowa ukryta funkcja prefiksu.

+/1<⊢∘≢⌸

Wypróbuj online!

+/ suma

1< czy 1 jest mniejsze niż

… ⌸ Dla każdego unikalnego elementu:

 ⊢∘ ignorując rzeczywisty unikalny element,

 ≢ liczba jego wystąpień

C (brzęk) 175 117 95 bajtów

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

Wypróbuj online!

Po raz pierwszy przesłałem jeden z nich, więc daj mi znać, jeśli występują problemy z formatowaniem lub coś w tym stylu.

Aktualizacje z komentarzy:

• -58 do 117 bajtów od Jo King
• -80 do 95 bajtów tylko z ASCII

oryginalne zgłoszenie

C # (interaktywny kompilator Visual C #) , 40 bajtów

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

Pierwszy szkic specyfikacji był niejasny i myślałem, że oznacza to zwrócenie wszystkich elementów, które pojawiają się więcej niż jeden raz. To jest zaktualizowana wersja.

Jakoś nie zauważyłem, że mój kod zwrócił liczbę elementów, które pojawiły się raz. Dzięki Paulowi Karamowi za złapanie tego!

Wypróbuj online!

Python 3 , 38 bajtów

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

Wypróbuj online!

J , 11 9 bajtów

-2 bajty dzięki Jonaszowi!

1#.1<1#.=

Wypróbuj online!

Oryginalne rozwiązanie:

1#.(1<#)/.~

Wypróbuj online!

Wyjaśnienie:

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

Rubinowy , 34 bajty

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

Wypróbuj online!

05AB1E , 4 bajty

Ù¢≠O

Wypróbuj online! lub jako pakiet testowy

Wyjaśnienie

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

Galaretka , 4 bajty

ĠITL

Wypróbuj online!

...Lub ĠIƇL

W jaki sposób?

Ġ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Ƈfiltrowałby, aby zachować tylko prawdziwe wyniki I( [[6],[3,6]]), które również mają pożądaną długość.

Perl 6 , 15 bajtów

+*.repeated.Set

Wypróbuj online!

Dość oczywiste. Anonimowy blok kodu, który pobiera liczbę ( +) Setelementów wśród repeatedelementów input ( *).

Zdałem sobie sprawę, że opublikowałem prawie takie samo rozwiązanie dla pokrewnego pytania.

Python 3 , 63 bajty

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

Wypróbuj online!

Java 8, 74 73 bajty

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

Wypróbuj online.

Wyjaśnienie:

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 bajtów ^SBCS

Używanie anonimowej ukrytej prefiksu metody Jonaha .

+/1<∪⍧⊢

Wypróbuj online!

+/ całkowita liczba wystąpień
   ^{dosłownie suma Prawd}

1< gdzie jeden jest mniejszy niż

∪ unikalne elementy ”

⍧ liczyć się

⊢ niezmodyfikowany argument

Haskell , 41 bajtów

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

Wypróbuj online!

Policz przyrostki, w których pierwszy element hpojawia się dokładnie raz w następnej części t.

Haskell , 40 bajtów

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

Wypróbuj online!

Kradzież metody z innych odpowiedzi.

Haskell, 41 bajtów

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

To rozwiązanie w zasadzie liczy, ile elementów listy ma ten sam element, który pojawia się dokładnie raz później na liście.

Haskell , 47 bajtów

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

Wypróbuj online!

To jest naiwne podejście. Jest prawdopodobnie coś, co można zrobić, aby to poprawić.

f[]=0

Wracamy 0po pustą listę

f(a:b)

W przypadku niepustej listy zaczynającej się od, aa następnie b.

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

Jeśli odfiltrowanie az bjest inne niż b(to ajest w b), zwracamy 1 więcej niż fzastosowane bz aodfiltrowanym s.

|1>0=f b

Jeśli filtrowanie as się nie zmienia, bpo prostu przeglądamy fresztę.

Oto inne podobne podejście, które ma tę samą długość:

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

Wypróbuj online!

JavaScript (ES6), 40 bajtów

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

Wypróbuj online!

Język Wolfram 34 bajty

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

Gathergrupuje identyczne liczby całkowite w listy. DeleteCases[...{x_}]eliminuje listy zawierające jeden numer. Lengthzwraca liczbę pozostałych list (każda zawierająca dwie lub więcej identycznych liczb całkowitych.

Japt , 12 11 9 8 6 bajtów

ü èÈÊÉ

Z dużą pomocą @ ASCII-Only i sugestiami @Shaggy i @Luis felipe De jesus Munoz.

Wypróbuj online!

Pyth, 6 bajtów

l{.-Q{

Wypróbuj tutaj

Wyjaśnienie

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

Brachylog , 7 bajtów

ọzt;1xl

Wypróbuj online!

Wyjaśnienie:

ọ          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 bajtów

miła okazja do zastosowania zmiennych zmiennych :

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

pobiera dane wejściowe z argumentów wiersza poleceń. Uruchom -nrlub wypróbuj online .

$argv[0]jest -i pojawia się tylko raz w argumentach, więc nie wpływa na wynik.

Element , 40 bajtów

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

Wypróbuj online!

Wymaga to, aby dane wejściowe miały dokładny format, taki jak [234, 2, 1000, 2, 99, 234](zamknięty []przecinkiem i spacją między liczbami całkowitymi).

Wyjaśnienie:

_                                        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 bajtów

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

Wypróbuj online! Link zawiera pakiet testowy, który dzieli każdą linię przecinkami. Wyjaśnienie:

O`.+

Sortuj równe wartości razem.

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

Policz liczbę przebiegów co najmniej dwóch wartości.

Czysty , 59 54 bajtów

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

Wypróbuj online!

Sortuje listę, grupuje sąsiednie równe elementy i liczy liczbę z więcej niż 1 pozycją.

Rdza, 126 bajtów

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

Poddaję się. Jest to w zasadzie to samo co Ruby. Istnieje „inny sposób” tworzenia tablicy i indeksowania do niej przy użyciu wartości w wektorze wejściowym, +100000, jednak konwersje typów (jako usize / jako i32) zajmują zbyt dużo miejsca.

MATL , 5 bajtów

8#uqz

Wypróbuj online! Lub sprawdź wszystkie przypadki testowe .

Wyjaśnienie

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

k, 8 bajtów

+/1<#:'=

brzmi: suma (długość każdej grupy)> 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)

Użyj przykładu (pierwszy przypadek testowy)

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

pisze 4