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

9

Haskell , 42 байта

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

Попробуйте онлайн! Злоупотребляет тем фактом, что целые числа в списке гарантированно находятся в пределах -100k и 100k.

Laikoni
источник

8

Баш + coreutils, 18

sort|uniq -d|wc -l

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

Цифровая травма
источник

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

Python 3 , 38 байт

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

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

Кирилл Л.
источник

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

Рубин , 34 байта

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

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

Кирилл Л.
источник

3

05AB1E , 4 байта

Ù¢≠O

Попробуйте онлайн! или как тестовый набор

объяснение

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

Emigna
источник

Таким образом, все значения, которые не 1, являются ложными?

Адам

@ Adám: Да, это правильно.

Emigna

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

Perl 6 , 15 байт

+*.repeated.Set

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

Довольно понятно. Блок анонимного кода, который получает count ( +) Setдля элементов среди repeatedэлементов input ( *).

Я понял, что выложил почти то же самое решение для связанного вопроса.

Джо Кинг
источник

3

Python 3 , 63 байта

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

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

pizzapants184
источник

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

JavaScript (ES6), 40 байт

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

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

Arnauld
источник

2

Wolfram Language 34 байта

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

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

DavidC
источник

1

Count[{_,__}]@*Gather

алефальфа

2

Japt , 12 11 9 8 6 байт

ü èÈÊÉ

С большой помощью @ ASCII-Only и предложениями @Shaggy и @Luis felipe De jesus Munoz.

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

Quintec
источник

11

только ASCII

9 9 9?

Только для ASCII

8 8

только ASCII

2

6

только ASCII

2

6 6

только ASCII

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

Брахилог , 7 байт

ọzt;1xl

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

Объяснение:

ọ          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.

Несвязанная строка
источник

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

Чистый , 59 54 байта

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

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

Сортирует список, группирует соседние равные элементы и считает число с более чем 1 элементом.

Οurous
источник

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

MATL , 5 байтов

8#uqz

Попробуйте онлайн! Или проверьте все тестовые случаи .

объяснение

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

Луис Мендо
источник

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

Дж. Сендра
источник

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

Ответы:

R , 20 байтов

Haskell , 42 байта

Баш + coreutils, 18

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

C (лязг) 175 117 95 байт

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

Python 3 , 38 байт

J , 11 9 байт

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

Рубин , 34 байта

05AB1E , 4 байта

Желе , 4 байта

Как?

Perl 6 , 15 байт

Python 3 , 63 байта

Java 8, 74 73 байта

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

Haskell , 41 байт

Haskell , 40 байт

Haskell, 41 байт

Haskell , 47 байтов

JavaScript (ES6), 40 байт

Wolfram Language 34 байта

Japt , 12 11 9 8 6 байт

Pyth, 6 байт

объяснение

Брахилог , 7 байт

PHP, 39 байт

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

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

Чистый , 59 54 байта

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

MATL , 5 байтов

объяснение

к, 8 байт

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

Ответы:

R , 20 байтов

Haskell , 42 байта

Баш + coreutils, 18

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

C (лязг) 175 117 95 байт

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

Python 3 , 38 байт

J , 11 9 байт

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

Рубин , 34 байта

05AB1E , 4 байта

Желе , 4 байта

Как?

Perl 6 , 15 байт

Python 3 , 63 байта

Java 8, 74 73 байта

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

Haskell , 41 байт

Haskell , 40 байт

Haskell, 41 байт

Haskell , 47 байтов

JavaScript (ES6), 40 байт

Wolfram Language 34 байта

Japt , 12 11 9 8 6 байт

Pyth, 6 байт

объяснение

Брахилог , 7 байт

PHP, 39 байт

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

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

Чистый , 59 54 байта

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

MATL , 5 байтов

объяснение

к, 8 байт

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

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