Sie erhalten ein Array und müssen die Anzahl der Ganzzahlen zurückgeben, die mehr als einmal vorkommen.

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

Dies gibt 2 zurück, da jedes von 234und 2mehr als einmal erscheint.

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

Die Liste wird niemals länger als 100.000 Ganzzahlen sein, und die Ganzzahlen in der Liste werden immer zwischen -100.000 und 100.000 liegen.

Ganzzahlen sollten gezählt werden, wenn sie mehr als einmal vorkommen. Wenn eine Ganzzahl also dreimal vorkommt, zählt sie immer noch nur als eine wiederholte Ganzzahl.

Testfälle

[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

Ist es das, was du suchst? Dient tablezum Zählen der Vorkommen der einzelnen scanEingabewerte. Prüft, ob count> 1 ist und summiert die Wahrheiten.

sum(table(scan())>1)

Probieren Sie es online!

Haskell , 42 Bytes

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

Probieren Sie es online! Missbrauch der Tatsache, dass die Ganzzahlen in der Liste garantiert zwischen -100k und 100k liegen.

Bash + Coreutils, 18

sort|uniq -d|wc -l

Probieren Sie es online!

APL (Dyalog Unicode) , 9 8 Byte ^SBCS

-1 danke an ngn

Anonyme implizite Präfixfunktion.

+/1<⊢∘≢⌸

Probieren Sie es online!

+/ die Summe von

1< ob 1 kleiner ist als

… ⌸ Für jedes einzelne Element:

 ⊢∘ Ignorieren des eigentlichen einzigartigen Elements,

 ≢ die Anzahl seiner Vorkommen

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

Probieren Sie es online!

Dies ist das erste Mal, dass ich eines dieser Dokumente eingereicht habe. Lassen Sie mich daher wissen, wenn Probleme mit der Formatierung oder Ähnlichem auftreten.

Updates aus den Kommentaren:

• -58 bis 117 Bytes von Jo King
• -80 bis 95 Bytes nur in ASCII

ursprüngliche Vorlage

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

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

Der erste Entwurf der Spezifikation war unklar, und ich dachte, er würde alle Elemente zurückgeben, die mehr als einmal vorkommen. Dies ist die aktualisierte Version.

Irgendwie habe ich nicht bemerkt, dass mein Code die Anzahl der Elemente zurückgab, die einmal vorkamen. Vielen Dank an Paul Karam, der das verstanden hat!

Probieren Sie es online!

Python 3 , 38 Bytes

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

Probieren Sie es online!

J , 11 9 Bytes

-2 Bytes danke an Jonah!

1#.1<1#.=

Probieren Sie es online!

Ursprüngliche Lösung:

1#.(1<#)/.~

Probieren Sie es online!

Erläuterung:

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

Probieren Sie es online!

05AB1E , 4 Bytes

Ù¢≠O

Probieren Sie es online! oder als Test Suite

Erläuterung

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

Gelee , 4 Bytes

ĠITL

Probieren Sie es online!

...Oder ĠIƇL

Wie?

Ġ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Ƈwürde filtern, um nur wahrheitsgemäße Ergebnisse von I( [[6],[3,6]]) zu erhalten, die auch die gewünschte Länge haben.

Perl 6 , 15 Bytes

+*.repeated.Set

Probieren Sie es online!

Ziemlich selbsterklärend. Ein anonymer Codeblock, der die Anzahl ( +) Setder Elemente unter den repeatedElementen der Eingabe ( *) abruft .

Ich habe festgestellt, dass ich für eine verwandte Frage fast dieselbe Lösung gepostet habe .

Python 3 , 63 Bytes

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

Probieren Sie es online!

Java 8, 74, 73 Bytes

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

Probieren Sie es online aus.

Erläuterung:

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 bis 7 Byte ^SBCS

Anonymes implizites Präfix nach Jonahs Methode .

+/1<∪⍧⊢

Probieren Sie es online!

+/ Die Gesamtzahl der Vorkommen ist
  ^{buchstäblich die Summe der Wahrheiten}

1< wo man kleiner ist als

∪ die einzigartigen Elemente

⍧ mitzählen

⊢ das unveränderte Argument

Haskell , 41 Bytes

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

Probieren Sie es online!

Count-Suffixe, bei denen das erste Element hgenau einmal im nachfolgenden Teil vorkommt t.

Haskell , 40 Bytes

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

Probieren Sie es online!

Die Methode aus anderen Antworten stehlen.

Haskell, 41 Bytes

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

Diese Lösung zählt im Grunde genommen, wie viele Elemente der Liste dasselbe Element haben, das genau einmal später in der Liste erscheint.

Haskell , 47 Bytes

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

Probieren Sie es online!

Dies ist der naive Ansatz. Es gibt wahrscheinlich etwas, das getan werden könnte, um dies zu verbessern.

f[]=0

Wir kehren 0für die leere Liste zurück

f(a:b)

Im Falle einer nicht leeren Liste beginnend mit aund dann b.

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

Wenn sich das Herausfiltern avon von bunterscheidet b(d. H. aIn b), geben wir 1 mehr zurück, als mit herausgefiltertem s fangewendet wurde.ba

|1>0=f b

Wenn sich das Filtern von as nicht ändert, blaufen wir einfach füber den Rest.

Hier ist ein ähnlicher Ansatz mit derselben Länge:

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

Probieren Sie es online!

JavaScript (ES6), 40 Byte

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

Probieren Sie es online!

Wolfram Language 34 Bytes

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

Gathergruppiert identische ganze Zahlen in Listen. DeleteCases[...{x_}]Entfernt Listen mit einer einzelnen Nummer. Lengthgibt die Anzahl der verbleibenden Listen zurück (jede enthält zwei oder mehr identische ganze Zahlen).

Japt , 12 11 9 8 6 Bytes

ü èÈÊÉ

Mit viel Hilfe von @ ASCII-Only und Vorschlägen von @Shaggy und @Luis felipe De jesus Munoz.

Probieren Sie es online!

Pyth, 6 Bytes

l{.-Q{

Probieren Sie es hier aus

Erläuterung

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

Probieren Sie es online!

Erläuterung:

ọ          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

eine schöne Gelegenheit, variable Variablen zu verwenden :

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

Nimmt Eingaben von Befehlszeilenargumenten entgegen. Laufen Sie mit -nroder versuchen Sie es online .

$argv[0]ist -und das kommt nur einmal in den Argumenten vor, hat also keinen Einfluss auf das Ergebnis.

Element , 40 Bytes

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

Probieren Sie es online!

Dies erfordert, dass die Eingabe in einem genauen Format erfolgt [234, 2, 1000, 2, 99, 234](eingeschlossen []mit einem Komma und einem Leerzeichen zwischen ganzen Zahlen).

Erläuterung:

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

Probieren Sie es online! Der Link enthält eine Testsuite, in der jede Zeile durch Kommas getrennt wird. Erläuterung:

O`.+

Gleiche Werte zusammen sortieren.

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

Zählen Sie die Anzahl der Läufe mit mindestens zwei Werten.

Sauber , 59 54 Bytes

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

Probieren Sie es online!

Sortiert die Liste, gruppiert benachbarte gleiche Elemente und zählt die Anzahl mit mehr als 1 Element.

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

Ich gebe auf. Dies ist im Grunde das gleiche wie Ruby. Es gibt eine "andere Möglichkeit", ein Array zu erstellen und es mithilfe der Werte im Eingabevektor (+100000) zu indizieren. Die Typkonvertierungen (als usize / als i32) belegen jedoch zu viel Platz.

MATL , 5 Bytes

8#uqz

Probieren Sie es online! Oder überprüfen Sie alle Testfälle .

Erläuterung

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

k, 8 Bytes

+/1<#:'=

liest als: Summe (Länge jeder Gruppe)> 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)

Anwendungsbeispiel (erster Testfall)

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

schreibt 4