15

Wir definieren den Hyper-Durchschnitt eines Arrays / einer Liste (von Zahlen) als arithmetisches Mittel der Summen seiner Präfixe.

Beispielsweise wird der Hyper-Durchschnitt der Liste [1, 4, -3, 10]auf folgende Weise berechnet:

Wir bekommen die Präfixe: [1], [1, 4], [1, 4, -3], [1, 4, -3, 10].
Summieren jeder: [1, 5, 2, 12].
Und nun das arithmetische Mittel der Elemente in dieser Liste erhalten: (1 + 5 + 2 + 12) / 4 = 5.

Ein Pseudoelement eines Arrays ist ein Element, dessen Wert streng niedriger als sein Hypermittelwert ist. Daher sind die Pseudo-Elemente unserer Beispielliste 1, 4und -3.

Bei einer gegebenen Liste von Gleitkommazahlen besteht Ihre Aufgabe darin, die Liste der Pseudoelemente zurückzugeben.

Sie müssen sich keine Gedanken über Gleitkommaungenauigkeiten machen.
Die Eingabeliste ist niemals leer und kann sowohl Ganzzahlen als auch Gleitkommazahlen enthalten. Falls angegeben, können ganze Zahlen als floats (mit <integer>.0) genommen werden
Sie können davon ausgehen, dass die Zahlen zu Ihrer Sprache passen, aber bitte missbrauchen Sie diese in keiner Weise.
Optional können Sie auch die Länge des Arrays als Eingabe verwenden.
Dies ist Codegolf , daher gelten die Standardregeln für das Tag. Der kürzeste Code in Bytes ( in jeder Sprache ) gewinnt!

Testfälle

Eingabe -> Ausgabe

[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

— Mr. Xcoder
quelle

Wenn für einige Sprachen die Länge des Arrays als zusätzliche Eingabe zulässig ist , sollte dies für alle Sprachen zulässig sein .

— Genisis

1

@ngenisis Es ist für alle Sprachen. Wenn sich Ihre Sendung auch durch die Länge verkürzt, können Sie dies gerne tun. Diese Spezifikation ist überhaupt nicht sprachbeschränkt.

— Mr. Xcoder

7

MATL , 8 Bytes

ttYsYm<)

Probieren Sie es online! Oder überprüfen Sie alle Testfälle .

Erläuterung

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

— Luis Mendo
quelle

7

05AB1E , 9 8 Bytes

-1 Bytes dank Magic Octopus Urn

ηOO¹g/‹Ï

Probieren Sie es online!

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

Den neuen ÅABefehl verwenden.

ηOÅA‹Ï

Probieren Sie es online!

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

— Riley
quelle

2

ηOO¹g/›Ïfür 8; auch es fängt an mit nOO!.

— Magic Octopus Urn

5

Japt v2.0a0, 12 11 10 Bytes

f<Uå+ x÷Ul

Probier es aus

Dank ETH- Hinweis auf redundantes Zeichen 1 Byte gespart .

Erläuterung

Implizite Eingabe eines Arrays U.

f<

Filtern ( f) Sie das Array, indem Sie prüfen, ob jedes Element kleiner ist als ...

Uå+

Ukumulativ reduziert ( å) durch Summieren ...

Mit dem resultierenden Array wiederum reduziert durch Summieren ...

/Ul

Und geteilt durch die Länge ( l) von U.

Das resultierende Array implizit ausgeben.

— Zottelig
quelle

4

Python 3 mit Numpy , 48 Bytes

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

Eingabe und Ausgabe sind Numpy-Arrays. Probieren Sie es online!

— Luis Mendo
quelle

1

+1 Endlich nutzt jemand cumsum!

— Mr. Xcoder

3

Gelee , 9 Bytes

+\S÷L<Ðf@

Probieren Sie es online!

— Undichte Nonne
quelle

Vielleicht <Ðf@sollte es stattdessen sein <Ðḟ@?

— Erik der Outgolfer

@EriktheOutgolfer hat aber alle Testfälle bestanden.

— Undichte Nonne

