15

Nous définissons l' hyper-moyenne d'un tableau / liste (de nombres) la moyenne arithmétique des sommes de ses préfixes.

Par exemple, l'hyper-moyenne de la liste [1, 4, -3, 10]est calculée de la manière suivante:

Nous obtenons les préfixes: [1], [1, 4], [1, 4, -3], [1, 4, -3, 10].
Somme chaque: [1, 5, 2, 12].
Et maintenant obtenir la moyenne arithmétique des éléments dans cette liste: (1 + 5 + 2 + 12) / 4 = 5.

Un pseudo-élément d'un tableau est un élément dont la valeur est strictement inférieure à son hyper-moyenne. Par conséquent, les pseudo-éléments de notre liste d'exemples sont 1, 4et -3.

Étant donné une liste de nombres à virgule flottante, votre tâche consiste à renvoyer la liste des pseudo-éléments.

Vous n'avez pas à vous soucier des inexactitudes en virgule flottante.
La liste d'entrée ne sera jamais vide et peut contenir à la fois des entiers et des flottants. Si mentionné, les entiers peuvent être pris comme des flottants (avec <integer>.0)
Vous pouvez supposer que les chiffres correspondent à la langue de votre choix, mais n'en abusez pas.
Facultativement, vous pouvez également prendre la longueur du tableau en entrée.
Il s'agit de code-golf , donc les règles standard pour le tag s'appliquent. Le code le plus court en octets ( dans chaque langue ) gagne!

Cas de test

Entrée -> Sortie

[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 M. Xcoder
la source

Si certaines langues sont autorisées à prendre la longueur du tableau comme entrée supplémentaire, elle doit être autorisée pour toutes les langues .

ngenisis

1

@ngenisis C'est pour toutes les langues. Si la durée raccourcit également votre programme, n'hésitez pas à le faire. Cette spécification n'est pas du tout restrictive en termes de langue.

M. Xcoder

7

MATL , 8 octets

ttYsYm<)

Essayez-le en ligne! Ou vérifiez tous les cas de test .

Explication

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
la source

7

05AB1E , 9 8 octets

-1 octets grâce à Magic Octopus Urn

ηOO¹g/‹Ï

Essayez-le en ligne!

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

Utilisation de la nouvelle ÅAcommande.

ηOÅA‹Ï

Essayez-le en ligne!

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

Riley
la source

2

ηOO¹g/›Ïpour 8; ça commence aussi par nOO!.

Urne de poulpe magique du

5

Japt v2.0a0, 12 11 10 octets

f<Uå+ x÷Ul

Essaye-le

1 octet économisé grâce à ETH signalant un caractère redondant.

Explication

Entrée implicite du tableau U.

f<

Filter ( f) le tableau en vérifiant si chaque élément est inférieur à ...

Uå+

Ucumulativement réduit ( å) en additionnant ...

Avec le tableau résultant à son tour réduit par sommation ...

/Ul

Et divisé par la longueur ( l) de U.

Sortie implicite du tableau résultant.

Hirsute
la source

4

Python 3 avec Numpy , 48 octets

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

L'entrée et la sortie sont des tableaux Numpy. Essayez-le en ligne!

Luis Mendo
la source

1

+1 Enfin, quelqu'un utilise cumsum!

M. Xcoder

3

Gelée , 9 octets

+\S÷L<Ðf@

Essayez-le en ligne!

Leaky Nun
la source

Peut-être <Ðf@devrait - il plutôt l'être <Ðḟ@?

Erik the Outgolfer

@EriktheOutgolfer mais il passe tous les tests.

Leaky Nun

Encore quelque chose ne me semble pas bon ... +\S÷Lcalcule tout d'abord l'hyper-moyenne, puis le <Ðf@met comme argument de droite et <retournera 1si un élément est un pseudo-élément, filtrant essentiellement les pseudo-éléments au lieu de filtrer les sortir.

Erik the Outgolfer

@EriktheOutgolfer Dans ce contexte, filtrer signifie filtrer pour.

Leaky Nun

3

Python 2 , 78 76 71 66 octets

-7 octets grâce à M. Xcoder.

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

Essayez-le en ligne!

totalement humain
la source

Je pense que vous pouvez le faire range(len(l))et l[:i+1]pour -2 octets (non testé)

M. Xcoder

Golfé et obscurci. ;) Merci!

Totalement humain

Votre solution n'est cependant pas valide. Changement x>sum(...)de x<sum(...)pour être valable, encore 76 octets

M. Xcoder

Où ... Fixé. >.>

totalement humain

Je suis surpris que personne n'ait choisi la <s>68</s>solution évidente de 66 octets: P

M. Xcoder

3

Haskell, 39 octets

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

Essayez-le en ligne!

Malheureusement , lengthest de type Int, donc je ne peux pas l' utiliser avec la division à virgule flottante /et je dois utiliser une solution de contournement: sum(1<$l).

nimi
la source

3

Husk , 10 9 octets

Merci @Zgarb d'avoir joué 1 octet au golf!

f</L⁰Σ∫⁰⁰

Essayez-le en ligne!

Non golfé / Explication

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

ბიმო
la source

2

f</L⁰Σ∫⁰⁰est de 9 octets, mais trois arguments lambda semblent maladroits.

Zgarb

3

JavaScript (ES6), 56 55 52 octets

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

Essaye-le

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>

Développer l'extrait

Hirsute
la source

3

Java 8, 81 octets

