Aby sprawdzić, czy lista liczb całkowitych nieujemnych jest zrównoważona , można sobie wyobrazić umieszczenie odpowiednich wag na tablicy, a następnie spróbować zrównoważyć tablicę na osi obrotu, tak aby podsumowane względne wagi po lewej i prawej stronie osi były takie same. Względny ciężar jest podawany przez pomnożenie ciężaru przez jego odległość od osi obrotu (patrz prawo dźwigni ).

^{(Źródło: wikipedia )}

Ten obraz odpowiada liście [100, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5]. Ta lista jest zrównoważona, ponieważ 5ma odległość 20 do osi obrotu, 100odległość 1 i 5*20 = 100 = 100*1.

Przykłady

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

W tym przypadku punkt obrotu znajduje się bezpośrednio pod 5, 3ma odległość 2 i 1oraz 7odległość 1. Tak więc obie strony po lewej i prawej stronie osi obrotu sumują się do 7( 3*2 + 1*1po lewej i 7*1po prawej stronie), a zatem lista [3, 1, 5, 7]jest zrównoważona.

Należy jednak pamiętać, że oś przestawna nie musi być umieszczana pod jednym z elementów listy, ale może również znajdować się pomiędzy dwoma elementami listy:

 6 3 1
#######
  ^

W tym przypadku odległości stają się 0.5, 1.5, 2.5, ...i tak dalej. Ta lista jest również zrównoważona, ponieważ 6*0.5 = 3 = 3*0.5 + 1*1.5.

Oś może być umieszczona tylko dokładnie pod jedną liczbą lub dokładnie pośrodku między dwiema liczbami, a nie np. W dwóch trzecich między dwiema liczbami.

Zadanie

Biorąc pod uwagę listę liczb całkowitych nieujemnych w dowolnym rozsądnym formacie, wypisz truthywartość, jeśli listę można zrównoważyć, a falsywartość w przeciwnym razie.

Możesz założyć, że lista wejściowa zawiera co najmniej dwa elementy i że co najmniej jeden element jest różny od zera.

To jest golf golfowy wyzwanie dla , więc wygrywa odpowiedź z najmniejszą liczbą bajtów w każdym języku.

Prawdziwe przypadki testowe

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

_{Znaleziono wiele powiązanych wyzwań, podczas gdy to wyzwanie było piaskownicą : czy jest to liczba zrównoważona? , Indeks równowagi sekwencji , Równowaga zestawu wag na huśtawce , Równoważenie słów , Czy przewrócę się? i Gdzie należy czop?}

Pyth, 12 10 bajtów

!%ys*VQUQs

Wypróbuj online

Zaoszczędzono 2 bajty dzięki panu Xcoder i Erikowi Outgolfer.

Wyjaśnienie

!%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 bajtów

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

Jest to problem środka masy w układzie współrzędnych z punktem początkowym w jednym z punktów, a następnie określasz, czy CM spada na punkt sieci, gdzie szerokość sieci = 1/2.

Wypróbuj online!

05AB1E , 6 bajtów

ƶO·IOÖ

Wypróbuj online!

W jaki sposób?

ƶO · IOÖ ~ Pełny program. I = wejście.

Lift ~ Lift I. Pomnóż każdy element z jego indeksem 1.
 O ~ Sum.
  · ~ Podwójnie. 
     Ö ~ Czy wielokrotność?
   IO ~ Suma I.

Galaretka , 6 bajtów

×JSḤọS

Wypróbuj online!

Wygląda na to, że Dziurawa Zakonnica zwróciła uwagę na bezcelowość.

Korzystanie z metody Pyth firmy Mnemonic.

Zwraca dodatnią liczbę całkowitą (prawda) lub zero (fałsz).

R , 34 bajty

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

Wypróbuj online!

Pobiera dane wejściowe jako wektor. Porty pamięciowy na odpowiedź . Zwraca 1x1macierz.

Japt , 10 bajtów

í* x*2 vUx

Wypróbuj online!

Wyjaśnienie:

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

Zwraca 1za prawdę, 0za fałsz.

Python 2 , 41 bajtów

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

Wyjście odbywa się za pomocą kodu wyjścia, więc 0 to prawda, a 1 to fałsz.

Wypróbuj online!

Julia , 31 27 bajtów

4 bajty zapisane dzięki @Dennis

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

Wypróbuj online!

Ruby , 47 bajtów

Zaoszczędzono 2 bajty dzięki Mr. Xcoder

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

Wypróbuj online!

C,  140  137 bajtów

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

Wypróbuj online!

Python 3 , 51 bajtów

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

Wypróbuj online!

Perl 6 , 23 bajtów

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

Sprawdź to

Wykorzystuje algorytm z różnych innych pozycji.

Rozszerzony:

{  # 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 bajtów

Pierwotnie zainspirowany rozwiązaniem Mnemonica

x* vUx*½

Spróbuj

1 3 bajty zapisane dzięki ETHproductions.

Wyjaśnienie

Domniemane wejście tablicy U. Zmniejsz przez dodanie ( x), mnożenie każdego elementu przez jego indeks 0 ( *) w procesie. Sprawdź, czy wynik jest równomiernie podzielny ( v) przez sumę oryginalnego wejścia ( Ux), przy czym każdy element jest mnożony przez 0,5 ( *½).

C # , 71 bajtów

Grał w golfa

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

Bez golfa

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

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

    return 2 * S % s < 1;
};

Pełny kod

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

Prasowe

• v1.0 - 71 bytes- Wstępne rozwiązanie.

Notatki

Mogłem mieć, lub nie, rażąco „pożyczyłem” rozwiązanie Dennis Python 2 ...

Haskell , 39 bajtów

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

Wypróbuj online!

APL (Dyalog) , 15 bajtów

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

Wypróbuj online!

Wygląda mi bardzo niechlujnie ...

Python 2 , 78 75 bajtów

dzięki Mr. Xcoder za -3 bajty

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

Wypróbuj online!

Julia 0.6 , 25 bajtów

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

Wypróbuj online!

PHP , 139 128 bajtów

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

Wypróbuj online!

• -2 bajty do usuwania cudzysłowów die dzięki manassehkatz
• -9 bajtów dzięki nauce standardu społeczności

Szybki , 76 bajtów

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

Wypróbuj online!

Perl 5 , 55 + 1 ( a) = 56 bajtów

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

Wypróbuj online!