Definición y reglas

Una matriz de golf es una matriz de enteros, donde cada elemento es mayor o igual que la media aritmética de todos los elementos anteriores. Su tarea es determinar si un conjunto de enteros positivos dados como entrada es golfoso o no.

• No necesita manejar la lista vacía.

• Se aplican las lagunas predeterminadas .

• Se aplican los métodos estándar de entrada y salida .

• Puede elegir dos valores distintos no vacíos. Ellos deben ser consistentes, y deben cumplir con todas las demás decisiones problemáticas reglas. Este es el código de golf , ¡el código más corto en cada idioma gana!

Casos de prueba y ejemplo

Por ejemplo, la siguiente matriz:

[1, 4, 3, 8, 6]

Es una matriz de golf, porque cada término es más alto que la media aritmética de los anteriores. Vamos a resolverlo paso a paso:

Número -> Elementos anteriores -> Promedio -> ¿Sigue la regla?

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

Todos los elementos respetan la condición, por lo tanto, este es un conjunto de golf. Tenga en cuenta que para el propósito de este desafío, asumiremos que el promedio de una lista vacía ( []) es 0.

Más casos de prueba:

Entrada -> Salida

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

Tenga en cuenta que este es el Rompecabezas 1 de CodeGolf-Hackathon y también está publicado en Anarchy Golf (ese está roto) - Publicado por el histocrático , pero yo soy el autor original en ambos sitios, y por lo tanto se me permite volver a publicarlos aquí.

Python 2 , 37 bytes

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

Pruébalo en línea!

Salidas a través del código de salida: fallas (código de salida 1) para matrices de golf, solo sale con el código de salida 0 para matrices que no son de golf. ovs y Jonathan Frech guardaron 3 bytes.

Python 2 , 44 bytes

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

Pruébalo en línea!

Una variante más tradicional, que vuelve Truepara los arreglos de golf, de lo contrario False. Jonathan Frech ahorró 2 bytes.

Jalea , 6 5 bytes

<ÆmƤE

Pruébalo en línea!

Cómo 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)

El código también funciona en valores negativos como [-3, -2]. Devuelve falsepara una matriz de golf, truepara otras matrices. Editar: Guardado 1 byte gracias a @JustinMariner.

Wolfram Language (Mathematica) , 35 bytes

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

Pruébalo en línea!

Salidas Falsepara matrices de golf y Trueotros.

MATL , 9 8 bytes

tYstf/<a

Salidas 0para matrices de golf, de lo 1contrario.

Pruébalo en línea!

Explicación

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

Pruébalo en línea!

Editar: -3 bytes gracias a Zgarb!

Explicación

La versión sin puntos anterior es equivalente al siguiente programa:

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

Dada una entrada s=[1,4,3,8,6], scanl1(+)scalcula las cantidades de prefijo [1,5,8,16,22]y zipWith(*)[1..](tail s)gotas el primer elemento y se multiplica todos los otros elementos con su índice: [4,6,24,24]. La lista ahora es elegante si en pares las sumas de prefijos son más pequeñas o iguales al índice de tiempos de los elementos, lo que puede verificarse comprimiendo ambas listas con (<=)y verificando que todos los resultados estén Truecon and.

C # (compilador de 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 adicionales para using System.Linq;

Pruébalo en línea!

APL (Dyalog) , 10 bytes

Esta es una función de prefijo tácito anónimo (llamado un tren monádico en términos de APL).

∧/⊢≥+\÷⍳∘≢

¡Pruebe todos los casos de prueba en TIO!

Lo es

 ∧/ todo cierto que

 ⊢ los elementos

 ≥ son mayores o iguales que

 +\ las sumas acumulativas

 ÷ dividido por

  ⍳ los enteros 1 a

  ∘ el

  ≢ cantidad de elementos

?

C (gcc) , 62 60 62 bytes

• Se eliminaron dos paréntesis superfluos.
• Se agregaron dos bytes para arreglar la reutilización de la función ( b=).

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

Pruébalo en línea!

05AB1E , 5 bytes

ηÅA÷W

Pruébalo en línea!

La amplia ayuda de Dennis y Adnan llegó a esta versión reducida. También se corrigió un error para hacer esto posible, gracias nuevamente chicos. Tomo poco crédito por esta respuesta.

05AB1E , 10 bytes

ηεÅA}ü.S_P

Pruébalo en línea!

Largo porque DgsO/es el equivalente de "media" en 05AB1E.

Aparentemente ÅAes media aritmética.

APL (Dyalog) , 15 bytes

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

Pruébalo en línea!

¿Cómo?

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

Pruébalo en línea!

