Chúng tôi xác định siêu trung bình của một mảng / danh sách (số) trung bình số học của các tổng tiền tố của nó.

Ví dụ: siêu trung bình của danh sách [1, 4, -3, 10]được tính theo cách sau:

• Chúng tôi nhận được các tiền tố : [1], [1, 4], [1, 4, -3], [1, 4, -3, 10].

• Tổng mỗi : [1, 5, 2, 12].

• Và bây giờ có được ý nghĩa số học của các yếu tố trong danh sách này : (1 + 5 + 2 + 12) / 4 = 5.

Một giả yếu tố của một mảng là một yếu tố có giá trị là đúng thấp hơn so với siêu trung bình của nó. Do đó, các yếu tố giả trong danh sách ví dụ của chúng tôi là 1, 4và -3.

Đưa ra một danh sách các số dấu phẩy động, nhiệm vụ của bạn là trả về danh sách các phần tử giả.

• Bạn không phải lo lắng về sự thiếu chính xác của dấu phẩy động.

• Danh sách đầu vào sẽ không bao giờ trống và nó có thể chứa cả số nguyên và số float. Nếu được đề cập, số nguyên có thể được coi là số float (với <integer>.0)

• Bạn có thể cho rằng các con số phù hợp với ngôn ngữ bạn chọn, nhưng xin đừng lạm dụng nó theo bất kỳ cách nào.

• Tùy chọn, bạn cũng có thể lấy chiều dài của mảng làm đầu vào.

• Đây là mã golf , vì vậy các quy tắc tiêu chuẩn cho thẻ được áp dụng. Mã ngắn nhất tính bằng byte ( trong mỗi ngôn ngữ ) sẽ thắng!

Các trường hợp thử nghiệm

Đầu vào -> Đầu ra

[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 byte

ttYsYm<)

Hãy thử trực tuyến! Hoặc xác minh tất cả các trường hợp thử nghiệm .

Giải trình

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 byte

-1 byte nhờ Magic Octopus Urn

ηOO¹g/‹Ï

Hãy thử trực tuyến!

η        # 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 byte

Sử dụng ÅAlệnh mới .

ηOÅA‹Ï

Hãy thử trực tuyến!

η      # 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 byte

f<Uå+ x÷Ul

Kiểm tra nó

• Lưu 1 byte nhờ ETH chỉ ra một ký tự dự phòng.

Giải trình

Đầu vào ngầm định của mảng U.

f<

Lọc ( f) mảng bằng cách kiểm tra xem mỗi phần tử có nhỏ hơn ...

Uå+

Utích lũy giảm ( å) bằng cách tóm tắt ...

x

Với mảng kết quả lần lượt giảm bằng cách tính tổng ...

/Ul

Và chia cho chiều dài ( l) của U.

Ngẫu nhiên xuất ra mảng kết quả.

Python 3 với Numpy , 48 byte

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

Đầu vào và đầu ra là mảng Numpy. Hãy thử trực tuyến!

Thạch , 9 byte

+\S÷L<Ðf@

Hãy thử trực tuyến!

Python 2 , 78 76 71 66 byte

-7 byte nhờ ông Xcoder.

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

Hãy thử trực tuyến!

Haskell, 39 byte

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

Hãy thử trực tuyến!

Thật không may lengthlà loại Int, vì vậy tôi không thể sử dụng nó với phân chia dấu phẩy động /và tôi phải sử dụng một cách giải quyết : sum(1<$l).

Husk , 10 9 byte

Cảm ơn @Zgarb vì đã chơi golf 1 byte!

f</L⁰Σ∫⁰⁰

Hãy thử trực tuyến!

Ungolfed / Giải thích

           -- 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 byte

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

Kiểm tra nó

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 byte

Biểu thức lambda này chấp nhận a List<Float>và biến đổi nó. Trình lặp của danh sách đầu vào phải hỗ trợ loại bỏ ( ArrayListví dụ như vậy). Chỉ định cho 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);}

Lambda

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

Dùng thử trực tuyến

Sự nhìn nhận

• -3 byte nhờ Kevin Cruijssen
• -17 byte nhờ Nevay

C # (Mono) , 95 byte

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

Hãy thử trực tuyến!

Python 3, 72 bytes

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

Try it online!

Python 3, 76 bytes

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

Input and output are lists of numbers. Try it online!

This works in Python 2 too (with the obvious replacement for print syntax in the footer).

Perl 6, 31 bytes

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

Try it online!

Pyth - 10 bytes

<#.OsM._QQ

Try it online here.

Pyth, 12 11 bytes

f<T.OsM._QQ

-1 byte thanks to Mr. Xcoder

Try it online!

Perl 5, 51 + 1 (-a) = 52 bytes

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

Try it online!

PHP, 84 bytes

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

takes input from command line arguments. Run with -nr or try it online.

summing up the partial lists is the same as summing up each element multiplied with the number of following elements +1 → no need to juggle with bulky array functions. It´s still long, though.

Röda, 46 41 39 bytes

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

Try it online!

J, 15 bytes

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

Try it online! Expects a J-style array (negatives represented using _ instead of - and elements separated by spaces -- see the TIO link for examples).

I don't know if there's a way to remove the parentheses around the mean (+/%#) but removing that and the cap would be the first thing I'd try to do to golf this further.

Explanation

Sometimes J reads like (obfuscated) English.

#~ [ < [: (+/ % #) +/\
                   +/\  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 bytes

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

Try it online!

Mathematica, 35 bytes

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

Function which expects a list of numbers as the first argument # and the length of the list as the second argument #2. #.Range[#2,1,-1]/#2 takes the dot product of the input list # and the the list Range[#2,1,-1] == {#2,#2-1,...,1}, then divides by the length #2. Then we return the Cases x_ in the input list # which are less than the hyper-average.

Without the length as a second argument, we need 6 more bytes:

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

K (oK), 26 bytes

Solution:

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

Try it online!

Examples:

> 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

Explanation:

Interpretted right-to-left. Struggled with a short way to extract prefixes:

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)

Notes:

Alternative version taking length of input as parameter (25 byte solution):

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

TI-Basic, 9 bytes

Ans*(Ans<mean(cumSum(Ans