15

Определим гиперсреднее для массива / списка (чисел) среднее арифметическое сумм его префиксов.

Например, гипер-среднее значение списка [1, 4, -3, 10]рассчитывается следующим образом:

Мы получаем префиксы: [1], [1, 4], [1, 4, -3], [1, 4, -3, 10].
Сложите каждый: [1, 5, 2, 12].
А теперь получите среднее арифметическое элементов в этом списке: (1 + 5 + 2 + 12) / 4 = 5 .

Псевдо-элемент массива является элементом, значение которого строго меньше , чем его гипер-среднего. Следовательно, псевдоэлементы нашего примера списка 1,4 и -3.

Учитывая список чисел с плавающей точкой, ваша задача - вернуть список псевдоэлементов.

Вам не нужно беспокоиться о неточностях с плавающей точкой.
Список ввода никогда не будет пустым и может содержать как целые числа, так и числа с плавающей точкой. Если упомянуто, целые числа могут быть взяты как числа с<integer>.0 )
Вы можете предположить, что цифры соответствуют выбранному вами языку, но, пожалуйста, не злоупотребляйте этим никоим образом.
При желании вы также можете использовать длину массива в качестве входных данных.
Это код-гольф , поэтому применяются стандартные правила для тега. Самый короткий код в байтах ( на каждом языке ) выигрывает!

Тестовые случаи

Вход -> Выход

[10.3] -> []
[5.4, 5.9] -> [5.4, 5.9]
[1, 4, -3, 10] -> [1, 4, -3]
[-300, -20,9, 1000] -> [-300, -20,9]
[3.3, 3.3, 3.3, 3.3] -> [3.3, 3.3, 3.3, 3.3]
[-289,93, 912,3, -819,39, 1000] -> [-289,93, -819,39]

code-golf number array-manipulation

— Мистер Xcoder
источник

Если некоторым языкам разрешено принимать длину массива в качестве дополнительного ввода, то это должно быть разрешено для всех языков .

— ngenisis

1

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

— Мистер Кскодер

7

MATL , 8 байт

ttYsYm<)

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

объяснение

tt    % Implicitly input array. Duplicate twice
Ys    % Cumulative sum
Ym    % Arithmetic mean
<     % Less than? (element-wise). Gives an array containing true / false
)     % Reference indexing : use that array as a mask to select entries 
      % from the input. Implicitly display

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

7

05AB1E , 9 8 байт

-1 байт благодаря волшебной урне осьминога

ηOO¹g/‹Ï

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

η        # Get prefixes
 O       # Sum each
  O¹g/   # Get the mean ( length(prefix list) equals length(original list) )
      ‹Ï # Keep only the value that are less than the mean

05AB1E , 6 байтов

Используя новую ÅAкоманду.

ηOÅA‹Ï

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

η      # Get prefixes
 O     # Sum each
  ÅA   # Get the mean
    ‹Ï #  Keep only the value that are less than the mean

— Райли
источник

2

ηOO¹g/›Ïза 8; также это начинается с nOO!.

— Волшебная урна с осьминогом

5

Japt v2.0a0, 12 11 10 байт

f<Uå+ x÷Ul

Проверь это

1 байт сохранен благодаря ETH, указывающему на избыточный символ.

объяснение

Неявный ввод массива U.

f<

Filter ( f) массив, проверяя, если каждый элемент меньше ...

Uå+

Uкумулятивно уменьшается ( å) путем суммирования ...

Получившийся массив в свою очередь уменьшается путем суммирования ...

/Ul

И делится на длину ( l) из U.

Неявно выведите полученный массив.

— мохнатый
источник

4

Python 3 с Numpy , 48 байтов

lambda x:x[x<mean(cumsum(x))]
from numpy import*

Вход и выход - массивы Numpy. Попробуйте онлайн!

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

1

+1 Наконец-то кто-то использует cumsum!

— г-н Xcoder

3

Желе , 9 байт

+\S÷L<Ðf@

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

— Дрянная Монахиня
источник

Может <Ðf@быть, вместо этого должно быть <Ðḟ@?

— Эрик Outgolfer

@EriktheOutgolfer, но он проходит все тестовые случаи.

— Утренняя монахиня

Тем не менее, что-то мне не кажется хорошим ... сначала +\S÷Lвычисляет гипер-среднее значение, затем <Ðf@ставит его в качестве правильного аргумента и <возвращает, 1если элемент является псевдоэлементом, по существу фильтруя псевдоэлементы вместо фильтрации их.

— Эрик Outgolfer

@EriktheOutgolfer В этом контексте фильтрация означает фильтрацию для.

— Утренняя монахиня

3

Python 2 , 78 76 71 66 байт

-7 байт благодаря мистеру Xcoder.

lambda l:[x for x in l if x<sum(sum(l[:i])for i in range(len(l)))]

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

— totallyhuman
источник

Я думаю, что вы можете сделать range(len(l))и l[:i+1]для -2 байтов (не проверено)

— г-н Xcoder

