Definisi dan Aturan

Sebuah Array Golfy adalah sebuah array bilangan bulat, di mana setiap elemen adalah lebih besar atau sama dengan mean aritmetik dari semua elemen sebelumnya. Tugas Anda adalah menentukan apakah array bilangan bulat positif yang diberikan sebagai input golf atau tidak.

• Anda tidak perlu menangani daftar kosong.

• Celah default berlaku .

• Metode Input dan Output Standar berlaku .

• Anda dapat memilih dua nilai non-kosong yang berbeda. Mereka harus konsisten, dan harus mematuhi semua aturan masalah keputusan lainnya . Ini adalah kode-golf , kode terpendek dalam setiap bahasa yang menang!

Uji Kasus & Contoh

Misalnya array berikut:

[1, 4, 3, 8, 6]

Adalah array golf, karena setiap istilah lebih tinggi dari rata-rata aritmatika dari mereka yang mendahuluinya. Mari kita selesaikan langkah demi langkah:

Nomor -> Elemen sebelumnya -> Rata-rata -> Mengikuti aturan?

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

Semua elemen menghormati kondisi ini, jadi ini adalah array golf. Perhatikan bahwa untuk tujuan tantangan ini, kami akan menganggap bahwa rata-rata daftar kosong ( []) adalah 0.

Lebih banyak kasus uji:

Input -> Output

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

Perhatikan bahwa ini adalah Puzzle 1 dari CodeGolf-Hackathon dan juga diposting di Anarchy Golf (yang rusak) - Diposting ulang oleh histokrat , tetapi saya adalah penulis asli di kedua situs, dan dengan demikian diizinkan untuk memposting ulang di sini.

Python 2 , 37 byte

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

Cobalah online!

Output melalui kode keluar: crash (kode keluar 1) untuk array golf, hanya keluar dengan kode keluar 0 untuk array non-golf. ovs dan Jonathan Frech menyimpan 3 byte.

Python 2 , 44 byte

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

Cobalah online!

Varian yang lebih tradisional, yang kembali Trueuntuk array golf, selain itu False. Jonathan Frech menyimpan 2 byte.

Jelly , 6 5 byte

<ÆmƤE

Cobalah online!

Bagaimana itu bekerja

<Æ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.

JavaScript (ES6), 33 32 byte

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

Kode juga berfungsi pada nilai negatif seperti [-3, -2]. Pengembalian falseuntuk array golf, trueuntuk array lainnya. Sunting: Disimpan 1 byte berkat @JustinMariner.

Bahasa Wolfram (Mathematica) , 35 byte

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

Cobalah online!

Output Falseuntuk array golf dan Truesebaliknya.

MATL , 9 8 byte

tYstf/<a

Output 0untuk array golf, 1jika tidak.

Cobalah online!

Penjelasan

Pertimbangkan 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

Haskell , 53 50 48 byte

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

Cobalah online!

Edit: -3 byte terima kasih kepada Zgarb!

Penjelasan

Versi bebas poin di atas setara dengan program berikut:

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

Diberi masukan s=[1,4,3,8,6], scanl1(+)smenghitung jumlah awalan [1,5,8,16,22]dan zipWith(*)[1..](tail s)tetes elemen pertama dan mengalikan semua elemen lain dengan indeks mereka: [4,6,24,24]. Daftar sekarang Golfy jika berpasangan dengan jumlah awalan lebih kecil atau sama dengan indeks elemen kali, yang dapat diperiksa dengan zipping kedua daftar dengan (<=)dan memeriksa bahwa semua hasil adalah Truedengan and.

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

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

tambahan 18 byte untuk using System.Linq;

Cobalah online!

APL (Dyalog) , 10 byte

Ini adalah fungsi awalan diam-diam anonim (disebut kereta monadik dalam istilah APL).

∧/⊢≥+\÷⍳∘≢

Coba semua test case di TIO!

Apakah itu

 ∧/ itu benar

 ⊢ elemen-elemen

 ≥ lebih besar atau sama dengan

 +\ jumlah kumulatif

 ÷ dibagi dengan

  ⍳ bilangan bulat 1 sampai

  ∘ itu

  ≢ sejumlah elemen

?

C (gcc) , 62 60 62 byte

• Menghapus dua tanda kurung berlebihan.
• Menambahkan dua byte untuk memperbaiki usabilitas fungsi ( b=).

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

Cobalah online!

05AB1E , 5 byte

ηÅA÷W

Cobalah online!

Bantuan luas dari Dennis dan Adnan sampai ke versi yang dikurangi ini. Juga bug telah diperbaiki untuk memungkinkan ini, terima kasih sekali lagi kawan. Saya menerima sedikit pujian untuk jawaban ini.

05AB1E , 10 byte

ηεÅA}ü.S_P

Cobalah online!

Lama karena DgsO/ setara dengan "rata-rata" di 05AB1E.

Rupanya ÅAberarti aritmatika.

APL (Dyalog), 15 bytes

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

Try it online!

How?

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

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.

Perl 5, 27 +2 (-ap) bytes

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

Try It Online

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.

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!

Matlab and Octave, 41 36 bytes

5 bytes saved thx to Luis Mendo

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

Try it online!

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

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.

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!

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

Julia 0.6, 29 bytes

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

Returns false or true.

Try it online!

R, 38 34 bytes

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

Try it online!

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

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.

Pyth, 11 10 bytes

-1 byte thanks to Mr. Xcoder

.A.egb.O<Q

Try it online!

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!

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.

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.

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!

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.

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