Bir dizinin / listenin hiper-ortalamasını (sayıların) öneklerinin toplamlarının aritmetik ortalamasını tanımlarız .

Örneğin, listenin hiper-ortalaması [1, 4, -3, 10]aşağıdaki şekilde hesaplanır:

• Biz önekleri olsun: [1], [1, 4], [1, 4, -3], [1, 4, -3, 10].

• Her Sum: [1, 5, 2, 12].

• Ve şimdi bu listede elemanların aritmetik ortalamasını almak: (1 + 5 + 2 + 12) / 4 = 5.

Bir dizinin sözde elemanı, değeri hiper-ortalamasından kesinlikle daha düşük olan bir öğedir . Bu nedenle, bizim örneğimizde listesinin sözde elemanları vardır 1, 4ve -3.

Kayan nokta sayılarının bir listesi verildiğinde, göreviniz sözde elemanlar listesini döndürmektir.

• Kayan nokta yanlışlıkları konusunda endişelenmenize gerek yok.

• Giriş listesi asla boş olmayacak ve hem tamsayı hem de kayan nokta içerebilir. Bahsedilirse, tamsayı şamandıra olarak (ile <integer>.0) alınabilir

• Sayıların tercih ettiğiniz dile uygun olduğunu varsayabilirsiniz, ancak lütfen bunu hiçbir şekilde kötüye kullanmayın.

• İsteğe bağlı olarak, dizinin uzunluğunu giriş olarak da alabilirsiniz.

• Bu kod golf , bu nedenle etiket için standart kurallar geçerlidir. Bayt cinsinden ( her dilde ) en kısa kod kazanır!

Test Durumları

Giriş -> Çıkış

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

ttYsYm<)

Çevrimiçi deneyin! Veya tüm test senaryolarını doğrulayın .

açıklama

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 bayt

Sihirli Ahtapot Urn sayesinde -1 bayt

ηOO¹g/‹Ï

Çevrimiçi deneyin!

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

Yeni ÅAkomutu kullanma .

ηOÅA‹Ï

Çevrimiçi deneyin!

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

f<Uå+ x÷Ul

Dene

• Fazlalık bir karaktere işaret eden ETH sayesinde 1 bayt kaydedildi .

açıklama

Örtülü dizi girişi U.

f<

fHer öğeden küçük olup olmadığını kontrol ederek diziye filtre uygulayın ( ).

Uå+

Uåtoplanarak toplu olarak azaltıldı ( ) ...

x

Sonuçta ortaya çıkan dizi de toplanarak azaltıldığında ...

/Ul

Ve uzunluğuna ( l) bölünür U.

Ortaya çıkan diziyi dolaylı olarak çıktılar.

Numpy ile Python 3 , 48 bayt

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

Giriş ve çıkış Numpy dizileridir. Çevrimiçi deneyin!

Jöle , 9 bayt

+\S÷L<Ðf@

Çevrimiçi deneyin!

Python 2 , 78 76 71 66 bayt

Bay Xcoder sayesinde -7 bayt.

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

Çevrimiçi deneyin!

Haskell, 39 bayt

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

Çevrimiçi deneyin!

Maalesef lengthtiptedir Intnoktanın bölünme kayan ile kullanamaması için, /ve ben bir çözüm kullanmak zorunda: sum(1<$l).

Kabuk , 10 9 bayt

1 bayt golf için @Zgarb teşekkürler!

f</L⁰Σ∫⁰⁰

Çevrimiçi deneyin!

Ungolfed / Açıklama

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

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

Dene

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 bayt

Bu lambda ifadesi List<Float>a'yı kabul eder ve değiştirir. Giriş listesinin yineleyicisi kaldırmayı desteklemelidir ( ArrayListörneğin, bunu yapar). Atayın 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);}

Ungolfed 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);
}

Çevrimiçi Deneyin

Teşekkür

• -3 bayt sayesinde Kevin Cruijssen
• Nevay sayesinde -17 bayt

C # (Mono) , 95 bayt

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

Çevrimiçi deneyin!

Python 3 , 72 bayt

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

Çevrimiçi deneyin!

Python 3 , 76 bayt

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

Girdi ve çıktı sayı listeleridir. Çevrimiçi deneyin!

Bu, Python 2'de de çalışır ( printaltbilgideki sözdiziminin açıkça değiştirilmesi ile ).

Perl 6 , 31 bayt

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

Çevrimiçi deneyin!

Pyth - 10 bayt

<#.OsM._QQ

Burada çevrimiçi deneyin .

Pyth, 12 11 bayt

f<T.OsM._QQ

Bay Xcoder sayesinde -1 bayt

Çevrimiçi deneyin!

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

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

Çevrimiçi deneyin!

PHP, 84 bayt

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

komut satırı bağımsız değişkenlerinden girdi alır. Birlikte çalışın-nr veya çevrimiçi deneyin .

kısmi listelerin toplanması, her bir elemanın aşağıdaki elemanların sayısıyla çarpılmasıyla aynıdır +1 → hantal dizi işlevleriyle dengelemeye gerek yoktur. Yine de uzun.

Röda , 46 41 39 bayt

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

Çevrimiçi deneyin!

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 bayt

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

Functionilk bağımsız değişken olarak bir sayı #listesi ve ikinci bağımsız değişken olarak listenin uzunluğunu bekler #2. #.Range[#2,1,-1]/#2giriş listesinin #ve listenin nokta ürününü alır Range[#2,1,-1] == {#2,#2-1,...,1}, sonra uzunluğa böler #2. Sonra Cases x_giriş listesinde #hiper-ortalamanın altında olanı döndürürüz .

İkinci bir argüman olarak uzunluk olmadan 6daha fazla bayta ihtiyacımız var :

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

K (ok) , 26 bayt

Çözüm:

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

Çevrimiçi deneyin!

Örnekler:

> 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

Açıklama:

Sağdan sola yorumlandı. Ön ekleri ayıklamak için kısa bir yolla mücadele etti:

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)

Notlar:

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