Contare le ripetizioni di un array

20

Riceverai un array e dovrai restituire il numero di numeri interi che si verificano più di una volta. 

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

Questo restituirà 2, poiché ciascuno di essi 234e 2appare più di una volta.

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

L'elenco non sarà mai più lungo di 100k interi e gli interi all'interno dell'elenco saranno sempre compresi tra -100k e 100k.

I numeri interi devono essere conteggiati se si verificano più di una volta, quindi se un numero intero si verifica 3 volte, verrà comunque conteggiato solo come un numero intero ripetuto.

Casi test

[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
code-golf  array-manipulation 
— jayko03
fonte
Cosa intendi con Once it counts the repetition, don't count again? Inoltre, poiché vogliamo trovare la ripetizione di un numero intero specifico, come potremmo sapere quale numero intero cercare se non ci viene dato? Infine, i casi di test sono un po 'confusi; quali sono output e quali input?
— Incarnazione dell'ignoranza il
4
L'ho modificato per provare a renderlo un po 'più chiaro. È questo che intendevi? Inoltre, inserisci le risposte per questi casi di test.
— Rɪᴋᴇʀ
1
Ho aggiunto alcune risposte ai casi di test, scusate se ho sbagliato
— MickyT
1
Ho votato per chiudere questa domanda fino a quando non confermi che questo è quello che volevi.
— Rɪᴋᴇʀ
4
Correlati (output degli articoli non unici, invece della quantità di articoli non unici).
— Kevin Cruijssen,

Risposte:

15

R , 20 byte

È questo ciò che cerchi? Utilizza tableper contare le occorrenze di ciascuno dei scanvalori di input. Verifica se il conteggio è> 1 e somma i valori.

sum(table(scan())>1)

Provalo online!

— MickyT
fonte
la mia mente è andata per duplicatedprima: l'umile tableè così utile per giocare a golf!
— Giuseppe,
Il tavolo @giuseppe è uno dei preferiti ora :)
— MickyT
7

APL (Dyalog Unicode) , 9 8 byte SBCS

-1 grazie a ngn

Funzione prefisso tacito anonimo.

+/1<⊢∘≢⌸

Provalo online!

+/ somma di

1< se 1 è inferiore a

... ⌸ per ogni elemento unico:

 ⊢∘ ignorando l'attuale elemento unico,

 ≢ il conteggio delle sue occorrenze

— Adamo
fonte
{1<≢⍵}⌸->1<⊢∘≢⌸
— ngn
@ngn Grazie. Incorporated.
— Adám
6

C (clang) 175 117 95 byte

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

Provalo online!

Questa è la prima volta che ho inviato uno di questi, quindi fatemi sapere se ci sono problemi con la formattazione o altro.

Aggiornamenti dai commenti:

  • -58 a 117 byte da Jo King
  • Da -80 a 95 byte solo da ASCII

presentazione originale

— Collin Phillips
fonte
5
Benvenuto, buon inizio. Non sono una persona C ma ecco un link a un consiglio per giocare a golf nella pagina C
— MickyT
2
117 byte => 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;}. Come notato solo da @ ASCII, le includes non influiscono sulla compilazione del programma
— Jo King,
2
@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;}
— ASCII il
1
@CollinPhillips sì. come puoi vedere nel link che ho pubblicato, si compila ancora bene senza le include
— ASCII-only
2
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);}
— ASCII, solo il
5

C # (compilatore interattivo Visual C #) , 40 byte

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

La prima bozza delle specifiche non era chiara e ho pensato che significasse restituire tutti gli elementi che appaiono più di una volta. Questa è la versione aggiornata.

In qualche modo non ho notato che il mio codice ha restituito il numero di elementi che sono apparsi una volta. Grazie a Paul Karam per averlo catturato!

Provalo online!

— Incarnazione dell'ignoranza
fonte
1
L'output è errato, è necessario contare gli elementi con 2 o più occorrenze. Dovrebbe essere n=>n.GroupBy(c=>c).Count(c=>c.Count()>=2). L'OP dice che la risposta a questa lista è 2. Il tuo codice ritorna 5. La modifica che ti ho dato ritorna 2.
— Paul Karam
1
O solo >1per mantenere il conteggio dei 40 byte
— Paul Karam,
@PaulKaram Non me ne sono accorto, grazie!
— Incarnazione dell'ignoranza il
4

J , 11 9 byte

-2 byte grazie a Giona!

1#.1<1#.=