Toma la entrada como una matriz literal (por ejemplo, @(1, 4, 3, 8, 6)) en $a. Establece nuestra $ovariable de rendimiento para ser 1. Luego se repite $a. En cada iteración, estamos (ab) usando la conversión implícita de PowerShell al *=resultado de una comparación booleana contra nuestro $orendimiento. El booleana es si el valor actual $_es -greater-que-o- equal a los términos anteriores $a[0..$i++]sumados ( -join'+'|iex) dividido por el número de términos que ya hemos visto $i. Entonces, si cualquier paso en el camino es falso, entonces $ose multiplicará por 0. De lo contrario, permanecerá en 1todo momento.

Luego simplemente colocamos $oen la tubería y la salida está implícita. 1para la verdad y 0para falsey.

Perl 5, 27 +2 (-ap) bytes

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

Pruébalo en línea

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

Pruébalo en línea!

Devuelve 0 para falso y 1 para verdadero.

3 Bytes más largos que el núcleo de los crislovelatos responden . Pero en total, varios bytes más cortos porque mi variante no necesita ninguna usingdeclaración.

Cubix , 35 bytes

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

Pruébalo en línea!

No es el uso más eficiente del espacio (6 no-ops en el código) No produce salida para una matriz de golf, 1para una matriz que no sea de golf.

Se expande al siguiente cubo:

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

Explicación próxima, pero básicamente presenta algo como la respuesta MATL de Luis Mendo o la respuesta Julia de Dennis .

¡Míralo correr!

Matlab y Octave, 41 36 bytes

5 bytes guardados gracias a Luis Mendo

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

Pruébalo en línea!

SQL (MySQL), 68 bytes

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

Pruébalo en línea!

Devuelve 1 para matrices de golf y 0 en caso contrario. Toma de entrada de una tabla llamada , t. Para crear t, ejecute:

CREATE TABLE t(i SERIAL,n INT)

y para cargar los valores:

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

Rubí , 30 bytes.

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

Pruébalo en línea!

Inspirado por la respuesta de Lynn . Lanza NoMethodErrorpara golf, vuelve de lo nilcontrario.

Python 2 , 52 bytes

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

Pruébalo en línea!

Python 2 , 50 48 44 42 bytes

• Se guardaron dos bytes alineando y usando and.
• Ahorré dos bytes gracias al Sr. Xcoder al encadenar la asignación S=k=0.
• Se guardaron dos bytes usando ory el valor booleano de la comparación como kvalor de incremento.
• Guardado dos bytes gracias a los ovs ; elevar a NameErrormediante el uso de una variable indefinida en lugar de a ZeroDivisionError.

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

Pruébalo en línea!

q / kdb + , 14 bytes

Solución:

min x>=avgs x:

Ejemplos:

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

Explicación:

Bastante simple con el avgsincorporado:

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

Devuelve falso o verdadero .

Pruébalo en línea!

R , 38 34 bytes

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

Pruébalo en línea!

Agregar ++ , 54 bytes

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

Pruébalo en línea!

Versión no original, 30 bytes.

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

Pruébalo en línea!

Tanto la salida 1 para matrices de golf y 0 en caso contrario

Cómo trabajan ellos

La primera versión fue creada por mí, sin verificar ninguna otra solución. El segundo fue inspirado por el comentario de Dennis , así que estoy menos contento con él.

La primera versión

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

D,g,@@#,BFB

que es una función diádica (es decir, toma $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 segunda versión

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

-1 byte gracias al Sr. Xcoder

.A.egb.O<Q

Pruébalo en línea!

Java (OpenJDK 8) , 96 bytes

Sé que no es un buen lenguaje de golf, ¡pero aún así lo intenté!

Matriz de entrada como primer argumento de entradas separadas por comas para probar.

Devuelve 1 para verdadero, 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;}

Pruébalo en línea!

Java 7, 100 bytes

Golfizado:

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

Sin golf:

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

Pruébalo en línea

Devuelve 0 para ungolfy y 1 para matrices de golf. Ligeramente más largo que java 8 respuesta.

PHP, 44 bytes

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

toma la entrada de los argumentos de la línea de comando, sale con 0(ok) para una matriz de golf, con 1else.

Ejecutar -nro probarlo en línea .

J, 19 bytes

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

+/\ % #\promedios de los prefijos: #\produce 1..n

}:0, agregue 0 al principio y elimine el último

[>: ¿Es la lista original elemento por elemento> = a la lista desplazada de promedios?

*/¿son todos los elementos mayores, es decir, la lista anterior es todo 1s?

Pruébalo en línea!

AWK , 39 bytes

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

Pruébalo en línea!

Tenga en cuenta que el enlace TIO tiene 5 bytes adicionales i=s=0para permitir la entrada de varias líneas.

Japt , 10 bytes

Se le ocurrieron dos soluciones de 10 bytes, parece que no puede mejorar eso.

eȨU¯Y x÷Y

Intentalo

Explicación

               :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

Intentalo

               :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