Trotzdem scheint mir etwas nicht gut zu sein ... +\S÷LBerechnet zuerst den Hyper-Durchschnitt, <Ðf@setzt ihn dann als das richtige Argument und <gibt zurück, 1wenn ein Element ein Pseudo-Element ist, und filtert im Wesentlichen nach den Pseudo-Elementen, anstatt zu filtern die raus.

— Erik der Outgolfer

@EriktheOutgolfer Herausfiltern bedeutet in diesem Zusammenhang herausfiltern nach.

— Undichte Nonne

3

Python 2 , 78 76 71 66 Bytes

-7 Bytes dank Mr. Xcoder.

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

Probieren Sie es online!

— total menschlich
quelle

Ich denke, Sie können range(len(l))und l[:i+1]für -2 Bytes (nicht getestet)

— Herr Xcoder

Golfen und verschleiert. ;) Vielen Dank!

— Totalhuman

Ihre Lösung ist jedoch ungültig. Wechsel x>sum(...)zu x<sum(...)für sie gültig ist, noch 76 Bytes

— Herr Xcoder

Wherps ... behoben. >.>

— totalhuman

Ich bin überrascht, dass niemand die offensichtliche <s>68</s>66-Byte-Lösung gewählt hat: P

— Mr. Xcoder

3

Haskell, 39 Bytes

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

Probieren Sie es online!

Leider ist lengthvom Typ Int, so dass ich es nicht mit Gleitkomma - Division verwenden kann , /und ich habe eine Abhilfe verwenden: sum(1<$l).

— nimi
quelle

3

Schale , 10 9 Bytes

Vielen Dank an @Zgarb für das Golfen ab 1 Byte!

f</L⁰Σ∫⁰⁰

Probieren Sie es online!

Ungolfed / Erklärung

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

— ბიმო
quelle

2

f</L⁰Σ∫⁰⁰ist 9 Bytes, aber drei Lambda-Argumente fühlen sich klobig an.

— Zgarb

3

JavaScript (ES6), 56 55 52 Byte

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

Probier es aus

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>

Erweitern Sie das Snippet

— Zottelig
quelle

3

Java 8, 81 Bytes

Dieser Lambda-Ausdruck akzeptiert a List<Float>und mutiert es. Der Iterator der Eingabeliste muss das Entfernen unterstützen ( ArrayListz. B. 's). Zuweisen zu 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);
}

Probieren Sie es online

Danksagung

-3 Bytes dank Kevin Cruijssen
-17 Bytes dank Nevay

— Jakob
quelle

1

Sie können maximal 3 Bytes , indem speichern t/=l;und ändern if(n<t)zu if(n<t/l).

— Kevin Cruijssen

1

Sie können eine Liste anstelle eines Arrays verwenden, um das angegebene Argument zu ändern, anstatt die resultierenden Werte 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 Byte) zu drucken .

— Nevay

2

C # (Mono) , 95 Bytes

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

Probieren Sie es online!

— DerLethalCoder
quelle

2

Python 3 , 72 Bytes

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

Probieren Sie es online!

— Halvard Hummel
quelle

Sehr clevere Lösung! Ich hätte nie gedacht, filterdass ich das übliche Listenverständnis für mich gewinnen würde.

— Mr. Xcoder

2

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

Eingabe und Ausgabe sind Listen von Zahlen. Probieren Sie es online!

Dies funktioniert auch in Python 2 (mit dem offensichtlichen Ersatz für die printSyntax in der Fußzeile).

— Luis Mendo
quelle

Müssen Sie die Liste umkehren?

— offiziell

@officialaimm Ich denke schon, weil die Aufzählungswerte 1,2,3, ... mit x [0], x [-1], x [-2] gehen müssen. Aber in allen Fällen scheint das Ergebnis das gleiche zu sein, hmm ...

— Luis Mendo

1

Ich habe ein Gegenbeispiel gefunden, das zeigt, dass eine Umkehrung tatsächlich notwendig ist

— Luis Mendo

Ah, egal .. ich dachte nur so, weil es alle Testfälle bestanden hat ...: P

— offiziell

2

Perl 6 , 31 Bytes

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

Probieren Sie es online!

— Sean
quelle

2

Pyth - 10 Bytes

<#.OsM._QQ

Probieren Sie es hier online aus .

— Maltysen
quelle

1

Pyth, 12 11 Bytes

