Đưa ra một danh sách không có số nguyên dương , công việc của bạn là xác định số lượng giá trị duy nhất của$(x, y, z, \dots)$$\pm x \pm y \pm z \pm \dots$

Ví dụ, hãy xem xét danh sách . Có tám cách có thể để tạo ra một khoản tiền:$(1, 2, 2)$

• $+ 1 + 2 + 2 \to +5$
• $+ 1 + 2 − 2 \to +1$
• $+ 1 − 2 + 2 \to +1$
• $+ 1 − 2 − 2 \to −3$
• $− 1 + 2 + 2 \to +3$
• $− 1 + 2 − 2 \to −1$
• $− 1 − 2 + 2 \to −1$
• $− 1 − 2 − 2 \to −5$

Có sáu khoản tiền duy nhất , vì vậy câu trả lời là .$\{5, -5, 1, -1, 3, -3\}$$6$

Các trường hợp thử nghiệm

[1, 2] => 4
[1, 2, 2] => 6
[s]*n => n+1
[1, 2, 27] => 8
[1, 2, 3, 4, 5, 6, 7] => 29
[3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5] => 45
[1, 7, 2, 8, 3, 1, 6, 8, 10, 9] => 56
[93, 28, 92, 100, 43, 66, 2, 98, 2, 52, 57, 75, 39, 77, 45, 15, 13, 82, 81, 20, 68, 14, 5, 3, 72, 56, 57, 1, 23, 25, 76, 59, 60, 71, 71, 24, 1, 3, 72, 84, 72, 28, 83, 62, 66, 45, 21, 28, 49, 57, 70, 3, 44, 47, 1, 54, 53, 56, 36, 20, 99, 9, 89, 74, 1, 14, 68, 47, 99, 61, 46, 26, 69, 21, 20, 82, 23, 39, 50, 58, 24, 22, 48, 32, 30, 11, 11, 48, 90, 44, 47, 90, 61, 86, 72, 20, 56, 6, 55, 59] => 4728

Giải pháp tham khảo (tối ưu hóa cho tốc độ và không kích thước).

Nếu bạn không thể xử lý trường hợp cuối cùng vì bạn sử dụng phương pháp vũ phu hoặc tương tự, thì tốt thôi.

Chấm điểm

Đây là môn đánh gôn , vì vậy giải pháp hợp lệ ngắn nhất (tính bằng byte) sẽ thắng.

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

