Definição e Regras

Uma matriz golfy é uma matriz de números inteiros, em que cada elemento é maior ou igual à média aritmética de todos os elementos anteriores. Sua tarefa é determinar se uma matriz de números inteiros positivos fornecida como entrada é de golfe ou não.

• Você não precisa lidar com a lista vazia.

• Aplicam-se brechas padrão .

• Aplicam-se os métodos padrão de entrada e saída .

• Você pode escolher dois valores distintos não vazios. Eles devem ser consistentes e devem obedecer a todas as outras regras de problemas de decisão . Este é o código-golfe , o código mais curto em cada idioma vence!

Casos de teste e exemplo

Por exemplo, a seguinte matriz:

[1, 4, 3, 8, 6]

É uma matriz de golfe, porque cada termo é maior que a média aritmética dos anteriores. Vamos trabalhar passo a passo:

Número -> Elementos precedentes -> Média -> Segue a regra?

1 -> [] -> 0,0 -> 1 ≥ 0,0 (Verdadeiro)
4 -> [1] -> 1,0 -> 4 ≥ 1,0 (Verdadeiro)
3 -> [1, 4] -> 2,5 -> 3 ≥ 2,5 (Verdadeiro)
8 -> [1, 4, 3] -> 2. (6) -> 8 ≥ 2. (6) (Verdadeiro)
6 -> [1, 4, 3, 8] -> 4,0 -> 6 ≥ 4,0 (Verdadeiro)

Todos os elementos respeitam a condição, portanto, esta é uma matriz de golfe. Observe que, para o propósito deste desafio, assumiremos que a média de uma lista vazia ( []) é 0.

Mais casos de teste:

Entrada -> Saída

