साइन-स्वैपिंग सम्स

Question

सकारात्मक पूर्णांक एक गैर-रिक्त सूची को देखते हुए , आपका काम के अनूठे मूल्यों की संख्या निर्धारित करना है± एक्स ± 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$

वहाँ छह अद्वितीय रकम , इसलिए उत्तर ।$\{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

संदर्भ समाधान (गति और आकार के लिए अनुकूलन)।

यदि आप अंतिम मामले को संभाल नहीं सकते हैं क्योंकि आप एक जानवर बल विधि या इसी तरह का उपयोग करते हैं, तो यह ठीक है।

स्कोरिंग

यह कोड-गोल्फ है , इसलिए सबसे छोटा वैध समाधान (बाइट्स में मापा गया) जीतता है।

Comments

क्या हमें उस मामले को संभालना है जहां इनपुट खाली सरणी है?

— चास ब्राउन

@ChasBrown इनपुट गैर-रिक्त है, पोस्ट के अनुसार।

— जुंगह्वान मिन

हम्म, मैं समझ नहीं पा रहा हूं कि तीसरा टेस्ट केस कैसे काम करता है, कृपया समझाने के लिए देखभाल करें?

— एरिक आउटोलॉफ़र

@EriktheOutgolfer यह प्रभावी रूप से कह रहा है कि यदि आपकी सरणी सभी समान संख्याओं (जैसे [2,2,2,2,...]) है तो उत्तर सरणी की लंबाई + 1 होनी चाहिए। ऐसा इसलिए है क्योंकि इस स्थिति में संकेतों की स्थिति अप्रासंगिक है और केवल प्रत्येक मामले की संख्या है

— reffu

@reffu यह एक मजाक के रूप में अधिक है, यह थोड़े लगता है जैसे कि यह त्रुटि द्वारा वहाँ शामिल किया गया है।

— एरिक द आउटलिफ़र

Answer 1

वोल्फ्राम भाषा (गणितज्ञ) , 27 बाइट्स

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

इसे ऑनलाइन आज़माएं!

अद्वितीय साइन-स्वैपिंग रकम की संख्या का पता लगाना अद्वितीय सबसेट रकम की संख्या खोजने के बराबर है।

एक प्रमाण में साइन-स्वैपिंग सम्स में से प्रत्येक में इनपुट के योग को जोड़ना और दो से विभाजित करना शामिल होगा। फिर, एक स्पष्ट आक्षेप है।

व्याख्या

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

प्रारंभिक मान होने के साथ, इनपुट के माध्यम से Iterate {0}: ( <current value>और <current value> + input elementसूचियों पर नक्शे) के बीच संघ को लें ।

Tr[1^ ... ]

Lengthसमारोह का गोल्फ संस्करण ।

Answer 2

जेली , 6 बाइट्स

ŒPS€QL

इसे ऑनलाइन आज़माएं!

पृष्ठभूमि

चलो एल इनपुट सूची और हो {पी, एन} सकारात्मक और नकारात्मक संकेत के साथ बीजीय summands में एक विभाजन। चुनौती युक्ति के लिए s _{{P, N}} = sum (P) - sum (N) की गणना की आवश्यकता होती है ।

हालाँकि, योग (P) + sum (N) = sum (L) और sum (L) विभाजन पर निर्भर नहीं करता है, हमारे पास s _{{P, N}} = sum (P) - sum (N) = sum (है) P) - (sum (L) - sum (P)) = 2sum (P) - sum (L) ।

इस प्रकार, योग (पी) के प्रत्येक अद्वितीय मूल्य एस _{{पी, एन} के} एक अद्वितीय मूल्य से मेल खाते हैं ।

यह काम किस प्रकार करता है

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

Answer 3

MATL , 11 10 बाइट्स

nW:qBGY*un

इसे ऑनलाइन आज़माएं! यह लुइस मेंडो के ऑक्टेव / MATLAB उत्तर का एक बंदरगाह है । मैं अभी भी 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]

