Để kiểm tra xem danh sách các số nguyên không âm có được cân bằng hay không , người ta có thể tưởng tượng việc đặt các trọng số tương ứng lên một bảng và sau đó thử cân bằng bảng trên một trục sao cho các trọng số tương đối được tóm tắt bên trái và bên phải của trục đều giống nhau. Trọng lượng tương đối được cho bằng cách nhân trọng lượng với khoảng cách của nó với trục (xem luật của đòn bẩy ).

^{(Nguồn: wikipedia )}

Hình ảnh này tương ứng với một danh sách [100, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5]. Danh sách này được cân bằng vì 5có khoảng cách từ 20 đến trục, 100khoảng cách là 1 và 5*20 = 100 = 100*1.

Ví dụ

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

Trong trường hợp này pivot là trực thuộc 5, các 3có khoảng cách 2 và 1và 7có khoảng cách 1. Vì vậy, cả hai bên trái và phải của tổng trục lên đến 7( 3*2 + 1*1ở bên trái và 7*1bên phải) và do đó danh sách [3, 1, 5, 7]được cân bằng.

Tuy nhiên, lưu ý rằng trục không phải được đặt dưới một trong các thành phần danh sách, nhưng cũng có thể được đặt ở giữa hai thành phần danh sách:

 6 3 1
#######
  ^

Trong trường hợp này khoảng cách trở thành 0.5, 1.5, 2.5, ...và như vậy. Danh sách này cũng được cân bằng vì 6*0.5 = 3 = 3*0.5 + 1*1.5.

Trục chỉ có thể được đặt chính xác dưới một số hoặc chính xác ở giữa giữa hai số, và không, ví dụ như ở hai phần ba giữa hai số.

Bài tập

Đưa ra một danh sách các số nguyên không âm ở bất kỳ định dạng hợp lý nào, xuất ra một truthygiá trị nếu danh sách có thể được cân bằng và một falsygiá trị khác.

Bạn có thể giả sử rằng danh sách đầu vào chứa ít nhất hai phần tử và ít nhất một phần tử khác không.

Đây là một thử thách golf-code , vì vậy câu trả lời với số lượng byte ít nhất trong mỗi ngôn ngữ sẽ thắng.

Thử nghiệm chân lý

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

Thử nghiệm giả

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

_{Rất nhiều thử thách liên quan được tìm thấy trong khi thử thách này được đóng hộp cát : Đó có phải là một con số cân bằng? , Chỉ số cân bằng của một chuỗi , Cân bằng một tập các trọng số trên một trò chơi bập bênh , Cân bằng các từ , tôi sẽ lật lại chứ? và trục thuộc về đâu?}

Bình thường, 12 10 byte

!%ys*VQUQs

Dùng thử trực tuyến

Đã lưu 2 byte nhờ Mr. Xcoder và Erik the Outgolfer.

Giải trình

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

Ngôn ngữ Wolfram (Mathicala) , 36 byte

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

Đây là một trung tâm của vấn đề khối lượng trong một hệ tọa độ có gốc tọa độ tại một trong các điểm và sau đó bạn xác định xem CM có rơi vào điểm mạng trong đó chiều rộng của mạng = 1/2 hay không.

Hãy thử trực tuyến!

05AB1E , 6 byte

ƶO·IOÖ

Hãy thử trực tuyến!

Làm sao?

ƶO · IOÖ ~ Chương trình đầy đủ. I = đầu vào.

ƶ ~ Nâng I. Nhân từng phần tử với chỉ số dựa trên 1 của nó.
 Ô ~ Tổng.
  · ~ Đôi. 
     Ö ~ Là bội số của?
   IO ~ Tổng của tôi

Thạch , 6 byte

×JSḤọS

Hãy thử trực tuyến!

Chà, có vẻ như Leaky Nun đã chỉ ra điều vô nghĩa.

Sử dụng phương pháp Pyth của Mnemonic.

Trả về một số nguyên dương (trung thực) hoặc bằng không (giả).

R , 34 byte

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

Hãy thử trực tuyến!

Đưa đầu vào như một vector. Cổng câu trả lời của mnemonic . Trả về một 1x1ma trận.

Japt , 10 byte

í* x*2 vUx

Hãy thử trực tuyến!

Giải trình:

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

Trả lại 1cho sự thật, 0cho giả.

Python 2 , 41 byte

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

Đầu ra là thông qua mã thoát, vì vậy 0 là trung thực và 1 là sai.

Hãy thử trực tuyến!

Julia , 31 tuổi 27 byte

4 byte được lưu nhờ @Dennis

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

Hãy thử trực tuyến!

Ruby , 47 byte

Đã lưu 2 byte nhờ Mr. Xcoder

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

Hãy thử trực tuyến!

C,  140  137 byte

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

Hãy thử trực tuyến!

Python 3 , 51 byte

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

Hãy thử trực tuyến!

Perl 6 , 23 byte

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

Kiểm tra nó

Sử dụng thuật toán từ các mục khác nhau.

Mở rộng:

{  # 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 byte

Ban đầu lấy cảm hứng từ giải pháp của Mnemonic

x* vUx*½

Thử nó

1 3 byte được lưu nhờ vào ETHproductions.

Giải trình

Đầu vào ngầm định của mảng U. Giảm bằng phép cộng ( x), nhân từng phần tử với chỉ số dựa trên 0 ( *) của nó trong quy trình. Kiểm tra xem kết quả có chia hết ( v) cho tổng của đầu vào ban đầu ( Ux) với mỗi phần tử được nhân với 0,5 ( *½) không.

C # , 71 byte

Chơi gôn

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

Bị đánh cắp

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

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

    return 2 * S % s < 1;
};

Mã đầy đủ

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

Phát hành

• v1.0 - 71 bytes- Giải pháp ban đầu.

Ghi chú

Tôi có thể có, hoặc có thể không, "ngang nhiên" mượn " giải pháp Dennis Python 2 ...

Haskell , 39 byte

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

Hãy thử trực tuyến!

APL (Dyalog) , 15 byte

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

Hãy thử trực tuyến!

Trông tôi rất vô dụng ...

Python 2 , 78 75 byte

cảm ơn ông Xcoder về -3 byte

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

Hãy thử trực tuyến!

Julia 0,6 , 25 byte

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

Hãy thử trực tuyến!

PHP , 139 128 byte

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

Hãy thử trực tuyến!

• -2 byte để xóa dấu ngoặc kép dienhờ manassehkatz
• -9 byte nhờ Học tiêu chuẩn cộng đồng

Swift , 76 byte

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

Hãy thử trực tuyến!

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

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

Hãy thử trực tuyến!