Para verificar se uma lista de números inteiros não negativos é balanceada , pode-se imaginar colocando os respectivos pesos em uma placa e, em seguida, tente equilibrar a placa em um pivô de modo que os pesos relativos resumidos à esquerda e à direita do pivô sejam os mesmos. O peso relativo é dado multiplicando o peso pela sua distância do pivô (consulte a lei da alavanca ).

^{(Fonte: wikipedia )}

Esta imagem corresponde a uma lista [100, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5]. Essa lista é equilibrada porque 5tem uma distância de 20 em relação ao pivô, a 100distância de 1 e 5*20 = 100 = 100*1.

Exemplos

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

Neste caso, o pivô está diretamente sob a 5, a 3distância 2 tem eo 1e 7tem distância 1. Assim, ambos os lados esquerdo e direito da soma pivô até 7( 3*2 + 1*1à esquerda e 7*1à direita) e, portanto, a lista [3, 1, 5, 7]é equilibrado.

Observe, no entanto, que o pivô não precisa ser colocado em um dos elementos da lista, mas também pode ser colocado entre dois elementos da lista:

 6 3 1
#######
  ^

Nesse caso, as distâncias se tornam 0.5, 1.5, 2.5, ...e assim por diante. Esta lista também é equilibrada porque 6*0.5 = 3 = 3*0.5 + 1*1.5.

O pivô só pode ser colocado exatamente abaixo de um número ou exatamente no meio entre dois números, e não, por exemplo, em dois terços entre dois números.

Tarefa

Dada uma lista de números inteiros não negativos em qualquer formato razoável, insira um truthyvalor se a lista puder ser equilibrada e um falsyvalor caso contrário.

Você pode supor que a lista de entrada contenha pelo menos dois elementos e que pelo menos um elemento seja diferente de zero.

Esse é um desafio do código-golfe , portanto, a resposta com a menor quantidade de bytes em cada idioma vence.

Truthy Testcases

[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]

_{Muitos desafios relacionados foram encontrados enquanto o desafio estava na caixa de areia : é um número equilibrado? , Índice de equilíbrio de uma sequência , Equilibrar um conjunto de pesos em uma gangorra , Balanceamento de palavras , vou inclinar? e Onde pertence o pivô?}

Pitão, 12 10 bytes

!%ys*VQUQs

Experimente online

Economizou 2 bytes graças ao Sr. Xcoder e Erik, o Outgolfer.

Explicação

!%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 é um problema do centro de massa em um sistema de coordenadas com a origem em um dos pontos e, em seguida, você determina se o CM cai em um ponto de rede onde a largura da rede é = 1/2.

Experimente online!

05AB1E , 6 bytes

ƶO·IOÖ

Experimente online!

Quão?

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

Lift ~ Lift I. Multiplique cada elemento com seu índice baseado em 1.
 O ~ Sum.
  · ~ Duplo. 
     Ö ~ É um múltiplo de?
   IO ~ A soma de I.

Gelatina , 6 bytes

×JSḤọS

Experimente online!

Bem, parece que a Freira Furada apontou o sentido inútil.

Usando a abordagem Pyth de Mnemonic.

Retorna um número inteiro positivo (verdade) ou zero (falsidade).

R , 34 bytes

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

Experimente online!

Recebe entrada como um vetor. Portos resposta mnemônica . Retorna uma 1x1matriz.

Japonês , 10 bytes

í* x*2 vUx

Experimente online!

Explicação:

 í* 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

Retorna 1por verdade, 0por falsidade.

Python 2 , 41 bytes

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

A saída é via código de saída, então 0 é verdadeiro e 1 é falso.

Experimente online!

Julia , 31 27 bytes

4 bytes salvos graças a @Dennis

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

Experimente online!

Ruby , 47 bytes

Economizou 2 bytes graças ao Sr. Xcoder

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

Experimente online!

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

Experimente online!

Python 3 , 51 bytes

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

Experimente online!

Perl 6 , 23 bytes

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

Teste-o

Usa o algoritmo de várias outras 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 na solução da Mnemonic

x* vUx*½

Tente

1 3 bytes salvos graças ao ETHproductions.

Explicação

Entrada implícita da matriz U. Reduza pela adição ( x), multiplicando cada elemento pelo seu índice baseado em 0 ( *) no processo. Verifique se o resultado é divisível igualmente ( v) pela soma da entrada original ( Ux), com cada elemento sendo multiplicado por 0,5 ( *½).

C # , 71 bytes

Golfe

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

Ungolfed

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

Lançamentos

• v1.0 - 71 bytes- Solução inicial.

Notas

Eu poderia ter, ou não ter, flagrantemente "emprestado" a solução Dennis Python 2 ...

Haskell , 39 bytes

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

Experimente online!

APL (Dyalog) , 15 bytes

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

Experimente online!

Parece-me muito sem-graça ...

Python 2 , 78 75 bytes

graças ao 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)]

Experimente online!

Julia 0.6 , 25 bytes

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

Experimente online!

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

Experimente online!

• -2 bytes para remover aspas diegraças a manassehkatz
• -9 bytes graças a Aprender o padrão da comunidade

Rápido , 76 bytes

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

Experimente online!

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

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

Experimente online!