f<T.OsM._QQ

-1 Byte danke an Herrn Xcoder

Probieren Sie es online!

— Dave
quelle

11 Bytes:f<T.OsM._QQ

— Mr. Xcoder

1

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

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

Probieren Sie es online!

— Xcali
quelle

1

PHP, 84 Bytes

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

Nimmt Eingaben von Befehlszeilenargumenten entgegen. Laufen Sie mit -nroder versuchen Sie es online .

Das Aufsummieren der Teillisten ist dasselbe wie das Aufsummieren jedes Elements multipliziert mit der Anzahl der folgenden Elemente +1 → Keine Notwendigkeit, mit sperrigen Array-Funktionen zu jonglieren. Es ist aber immer noch lang.

— Titus
quelle

1

Röda , 46 41 39 Bytes

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

Probieren Sie es online!

— fergusq
quelle

1

J, 15 Bytes

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

Probieren Sie es online! Erwartet ein Array im J-Stil (Negative werden mit dargestellt_- werden durch Leerzeichen anstelle von Elementen dargestellt - Beispiele finden Sie unter dem TIO-Link).

Ich weiß nicht, ob es eine Möglichkeit gibt, die Klammern um den Mittelwert zu entfernen (+/%# ) zu entfernen, aber dies und die Kappe zu entfernen, wäre das erste, was ich versuchen würde, um so weiter Golf zu spielen.

Erläuterung

Manchmal liest J wie (verschleiertes) Englisch.

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

— cole
quelle

1

Du hast mich 3 Minuten geschlagen :)

— Jonah

12 Bytes mit#~]<1#.+/\%#

— Meilen

@miles Sofern Sie nicht der Meinung sind, dass es ähnlich genug ist, könnte Ihr Kommentar eine eigene Antwort rechtfertigen. EDIT: Ich finde es selbst sehr clever.

— Cole

1

R , 31 Bytes

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

Probieren Sie es online!

— Giuseppe
quelle

1

Mathematica, 35 Bytes

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

FunctionDies erwartet eine Liste von Zahlen als erstes Argument #und die Länge der Liste als zweites Argument #2. #.Range[#2,1,-1]/#2Nimmt das Skalarprodukt der Eingabeliste #und der Liste Range[#2,1,-1] == {#2,#2-1,...,1}und dividiert dann durch die Länge #2. Dann geben wir das Cases x_in der Eingabeliste zurück# die kleiner als der Hyper-Durchschnitt sind.

Ohne die Länge als zweites Argument benötigen wir 6mehr Bytes:

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

— Genisis
quelle

0

K (oK) , 26 Bytes

Lösung:

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

Probieren Sie es online!

Beispiele:

> 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

Erläuterung:

Von rechts nach links interpretiert. Kämpfte mit einem kurzen Weg, um Präfixe zu extrahieren:

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)

Anmerkungen:

Alternative Version, die die Länge der Eingabe als Parameter verwendet ( 25- Byte-Lösung):

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

— Streetster
quelle

0

TI-Basic, 9 Bytes

Ans*(Ans<mean(cumSum(Ans

— Timtech
quelle

Filtern Sie die Pseudoelemente heraus!

Testfälle

MATL , 8 Bytes

Erläuterung

05AB1E , 9 8 Bytes

05AB1E , 6 Bytes

Japt v2.0a0, 12 11 10 Bytes

Erläuterung

Python 3 mit Numpy , 48 Bytes

Gelee , 9 Bytes

Python 2 , 78 76 71 66 Bytes

Haskell, 39 Bytes

Schale , 10 9 Bytes

Ungolfed / Erklärung

JavaScript (ES6), 56 55 52 Byte

Probier es aus

Java 8, 81 Bytes

Ungolfed Lambda

Danksagung

C # (Mono) , 95 Bytes

Python 3 , 72 Bytes

Python 3 , 76 Bytes

Perl 6 , 31 Bytes

Pyth - 10 Bytes

Pyth, 12 11 Bytes

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

PHP, 84 Bytes

Röda , 46 41 39 Bytes

J, 15 Bytes

Erläuterung

R , 31 Bytes

Mathematica, 35 Bytes

K (oK) , 26 Bytes

TI-Basic, 9 Bytes