Esta lista pode ser equilibrada?


23

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

alavanca da wikipedia (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 , 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ô?


O pivô pode ser colocado antes do primeiro número ou depois do último número?
Erik the Outgolfer

@EriktheOutgolfer Se todos os pesos não forem negativos, não.

Eu acho que isso pode ser um tolo. Ou ficou sentado na Sandbox por um tempo?
Shaggy

relacionados . (cc @Shaggy Talvez isso era o que você estava pensando)
Mr. Xcoder

2
@Giuseppe @Steadybox I addedYou can assume that the input list contains at least two elements and that at least one element is non-zero.
Laikoni

Respostas:


7

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.

Você pode usar yno lugar de*2
Sr. Xcoder

10 bytes:!%ys*VQUQs
Erik the Outgolfer


4

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.

Parece falhar [1,1](deve ser verdade). Parece que a duplicação implícita não está realmente lá.
Zgarb

@Zgarb Fixed (?)
Mr. Xcoder

2

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


Será que este trabalho?
Leaky Nun

@LeakyNun Não tão certo, é por isso que eu usei LḶvez (embora iria ter sucesso para todos os casos de teste). EDIT: Oooh, agora que penso sobre isso de novo, parece tão ... ( b | a ⇔ b | a + b duh)
Erik the Outgolfer


2

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.





1

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!



1

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 「$_」)
}

1

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


Salve um byte com m* x*2 vUx. Isso me faz pensar se m* x*2pode ser reduzido ainda mais ...
ETHproductions

Obrigado, @ETHproductions; esse é outro novo truque que aprendi hoje.
Shaggy

Eu tenho isto, é só usar x*e verificar se ele é divisível por Ux*½:)
ETHproductions

Sim, acho que esse truque não está documentado em nenhum lugar ... Mas sempre que você usa um operador binário como uma função automática sem um segundo argumento, ele usa o índice por padrão (como se você fizesse XY{X*Y})
ETHproductions

Ah, agora, isso é simplesmente engenhoso, @ETHproductions. :)
Shaggy

1

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






0

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!


11
A menos que eu entenda este [ codegolf.meta.stackexchange.com/questions/2447/... você deve ser capaz de usar die(1)e die(0)e salvar 4 bytes utilizando o código de saída em vez de uma string impressa.
usar o seguinte comando

@manassehkatz Se você usar die sem aspas no tio.run, ele o tratará como um código de status (o que deveria) e não o colocará na seção Output. Então, acabei de adicionar aspas para impedir que as pessoas
façam nitpicking.


Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.