Tr[1^Fold[#⋃+##&,{0},#]]&

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

Tìm số lượng tổng hoán đổi ký hiệu duy nhất tương đương với việc tìm số lượng tổng phụ duy nhất.

Một bằng chứng sẽ liên quan đến việc thêm tổng của đầu vào cho mỗi khoản tiền hoán đổi ký hiệu và chia cho hai. Sau đó, có một sự lựa chọn rõ ràng.

Giải trình

Fold[#⋃+##&,{0},#]

Lặp lại thông qua đầu vào, với giá trị ban đầu là {0}: lấy liên kết giữa <current value>và <current value> + input element(ánh xạ vào danh sách).

Tr[1^ ... ]

Phiên bản golf của Lengthchức năng.

Thạch , 6 byte

ŒPS€QL

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

Lý lịch

Đặt L là danh sách đầu vào và {P, N} một phân vùng thành các đại số đại số với các dấu hiệu tích cực và tiêu cực. Thông số thử thách yêu cầu tính s _{{P, N}} = sum (P) - sum (N) .

Tuy nhiên, vì sum (P) + sum (N) = sum (L) và sum (L) không phụ thuộc vào phân vùng, nên chúng tôi có s _{{P, N}} = sum (P) - sum (N) = sum ( P) - (tổng (L) - tổng (P)) = 2sum (P) - tổng (L) .

Do đó, mỗi giá trị duy nhất của tổng (P) tương ứng với một giá trị duy nhất của s _{{P, N}} .

Làm thế nào nó hoạt động

ŒPS€QL  Main link. Argument: A (array)

ŒP      Powerset; generate all subarrays of A.
  S€    Take the sum of each.
    Q   Unique; deduplicate the sums.
     L  Take the length.

MATL , 11 10 byte

nW:qBGY*un

Hãy thử trực tuyến! Đây là một câu trả lời Octave / MATLAB của Luis Mendo . Tôi vẫn đang cố gắng học MATL và tôi nghĩ rằng tôi sẽ đăng nó cùng với một lời giải thích, vì MATL là ngôn ngữ của tháng.

Giải trình:

Đây là phần đọc cho bất kỳ ai không quen thuộc với lập trình dựa trên ngăn xếp nói chung và MATL nói riêng.

Vectơ đầu vào được đặt ngầm trên ngăn xếp. Lưu ý rằng khi một thao tác được thực hiện trên một phần tử trong ngăn xếp, thì phần tử đó sẽ bị xóa khỏi ngăn xếp.

                % Stack:
                % [1, 2, 2]
n               % Counts the number of elements of the vector on the top of the stack.
                % Stack:
                % [3]
 W              % Raise 2^x, where x is the number above it in the stack
                % Stack:
                % [8]
  :             % Range from 1...x, where x is the number above it in the stack.                    % Stack:
                % [1, 2, 3, 4, 5, 6, 7, 8]
   q            % Decrement. Stack:
                % [0, 1, 2, 3, 4, 5, 6, 7]
    B           % Convert to binary. Stack:
                % [0,0,0; 0,0,1; 0,1,0; 0,1,1; 1,0,0; 1,0,1; 1,1,0; 1,1,1] 
     G          % Push input again. Stack:           
                % [0,0,0; 0,0,1; 0,1,0; 0,1,1; 1,0,0; 1,0,1; 1,1,0; 1,1,1], [1; 2; 2]
      Y*        % Matrix multiplication of the two elements on the stack.
                % Stack:
                % [0; 2; 2; 4; 1; 3; 3; 5]
        u       % Keep only unique elements. Stack:
                % [0; 2; 4; 1; 3; 5]
         n      % Number of elements in the vector. Stack:
                % [6]

Và sau đó nó xuất ra phần tử cuối cùng trên ngăn xếp.

Python 2 , 55 byte

s={0}
for n in input():s|={t+n for t in s}
print len(s)

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

Python 2 , 52 byte

k=1
for n in input():k|=k<<n
print bin(k).count('1')

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

Sử dụng biểu diễn nhị phân của một số để lưu trữ các tập hợp con có thể tiếp cận.

05AB1E , 4 byte

æOÙg

Sử dụng cách tiếp cận tương tự được sử dụng trong câu trả lời của Dennis 'Jelly .

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

Haskell, 46 byte

import Data.List
length.nub.map sum.mapM(:[0])

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

Thay vì tổng hợp các tập hợp con của danh sách đầu vào, chúng tôi thực hiện tất cả các kết hợp hoặc giữ một số hoặc thay thế nó bằng 0, ví dụ:

mapM(:[0])[1,2,3] -> [[1,2,3],[1,2,0],[1,0,3],[1,0,0],[0,2,3],[0,2,0],[0,0,3],[0,0,0]]

Đây là hai byte ngắn hơn subsequences.

R, 83 75 byte

-8 byte nhờ JayCe và Giuseppe

Tạo một ma trận gồm tất cả các kết hợp có thể có (1, -1) cho kích thước của vectơ đầu vào, nhân số này với vectơ gốc để lấy tổng. Sau đó, duy nhất và tìm độ dài của kết quả.

function(v)nrow(unique(t(t(expand.grid(rep(list(c(1,-1)),sum(v|1)))))%*%v))

phiên bản trước:

f=function(v)nrow(unique(as.matrix(expand.grid(rep(list(c(1,-1)),length(v))))%*%v))

Ungolfed với ý kiến:

f=function(vector){

  List=rep(list(c(1,-1)),length(vector))   ## Create a list with length(vector) elements, all (1,-1)

  Combinations=expand.grid(Length)    ## get all combinations of the elements of the list, e.g, 1,-1,1,1,-1,1

  Matrix=as.matrix(Combinations)   ## convert to matrix

  Results=Matrix%*%vector   ## multiply the matrix original vector to get a Nx1 matrix

  Unique_results=unique(Results)   ## unique the results

  nrow(Unique_results)   ## length = number of rows of unique values
  }

Octave / MATLAB, 45 41 40 byte

@(x)nnz(unique(dec2bin(0:2^nnz(x)-1)*x))

Đầu vào là một vectơ cột (sử dụng ;như dấu phân cách).

Các lỗi mã cho trường hợp thử nghiệm cuối cùng do hạn chế bộ nhớ.

Điều này sử dụng một ý tưởng từ câu trả lời của JungHwan Min (tập hợp con thay vì dấu hiệu xen kẽ) để lưu một vài byte.

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

Pari / GP , 39 byte

a->#[1|n<-Vec(prod(i=1,#a,1+x^a[i])),n]

$\prod_{i \in a}(1+x^i)$$a$

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

Python 3 , 61 byte

f=lambda a,s={0}:a and f(a[1:],s|{u+a[0]for u in s})or len(s)

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

Phương pháp đệ quy, theo dõi các tập hợp con duy nhất.

Điều thú vị là nhịp đập này vượt trội itertools:

76 byte

lambda a:len({*map(sum,product(*([0,x]for x in a)))})
from itertools import*

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

Bình thường , 5 byte

l{sMy

Sử dụng cách tiếp cận tương tự được sử dụng trong câu trả lời của Dennis 'Jelly .

Hãy thử nó ở đây.

Tùy viên , 29 byte

{#Unique[Flat!±_]}@Fold[`±]

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

Điều này hoạt động bằng cách gấp ±toán tử trên danh sách đầu vào, sau đó lấy ±danh sách đó, sau đó đếm các nguyên tử duy nhất của mảng.

Dưới đây là một số ví dụ về cách hoạt động của nếp gấp:

Fold[`±][ [1,2] ] == 1 ± 2
                  == [1 + 2, 1 - 2]
                  == [3, -1]
Fold[`±][ [1,2,2] ] == (1 ± 2) ± 2
                    == [3, -1] ± 2
                    == [[3 + 2, 3 - 2], [-1 + 2, -1 - 2]]
                    == [[5, 1], [1, -3]]
                    == [5, 1, 1, -3]
Fold[`±][ [4,4,4,4] ] == (4 ± 4) ± 4 ± 4
                      == [8, 0] ± 4 ± 4
                      == [[12, 4], [4, -4]] ± 4
                      == [[[16, 8], [8, 0]], [[8, 0], [0, -8]]]
                      == [16, 8, 8, 0, 8, 0, 0, -8]
                      == [16, 8, 0, -8]

Sau đó, chúng tôi tạo ra tất cả các hoán vị của dấu hiệu cuối cùng bằng cách áp dụng PlusMinus một lần nữa.

Phiên bản hiệu quả hơn, 31 byte

`#@(q:=Unique@Flat@`±)@Fold[q]

Hãy thử trực tuyến! Điều này không hết thời gian trong trường hợp thử nghiệm cuối cùng, vì nó không tạo ra các kết hợp không cần thiết.

R , 62 byte

function(V)sum(unique(c(V%*%combn(rep(0:1,L),L<-sum(V|1))))|1)

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

Thuật toán của cổng Dennis. Nó gần nhất với các câu trả lời Octave / MATL vì nó sử dụng một sản phẩm ma trận và bitmap tương tự để đưa vào / loại trừ các thuật ngữ.

APL (Dyalog cổ điển) , 12 11 byte

-1 cảm ơn H.PWiz

≢⊃(+∪⊢)/⎕,0

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

Perl 5 -p , 39 byte

s/^| /{+,-}/g;$_=grep!$s{eval$_}++,glob

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

JavaScript (ES6), 63 byte

f=([c,...a],s=n=!(o={}))=>c?f(a,s-c)|f(a,s+c)&&n:o[s]=o[s]||++n

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

Husk , 5 byte

LumΣṖ

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

Cảng Dennis 'Jelly trả lời.

Giải trình

LumΣṖ                     [1,2,2]
    Ṗ  Powerset           [[],[1],[2],[1,2],[2],[1,2],[2,2],[1,2,2]]
  mΣ   Sum each           [0,1,2,3,2,3,4,5]
 u     Remove duplicates  [0,1,2,3,4,5]
L      Length             6

Perl 6 , 33 byte

{+set ([X](^2 xx$_)XZ*$_,)>>.sum}

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

Tiện ích Bash + GNU, 49 byte

eval echo "{,-}${@//,/{+,-\}}\;"|bc|sort -u|wc -l

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

Đầu vào được đưa ra dưới dạng danh sách được phân tách bằng dấu phẩy tại dòng lệnh.

Giải trình

               ${@//,/{+,-\}}                      # Replace commas with {+,-}
          "{,-}${@//,/{+,-\}}\;"                   # Build a brace expansion with {+,-} before every number and ; at the end
eval echo "{,-}${@//,/{+,-\}}\;"                   # Expand to give every combination expression, separated by ;
                                |bc                # Arithmetically evaluate each line
                                   |sort -u        # Remove duplicates
                                            wc -l  # Count

x86_64 ngôn ngữ máy cho Linux, 31 29 byte

 0:   31 d2                   xor    %edx,%edx
 2:   6a 01                   pushq  $0x1
 4:   58                      pop    %rax
 5:   8b 0c 97                mov    (%rdi,%rdx,4),%ecx
 8:   48 89 c3                mov    %rax,%rbx
 b:   ff c2                   inc    %edx
 d:   48 d3 e3                shl    %cl,%rbx
10:   48 09 d8                or     %rbx,%rax
13:   39 d6                   cmp    %ese,%edx
15:   7c ee                   jle    5 <+0x5>
17:   f3 48 0f b8 c0          popcnt %rax,%rax
1c:   c3                      retq

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

Lấy cảm hứng từ câu trả lời của @ xnor. Yêu cầu một máy có POPCNThướng dẫn.

C (gcc) , 74 69 byte

f(a,b)int*a;{long k=1;for(;b--;k|=k<<a[b]);a=__builtin_popcountl(k);}

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

Cổng C của câu trả lời của @ xnor

APL (Dyalog Classic) , 34 33 32 byte

{≢∪⍵+.×⍨↑{,⍵∘.,U}⍣(≢1↓⍵)⊢U←¯1 1}

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

Cảm ơn @ngn cho -1 byte!

Sạch , 82 byte

import StdEnv
f[]=length
f[h:t]=f t o foldr(\e l=removeDup[e+h,e-h:l])[]
?l=f l[0]

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

Xác định hàm ? :: [Int] -> Intsử dụng f :: [Int] -> ([Int] -> Int)như một trình trợ giúp để giảm trên mỗi tổng có thể sau khi cộng hoặc trừ.

APL (Dyalog Classic) , 21 byte

⍴∘∪⊢+.×1-2×2(⍴⍨⊤∘⍳*)⍴

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

Giải trình

2(⍴⍨⊤∘⍳*)⍴

Một hàm đào tạo tương đương với {((⍴⍵)⍴2)⊤⍳(⍴⍵)}, tạo ra một ma trận có các biểu diễn nhị phân từ 0 đến độ dài của đầu vào dưới dạng các cột

1-2×

Bản đồ 1s đến -1s và 0s đến 1s

⊢+.×

Phép nhân ma trận với đầu vào, cung cấp một mảng của tất cả các khoản tiền có thể

⍴∘∪

Xóa các bản sao, sau đó đếm

Java 8, 207 83 44 byte

s->Long.bitCount(s.reduce(1L,(r,c)->r|r<<c))

Cổng câu trả lời Python 2 của @ xnor .
-39 byte nhờ @Jakob .

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

s->               // Method with Long-Stream parameter and long return-type
  Long.bitCount(  //  Return the amount of 1s in the binary representation of:
    s.reduce(1L,  //   Result-Long, starting at 1
     (r,c)->      //   Loop pair-wise (result,current):
      r|          //    Bitwise-OR the result `r` with:
        r<<c))    //    result `r` bitwise left-shifted by the current `c`

Java 8, 85 byte

Một cổng Java khác của câu trả lời của xnor . Giống như câu trả lời ban đầu, điều này sử dụng một bitmap có độ chính xác tùy ý để không có giới hạn trên đối với kích thước của một tập hợp con.

Đó là một lambda từ một chuỗi java.util.stream.Stream<Integer> đến int.

s->s.reduce(java.math.BigInteger.ONE,(a,e)->a.or(a.shiftLeft(e)),(u,v)->u).bitCount()

Dùng thử trực tuyến

Lưu ý rằng bộ kết hợp (đối số thứ ba đến reduce) không được sử dụng do luồng là tuần tự. Hàm tôi chọn là tùy ý.

Julia 0,6 , 54 52 byte

V->(~W=W==[]?0:∪([n=W[] -n].+~W[2:end]))(V)|>endof

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

( -2 byte bằng cách thay thế ¬bằng ~, nhờ Jo King )

Hoạt động cho tất cả các trường hợp thử nghiệm. Làm cho việc sử dụng phát sóng để thu thập tất cả các khoản tiền có thể, sau đó đếm chúng.

Giải trình:

function g_(V)
  function inner(W)  #named ~ in golf version to save bytes
    W == [] ? 0 :    #return 0 when input empty (base case)
    ∪(               #unique elements of
      [n=W[] -n]     #take the first element and its negation
      .+             #broadcast-add that to each element of
      inner([2:end]) #sign-swapping sums of the rest of the array
     )
  end                #returns the list of unique elements out of those sums
  return endof(inner(V)) #return the length of that list
end

Giải pháp cũ hơn:

Julia 0,6 , 64 byte

N->endof(∪([2(i&2^~-j>0)-1 for i=0:~-2^(l=endof(N)),j=1:l]*N))

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

Hoạt động cho các mảng đầu vào có độ dài lên tới 63 (vì vậy không hoạt động cho trường hợp thử nghiệm cuối cùng, điều này cũng ổn theo OP).

Giải trình:

function f_(N)
  endof(                            #length of
        ∪(                          #unique elements of
          [
           (i & 2^(j-1) > 0)        #check j'th bit (from right) of i
           * 2 - 1                  #convert bit value from (0,1)=>(-1,1)
           for i = 0:2^endof(N)-1,  #where i is numbers 0 to 2^length(N)-1
           j = 1:endof(N)           #and j is 1 to length(N) (i.e. the bits in i)
          ]                         #so we have a matrix [-1 -1 -1;1 -1 -1;1 -1 1;...]
          *                         #matrix multiply that with the input array, 
          N                         #thus calculating different combinations of 
         ))                         #sign-swapping sums
end

JavaScript (Nút Babel) , 64 byte

F=([f,...r],s=[0])=>f?F(r,s.flatMap(x=>[x+f,x])):new Set(s).size

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

Điều này sẽ không làm việc cho testcase cuối cùng.

Giải pháp hiệu quả hơn (hoạt động trên testcase cuối cùng):

JavaScript (Nút Babel) , 71 byte

F=([f,...r],s=[0])=>f?F(r,[...new Set(s.flatMap(x=>[x+f,x]))]):s.length

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

Điều này sẽ không hoạt động trong một trình duyệt thực sự do Array#smoosh.

Nhờ Bubbler, [x+f,x-f]-> [x+f,x]tiết kiệm 2 byte.

Màu đỏ , 73 byte

func[b][s:[0]foreach n b[foreach m s[s: union s reduce[m + n]]]length? s]

Cổng Dennis 'Python 2 trả lời. Không xử lý trường hợp thử nghiệm cuối cùng.

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