Para verificar si una lista de enteros no negativos está equilibrada , uno puede imaginar poner los respectivos pesos en un tablero y luego tratar de equilibrar el tablero en un pivote de modo que los pesos relativos resumidos a la izquierda y a la derecha del pivote sean los mismos. El peso relativo se da multiplicando el peso con su distancia al pivote (vea la ley de la palanca ).

^{(Fuente: wikipedia )}

Esta imagen corresponde a una lista [100, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5]. Esta lista está equilibrada porque 5tiene una distancia de 20 al pivote, 100una distancia de 1 y 5*20 = 100 = 100*1.

Ejemplos

 3 1 5 7
#########
     ^

En este caso, el pivote está directamente debajo de 5, 3tiene la distancia 2 y el 1y 7tiene la distancia 1. Por lo tanto, ambos lados izquierdo y derecho del pivote se suman 7( 3*2 + 1*1a la izquierda y 7*1a la derecha) y, por lo tanto, la lista [3, 1, 5, 7]está equilibrada.

Sin embargo, tenga en cuenta que el pivote no tiene que colocarse debajo de uno de los elementos de la lista, sino que también puede ubicarse entre dos elementos de la lista:

 6 3 1
#######
  ^

En este caso las distancias se vuelven 0.5, 1.5, 2.5, ...y así sucesivamente. Esta lista también está equilibrada porque 6*0.5 = 3 = 3*0.5 + 1*1.5.

El pivote solo se puede colocar exactamente debajo de un número o exactamente en el medio entre dos números, y no, por ejemplo, en dos tercios entre dos números.

Tarea

Dada una lista de enteros no negativos en cualquier formato razonable, generar un truthyvalor si la lista se puede equilibrar y un falsyvalor de lo contrario.

Puede suponer que la lista de entrada contiene al menos dos elementos y que al menos un elemento no es cero.

Este es un desafío de código de golf , por lo que gana la respuesta con la menor cantidad de bytes en cada idioma.

Casos de prueba de la verdad

[1, 0]
[3, 1, 5, 7]
[6, 3, 1]
[100, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5]
[10, 4, 3, 0, 2, 0, 5]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
[7, 7, 7, 7]

Falsy Testcases

[1, 2]
[3, 6, 5, 1, 12]
[0, 0, 2, 0, 1, 0]
[1, 2, 3, 4, 5, 6, 7, 8, 9]
[6, 3, 2, 4, 0, 1, 2, 3]
[4, 0, 0, 2, 3, 5, 2, 0, 1, 2, 3, 0, 0, 1, 2, 4, 3, 1, 3, 0, 0, 2]
[100, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5]

_{Se encontraron muchos desafíos relacionados mientras este desafío estaba encerrado : ¿Es un número equilibrado? , Índice de equilibrio de una secuencia , Equilibrar un conjunto de pesas en un balancín , Equilibrar palabras , ¿Me volcaré? y ¿A dónde pertenece el pivote?}

Pyth, 12 10 bytes

!%ys*VQUQs

Pruébalo en línea

Ahorré 2 bytes gracias a Mr. Xcoder y Erik the Outgolfer.

Explicación

!%ys*VQUQs
    *VQUQ    Multiply each input by its index.
  ys         Take twice the sum (to handle half-integer positions).
!%       sQ  Check if that's a multiple of the total weight.

Wolfram Language (Mathematica) , 36 bytes