और फिर यह स्टैक पर अंतिम तत्व को स्पष्ट रूप से आउटपुट करता है।

Comments

अच्छी व्याख्या!

— लुइस मेंडो

Answer 4

पायथन 2 , 55 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Answer 5

पायथन 2 , 52 बाइट्स

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

इसे ऑनलाइन आज़माएं!

एक नंबर के बाइनरी प्रतिनिधित्व का उपयोग करता है जो पहुंच योग्य सबसेट रकम जमा करता है।

Comments

क्या आप बता सकते हैं कि यह कैसे काम करता है? क्या आप स्वयं इसे लेकर आए थे, या यह कुछ ज्ञात परिणाम है?

— सूंदर -

@ सूंदर यह उतना जटिल नहीं है। यह उत्तर कई अन्य उत्तरों की तरह अद्वितीय रकम (साइन-स्वैपिंग नहीं) की गणना करता है। कश्मीर में प्रत्येक बिट एक राशि से मेल खाती है। k<<nप्रत्येक योग में n जोड़ता है। kसभी नए kलोगों को रखने के दौरान इन नए योगों को संग्रहीत करना , और नकली सिम्स रिकॉर्ड नहीं किए गए हैं

— H.PWiz

आह, ब्रेक्जिट्स का निशान, जुंगहवन मिन के जीवत्ति विचार पर वापस जाता है , यह मुख्य अंतर्दृष्टि थी जो मुझे याद आ रही थी। यहां प्रत्येक सब्सेट योग को बिटस्ट्रिंग में उस स्थिति में 1 से दर्शाया जाता है (एलएसबी में प्रारंभिक 1 के साथ खाली सबसेट के लिए योग 0 का प्रतिनिधित्व करता है)। अभी भी कुछ ऐसा नहीं है जिसे मैं "जटिल नहीं" कहूंगा, लेकिन यह सिर्फ मेरी अनुभवहीनता हो सकती है। :)

— सूंदर -

Answer 6

05AB1E , 4 बाइट्स

æOÙg

डेनिस के जेली उत्तर में उपयोग किए गए उसी दृष्टिकोण का उपयोग करता है ।

इसे ऑनलाइन आज़माएं!

Answer 7

हास्केल, 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।

Comments

अच्छा जवाब! मुझे उम्मीद f x=sum[1|i<-[0..sum x],elem i$sum<$>mapM(:[0])x]थी कि आयात की तुलना में कुछ कम होगा, लेकिन जाहिर है, ऐसा नहीं है।

— लिन

मैथेमेटिका एक के अनुवाद से भी अच्छा, हालांकि मुझे लगता है कि यह बहुत अच्छा है:import Data.List;length.foldr((<*>)union.map.(+))[0]

— जॉन पूर्डी

Answer 8

आर, 83 75 बाइट्स

जेसी और Giuseppe के लिए -8 बाइट्स धन्यवाद

इनपुट वेक्टर के आकार के लिए (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
  }

Comments

कुछ बाइट्स बचाएं t: TIO

— JayCe

और sum(v|1)एक बाइट से कम हैlength(v)

— Giuseppe

Answer 9

ऑक्टेव / MATLAB, 45 41 40 बाइट्स

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

इनपुट एक कॉलम वेक्टर ( ;विभाजक के रूप में उपयोग ) है।

स्मृति प्रतिबंधों के कारण पिछले परीक्षण मामले की कोड त्रुटियां।

यह कुछ बाइट्स को बचाने के लिए JungHwan Min के उत्तर (वैकल्पिक संकेतों के बजाय सबसेट) से एक विचार का उपयोग करता है ।

इसे ऑनलाइन आज़माएं!

Answer 10

परी / जीपी , 39 बाइट्स

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

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

इसे ऑनलाइन आज़माएं!

Comments

यह एक अच्छा तरीका है!

— जुंगवान मिन

Answer 11

पायथन 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*

इसे ऑनलाइन आज़माएं!

Answer 12

अजगर , 5 बाइट्स

