Подсчет повторений массива

20

Вы получите массив и должны вернуть количество целых чисел, встречающихся более одного раза. 

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

Это вернет 2, так как каждый из них 234и 2появится более одного раза.

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

Список никогда не будет длиннее целых 100 000, а целые числа внутри списка всегда будут в диапазоне от -100 000 до 100 000.

Целые числа должны учитываться, если они встречаются более одного раза, поэтому, если целое число встречается 3 раза, оно все равно будет учитываться только как одно повторное целое число.

Контрольные примеры

[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
источник
Что вы имеете в виду Once it counts the repetition, don't count again? Кроме того, поскольку мы хотим найти повторение определенного целого числа, как бы мы узнали, какое целое число искать, если нам его не дали? Наконец, контрольные примеры немного сбивают с толку; какие выходные, а какие входные?
— Воплощение Невежества
4
Я отредактировал это, чтобы попытаться сделать это немного яснее. Это то, что вы хотели? Кроме того, пожалуйста, введите ответы для этих тестовых случаев.
— Rɪᴋᴇʀ
1
Я добавил некоторые ответы на тестовые случаи, извините, если я ошибаюсь
— MickyT
1
Я проголосовал, чтобы закрыть этот вопрос, пока вы не подтвердите, что это то, что вы хотели.
— Rɪᴋᴇʀ
4
Связанный (вывод неуникальных предметов вместо количества неуникальных предметов).
— Кевин Круйссен

Ответы:

15

R , 20 байтов

Это то, что вы после? Используется tableдля подсчета вхождений каждого из scanвходных значений. Проверяет, является ли число> 1, и суммирует истины.

sum(table(scan())>1)

Попробуйте онлайн!

— MickyT
источник
мой разум пошел duplicatedпервым - скромный tableтак полезен для игры в гольф!
— Джузеппе
Стол @giuseppe теперь любимый :)
— MickyT
7

APL (Dyalog Unicode) , 9 8 байтов SBCS

-1 благодаря ngn

Функция анонимного молчаливого префикса.

+/1<⊢∘≢⌸

Попробуйте онлайн!

+/ сумма

1< 1 меньше чем

… ⌸ Для каждого уникального элемента:

 ⊢∘ игнорируя фактический уникальный элемент,

 ≢ количество его появлений

— Адам
источник
{1<≢⍵}⌸->1<⊢∘≢⌸
— ngn
@ngn Спасибо. Incorporated.
— адам
6

C (лязг) 175 117 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);}

Попробуйте онлайн!

Это первый раз, когда я отправил один из них, поэтому дайте мне знать, есть ли какие-либо проблемы с форматированием или что-то еще.

Обновления от комментариев:

  • От -58 до 117 байт от Джо Кинга
  • От -80 до 95 байтов только от ASCII

оригинал

— Коллин Филлипс
источник
5
Добро пожаловать, хорошее начало. Я не человек С, но вот ссылка на советы по игре в гольф на странице С
— MickyT
2
117 байт => 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;}. Как отмечалось только в @ ASCII, includeони не влияют на компиляцию вашей программы
— Джо Кинг,
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
1
@CollinPhillips да. как вы можете видеть по ссылке, которую я разместил, она все равно прекрасно компилируется без включений
— только ASCII
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
5

C # (интерактивный компилятор Visual C #) , 40 байт

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

Первый черновик спецификации был неясен, и я подумал, что это значит вернуть все элементы, которые появляются более одного раза. Это обновленная версия.

Почему-то я не заметил, что мой код вернул количество элементов, появившихся однажды. Спасибо Полу Караму за это!

Попробуйте онлайн!

— Воплощение невежества
источник
1
Ваш вывод неверен, он должен считать элементы с 2 или более вхождениями. Так и должно быть n=>n.GroupBy(c=>c).Count(c=>c.Count()>=2). ОП говорит, что ответом этого списка является 2. Ваш код возвращает 5. Изменение, которое я дал вам, возвращает 2.
— Пол Карам
1
Или просто >1сохранить счет 40 байтов
— Пол Карам
@PaulKaram Я этого не заметил, спасибо!
— Воплощение Невежества
4

J , 11 9 байт

-2 байта благодаря Ионе!

1#.1<1#.=

Попробуйте онлайн!

Оригинальное решение:

1#.(1<#)/.~

Попробуйте онлайн!

Объяснение:

        /.~   group the list by itself
   (   )      for each group
    1<#       is the length greater than 1
