เรากำหนดค่าเฉลี่ยสูงเกินไปของอาร์เรย์ / รายการ (ของตัวเลข) ค่าเฉลี่ยเลขคณิตของผลรวมของส่วนนำหน้า

ตัวอย่างเช่นไฮเปอร์เฉลี่ยของรายการ[1, 4, -3, 10]คำนวณในลักษณะต่อไปนี้:

• เราได้คำนำหน้า: [1], [1, 4], [1, 4, -3], [1, 4, -3, 10].

• รวมแต่ละ: [1, 5, 2, 12].

• (1 + 5 + 2 + 12) / 4 = 5และขณะนี้ได้รับค่าเฉลี่ยเลขคณิตขององค์ประกอบในรายการนี้:

หลอกองค์ประกอบของอาร์เรย์เป็นองค์ประกอบที่มีค่าอย่างเคร่งครัดต่ำกว่าของ Hyper-เฉลี่ย ดังนั้นหลอกองค์ประกอบของรายการตัวอย่างของเรามี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, 1,000] -> [-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 ไบต์ขอบคุณMagic Octopus Urn

η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 ไบต์ขอบคุณ Mr. Xcoder

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

ลองออนไลน์!

Haskell, 39 ไบต์

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

ลองออนไลน์!

แต่น่าเสียดายที่lengthเป็นประเภทIntดังนั้นฉันไม่สามารถใช้กับลอยส่วนจุดและฉันต้องใช้วิธีแก้ปัญหา:/sum(1<$l)

Husk , 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

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 ไบต์

การแสดงออกแลมบ์ดานี้ยอมรับ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 ไบต์ขอบคุณNevay

C # (Mono) , 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 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