l{sMy

डेनिस के जेली उत्तर में उपयोग किए गए उसी दृष्टिकोण का उपयोग करता है ।

इसे यहाँ आज़माएँ।

Answer 13

अटैची , 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]

फिर हम एक बार फिर प्लसमिनस लगाकर अंतिम संकेत के सभी क्रमपरिवर्तन को उत्पन्न करते हैं।

एक अधिक कुशल संस्करण, 31 बाइट्स

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

इसे ऑनलाइन आज़माएं! यह अंतिम परीक्षण मामले पर समय नहीं देता है, क्योंकि यह अनावश्यक संयोजन उत्पन्न नहीं करता है।

Answer 14

आर , 62 बाइट्स

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

इसे ऑनलाइन आज़माएं!

पोर्ट्स डेनिस एल्गोरिथम। यह ऑक्टेव / MATL उत्तरों के सबसे करीब है क्योंकि यह समान बिटमैप और मैट्रिक्स उत्पाद को शामिल करने / शब्दों को शामिल करने के लिए उपयोग करता है।

Answer 15

एपीएल (डायलॉग क्लासिक) , 12 11 बाइट्स

-1 H.PWiz को धन्यवाद

≢⊃(+∪⊢)/⎕,0

इसे ऑनलाइन आज़माएं!

Comments

जैसा कि अन्य उत्तरों में उल्लेख किया गया है, -⍨हो सकता है⊢

— H.PWiz

@ H.PWiz धन्यवाद, बहुत अच्छा!

— ngn

Answer 16

पर्ल 5 -p , 39 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Answer 17

जावास्क्रिप्ट (ईएस 6), 63 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Answer 18

भूसी , 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

Comments

अनिवार्य रूप से चरित्र के लिए पायथ उत्तर के बराबर है ।

— इसहाक

Answer 19

पर्ल 6 , 33 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Answer 20

बैश + जीएनयू उपयोगिताओं, 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

Answer 21

लिनक्स के लिए x86_64 मशीन भाषा, 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निर्देश के साथ एक मशीन की आवश्यकता है ।

Answer 22

सी (जीसीसी) , 74 69 बाइट्स

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

इसे ऑनलाइन आज़माएं!

@ Xnor के उत्तर का सी पोर्ट

Answer 23

APL (Dyalog Classic) , 34 33 32 बाइट्स

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

इसे ऑनलाइन आज़माएं!

@ बाइट के लिए धन्यवाद!

Comments

1-⍨≢⍵->≢1↓⍵

— ngn

+.×⍨->+.×

— ngn

बाद वाला काम नहीं करता, मुझे डर है।

— ज़ाचारि

उफ़, मैं नहीं जानता कि क्यों मैंने सोचा कि आप वैक्टर पर लागू कर रहे हैं + × ... खेद है।

— NGN

Answer 24

स्वच्छ , 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)एक सहायक के रूप में एक अतिरिक्त या घटाव के बाद प्रत्येक संभव राशि से अधिक कम करने के लिए।

Comments

यहाँ हास्केल में संदर्भ समाधान का एक गोल्फ संस्करण है; यह निश्चित नहीं है कि यह क्लीन पर कितना ले जा सकता है, लेकिन आप इससे कुछ पाने में सक्षम हो सकते हैं।

— फल तोड़ना

@EsolangingFruit धन्यवाद, लेकिन यह पहले से ही एक ही दृष्टिकोण का उपयोग कर रहा है और मुझे इसे संदर्भ समाधान के साथ भी छोटा करने का कोई तरीका नहीं मिल रहा है।

— .urous

Answer 25

APL (Dyalog Classic) , 21 बाइट्स

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

इसे ऑनलाइन आज़माएं!

व्याख्या

2(⍴⍨⊤∘⍳*)⍴

के बराबर एक फ़ंक्शन ट्रेन {((⍴⍵)⍴2)⊤⍳(⍴⍵)}, जो एक मैट्रिक्स उत्पन्न करती है जिसमें कॉलम के रूप में इनपुट की लंबाई के लिए 0 का द्विआधारी प्रतिनिधित्व होता है