IntegerQ[2#.Range[t=Tr[1^#]]/(t-1)]&

Este es un problema de centro de masa en un sistema de coordenadas con el origen en uno de los puntos y luego determina si el CM cae en un punto de red donde el ancho de red = 1/2.

Pruébalo en línea!

05AB1E , 6 bytes

ƶO·IOÖ

Pruébalo en línea!

¿Cómo?

ƶO · IOÖ ~ Programa completo. I = entrada.

Lift ~ Elevación I. Multiplica cada elemento con su índice basado en 1.
 O ~ Sum.
  · ~ Doble. 
     Ö ~ ¿Es múltiplo de?
   IO ~ La suma de I.

Jalea , 6 bytes

×JSḤọS

Pruébalo en línea!

Bueno, parece que Leaky Nun señaló lo inútil.

Usando el enfoque Pyth de Mnemonic.

Devuelve un entero positivo (verdad) o cero (falso).

R , 34 bytes

function(n)!(n%*%seq(n)*2)%%sum(n)

Pruébalo en línea!

Toma la entrada como un vector. La respuesta mnemónica de Ports . Devuelve una 1x1matriz.

Japt , 10 bytes

í* x*2 vUx

Pruébalo en línea!

Explicación:

 í* x*2 vUx
U            // Implicit Input                 [3, 1, 5, 7]
 í           // Pair the input with its index  [[3,0],[1,1],[5,2],[7,3]]
  *          // Multiply each item             [0,1,10,21]
    x        // Sum                            32
     *2      // Double                         64
        v    // Divisible by:
         Ux  //   Sum of Input                 16
             // Explicit Output                1

Vuelve 1por la verdad, 0por la falsedad.

Python 2 , 41 bytes

S=s=0
for n in input():S-=s;s-=n
1>>2*S%s

La salida es a través del código de salida, por lo que 0 es verdadero y 1 es falso.

Pruébalo en línea!

Julia , 31 27 bytes

4 bytes guardados gracias a @Dennis

!n=2n[i=1:end]⋅i%sum(n)<1

Pruébalo en línea!

Ruby , 47 bytes

Guardado 2 bytes gracias al Sr. Xcoder

->k{(k.map.with_index{|x,i|x*i*2}.sum%k.sum)<1}

Pruébalo en línea!

C,  140  137 bytes

float l,r;i,j,t;f(L,n)int*L;{for(i=t=-1;++i<2*n;t*=l-r)for(l=r=j=0;j<n;++j)l+=j<i/2.?L[j]*(i/2.-j):0,r+=j>i/2.?L[j]*(j-i/2.):0;return!t;}

Pruébalo en línea!

Python 3 , 51 bytes

lambda k:sum(i*e*2for i,e in enumerate(k))%sum(k)<1

Pruébalo en línea!

Perl 6 , 23 bytes

{sum(1..*Z*$_)*2%%.sum}

Pruébalo

Utiliza el algoritmo de varias otras entradas.

Expandido:

{  # bare block lambda with implicit parameter ｢$_｣

    sum(

        1 .. *  # Range starting from 1

      Z*        # Zip using &infix:«*»

        $_      # the input

    ) * 2

  %%            # is divisible by

    .sum        # the sum of the input (implicit method call on ｢$_｣)
}

Japt, 11 10 8 bytes

Originalmente inspirado en la solución de Mnemonic

x* vUx*½

Intentalo

1 3 bytes guardados gracias a ETHproductions.

Explicación

Entrada implícita de la matriz U. Reduzca mediante la suma ( x), multiplicando cada elemento por su índice basado en 0 ( *) en el proceso. Verifique si el resultado es divisible ( v) por la suma de la entrada original ( Ux) con cada elemento multiplicado por 0.5 ( *½).

C # , 71 bytes

Golfed

a=>{int i,s,S=s=i=0;while(i<a.Length){S-=s;s-=a[i++];}return 2*S%s<1;};

Sin golf

a => {
    int
        i, s, S = s = i = 0;

    while( i < a.Length ) {
        S -= s;
        s -= a[ i++ ];
    }

    return 2 * S % s < 1;
};

Código completo

using System;

namespace Namespace {
    class Program {
        static void Main( String[] args ) {
            Func<Int32[], Boolean> f = a => {
                int
                    i, s, S = s = i = 0;

                while( i < a.Length ) {
                    S -= s;
                    s -= a[ i++ ];
                }

                return 2 * S % s < 1;
            };

            List<Int32[]>
                testCases = new List<Int32[]>() {
                    new Int32[] {1, 0},
                    new Int32[] {3, 1, 5, 7},
                    new Int32[] {6, 3, 1},
                    new Int32[] {100, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5},
                    new Int32[] {10, 4, 3, 0, 2, 0, 5},
                    new Int32[] {1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
                    new Int32[] {7, 7, 7, 7},

                    new Int32[] {1, 2},
                    new Int32[] {3, 6, 5, 1, 12},
                    new Int32[] {0, 0, 2, 0, 1, 0},
                    new Int32[] {1, 2, 3, 4, 5, 6, 7, 8, 9},
                    new Int32[] {6, 3, 2, 4, 0, 1, 2, 3},
                    new Int32[] {4, 0, 0, 2, 3, 5, 2, 0, 1, 2, 3, 0, 0, 1, 2, 4, 3, 1, 3, 0, 0, 2},
                    new Int32[] {100, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5},
                };

            foreach( Int32[] testCase in testCases ) {
                Console.WriteLine( $"{{ {String.Join(", ", testCase)} }}\n{f( testCase )}" );
            }

            Console.ReadLine();
        }
    }
}

Lanzamientos

• v1.0 - 71 bytes- Solución inicial.

Notas

Podría tener, o podría no haberlo hecho, "tomar prestada" descaradamente la solución de Dennis Python 2 ...

Haskell , 39 bytes

f l=2*sum(zipWith(*)l[0..])`mod`sum l<1

Pruébalo en línea!

APL (Dyalog) , 15 bytes

0≡+⌿|(+⌿+⍨×⍳∘≢)

Pruébalo en línea!

Me parece muy poco golfista ...

Pitón 2 , 78 75 bytes

gracias al Sr. Xcoder por -3 bytes

lambda l:0in[sum(v*(i-y*2)for y,v in enumerate(l))for i in range(len(l)*2)]

Pruébalo en línea!

Julia 0.6 , 25 bytes

~=sum
!x=~cumsum(2x)%~x<1

Pruébalo en línea!

PHP , 139 128 bytes

<?php $a=explode(',',fgets(STDIN));for($i=0;$i<count($a)-.5;$i+=.5){$z=0;foreach($a as $k=>$v)$z+=($k-$i)*$v;if($z==0)die(1);}?>

Pruébalo en línea!

• -2 bytes para eliminar comillas alrededor die gracias a manassehkatz
• -9 bytes gracias a Aprender el estándar de la comunidad

Swift , 76 bytes

{var i=0,t=0;print($0.reduce(0){$0+($1*i,t+=$1,i+=1).0}*2%t<1)}as([Int])->()

Pruébalo en línea!

Perl 5 , 55 + 1 ( a) = 56 bytes

$.=0;map$.+=$p++*$_,@F;$#F+($p=$i-=.5)&&$.&&redo;say!$.

Pruébalo en línea!