Am I a golfy array?

Question

Definition and Rules

A golfy array is an array of integers, where each element is higher than or equal to the arithmetic mean of all the previous elements. Your task is to determine whether an array of positive integers given as input is golfy or not.

• You do not need to handle the empty list.

• Default loopholes apply.

• Standard Input and Output methods apply.

• You can choose any two distinct non-empty values. They must be consistent, and must comply with all other decision-problem rules. This is code-golf, shortest code in each language wins!

Test Cases & Example

For example the following array:

[1, 4, 3, 8, 6]

Is a golfy array, because each term is higher than the arithmetic mean of those preceding it. Let's work it out step-by-step:

Number -> Preceding elements -> Average -> Follows the rule?

1      -> []                 -> 0.0     -> 1 ≥ 0.0   (True)
4      -> [1]                -> 1.0     -> 4 ≥ 1.0   (True)
3      -> [1, 4]             -> 2.5     -> 3 ≥ 2.5   (True)
8      -> [1, 4, 3]          -> 2.(6)   -> 8 ≥ 2.(6) (True)
6      -> [1, 4, 3, 8]       -> 4.0     -> 6 ≥ 4.0   (True)

All the elements respect the condition, thus this is a golfy array. Note that for the purpose of this challenge, we will assume that the average of an empty list ([]) is 0.

More test cases:

Input -> Output

[3]                 -> True
[2, 12]             -> True
[1, 4, 3, 8, 6]     -> True
[1, 2, 3, 4, 5]     -> True
[6, 6, 6, 6, 6]     -> True
[3, 2]              -> False
[4, 5, 6, 4]        -> False
[4, 2, 1, 5, 7]     -> False
[45, 45, 46, 43]    -> False
[32, 9, 15, 19, 10] -> False

---

Note that this is Puzzle 1 from CodeGolf-Hackathon and is also posted on Anarchy Golf (that one is broken) - Reposted by histocrat, but I am the original author on both sites, and thus allowed to repost them here.

Answer 1

Python 2, 37 bytes

def g(a):sum(a)>len(a)*a.pop()or g(a)

Try it online!

Outputs via exit code: crashes (exit code 1) for golfy arrays, just exits with exit code 0 for non-golfy arrays. ovs and Jonathan Frech saved 3 bytes.

Python 2, 44 bytes

f=lambda a:a and sum(a)<=len(a)*a.pop()*f(a)

Try it online!

A more traditional variant, which returns True for golfy arrays, else False. Jonathan Frech saved 2 bytes.

Answer 2

Jelly, 6 5 bytes

<ÆmƤE

Try it online!

How it works

<ÆmƤE  Main link. Argument: A (integer array)

 ÆmƤ   Compute the arithmetic means (Æm) of all prefixes (Ƥ) of A.
<      Perform element-wise comparison. Note that the leftmost comparison always
       yields 0, as n is equal to the arithmetic mean of [n].
    E  Test if all elements of the resulting array are equal, which is true if and
       only if all comparisons yielded 0.

Answer 3

JavaScript (ES6), 33 32 bytes

a=>a.some(e=>e*++i<(s+=e),s=i=0)

Code also works on negative values such as[-3, -2]. Returns false for a golfy array, true for other arrays. Edit: Saved 1 byte thanks to @JustinMariner.

Answer 4

Wolfram Language (Mathematica), 35 bytes