1#.           sum by base-1 conversion
— Гален Иванов
источник
Привет, Гален. 1#.1<1#.=9 байт + добро, давай самому классифицировать веселье.
— Иона
1
@ Джона Спасибо! Честно говоря, я не знал об этом.
— Гален Иванов
1
— Адам
@ Adám и тут я был рад, что заставил J связать себя с APL. Снова сорвали :)
— Иона
3

Желе , 4 байта

ĠITL

Попробуйте онлайн!

...Или ĠIƇL

Как?

Ġ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Ƈбудет фильтровать, чтобы сохранить только достоверные результаты I( [[6],[3,6]]), который также имеет желаемую длину.

— Джонатан Аллан
источник
3

Java 8, 74 73 байта

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

Попробуйте онлайн.

Объяснение:

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
— Кевин Круйссен
источник
3

APL (Dyalog Extended) , 8 7 байтов SBCS

Функция анонимного молчаливого префикса с использованием метода Джоны .

+/1<∪⍧⊢

Попробуйте онлайн!

+/ общее количество вхождений
  буквально сумма правд

1< где один меньше чем

∪ уникальные элементы

⍧ считать в

⊢ неизмененный аргумент

— Адам
источник
3

Haskell , 41 байт

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

Попробуйте онлайн!

Подсчитайте суффиксы, в которых первый элемент hпоявляется ровно один раз в той части, tкоторая идет после.

Haskell , 40 байт

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

Попробуйте онлайн!

Кража метода из других ответов.

— XNOR
источник
Черт возьми, у нас был тот же самый ответ
— гордый haskeller
3

Haskell, 41 байт

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

Это решение в основном подсчитывает, сколько элементов списка имеют один и тот же элемент, и они появляются в списке ровно один раз позже.

— гордый хаскеллер
источник
2

Haskell , 47 байтов

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

Попробуйте онлайн!

Это наивный подход. Вероятно, что-то можно сделать, чтобы улучшить это.

f[]=0

Возвращаем 0за пустой список

f(a:b)

В случае непустого списка, начиная с aи затем b.

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

Если фильтрация aвне bотличается от b(то есть aв b), то мы возвращаем на 1 больше, чем fприменено bс aотфильтрованными s.

|1>0=f b

Если фильтрация as не меняется, bмы просто fпересекаем все остальное.

Вот еще один похожий подход, который имеет такую ​​же длину:

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

Попробуйте онлайн!

— Мастер пшеницы
источник
2

Wolfram Language 34 байта

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

Gatherгруппирует одинаковые целые числа в списки. DeleteCases[...{x_}]удаляет списки, содержащие одно число. Lengthвозвращает количество оставшихся списков (каждый из которых содержит два или более одинаковых целых числа.

— DavidC
источник
1
Count[{_,__}]@*Gather
— алефальфа
2

Pyth, 6 байт

l{.-Q{

Попробуй здесь

объяснение

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

PHP, 39 байт

хороший повод использовать переменные переменные :

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

принимает входные данные из аргументов командной строки. Запустите -nrили попробуйте онлайн .

$argv[0]это -и что появляется только один раз в аргументах, так что это не влияет на результат.

— Titus
источник
1

Элемент , 40 байт

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

Попробуйте онлайн!

Это требует ввода в точном формате, как [234, 2, 1000, 2, 99, 234](в[] в запятую и через пробел между целыми числами).

Объяснение:

_                                        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
источник
1

Сетчатка 0.8.2 , 19 байт

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

Попробуйте онлайн! Ссылка включает набор тестов, который разделяет каждую строку на запятые. Объяснение:

O`.+

Сортировать равные значения вместе.

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

Подсчитайте количество прогонов не менее двух значений.

— Нил
источник
1

Ржавчина, 126 байт

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

Я сдаюсь. Это в основном то же самое, что и Ruby. Существует «другой способ» создания массива и индексации в нем, используя значения во входном векторе +100000, однако преобразования типов (например, в формате i32 / i32) занимают слишком много места.

— не яркий
источник
1

к, 8 байт

+/1<#:'=

читается как: сумма (длина каждой группы)> 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)

Пример использования (первый тестовый пример)

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

пишет 4

— Дж. Сендра
источник
Используя наш сайт, вы подтверждаете, что прочитали и поняли нашу Политику в отношении файлов cookie и Политику конфиденциальности.
Licensed under cc by-sa 3.0 with attribution required.