Definizione e regole

Un array golfy è un array di numeri interi, in cui ogni elemento è superiore o uguale alla media aritmetica di tutti gli elementi precedenti. Il tuo compito è determinare se un array di numeri interi positivi forniti come input è golfy oppure no.

• Non è necessario gestire l'elenco vuoto.

• Si applicano scappatoie predefinite .

• Si applicano i metodi di input e output standard .

• È possibile scegliere due valori distinti non vuoti. Essi devono essere coerenti, e devono rispettare tutte le altre decisioni problematiche regole. Questo è code-golf , vince il codice più corto in ogni lingua!

Casi di prova ed esempio

Ad esempio il seguente array:

[1, 4, 3, 8, 6]

È una matrice golfistica, perché ogni termine è superiore alla media aritmetica di quelli che la precedono. Lavoriamo passo per passo:

Numero -> Elementi precedenti -> Media -> Segue la regola?

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

Tutti gli elementi rispettano la condizione, quindi questa è una matrice da golf. Nota che ai fini di questa sfida, assumeremo che la media di un elenco vuoto ( []) sia 0.

Altri casi di test:

Ingresso -> Uscita

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

Si noti che questo è Puzzle 1 da CodeGolf-Hackathon ed è disponibile anche sul Anarchy Golf (che si è rotto) - Condiviso da histocrat , ma io sono l'autore originale su entrambi i siti, e, quindi, ha permesso di ripubblicare qui.

Python 2 , 37 byte

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

Provalo online!

Uscite tramite codice di uscita: arresti anomali (codice di uscita 1) per array golfy, esce solo con il codice di uscita 0 per array non golfy. ovs e Jonathan Frech hanno salvato 3 byte.

Python 2 , 44 byte

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

Provalo online!

Una variante più tradizionale, che ritorna Trueper gli array da golf, altro False. Jonathan Frech ha salvato 2 byte.

Gelatina , 6 5 byte

<ÆmƤE

Provalo online!

Come funziona

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

Il codice funziona anche su valori negativi come [-3, -2]. Restituisce falseper un array golfy, trueper altri array. Modifica: salvato 1 byte grazie a @JustinMariner.

Wolfram Language (Mathematica) , 35 byte

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

Provalo online!

Uscite Falseper array da golf e Truenon.

MATL , 9 8 byte

tYstf/<a

Uscite 0per array da golf, 1altrimenti.

Provalo online!

Spiegazione

Considera l'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

Provalo online!

Modifica: -3 byte grazie a Zgarb!

Spiegazione

La precedente versione senza punti è equivalente al seguente programma:

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

Dato un ingresso s=[1,4,3,8,6], scanl1(+)scalcola le somme prefisso [1,5,8,16,22]e zipWith(*)[1..](tail s)lascia cadere il primo elemento e si moltiplica tutti gli altri elementi con loro indice: [4,6,24,24]. La lista è ora Golfy se coppie somme prefisso sono minore o uguale all'indice elementi volte, che può essere controllato da comprimendo entrambe le liste con (<=)e verificando che tutti i risultati sono Truecon and.

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

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

18 byte aggiuntivi per using System.Linq;

Provalo online!

APL (Dyalog) , 10 byte

Questa è una funzione anonimo prefisso tacito (chiamato treno monadico in termini APL).

∧/⊢≥+\÷⍳∘≢

Prova tutti i casi di test su TIO!

È

 ∧/ tutto vero

 ⊢ gli elementi

 ≥ sono maggiori o uguali a

 +\ le somme cumulative

 ÷ diviso per

  ⍳ gli interi da 1 a

  ∘ il

  ≢ numero di elementi

?

C (gcc) , 62 60 62 byte

• Rimosse due parentesi superflue.
• Aggiunti due byte per correggere la riusabilità della funzione ( b=).

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

Provalo online!

05AB1E , 5 byte

ηÅA÷W

Provalo online!

L'ampio aiuto di Dennis e Adnan è arrivato a questa versione ridotta. Inoltre è stato corretto un bug per renderlo possibile, grazie ancora ragazzi. Prendo poco credito per questa risposta.

05AB1E , 10 byte

ηεÅA}ü.S_P

Provalo online!

Long perché DgsO/è l'equivalente di "mean" in 05AB1E.

Apparentemente ÅAè media aritmetica.

APL (Dyalog) , 15 byte

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

Provalo online!

Come?

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

PowerShell , 60 byte

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

Provalo online!

Accetta input come array letterale (ad es. @(1, 4, 3, 8, 6)) In $a. Imposta la nostra $ovariabile di output come 1. Quindi passa attraverso $a. Ogni iterazione, stiamo (ab) usando il cast implicito di PowerShell per *=il risultato di un confronto booleano con il nostro $ooutput. Il valore booleano è se il valore corrente $_è più o -gmeno rispetto eai termini precedenti $a[0..$i++]sommati ( -join'+'|iex) divisi per quanti termini abbiamo già visto $i. Quindi, se un passo lungo la strada è falso, $overrà moltiplicato per 0. Altrimenti, rimarrà per 1tutto.