Гольф и запутанный. ;) Благодарность!

— полностью человек

Ваше решение неверно, хотя. Изменение x>sum(...)к x<sum(...)для того , чтобы быть действительным, еще 76 байт

— г Xcoder

Wherps ... Исправлено. >.>

— полностью человек

Я удивлен, что никто не выбрал очевидное <s>68</s>66-байтовое решение: P

— Mr. Xcoder

3

Haskell, 39 байт

f l=filter(<sum(scanl1(+)l)/sum(1<$l))l

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

К сожалению , lengthэто типа Int, поэтому я не могу использовать его с плавающей точкой разделения , /и я должен использовать обходной путь: sum(1<$l).

— Ними
источник

3

Шелуха , 10 9 байт

Спасибо @Zgarb за игру в 1 байт!

f</L⁰Σ∫⁰⁰

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

Ungolfed / Пояснение

           -- argument is ⁰ (list) 
f       ⁰  -- filter the original list with
 <         --   element strictly smaller than
     Σ∫⁰   --   sum of all prefixes
  /L⁰      --   averaged out

— ბიმო
источник

2

f</L⁰Σ∫⁰⁰9 байт, но три лямбда-аргумента кажутся неуклюжими.

— Згарб

3

JavaScript (ES6), 56 55 52 байта

a=>a.filter(x=>x<t/a.length,a.map(x=>t+=s+=x,s=t=0))

Проверь это

o.innerText=(f=

a=>a.filter(x=>x<t/a.length,a.map(x=>t+=s+=x,s=t=0))

)(i.value=[1,4,-3,10]);oninput=_=>o.innerText=f(i.value.split`,`.map(eval))

<input id=i><pre id=o>

Развернуть фрагмент

— мохнатый
источник

3

Java 8, 81 байт

Это лямбда-выражение принимает List<Float>и мутирует его. Итератор списка ввода должен поддерживать удаление ( ArrayListнапример, делает). Присвоить Consumer<List<Float>>.

a->{float l=0,t=0,u;for(float n:a)t+=n*(a.size()-l++);u=t/l;a.removeIf(n->n>=u);}

Неуправляемая лямбда

a -> {
    float l = 0, t = 0, u;
    for (float n : a)
        t += n * (a.size() - l++);
    u = t / l;
    a.removeIf(n -> n >= u);
}

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

Подтверждения

-3 байта благодаря Кевину Круйссену
-17 байт благодаря Nevay

— Jakob
источник

1

Вы можете сохранить 3 байта, удалив t/=l;и изменив if(n<t)на if(n<t/l).

— Кевин Круйссен

1

Вы можете использовать список вместо массива, чтобы иметь возможность изменять предоставленный аргумент, а не печатать результирующие значения a->{float l=0,t=0,u;for(float n:a)t+=n*(a.size()-l++);u=t/l;a.removeIf(n->n>=u);}(81 байт).

— Невай

2

C # (моно) , 95 байт

using System.Linq;a=>a.Where(d=>d<new int[a.Length].Select((_,i)=>a.Take(i+1).Sum()).Average())

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

— TheLethalCoder
источник

2

Python 3 , 72 байта

lambda x:[*filter((sum(-~a*b for a,b in enumerate(x))/len(x)).__gt__,x)]

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

— Халвард Хаммель
источник

Очень умное решение! Я никогда не думал, filterчто победит обычное понимание списка.

— г-н Xcoder

2

Python 3 , 76 байт

lambda x:[w for w in x if w<sum(u*v+v for u,v in enumerate(x[::-1]))/len(x)]

Вход и выход представляют собой списки чисел. Попробуйте онлайн!

Это работает и в Python 2 (с очевидной заменой printсинтаксиса в нижнем колонтитуле).

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

Вам нужно перевернуть список?

— officialaimm

@officialaimm Я так думаю, потому что значения перечисления 1,2,3, ... должны идти с x [0], x [-1], x [-2]. Но во всех случаях результат кажется одинаковым, хм ...

— Луис Мендо

1

Я нашел контрпример, который показывает, что реверсирование действительно необходимо

— Луис Мендо

Ах, не берите в голову .. Я просто так думал, потому что он прошел все тестовые случаи ...: P

— officialaimm

2

Perl 6 , 31 байт

{.grep(flat([\,] $_).sum/$_>*)}

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

— Шон
источник

2

Pyth - 10 байт

<#.OsM._QQ

Попробуйте это онлайн здесь .

— Maltysen
источник

1

Pyth, 12 11 байтов

f<T.OsM._QQ

-1 байт благодаря мистеру Xcoder

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

— Дейв
источник

11 байт:f<T.OsM._QQ

— г-н Xcoder

1

Perl 5 , 51 + 1 (-a) = 52 байта