Provalo online!

Soluzione originale:

1#.(1<#)/.~

Provalo online!

Spiegazione:

        /.~   group the list by itself
   (   )      for each group
    1<#       is the length greater than 1
1#.           sum by base-1 conversion
— Galen Ivanov
fonte
Ehi Galeno. 1#.1<1#.=per 9 byte + buon vecchio divertimento auto-classificante.
— Giona
1
@Giona Grazie! Onestamente, non ne ero a conoscenza.
— Galen Ivanov,
1
@Jonah Nice!
— Adám,
@Adám e qui sono stato contento di aver fatto legare J a APL. Sventato di nuovo :)
— Giona il
3

Gelatina , 4 byte

ĠITL

Provalo online!

...O ĠIƇL

Come?

Ġ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Ƈfiltrerebbe per mantenere solo i risultati sinceri di I( [[6],[3,6]]) che ha anche la lunghezza desiderata.

— Jonathan Allan
fonte
3

Perl 6 , 15 byte

+*.repeated.Set

Provalo online!

Abbastanza autoesplicativo. Un blocco di codice anonimo che ottiene il conteggio ( +) Setdegli elementi tra gli repeatedelementi dell'input ( *).

Mi sono reso conto di aver pubblicato quasi la stessa identica soluzione per una domanda correlata.

— Jo King
fonte
3

Java 8, 74 73 byte

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

Provalo online.

Spiegazione:

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
— Kevin Cruijssen
fonte
3

Haskell, 41 byte

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

Questa soluzione conta sostanzialmente quanti elementi dell'elenco hanno lo stesso elemento apparire esattamente una volta più tardi nell'elenco.

— haskeller orgoglioso
fonte
2

Haskell , 47 byte

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

Provalo online!

Questo è l'approccio ingenuo. C'è probabilmente qualcosa che potrebbe essere fatto per migliorare questo.

f[]=0

Torniamo 0per l'elenco vuoto

f(a:b)

Nel caso di un elenco non vuoto che inizia con ae quindi b.

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

Se il filtraggio di aout bè diverso da b(cioè è ain b), restituiamo 1 in più rispetto fa quello applicato bcon as filtrato.

|1>0=f b

Se il filtro as non cambia, ballora ci fimbattiamo nel resto.

Ecco un altro approccio simile che ha la stessa lunghezza:

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

Provalo online!

— Mago del grano
fonte
2

Wolfram Language 34 byte

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

Gatherraggruppa interi identici in elenchi. DeleteCases[...{x_}]elimina le liste contenenti un singolo numero. Lengthrestituisce il numero di elenchi rimanenti (ciascuno contenente due o più numeri interi identici.

— DavidC
fonte
1
Count[{_,__}]@*Gather
— alephalpha,
2

Pyth, 6 byte

l{.-Q{

Provalo qui

Spiegazione

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

PHP, 39 byte

una bella occasione per usare variabili variabili :

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

accetta input dagli argomenti della riga di comando. Corri con -nro provalo online .

$argv[0]è -e questo appare solo una volta negli argomenti, quindi non influisce sul risultato.

— Titus
fonte
1

Elemento , 40 byte

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

Provalo online!

Ciò richiede che l'input sia in un formato preciso come [234, 2, 1000, 2, 99, 234](racchiuso []da una virgola e uno spazio tra numeri interi).

Spiegazione:

_                                        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
— PhiNotPi
fonte
1

Retina 0.8.2 , 19 byte

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

Provalo online! Il collegamento include una suite di test che divide ciascuna linea tra virgole. Spiegazione:

O`.+

Ordina valori uguali insieme.

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

Contare il numero di esecuzioni di almeno due valori.

— Neil
fonte
1

Pulito , 59 54 byte

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

Provalo online!

Ordina l'elenco, raggruppa elementi uguali adiacenti e conta il numero con più di 1 elemento.

— Οurous
fonte
1

Ruggine, 126 byte

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

Mi arrendo. Questo è fondamentalmente lo stesso di Ruby. Esiste un "altro modo" per creare un array e indicizzarlo utilizzando i valori nel vettore di input, +100000, tuttavia le conversioni dei tipi (come usize / as i32) occupano troppo spazio.

— don luminoso
fonte
1

k, 8 byte

+/1<#:'=

legge come: somma (lunghezza di ciascun gruppo)> 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)

Esempio di utilizzo (primo caso di test)

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

scrive 4

— J. Sendra
fonte
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.