Визначимо середнє значення серед масиву / списку (чисел) середнього арифметичного сум його префіксів.

Наприклад, середнє значення середнього списку [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]

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

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

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

f<Uå+ x÷Ul

Перевірте це

• 1 байт збережено завдяки ETH, що вказує на надлишковий символ.

Пояснення

Неявне введення масиву U.

f<

Фільтруйте ( f) масив, перевіряючи, чи кожен елемент менше ...

Uå+

Uкумулятивно зменшено ( å) шляхом підсумовування ...

x

З отриманим масивом у свою чергу зменшується підсумовуючи ...

/Ul

І ділиться на довжину ( l) U.

Неоднозначно виводить отриманий масив.

Python 3 з Numpy , 48 байт

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

Вхід і вихід - це масиви Numpy. Спробуйте в Інтернеті!

Желе , 9 байт

+\S÷L<Ðf@

Спробуйте в Інтернеті!

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)))]

Спробуйте в Інтернеті!

Хаскелл, 39 байт

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

Спробуйте в Інтернеті!

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

Лушпиння , 10 9 байт

Дякуємо @Zgarb за те, що ми граємо на 1 байт!

f</L⁰Σ∫⁰⁰

Спробуйте в Інтернеті!

Необережений / Пояснення

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

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>

Java 8, 81 байт

Цей лямбдаський вираз приймає a 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 байти завдяки Kevin Cruijssen
• -17 байт завдяки Невайю

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

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

Спробуйте в Інтернеті!

Python 3 , 72 байти

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

Спробуйте в Інтернеті!

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синтаксису в нижньому колонтитулі).

Perl 6 , 31 байт

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

Спробуйте в Інтернеті!

Pyth - 10 байт

<#.OsM._QQ

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

Pyth, 12 11 байт

f<T.OsM._QQ

-1 байт завдяки спадару Xcoder

Спробуйте в Інтернеті!

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

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

Спробуйте в Інтернеті!

PHP, 84 байти

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

приймає дані з аргументів командного рядка. Запустіть -nrабо спробуйте в Інтернеті .

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

Рода , 46 41 39 байт

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

Спробуйте в Інтернеті!

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

R , 31 байт

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

Спробуйте в Інтернеті!

Математика, 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]&

K (oK) , 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

TI-Basic, 9 байт

Ans*(Ans<mean(cumSum(Ans