Quindi posizioniamo semplicemente $osulla pipeline e l'output è implicito. 1per la verità e 0per la falsità.

Perl 5, 27 +2 (-ap) byte

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

Provalo online

C # (.NET Core) , 74 byte

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

Provalo online!

Restituisce 0 per falso e 1 per vero.

3 byte più lunghi rispetto alla risposta del core delle crisalavature . Ma in totale alcuni byte sono più brevi perché la mia variante non ha bisogno di alcuna usingistruzione.

Cubix , 35 byte

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

Provalo online!

Non l'uso più efficiente dello spazio (6 no-op nel codice) Non produce output per un array golfy, 1per un array non golfy.

Si espande nel cubo seguente:

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

Spiegazione imminente, ma fondamentalmente porta qualcosa come la risposta MATL di Luis Mendo o la risposta Julia di Dennis .

Guarda correre!

Matlab e Octave, 41 36 byte

5 byte salvati grazie a Luis Mendo

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

Provalo online!

SQL (MySQL), 68 byte

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

Provalo online!

Restituisce 1 per gli array da golf e 0 in caso contrario. Riceve l'input da una tabella denominata , t. Per creare t, esegui:

CREATE TABLE t(i SERIAL,n INT)

e per caricare i valori:

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

Rubino , 30 byte

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

Provalo online!

Ispirato dalla risposta di Lynn . Lancia NoMethodErrorper golfy, ritorna nilaltrimenti.

Python 2 , 52 byte

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

Provalo online!

Python 2 , 50 48 44 42 byte

• Due byte salvati mediante allineamento e utilizzo and.
• Risparmio di due byte grazie a Mr. Xcoder concatenando l'incarico S=k=0.
• Salvato due byte usando ore il valore booleano del confronto come kvalore di incremento.
• Salvato due byte grazie agli ovs ; alzare a NameErrorusando una variabile non definita invece di a ZeroDivisionError.

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

Provalo online!

q / kdb + , 14 byte

Soluzione:

min x>=avgs x:

Esempi:

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

Spiegazione:

Abbastanza semplice con il avgsbuilt-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 byte

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

Restituisce falso o vero .

Provalo online!

R , 38 34 byte

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

Provalo online!

Aggiungi ++ , 54 byte

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

Provalo online!

Versione non originale, 30 byte

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

Provalo online!

Entrambi producono 1 per mazze da golf e 0 in caso contrario

Come funzionano

La prima versione è stata creata da me, senza controllare altre soluzioni. Il secondo è stato ispirato dal commento di Dennis , quindi ne sono meno contento.

La prima versione

$f$$A$$A$$B := [1, ... \vert{A}\vert]$$\vert{A}\vert$$A$dbLR$$[B, A]$$g$$A$$B$$B$$g$$g$

D,g,@@#,BFB

$2$#BF$A$$e \in x$$[...A, e]$$...$B$e$$A$

$g$$k$€gk$2${...}IKUYZgkluw

$g$$x$$A$$k$$k$

D,k,@,¦+AbL/

¦+AbL/$C$

$C$$A$$0$$0$$[0]$$C$0b]$$C^+$

$A$$A$ABcB]Bczip$C^+$

$p \in A, q \in C^+; p < q \equiv \neg(p \ge q)$$p, q$$0$$1$$0$ª!

La seconda versione

$24$$A$¬+$[A_0, A_0+A_1, A_0+A_1+A_2, ..., A_0+...+A_i]$J$B := [1 ... \vert{A}\vert]$$\vert{A}\vert$

$A$$B$BcB/$0$@0@B]$C^+$

$A$$C^+$

Pyth , 11 10 byte

-1 byte grazie a Mr. Xcoder

.A.egb.O<Q

Provalo online!

Java (OpenJDK 8) , 96 byte

So che non è un buon linguaggio per giocare a golf, ma ci ho ancora provato!

Input array come primo argomento di ints separati da virgola da testare.

Restituisce 1 per vero, 0 per falso.

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

Provalo online!

Java 7, 100 byte

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

Provalo online

Restituisce 0 per ungolfy e 1 per array golfy. Leggermente più lungo della risposta java 8.

PHP, 44 byte

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

accetta input dagli argomenti della riga di comando, esce con 0(ok) per un array golfy, con 1else.

Corri con -nro provalo online .

J, 19 byte

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

+/\ % #\medie dei prefissi: #\produce 1..n

}:0, aggiungi 0 all'inizio e rimuovi l'ultimo

[>: è l'elemento elenco originale per elemento> = nell'elenco spostato delle medie?

*/sono tutti gli elementi maggiori, ovvero l'elenco precedente è tutto 1s?

Provalo online!

AWK , 39 byte

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

Provalo online!

Si noti che il collegamento TIO ha 5 byte extra i=s=0per consentire l'immissione su più righe.

Japt , 10 byte

È arrivato con due soluzioni da 10 byte, non riesco a migliorarlo.

eȨU¯Y x÷Y

Provalo

Spiegazione

               :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

Alternativa

eÈ*°Y¨(T±X

Provalo

               :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