Max[Accumulate@#-Range@Tr[1^#]#]>0&

Try it online!

Outputs False for golfy arrays and True otherwise.

Answer 5

MATL, 9 8 bytes

tYstf/<a

Outputs 0 for golfy arrays, 1 otherwise.

Try it online!

Explanation

Consider input [1, 4, 3, 8, 6].

t    % Implicit input. Duplicate
     % STACK: [1, 4, 3, 8, 6], [1, 4, 3, 8, 6]
Ys   % Cumulative sum
     % STACK: [1, 4, 3, 8, 6], [1, 5, 8, 16, 22]
t    % Duplicate
     % STACK: [1, 4, 3, 8, 6], [1, 5, 8, 16, 22], [1, 5, 8, 16, 22]
f    % Find: indices of nonzeros. Gives [1, 2, ..., n], where n is input size
     % STACK: [1, 4, 3, 8, 6], [1, 5, 8, 16, 22], [1, 2, 3, 4, 5]
/    % Divide, element-wise
     % STACK: [1, 4, 3, 8, 6], [1, 2.5, 2.6667, 4, 4.4]
<    % Less than?, element-wise
     % STACK: [0, 0, 0, 0, 0]
a    % Any: true if and only there is some nonzero. Implicit display
     % STACK: 0

Answer 6

Haskell, 53 50 48 bytes

and.(z(<=).scanl1(+)<*>z(*)[1..].tail)
z=zipWith

Try it online!

Edit: -3 bytes thanks to Zgarb!

Explanation

The above point-free version is equivalent to the following program:

f s = and $ zipWith(<=) (scanl1(+)s) (zipWith(*)[1..](tail s))

Given an input s=[1,4,3,8,6], scanl1(+)s computes the prefix sums [1,5,8,16,22] and zipWith(*)[1..](tail s) drops the first element and multiplies all other elements with their index: [4,6,24,24]. The list is now golfy if pairwise the prefix sums are smaller or equal to the elements times index, which can be checked by zipping both lists with (<=) and checking that all results are True with and.

Answer 7

C# (Visual C# Compiler), 71 + 18 = 89 bytes

x=>x.Select((n,i)=>new{n,i}).Skip(1).All(y=>x.Take(y.i).Average()<=y.n)

additional 18 bytes for using System.Linq;

Try it online!

Answer 8

C (gcc), 62 60 62 bytes

• Removed two superfluous parentheses.
• Added two bytes to fix function's reusability (b=).

f(A,S,k,b)int*A;{for(S=k=b=0;*A;S+=*A++)b+=!(S<=*A*k++);b=!b;}

Try it online!

Answer 9

05AB1E, 5 bytes

ηÅA÷W

Try it online!

Extensive help from Dennis and Adnan got to this reduced version. Also a bug was fixed to make this possible, thanks again you guys. I take little credit for this answer.

---

05AB1E, 10 bytes

ηεÅA}ü.S_P

Try it online!

---

Long because DgsO/ is the equivalent of "mean" in 05AB1E.

Apparently ÅA is arithmetic mean.

Answer 10

APL (Dyalog), 10 bytes

This is an anonymous tacit prefix function (called a monadic train in APL terms).

∧/⊢≥+\÷⍳∘≢

Try all the test cases on TIO!

Is it

 ∧/ all-true that

 ⊢ the elements

 ≥ are greater than or equal to

 +\ the cumulative sums

 ÷ divided by

  ⍳ the integers 1 through

  ∘ the

  ≢ number of elements

?

Answer 11

APL (Dyalog), 15 bytes

∧/⊢≥((+/÷≢)¨,\)

Try it online!

How?

            ,\  all prefixes
           ¨    for each
      +/÷≢      calculate arithmetic mean
  ⊢≥            element wise comparison
∧/              logically and the result

Answer 12

PowerShell, 60 bytes

param($a)$o=1;$a|%{$o*=$_-ge($a[0..$i++]-join'+'|iex)/$i};$o

Try it online!

Takes input as a literal array (e.g., @(1, 4, 3, 8, 6)) into $a. Sets our $output variable to be 1. Then loops through $a. Each iteration, we're (ab)using PowerShell's implicit casting to *= the result of a Boolean comparison against our $output. The Boolean is whether the current value $_ is -greater-than-or-equal to the previous terms $a[0..$i++] added together (-join'+'|iex) divided by how many terms we've already seen $i. So, if any step along the way is false, then $o will get multiplied by 0. Otherwise, it will remain 1 throughout.

We then simply place $o onto the pipeline and output is implicit. 1 for truthy and 0 for falsey.

Answer 13

Perl 5, 27 +2 (-ap) bytes

$_=!grep$_*++$n<($s+=$_),@F

Try It Online

Answer 14

Matlab and Octave, 41 36 bytes

5 bytes saved thx to Luis Mendo

all([a inf]>=[0 cumsum(a)./find(a)])

Try it online!

Answer 15

C# (.NET Core), 74 bytes

x=>{for(int i=1,s=0;i<x.Count;)if(x[i]<(s+=x[i-1])/i++)return 0;return 1;}

Try it online!

Returns 0 for false and 1 for true.

3 Bytes longer than core of chryslovelaces answer. But in total several Bytes shorter because my variant doesn't need any using statements.

Answer 16

Cubix, 35 bytes

/I?/\+psu0^.\)*sqs;-\;;U;O1.....?@^

Try it online!

Not the most efficient use of space (6 no-ops in the code) Produces no output for a golfy array, 1 for a not-golfy array.

Expands to the following cube:

      / I ?
      / \ +
      p s u
0 ^ . \ ) * s q s ; - \
; ; U ; O 1 . . . . . ?
@ ^ . . . . . . . . . .
      . . .
      . . .
      . . .

Explanation forthcoming, but it basically ports something like Luis Mendo's MATL answer or Dennis' Julia answer.

Watch it run!

Answer 17

SQL (MySQL), 68 bytes