Cette expression lambda accepte un List<Float>et le mute. L'itérateur de la liste d'entrée doit prendre en charge la suppression (c'est ArrayListle cas, par exemple). Attribuer à 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 non golfé

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

Essayez-le en ligne

Remerciements

-3 octets grâce à Kevin Cruijssen
-17 octets grâce à Nevay

Jakob
la source

1

Vous pouvez enregistrer 3 octets en supprimant t/=l;et en changeant if(n<t)pour if(n<t/l).

Kevin Cruijssen

1

Vous pouvez utiliser une liste au lieu d'un tableau pour pouvoir modifier l'argument fourni plutôt que d'imprimer les valeurs résultantes 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 octets).

Nevay

2

C # (Mono) , 95 octets

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

Essayez-le en ligne!

TheLethalCoder
la source

2

Python 3 , 72 octets

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

Essayez-le en ligne!

Halvard Hummel
la source

Solution très intelligente! Je n'ai jamais pensé filtergagner la compréhension habituelle des listes.

M. Xcoder

2

Python 3 , 76 octets

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

L'entrée et la sortie sont des listes de nombres. Essayez-le en ligne!

Cela fonctionne également en Python 2 (avec le remplacement évident de la printsyntaxe dans le pied de page).

Luis Mendo
la source

Devez-vous inverser la liste?

officialaimm

@officialaimm Je pense que oui, car les valeurs d'énumération 1,2,3, ... doivent aller avec x [0], x [-1], x [-2]. Mais dans tous les cas, le résultat semble être le même, hmm ...

Luis Mendo

1

J'ai trouvé un contre - exemple qui montre que l'inversion est en effet nécessaire

Luis Mendo

Ah, tant pis .. je le pensais juste parce qu'il a passé tous les cas de test ...: P

officialaimm

2

Perl 6 , 31 octets

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

Essayez-le en ligne!

Sean
la source

2

Pyth - 10 octets

<#.OsM._QQ

Essayez-le en ligne ici .

Maltysen
la source

1

Pyth, 12 11 octets

f<T.OsM._QQ

-1 octet merci à M. Xcoder

Essayez-le en ligne!

Dave
la source

11 octets:f<T.OsM._QQ

M. Xcoder

1

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

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

Essayez-le en ligne!

Xcali
la source

1

PHP, 84 octets

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

prend l'entrée des arguments de ligne de commande. Courez avec -nrou essayez-le en ligne .

résumer les listes partielles équivaut à résumer chaque élément multiplié par le nombre d'éléments suivants +1 → pas besoin de jongler avec des fonctions de tableau volumineuses. Mais c'est encore long.

Titus
la source

1

Röda , 46 41 39 octets

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

Essayez-le en ligne!

fergusq
la source

1

J, 15 octets

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

Essayez-le en ligne! Attend un tableau de style J (les négatifs représentés en utilisant _au lieu de- et les éléments séparés par des espaces - voir le lien TIO pour des exemples).

Je ne sais pas s'il existe un moyen de supprimer les parenthèses autour de la moyenne (+/%# ), mais la suppression de cela et la casquette serait la première chose que j'essaierais de faire pour jouer au golf plus loin.

Explication

Parfois, J lit comme (obscurci) l'anglais.

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

1

tu m'as battu 3 minutes :)

Jonah

12 octets avec#~]<1#.+/\%#

miles

@miles Sauf si vous pensez que c'est assez similaire, je pense que votre commentaire pourrait justifier sa propre réponse. EDIT: Je pense que c'est très intelligent moi-même.

cole

1

R , 31 octets

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

Essayez-le en ligne!

Giuseppe
la source

1

Mathematica, 35 octets

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

Functionqui attend une liste de nombres comme premier argument #et la longueur de la liste comme deuxième argument #2. #.Range[#2,1,-1]/#2prend le produit scalaire de la liste d'entrée #et la liste Range[#2,1,-1] == {#2,#2-1,...,1}, puis divise par la longueur #2. Ensuite, nous renvoyons les Cases x_dans la liste d'entrée #qui sont inférieurs à l'hyper-moyenne.

Sans la longueur comme deuxième argument, nous avons besoin de 6plus d'octets:

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

ngenisis
la source

0

K (oK) , 26 octets

Solution:

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

Essayez-le en ligne!

Exemples:

> 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

Explication:

Interprétée de droite à gauche. Lutté avec un moyen court d'extraire des préfixes:

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)

Remarques:

Version alternative prenant la longueur de l'entrée comme paramètre ( solution à 25 octets):

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

streetster
la source

0

TI-Basic, 9 octets

Ans*(Ans<mean(cumSum(Ans

Timtech
la source

Filtrez les pseudo-éléments!

Cas de test

Réponses:

MATL , 8 octets

Explication

05AB1E , 9 8 octets

05AB1E , 6 octets

Japt v2.0a0, 12 11 10 octets

Explication

Python 3 avec Numpy , 48 octets

Gelée , 9 octets

Python 2 , 78 76 71 66 octets

Haskell, 39 octets

Husk , 10 9 octets

Non golfé / Explication

JavaScript (ES6), 56 55 52 octets

Essaye-le

Java 8, 81 octets

Lambda non golfé

Remerciements

C # (Mono) , 95 octets

Python 3 , 72 octets

Python 3 , 76 octets

Perl 6 , 31 octets

Pyth - 10 octets

Pyth, 12 11 octets

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

PHP, 84 octets

Röda , 46 41 39 octets

J, 15 octets

Explication

R , 31 octets

Mathematica, 35 octets

K (oK) , 26 octets

TI-Basic, 9 octets