1-2×

मैप्स 1रों करने -1और 0रों को 1रों

⊢+.×

इनपुट के साथ मैट्रिक्स गुणन, जो सभी संभावित रकमों की एक सरणी देता है

⍴∘∪

डुप्लिकेट निकालें, फिर गिनें

Answer 26

जावा 8, 207 83 44 बाइट्स

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

@ Xnor के पायथन 2 उत्तर का पोर्ट ।
-39 बाइट्स @ जाकोब को धन्यवाद ।

इसे ऑनलाइन आज़माएं ।

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`

Comments

44 बाइट्स हम सभी की जरूरत है! की एक धारा ले रहा है Long: s->Long.bitCount(s.reduce(1l,(a,e)->a|a<<e))।

— जैकब

@ जाकोब धन्यवाद! मैं हमेशा .reduce(और .bitCountसाथ ही मैं जोड़ सकता हूँ .. के बारे में भूल जाते हैं ..>) -39 वहाँ ठीक है! :)

— केविन क्रूज़सेन

इसके अलावा, मैंने सिर्फ एक मनमाना-सटीक संस्करण बनाया है । ऐसा करने का सबसे सस्ता तरीका सेट के बजाय बिटमैप के साथ अभी भी लगता है।

— जैकब

Answer 27

जावा 8, 85 बाइट्स

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

यह ऑनलाइन की कोशिश करो

ध्यान दें कि reduceधारा क्रमिक होने के बाद कंबाइनर (तीसरा तर्क ) अप्रयुक्त है। मेरे द्वारा चुना गया कार्य मनमाना है।

Answer 28

जूलिया 0.6 , 54 52 बाइट्स

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

इसे ऑनलाइन आज़माएं!

( जो किंग के लिए धन्यवाद के साथ -2 बाइट्स , धन्यवाद¬~ )

सभी परीक्षण मामलों के लिए काम करता है। प्रसारण का उपयोग सभी संभव रकम एकत्र करने के लिए करता है, फिर उन्हें गिनता है।

स्पष्टीकरण:

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

---

पुराना समाधान:

जूलिया 0.6 , 64 बाइट्स

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

इसे ऑनलाइन आज़माएं!

63 तक लंबाई के साथ इनपुट सरणियों के लिए काम करता है (इसलिए पिछले परीक्षण के मामले में काम नहीं करता है, जो ओपी के अनुसार ठीक है)।

स्पष्टीकरण:

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

Answer 29

जावास्क्रिप्ट (बैबेल नोड) , 64 बाइट्स

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

इसे ऑनलाइन आज़माएं!

यह अंतिम टेस्टकेस के लिए काम नहीं करेगा।

---

अधिक प्रभावी समाधान (अंतिम परीक्षण पर काम करता है):

जावास्क्रिप्ट (बैबेल नोड) , 71 बाइट्स

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

इसे ऑनलाइन आज़माएं!

---

यह वास्तविक ब्राउज़र में काम नहीं करेगा Array#smoosh।

बब्लर के लिए धन्यवाद, [x+f,x-f]-> [x+f,x]2 बाइट्स बचाता है।

Comments

आप उपयोग कर सकते हैं [x+f,x]के स्थान पर [x+f,x-f]( JungHwan मिन द्वारा सबूत )।

— बब्बलर

ES6 संस्करण के लिए 2 बाइट्स:F=([f,...r],s=[0])=>f?F(r,[...s,...s.map(x=>x+f)]):new Set(s).size

— नील

@Neil, और ... [...s,...s.map(x=>x+f)], s.concat(s.map(x=>x+f)), और, s,s.map(x=>s.push(x+f))शेयर एक ही लंबाई ...

— TSH

Answer 30

लाल , 73 बाइट्स

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

पोर्ट ऑफ डेनिस 'पायथन 2 उत्तर। अंतिम परीक्षण मामले को संभालता नहीं है।

इसे ऑनलाइन आज़माएं!