select min(n>=(select ifnull(avg(n),1)from t s where s.i<t.i))from t

Try it online!

Returns 1 for golfy arrays, and 0 otherwise. Takes input from a named table, t. In order to create t, run:

CREATE TABLE t(i SERIAL,n INT)

and to load the values:

truncate table t;insert into t(n)values(3),(2);

Answer 18

Python 2, 52 bytes

lambda A:all(k*j>=sum(A[:j])for j,k in enumerate(A))

Try it online!

Python 2, 50 48 44 42 bytes

• Saved two bytes by inlining and using and.
• Saved two bytes thanks to Mr. Xcoder by chaining assignment S=k=0.
• Saved two bytes by using or and the comparison's boolean value as k's increment value.
• Saved two bytes thanks to ovs; raising a NameError by using an undefined variable instead of a ZeroDivisionError.

S=k=0
for j in input():k+=S<=j*k or J;S+=j

Try it online!

Answer 19

Ruby, 30 bytes

->a{0until a.pop*a.size<a.sum}

Try it online!

Inspired by Lynn's answer. Throws NoMethodError for golfy, returns nil otherwise.

Answer 20

q/kdb+, 14 bytes

Solution:

min x>=avgs x:

Examples:

q)min x>=avgs x:1 4 3 8 6
1b                           / truthy
q)min x>=avgs x:4 2 1 5 7
0b                           / falsey

Explanation:

Fairly simple with the avgs built-in:

min x>=avgs x: / solution
            x: / store input in variable x
       avgs    / calculate running averages
    x>=        / array comparison, x greater than running average
min            / take minimum of list of booleans

Answer 21

Julia 0.6, 29 bytes

!x=any(find(x).*x.<cumsum(x))

Returns false or true.

Try it online!

Answer 22

Add++, 54 bytes

D,g,@@#,BFB
D,k,@,¦+AbL/
D,f,@,dbLR$€g€k0b]$+ABcB]£>ª!

Try it online!

Unoriginal version, 30 bytes

D,f,@,¬+AbLRBcB/@0@B]ABcB]£>ª!

Try it online!

Both output 1 for golfy arrays and 0 otherwise

How they work

The first version was created by me, without checking any other solutions. The second was inspired by Dennis' comment, so I'm less happy with it.

The first version

Here, we define our main function \$f\$ that computes the golfiness of our input array, \$A\$. First, we need to yield the suffixes of \$A\$, which is done by first generating the range \$B := [1, ... \vert{A}\vert]\$, where \$\vert{A}\vert\$ denotes the length of \$A\$. This is done with the code dbLR$, which leaves \$[B, A]\$ as the stack. We then iterate the dyadic function \$g\$ over these two lists. Being dyadic, the function binds its left argument as \$A\$ for each iterated element. It then iterates over the range \$B\$, which each element from \$B\$ being the right argument provided to \$g\$. \$g\$ is defined as

D,g,@@#,BFB

which is a dyadic function (i.e. takes \$2\$ arguments), and pushes its arguments to the stack in reversed order (#) before execution. BF then flattens the two arguments. We'll assume that the arguments are \$A\$ and \$e \in x\$. This leaves the stack as \$[...A, e]\$, where \$...\$ represents an array splat. Finally, B takes the first \$e\$ elements of \$A\$ and returns a list containing those elements.

Note : The function names \$g\$ and \$k\$ aren't chosen randomly. If the commands given to an operator (such as €) doesn't currently have a function (which g and k don't), then the named functions are searched for a matching function. This saves \$2\$ bytes, as normally the function would have to wrapped in {...} to be recognised as a user-defined function. At the time of writing, the currently unused single byte commands are I, K, U, Y, Z, g, k, l, u and w.

When \$g\$ is applied over the elements of a range \$x\$, this returns a list of prefixes for \$A\$. We then map our second helper function \$k\$ over each of these prefixes. \$k\$ is defined as

D,k,@,¦+AbL/

which is the standard implementation of the arithmetic mean. ¦+ calculates the sum of the argument, AbL calculates its length, then / divides the sum by the length. This calculates the arithmetic mean of each prefix, yielding a new array, \$C\$.

Unfortunately, \$C\$ contains the mean of \$A\$ as its final element, and does not include the mean of the empty list, \$0\$. Therefore, we would have to remove the final element, and prepend a \$0\$, but popping can be skipped, saving two bytes, for reasons explained in a second. Instead, we push \$[0]\$ underneath \$C\$ with 0b]$, then concatenate the two arrays forming a new array, \$C^+\$.

Now, we need to check each element as being less than its corresponding element in \$A\$. We push \$A\$ once again and zip the two arrays together with ABcB]. This is the reason we don't need to pop the final element: Bc is implemented with Python's zip function, which truncates the longer arrays to fit the length of the shortest array. Here, this removes the final element of \$C^+\$ when creating the pairs.