$a+=$_*(@F-$c++)for@F;for(@F){print$_,$"if$_<$a/@F}

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

— Xcali
источник

1

PHP, 84 байта

for($i=--$argc;$i;)$s+=$i--/$argc*$r[]=$argv[++$k];foreach($r as$x)$x<$s&&print$x._;

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

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

— Titus
источник

1

Röda , 46 41 39 байт

f l{l|[_]if[_1*#l<seq(1,#l)|l[:_]|sum]}

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

— fergusq
источник

1

J 15 байт

#~[<[:(+/%#)+/\

Попробуйте онлайн! Ожидается массив в стиле J (негативы, представленные с использованием_ вместо -и элементов, разделенных пробелами - см. Ссылку на TIO для примеров).

Я не знаю, есть ли способ убрать скобки вокруг среднего значения (+/%# ), но удалив это, и колпачок был бы первым, что я попытался бы сделать, чтобы дальше играть в гольф.

объяснение

Иногда J читает как (обфусцированный) английский.

#~ [ < [: (+/ % #) +/\
                   +/\  Sum prefixes
                     \   Get prefixes
                   +/    Sum each
          (+/ % #)      Mean
           +/            Sum of array
              %          Divided by
                #        Length of array
   [ <                  Input array is less than?
                         (gives boolean array of pairwise comparisons)
#~                      Filter by

— капуста
источник

1

ты избил меня до 3 минут :)

— Иона

12 байт с#~]<1#.+/\%#

— миль

@ Мили Если вы не думаете, что это достаточно похоже, я думаю, ваш комментарий может оправдать свой ответ. РЕДАКТИРОВАТЬ: Я думаю, что это очень умный сам.

— Коул

1

R , 31 байт

function(l)l[l<mean(cumsum(l))]

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

— Giuseppe
источник

1

Mathematica, 35 байт

Cases[#,x_/;x<#.Range[#2,1,-1]/#2]&

Functionкоторый ожидает список чисел в качестве первого аргумента #и длину списка в качестве второго аргумента #2. #.Range[#2,1,-1]/#2берёт скалярное произведение списка ввода #и списка Range[#2,1,-1] == {#2,#2-1,...,1}, затем делит на длину #2. Затем мы возвращаем Cases x_в списке ввода# который меньше гипер-среднего.

Без длины в качестве второго аргумента нам нужно 6больше байтов:

Cases[#,x_/;x<#.Range[h=Tr[1^#],1,-1]/h]&

— ngenisis
источник

0

K (ок) , 26 байтов

Решение:

x@&x<(+/+/'x@!:'1+!#x)%#x:

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

Примеры:

> x@&x<(+/+/'x@!:'1+!#x)%#x:1 4 -3 10
1 4 -3
> x@&x<(+/+/'x@!:'1+!#x)%#x:-289.93 912.3 -819.39 1000
-289.93 -819.39

Объяснение:

Интерпретируется справа налево. Бороться с коротким способом извлечения префиксов:

x@&x<(+/+/'x@!:'1+!#x)%#x: / the solution
                        x: / store input in x, x:1 4 -3 10
                       #   / count, return length of x, #1 4 -3 10 => 4
     (               )     / do everything in the brackets together
                   #x      / count x
                  !        / til, range 0..x, !4 => 0 1 2 3
                1+         / add 1 vectorised, 1+0 1 2 3 => 1 2 3 4
             !:'           / til each, e.g. !1, !2, !3, !4
           x@              / index into x at these indices (now we have the prefixes)
        +/'                / sum (+ over) each, e.g. 1 5 2 12
      +/                   / sum over, e.g. 20
                      %    / right divided by left, 20%4 => 5 (now we have the hyper average)
   x<                      / boolean list where x less than 5
  &                        / indices where true, &0111b => 1 2 3
x@                         / index into x at these indices (now we have the filtered list)

Примечания:

Альтернативная версия, принимающая длину ввода в качестве параметра ( 25- байтовое решение):

> {x@&x<(+/+/'x@!:'1+!y)%y}[1 4 -3 10;4]
1 4 -3

— streetster
источник

0

TI-Basic, 9 байтов

Ans*(Ans<mean(cumSum(Ans

— Timtech
источник

Отфильтруйте псевдоэлементы!

Тестовые случаи

MATL , 8 байт

объяснение

05AB1E , 9 8 байт

05AB1E , 6 байтов

Japt v2.0a0, 12 11 10 байт

объяснение

Python 3 с Numpy , 48 байтов

Желе , 9 байт

Python 2 , 78 76 71 66 байт

Haskell, 39 байт

Шелуха , 10 9 байт

Ungolfed / Пояснение

JavaScript (ES6), 56 55 52 байта

Проверь это

Java 8, 81 байт

Неуправляемая лямбда

Подтверждения

C # (моно) , 95 байт

Python 3 , 72 байта

Python 3 , 76 байт

Perl 6 , 31 байт

Pyth - 10 байт

Pyth, 12 11 байтов

Perl 5 , 51 + 1 (-a) = 52 байта

PHP, 84 байта

Röda , 46 41 39 байт

J 15 байт

объяснение

R , 31 байт

Mathematica, 35 байт

K (ок) , 26 байтов

TI-Basic, 9 байтов