[3] -> Verdadeiro
[2, 12] -> Verdadeiro
[1, 4, 3, 8, 6] -> Verdadeiro
[1, 2, 3, 4, 5] -> Verdadeiro
[6, 6, 6, 6, 6] -> Verdadeiro
[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

Observe que este é o quebra - cabeça 1 do CodeGolf-Hackathon e também é publicado no Anarchy Golf (que está quebrado) - Reeditado por histocrat , mas eu sou o autor original dos dois sites e, portanto, posso repassá- los aqui.

Python 2 , 37 bytes

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

Experimente online!

Saídas via código de saída: trava (código de saída 1) para matrizes de golfe, apenas sai com o código de saída 0 para matrizes que não são de golfe. ovs e Jonathan Frech salvou 3 bytes.

Python 2 , 44 bytes

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

Experimente online!

Uma variante mais tradicional, que retorna Truepara matrizes de golfe, além disso False. Jonathan Frech salvou 2 bytes.

Gelatina , 6 5 bytes

<ÆmƤE

Experimente online!

Como funciona

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

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

O código também funciona com valores negativos, como [-3, -2]. Retorna falsepara uma matriz de golfe, truepara outras matrizes. Edit: Salvo 1 byte graças a @JustinMariner.

Wolfram Language (Mathematica) , 35 bytes

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

Experimente online!

Saídas Falsepara matrizes de golfe e Trueoutros.

MATL , 9 8 bytes

tYstf/<a

Saídas 0para matrizes de golfe, 1caso contrário.

Experimente online!

Explicação

Considere entrada [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 bytes

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

Experimente online!

Edit: -3 bytes graças ao Zgarb!

Explicação

A versão sem pontos acima é equivalente ao seguinte programa:

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

Dada uma entrada s=[1,4,3,8,6], scanl1(+)scalcula as somas de prefixo [1,5,8,16,22]e zipWith(*)[1..](tail s)deixa cair o primeiro elemento e multiplica-se todos os outros elementos, com o seu índice de: [4,6,24,24]. A lista agora está ativa se, em pares, as somas do prefixo forem menores ou iguais ao índice de elementos e tempos, que pode ser verificado zipando ambas as listas (<=)e verificando se todos os resultados estão Truecom and.

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

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

18 bytes adicionais para using System.Linq;

Experimente online!

APL (Dyalog) , 10 bytes

Esta é uma função de prefixo tácito anônimo (chamado de trem monádico em termos de APL).

∧/⊢≥+\÷⍳∘≢

Experimente todos os casos de teste no TIO!

É isso

 ∧/ totalmente verdade que

 ⊢ os elementos

 ≥ são maiores ou iguais a

 +\ as somas acumuladas

 ÷ dividido por

  ⍳ os inteiros de 1 a

  ∘ a

  ≢ número de elementos

?

C (gcc) , 62 60 62 bytes

• Removidos dois parênteses supérfluos.
• Adicionado dois bytes para corrigir a reutilização da função ( b=).

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

Experimente online!

05AB1E , 5 bytes

ηÅA÷W

Experimente online!

A extensa ajuda de Dennis e Adnan chegou a esta versão reduzida. Também foi corrigido um erro para tornar isso possível, obrigado novamente a vocês. Tomo pouco crédito por esta resposta.

05AB1E , 10 bytes

ηεÅA}ü.S_P

Experimente online!

Longo porque DgsO/é o equivalente a "médio" em 05AB1E.

Aparentemente ÅAé a média aritmética.

APL (Dyalog) , 15 bytes

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

Experimente online!

Quão?

            ,\  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

Experimente online!

Leva a entrada como uma matriz literal (por exemplo, @(1, 4, 3, 8, 6)) para $a. Define nossa $ovariável utput como 1. Então faz um loop $a. A cada iteração, estamos (ab) usando a conversão implícita do PowerShell para *=o resultado de uma comparação booleana em relação à nossa $oprodução. O booleano é se o valor atual $_é igual -gou superior eaos termos anteriores $a[0..$i++]somados ( -join'+'|iex) dividido por quantos termos já vimos $i. Portanto, se qualquer passo no caminho for falso, ele $oserá multiplicado por 0. Caso contrário, ele permanecerá por 1toda parte.

Simplesmente colocamos $ono pipeline e a saída está implícita. 1por verdade e 0por falsey.

Perl 5, 27 +2 (-ap) bytes

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

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

Experimente online!

Retorna 0 para falso e 1 para verdadeiro.

Resposta de 3 bytes a mais do que o núcleo dos chryslovelaces . Mas, no total, vários bytes mais curtos porque minha variante não precisa de nenhuma instrução.using

Cubix , 35 bytes

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

Experimente online!

Não é o uso mais eficiente do espaço (6 não operações no código) Não produz saída para uma matriz de golfe, 1para uma matriz que não seja de golfe.

Expande para o seguinte cubo:

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

Explicação a seguir , mas basicamente contém algo como a resposta MATL de Luis Mendo ou a resposta Julia de Dennis .

Assista correr!

Matlab e Octave, 41 36 bytes

5 bytes salvos thx em Luis Mendo

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

Experimente online!

SQL (MySQL), 68 bytes

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

Experimente online!

Retorna 1 para matrizes de golfe e 0 caso contrário. Toma a entrada de uma tabela chamada , t. Para criar t, execute:

CREATE TABLE t(i SERIAL,n INT)

e para carregar os valores:

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

Ruby , 30 bytes

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

Experimente online!

Inspirado pela resposta de Lynn . Joga NoMethodErrorpara o golfe, retorna nilcaso contrário.

Python 2 , 52 bytes

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

Experimente online!

Python 2 , 50 48 44 42 bytes

• Salva dois bytes inlining e usando and.
• Economizou dois bytes graças ao Sr. Xcoder , encadeando a atribuição S=k=0.
• Salva dois bytes usando ore o valor booleano da comparação como kvalor de incremento.
• Economizou dois bytes graças ao ovs ; aumentando a NameErrorusando uma variável indefinida em vez de a ZeroDivisionError.

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

Experimente online!

q / kdb + , 14 bytes

Solução:

min x>=avgs x:

Exemplos:

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

Explicação:

Bastante simples com o 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 bytes

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

Retorna falso ou verdadeiro .

Experimente online!

R , 38 34 bytes

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

Experimente online!

Adicione ++ , 54 bytes

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

Experimente online!

Versão não original, 30 bytes

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

Experimente online!

A saída 1 para matrizes de golfe e 0 de outra forma

Como eles trabalham

A primeira versão foi criada por mim, sem verificar outras soluções. O segundo foi inspirado no comentário de Dennis , então estou menos feliz com isso.

A primeira versão

$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$ª!

A segunda versão

$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^+$

Pitão , 11 10 bytes

-1 byte graças ao Sr. Xcoder

.A.egb.O<Q

Experimente online!

Java (OpenJDK 8) , 96 bytes

Sei que não é uma boa linguagem para o golfe, mas ainda assim!

Matriz de entrada como primeiro argumento de ints separados por vírgula para testar.

Retorna 1 para verdadeiro, 0 para 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;}

Experimente online!

Java 7, 100 bytes

Golfe:

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

Experimente online

Retorna 0 para ungolfy e 1 para matrizes de golfe. Um pouco mais que a resposta java 8.

PHP, 44 bytes

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

recebe entrada dos argumentos da linha de comando, sai com 0(ok) para uma matriz de golfe, com 1mais.

Corra com -nrou experimente online .

J, 19 bytes

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

+/\ % #\médias dos prefixos: #\produz 1..n

}:0, adicione 0 ao começo e remova o último

[>: é o elemento da lista original por elemento> = para a lista deslocada de médias?

*/são todos os elementos de maior, ou seja, a lista anterior é todos os 1s?

Experimente online!

AWK , 39 bytes

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

Experimente online!

Observe que o link TIO possui 5 bytes extras i=s=0para permitir a entrada de várias linhas.

Japonês , 10 bytes

Chegou com duas soluções de 10 bytes, parece que não consegue melhorar isso.

eȨU¯Y x÷Y

Tente

Explicação

               :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

Alternativo

eÈ*°Y¨(T±X

Tente

               :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