Finally, we starmap \$p \in A, q \in C^+; p < q \equiv \neg(p \ge q)\$ over each pair \$p, q\$ to obtain an array of all \$0\$s if the array is golfy, and array containing at least a single \$1\$ if otherwise. We then check that all elements are falsey i.e. are equal to \$0\$ with ª! and return that value.

The second version

This takes advantage of Dennis' approach to remove \$24\$ bytes, by eliminating the helper functions. Given our input array of \$A\$, we first compute the cumulative sums with ¬+, i.e the array created from \$[A_0, A_0+A_1, A_0+A_1+A_2, ..., A_0+...+A_i]\$. We then generate Jelly's equivalent of J (indicies), by calculating the range \$B := [1 ... \vert{A}\vert]\$ where \$\vert{A}\vert\$ once again means the length of the array.

Next, we divide each element in \$A\$ by the corresponding index in \$B\$ with BcB/ and prepend \$0\$ with @0@B]. This results in a new array, \$C^+\$, defined as

$$C^+ := [0, A_0, \frac{A_0+A_1}{2}, \frac{A_0+A_1+A_2}{3}, ..., \frac{A_0+...+A_i}{i+1}]$$

The final part is identical to the first version: we push and zip \$A\$ with \$C^+\$, then starmap inequality over each pair before asserting that all elements in the resulting array were falsy.

Answer 23

R, 38 34 bytes

function(x)any(cumsum(x)/seq(x)>x)

Try it online!

Answer 24

Pyth, 11 10 bytes

-1 byte thanks to Mr. Xcoder

.A.egb.O<Q

Try it online!

Answer 25

Java (OpenJDK 8), 96 bytes

I know it's not a good golfing language, but I still gave it a go!

Input array as first argument of comma separated ints to test.

Returns 1 for true, 0 for false.

a->{int i=1,j,r=1,s=0;for(;i<a.length;i++,s=0){for(j=0;j<i;s+=a[j++]);r=s/i>a[i]?0:r;}return r;}

Try it online!

Answer 26

Java 7, 100 bytes

Golfed:

int g(int[]a){int i=1,m=0,s=m,r=1;for(;i<a.length;){s+=a[i-1];m=s/i;r-=a[i++]<m&&r>0?1:0;}return r;}

Ungolfed:

int golfy(int[]a)
{
    int i = 1, m = 0, s = m, r = 1;
    for (; i < a.length;)
    {
        s += a[i-1];
        m = s / i;
        r -= a[i++] < m && r>0? 1 : 0;
    }
    return r;
}

Try it online

Returns 0 for ungolfy and 1 for golfy arrays. Slightly longer than java 8 answer.

Answer 27

PHP, 44 bytes

while($n=$argv[++$i])$n<($s+=$n)/$i&&die(1);

takes input from command line arguments, exits with 0 (ok) for a golfy array, with 1 else.

Run with -nr or try it online.

Answer 28

J, 19 bytes

[:*/[>:[:}:0,+/\%#\

+/\ % #\ averages of the prefixes: #\ produces 1..n

}:0, add 0 to the beginning and remove the last

[>: is the original list element by element >= to the shifted list of averages?

*/ are all the elements greater, ie, the previous list is all 1s?

Try it online!

Answer 29

AWK, 39 bytes

{for(;i++*$i>=s&&i<=NF;s+=$i);$0=i>NF}1

Try it online!

Note that the TIO link has 5 extra bytes i=s=0 to allow for multi-line input.

Answer 30

Japt, 10 bytes

Came up with two 10 byte solutions, can't seem to improve on that.

eȨU¯Y x÷Y

Try it

---

Explanation

               :Implicit input of array U
eÈ             :Is every element, at 0-based index Y
  ¨            :Greater than or equal to
   U¯Y         :U sliced from index 0 to index Y
        ÷Y     :Divide each element by Y
       x       :Reduce by addition

---

Alternative

eÈ*°Y¨(T±X

Try it

               :Implicit input of array U
eÈ             :Is every element X (at 0-based index Y)
  *°Y          :Multiplied by Y incremented by 1
     ¨         :Greater than or equal to
      (T±X     :T (initially 0) incremented by X

Answer 31

Kotlin, 51 bytes

foldIndexed(0,{i,s,e->if(s<0||s>e*i)-1 else s+e})>0

Try it online!

(69 bytes with entire declaration of extension function)

fun List<Int>.g()=foldIndexed(0,{i,s,e->if(s<0||s>e*i)-1 else s+e})>0