Contar repetições de uma matriz

20

Você receberá uma matriz e deve retornar o número de números inteiros que ocorrem mais de uma vez. 

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

Isso retornará 2, já que cada um 234e 2aparecerá mais de uma vez.

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

A lista nunca terá mais de 100k números inteiros e os números inteiros dentro da lista sempre estarão entre -100k e 100k.

Os números inteiros devem ser contados se ocorrerem mais de uma vez; portanto, se um número inteiro ocorrer 3 vezes, ele ainda será contabilizado apenas como um número inteiro repetido.

Casos de teste

[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
Como assim Once it counts the repetition, don't count again? Além disso, como queremos encontrar a repetição de um número inteiro específico, como saberíamos qual número inteiro procurar se não recebermos? Por fim, os casos de teste são um pouco confusos; quais são as saídas e quais são as entradas?
— Modalidade de ignorância
4
Eu editei isso para tentar torná-lo um pouco mais claro. É isso que você pretendia? Além disso, insira respostas para esses casos de teste.
— Rɪᴋᴇʀ
1
Eu adicionei algumas respostas para os casos de teste, desculpe se eu der errado
— MickyT 24/02
1
Votei em encerrar esta pergunta até você confirmar que era isso que pretendia.
— Rɪᴋᴇʀ
4
Relacionado (gera itens não exclusivos, em vez da quantidade de itens não exclusivos).
— Kevin Cruijssen 24/02

Respostas:

15

R , 20 bytes

É isso que você procura? Usa tablepara contar as ocorrências de cada um dos scanvalores de entrada. Testa se a contagem é> 1 e soma as verdades.

sum(table(scan())>1)

Experimente online!

— MickyT
fonte
minha mente foi a duplicatedprimeira - o humilde tableé tão útil para jogar golfe!
— Giuseppe
@giuseppe table é um favorito agora :)
— MickyT 25/02
6

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

Experimente online!

Esta é a primeira vez que enviei uma delas. Entre em contato se houver algum problema com a formatação ou algo assim.

Atualizações dos comentários:

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

envio original

— Collin Phillips
fonte
5
Bem-vindo, bom começo. Eu não sou uma pessoa C, mas aqui está um link para dicas para a página C de golfe
— MickyT 25/02
2
117 bytes => 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;}. Como observado apenas no ASCII, os includes não afetam a compilação do seu programa
— 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;}
— Somente ASCII
1
@CollinPhillips yes. como você pode ver no link que eu publiquei, ele ainda compila bem sem incluir
— 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);}
— Somente ASCII em
5

C # (compilador interativo do Visual C #) , 40 bytes

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

O primeiro rascunho da especificação não era claro, e achei que significa devolver todos os elementos que aparecem mais de uma vez. Esta é a versão atualizada.

De alguma forma, eu não percebi que meu código retornava o número de elementos que apareceram uma vez. Obrigado a Paul Karam por entender isso!

Experimente online!

— Forma de Ignorância
fonte
1
Sua saída está errada, ela precisa contar os elementos com 2 ou mais ocorrências. Deveria ser n=>n.GroupBy(c=>c).Count(c=>c.Count()>=2). O OP diz que a resposta desta lista é 2. Seu código retorna 5. A alteração que eu lhe dei retorna 2.
— Paul Karam
1
Ou apenas >1para manter a contagem de 40 bytes
— Paul Karam
@PaulKaram Eu não percebi isso, obrigado!
— Modalidade de ignorância
4

J , 11 9 bytes

-2 bytes graças a Jonah!

1#.1<1#.=

Experimente online!

Solução original:

1#.(1<#)/.~

Experimente online!

Explicação:

        /.~   group the list by itself
   (   )      for each group
    1<#       is the length greater than 1
1#.           sum by base-1 conversion
— Galen Ivanov
fonte
Olá Galen. 1#.1<1#.=por 9 bytes + boa e divertida auto-classificação.
— Jonah
1
@Jonah Thanks! Honestamente, eu não estava ciente disso.
— Galen Ivanov
1
@Jonah Nice!
— Adám 25/02
@ Adám, e fiquei satisfeito por ter conseguido o empate com o APL. Frustrado novamente :)
— Jonah
3

Gelatina , 4 bytes

ĠITL

Experimente online!

...Ou ĠIƇL

Quão?

Ġ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Ƈfiltraria para manter apenas os resultados verdadeiros de I( [[6],[3,6]]) que também tenham o comprimento desejado.

— Jonathan Allan
fonte
3

Java 8, 74 73 bytes

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

Experimente online.

Explicação:

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 bytes

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

Esta solução basicamente conta quantos elementos da lista têm o mesmo elemento exatamente exatamente uma vez mais tarde na lista.

— orgulhoso haskeller
fonte
2

Haskell , 47 bytes

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

Experimente online!

Essa é a abordagem ingênua. É provável que algo possa ser feito para melhorar isso.

f[]=0

Voltamos 0para a lista vazia

f(a:b)

No caso de uma lista não vazia, iniciando com ae depois b.

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

Se a filtragem ade bfor diferente de b(que está ainserida b), retornamos 1 mais do que o faplicado bcom os as filtrados.

|1>0=f b

Se a filtragem as não mudar b, simplesmente fatravessaremos o resto.

Aqui está outra abordagem semelhante que tem o mesmo comprimento:

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

Experimente online!

— Assistente de Trigo
fonte
2

Wolfram Language 34 bytes

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

Gatheragrupa números inteiros idênticos em listas. DeleteCases[...{x_}]elimina listas contendo um único número. Lengthretorna o número de listas restantes (cada uma contendo dois ou mais números inteiros idênticos.

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

Pitão, 6 bytes

l{.-Q{

Experimente aqui

Explicação

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

PHP, 39 bytes

uma boa ocasião para usar variáveis ​​variáveis :

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

recebe entrada dos argumentos da linha de comando. Corra com -nrou experimente online .

$argv[0]é -e aparece apenas uma vez nos argumentos, portanto não afeta o resultado.

— Titus
fonte
1

Elemento , 40 bytes

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

Experimente online!

Isso requer que a entrada esteja em um formato preciso, como [234, 2, 1000, 2, 99, 234](incluído no[] com uma vírgula e espaço entre números inteiros).

Explicação:

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

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

Experimente online! O link inclui o conjunto de testes que divide cada linha em vírgulas. Explicação:

O`.+

Classifique valores iguais juntos.

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

Conte o número de execuções de pelo menos dois valores.

— Neil
fonte
1

Limpo , 59 54 bytes

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

Experimente online!

Classifica a lista, agrupa elementos iguais adjacentes e conta o número com mais de 1 item.

— Furioso
fonte
1

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

Desisto. Isso é basicamente o mesmo que Ruby. Existe uma "outra maneira" de criar uma matriz e indexá-la usando os valores no vetor de entrada +100000; no entanto, as conversões de tipo (como usize / como i32) ocupam muito espaço.

— não brilhante
fonte
1

k, 8 bytes

+/1<#:'=

lê como: soma (comprimento 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)

Exemplo de uso (primeiro caso de teste)

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

escreve 4

— J. Sendra
fonte
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.