รับรายการที่ไม่ว่างของจำนวนเต็มบวก , งานของคุณคือการกำหนดจำนวนค่าที่ไม่ซ้ำของ± x ± y ± z ± $(x, y, z, \dots)$$\pm x \pm y \pm z \pm \dots$

ตัวอย่างเช่นพิจารณารายการ ) มีวิธีที่เป็นไปได้แปดวิธีในการสร้างผลรวม:$(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$

มีหกจำนวนเงินที่ไม่ซ้ำกันดังนั้นคำตอบคือ6$\{5, -5, 1, -1, 3, -3\}$$6$

กรณีทดสอบ

[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

โซลูชันอ้างอิง (ปรับให้เหมาะสมสำหรับความเร็วและไม่ปรับขนาด)

หากคุณไม่สามารถจัดการกับกรณีสุดท้ายเพราะคุณใช้วิธีการดุร้ายหรือคล้ายกันนั่นเป็นเรื่องปกติ

เกณฑ์การให้คะแนน

นี่คือรหัสกอล์ฟดังนั้นวิธีแก้ปัญหาที่สั้นที่สุดที่ถูกต้อง (วัดเป็นไบต์) ชนะ

ภาษา Wolfram (Mathematica) , 27 ไบต์

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

ลองออนไลน์!

การหาจำนวนของผลรวมการสลับเครื่องหมายที่ไม่ซ้ำกันนั้นเทียบเท่ากับการหาจำนวนของผลรวมย่อยที่ไม่ซ้ำ

หลักฐานจะเกี่ยวข้องกับการเพิ่มผลรวมของอินพุตให้กับผลรวมของการแลกเปลี่ยนการลงชื่อและหารด้วยสอง จากนั้นมีความชัดเจนที่ชัดเจน

คำอธิบาย

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

วนซ้ำผ่านอินพุตโดยมีค่าเริ่มต้นเป็น{0}: ทำการรวมค่าระหว่าง<current value>และ<current value> + input element(แม็พลงในรายการ)

Tr[1^ ... ]

รุ่น Golfy ของLengthฟังก์ชั่น

เยลลี่ 6 ไบต์

ŒPS€QL

ลองออนไลน์!

พื้นหลัง

ให้Lเป็นรายการอินพุตและ{P, N}พาร์ติชันลงในการสรุปเชิงพีชคณิตด้วยสัญญาณบวกและลบ ข้อมูลจำเพาะท้าทายต้องคำนวณs _{{P, N}} = ผลรวม (P) - ผลรวม (N)

อย่างไรก็ตามเนื่องจากผลรวม (P) + ผลรวม (N) = ผลรวม (L)และผลรวม (L)ไม่ได้ขึ้นอยู่กับพาร์ติชันเราจึงมีs _{{P, N}} = ผลรวม (P) - ผลรวม (N) = ผลรวม ( P) - (ผลรวม (L) - ผลรวม (P)) = 2sum (P) - ผลรวม (L)

ดังนั้นแต่ละค่าที่ไม่ซ้ำกันของผลรวม (P)สอดคล้องกับค่าหนึ่งที่เป็นเอกลักษณ์ของs _{P, N}

มันทำงานอย่างไร

Œ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 ไบต์

nW:qBGY*un

ลองออนไลน์! นี่เป็นพอร์ตของคำตอบOctave / MATLABของ Luis Mendo ฉันยังคงพยายามที่จะเรียนรู้ MATL และฉันคิดว่าฉันโพสต์พร้อมกับคำอธิบายเนื่องจาก MATL เป็นภาษาของเดือน

คำอธิบาย:

นี่คือการอ่านผ่านสำหรับทุกคนที่ไม่คุ้นเคยกับการเขียนโปรแกรมแบบกองซ้อนโดยทั่วไปและโดยเฉพาะอย่างยิ่ง MATL

เวกเตอร์อินพุตถูกวางโดยปริยายบนสแต็ก โปรดทราบว่าเมื่อมีการดำเนินการกับองค์ประกอบในสแต็กองค์ประกอบนั้นจะถูกลบออกจากสแต็ก

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

จากนั้นมันจะแสดงองค์ประกอบสุดท้ายบนสแต็กโดยปริยาย

Python 2 , 55 ไบต์

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

ลองออนไลน์!

Python 2 , 52 ไบต์

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

ลองออนไลน์!

ใช้การแทนเลขฐานสองของตัวเลขเพื่อเก็บผลรวมย่อยที่เข้าถึงได้

05AB1E , 4 ไบต์

æOÙg

ใช้วิธีการเดียวกับที่ใช้ในเดนนิสคำตอบของวุ้น

ลองออนไลน์!

Haskell, 46 ไบต์

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

ลองออนไลน์!

แทนที่จะรวมส่วนย่อยของรายการอินพุตเราสร้างชุดค่าผสมทั้งหมดของการเก็บหมายเลขหรือแทนที่ด้วย0เช่น

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

subsequencesนี่คือสองไบต์สั้นกว่า

R, 83 75 ไบต์

-8 ไบต์ขอบคุณ JayCe และ Giuseppe

สร้างเมทริกซ์ของชุดค่าผสมที่เป็นไปได้ทั้งหมดของ (1, -1) สำหรับขนาดของเวกเตอร์อินพุตคูณด้วยเวกเตอร์ดั้งเดิมเพื่อให้ได้ผลรวม จากนั้นมีเอกลักษณ์และค้นหาความยาวของผลลัพธ์

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

รุ่นก่อนหน้า:

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

ไม่พอใจกับความคิดเห็น:

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
  }

อ็อกเทฟ / MATLAB, 45 41 40 ไบต์

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

อินพุตเป็นเวกเตอร์คอลัมน์ (ใช้;เป็นตัวคั่น)

ข้อผิดพลาดของรหัสสำหรับกรณีทดสอบล่าสุดเนื่องจากข้อ จำกัด ของหน่วยความจำ

สิ่งนี้ใช้แนวคิดจากคำตอบของ JungHwan Min (ชุดย่อยแทนเครื่องหมายสลับ) เพื่อบันทึกสองสามไบต์

ลองออนไลน์!

Pari / GP , 39 ไบต์

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

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

ลองออนไลน์!

Python 3 , 61 ไบต์

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

ลองออนไลน์!

วิธีแบบเรียกซ้ำการติดตามจำนวนเงินที่เป็นเอกลักษณ์

ความสนุกที่แท้จริงคือจังหวะนี้เต้นได้ไกลitertools:

76 ไบต์

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

ลองออนไลน์!

Pyth , 5 ไบต์

l{sMy

ใช้วิธีการเดียวกับที่ใช้ในเดนนิสคำตอบของวุ้น

ลองที่นี่

ทูต , 29 ไบต์

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

ลองออนไลน์!

สิ่งนี้ทำงานโดยการพับ±โอเปอเรเตอร์เหนือรายการอินพุตจากนั้นนำ±รายการนั้นจากนั้นนับอะตอมที่ไม่ซ้ำกันของอาร์เรย์

นี่คือตัวอย่างของวิธีการพับ:

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]

จากนั้นเราสร้างการเรียงสับเปลี่ยนทั้งหมดของสัญญาณสุดท้ายโดยใช้ PlusMinus อีกครั้ง

รุ่นที่มีประสิทธิภาพมากขึ้น 31 ไบต์

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

ลองออนไลน์! นี่ไม่ใช่การหมดเวลาสำหรับกรณีทดสอบขั้นสุดท้ายเนื่องจากไม่ได้สร้างชุดค่าผสมที่ไม่จำเป็น

R , 62 ไบต์

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

ลองออนไลน์!

อัลกอริทึมของพอร์ตเดนนิส มันใกล้เคียงที่สุดกับคำตอบของ Octave / MATL เนื่องจากมันใช้บิตแมปและผลิตภัณฑ์เมทริกซ์ที่คล้ายกันสำหรับการรวม / แยกคำ

APL (Dyalog คลาสสิก) , 12 11 ไบต์

-1 ขอบคุณ H.PWiz

≢⊃(+∪⊢)/⎕,0

ลองออนไลน์!

Perl 5 -p , 39 ไบต์

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

ลองออนไลน์!

JavaScript (ES6), 63 ไบต์

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

ลองออนไลน์!

Husk , 5 ไบต์

LumΣṖ

ลองออนไลน์!

คำตอบของเยลลี่พอร์ตของเดนนิส

คำอธิบาย

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 ไบต์

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

ลองออนไลน์!

ยูทิลิตีBash + GNU ขนาด 49 ไบต์

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

ลองออนไลน์!

อินพุตที่กำหนดเป็นรายการที่คั่นด้วยเครื่องหมายจุลภาคที่บรรทัดรับคำสั่ง

คำอธิบาย

               ${@//,/{+,-\}}                      # 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 ภาษาเครื่องสำหรับ Linux, 31 29 ไบต์

 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

ลองออนไลน์!

แรงบันดาลใจจากคำตอบของ @ xnor ต้องใช้เครื่องที่มีPOPCNTคำสั่ง

C (gcc) , 74 69 ไบต์

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

ลองออนไลน์!

คำตอบของ C @ @ พอร์ตของพอร์ต

APL (Dyalog Classic) , 34 33 32 ไบต์

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

ลองออนไลน์!

ขอบคุณ @ngn สำหรับ -1 ไบต์!

ทำความสะอาด , 82 ไบต์

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

ลองออนไลน์!

กำหนดฟังก์ชั่นที่? :: [Int] -> Intใช้f :: [Int] -> ([Int] -> Int)เป็นผู้ช่วยเพื่อลดผลรวมที่เป็นไปได้หลังจากการบวกหรือการลบ

APL (Dyalog Classic)ขนาด 21 ไบต์

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

ลองออนไลน์!

คำอธิบาย

2(⍴⍨⊤∘⍳*)⍴

ฟังก์ชั่นการฝึกอบรมเทียบเท่ากับ{((⍴⍵)⍴2)⊤⍳(⍴⍵)}ซึ่งสร้างเมทริกซ์ที่มีการเป็นตัวแทนไบนารีของ 0 ถึงความยาวของอินพุตเป็นคอลัมน์

1-2×

แผนที่1เพื่อ-1และ0เพื่อ1s

⊢+.×

การคูณเมทริกซ์ด้วยอินพุตซึ่งให้ผลรวมเป็นไปได้ทั้งหมด

⍴∘∪

ลบรายการซ้ำจากนั้นนับ

Java 8, 207 83 44 ไบต์

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

ท่าเรือของ @ XNOR งูหลาม 2 คำตอบ
-39 ไบต์ขอบคุณที่@Jakob

ลองมันออนไลน์

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 ไบต์

อีกพอร์ตของ Java XNOR 'คำตอบ เช่นเดียวกับคำตอบดั้งเดิมนี่ใช้บิตแมปที่มีความแม่นยำตามอำเภอใจดังนั้นจึงไม่มีข้อ จำกัด สูงสุดสำหรับขนาดของผลรวมย่อย

มันเป็นแลมบ์ดาจากลำดับไปjava.util.stream.Stream<Integer>int

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

ลองใช้ออนไลน์

โปรดทราบว่า combiner (อาร์กิวเมนต์ที่สามถึงreduce) ไม่ได้ใช้เนื่องจากสตรีมเป็นลำดับ ฟังก์ชั่นที่ฉันเลือกนั้นมีความหมาย

Julia 0.6 , 54 52 ไบต์

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

ลองออนไลน์!

( -2 ไบต์โดยแทนที่¬ด้วย~ขอบคุณJo King )

ใช้งานได้กับทุกกรณีทดสอบ ใช้การออกอากาศเพื่อรวบรวมผลรวมทั้งหมดที่เป็นไปได้จากนั้นนับจำนวน

คำอธิบาย:

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

วิธีแก้ปัญหาที่เก่ากว่า:

Julia 0.6 , 64 bytes

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

ลองออนไลน์!

ใช้งานได้กับอาร์เรย์อินพุตที่มีความยาวไม่เกิน 63 (ไม่สามารถใช้กับกรณีทดสอบล่าสุดซึ่งใช้ได้ตาม OP)

คำอธิบาย:

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 (โหนดบาเบล) , 64 ไบต์

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

ลองออนไลน์!

สิ่งนี้จะไม่ได้ผลสำหรับการทดสอบครั้งสุดท้าย

วิธีแก้ปัญหาที่มีประสิทธิภาพมากขึ้น (ทำงานบน testcase ล่าสุด):

JavaScript (โหนดบาเบล) , 71 ไบต์

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

ลองออนไลน์!

Array#smooshนี้จะไม่ทำงานในเบราว์เซอร์ที่แท้จริงเนื่องจาก

ขอบคุณ Bubbler [x+f,x-f]-> [x+f,x]บันทึก 2 ไบต์

สีแดง 73 ไบต์

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

คำตอบ Port of Dennis 'Python 2 ไม่จัดการกับกรณีทดสอบล่าสุด

ลองออนไลน์!