शून्य-राशि की गणना

25

एक प्रोग्राम या फ़ंक्शन लिखिए जो n ≥ 1 दिया गया समाधानों की संख्या ± 1 or 2 ± 3 ± ...। N = 0 है।

N = 6 के लिए कोई समाधान नहीं हैं, इसलिए उत्तर 0. है = n = 4 के लिए दो समाधान हैं, इसलिए उत्तर 2 है (दो समाधान 1 - 2 - 3 + 4 = -1 + 2 + 3 - 4 हैं = ०)।

यह OEIS अनुक्रम A063865 है । कुछ उदाहरण इनपुट / आउटपस हैं:

n       a(n)
1       0
2       0
3       2
4       2
5       0
6       0
7       8
8       14
9       0
10      0
11      70
12      124
13      0
14      0
15      722
16      1314

बाइट्स में सबसे छोटा कोड जीतता है।

code-golf  math  arithmetic 
— orlp
स्रोत
2
— मनीष कुंडू
1
@ManishKundu हम्म, मैं कहूंगा कि मेरे लिए एक संभावित डुप लक्ष्य की तरह बहुत अधिक लग रहा है, बस अंत में "लंबाई" का सौदा करें या इसके बजाय "फ़िल्टर द्वारा बराबर राशि" के लिए "प्रत्येक राशि की गणना करें" इसके लिए एक उत्तर दें। ।
— 11
2
@EriktheOutgolfer मुझे उस चुनौती के बारे में पता नहीं था, लेकिन इसका जवाब काफी हद तक अलग हो सकता है, उदाहरण के लिए मेरा देखें।
— orlp
2
@ मनिष्ककुंडू ने मुझे समझाया कि यह चुनौती अलग कैसे है ...
— orlp
2
हां मैंने वह देखा। हालांकि यह दुर्भाग्यपूर्ण है कि आपने गलती से अपने ही सवाल को टाल दिया है, लेकिन आपको उस वोट के लिए बाध्य नहीं किया जाना चाहिए जिससे आप असहमत हैं।
— डेनिस

जवाबों:

6

05AB1E , 10 बाइट्स

X®‚sã€ƶO_O

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

व्याख्या

X®‚          # push [1,-1]
   sã        # cartesian product with input
     €ƶ      # multiply each element in each list with its 1-based index
       O     # sum each list
        _    # logical negation of each sum
         O   # sum
— Emigna
स्रोत
1
+1 के लिए O_O...
— फल
कोड .. यह मुझे घूर रहा है। मैं क्या करूं?
— caird coinheringaahing
5

C (gcc), 45 62 52 50 बाइट्स

f(n,r){n=n?f(n-1,r+n)+f(n-1,r-n):!r;}F(n){f(n,0);}

केविन क्रूज़सेन के जावा 8 उत्तर का पोर्ट ।

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

ध्यान दें कि टिप्पणियों में सुझाए गए सुधारों के कारण, कोड क्लैंग के साथ संकलित होने पर काम नहीं करने के बिंदु पर अपरिभाषित व्यवहार पैदा करता है।

3 बाइट्स गोल्फ के लिए इथेन के लिए धन्यवाद । 10 और बाइट गोल्फिंग के लिए केविन क्रूज़सेन को धन्यवाद । एक और 2 बाइट गोल्फिंग के लिए क्रिस्टोफ़ के लिए धन्यवाद ।

Ungolfed संस्करण:

f(n, r) { // recursive function - return type and parameter type are omitted, they default to int
    n = // instead of returning, we set n - dirty trick
        n ? // if n is not 0, recurse
        f(n-1,r+n) // +n
       +f(n-1,r-n) // -n
        !r; // else if r != 0 return 0 else return 1
}
F(n) { // function to start the recursion; again implicitly int(int)
    n = f(n, 0); // call the recursive function; this time we simply don't return
}
— OOBalance
स्रोत
1
आप के r?0:1साथ की जगह 3 बाइट्स दाढ़ी कर सकते हैं !r। 42 बाइट्स
— एटीन
2
ऐसा लगता है कि आप आरंभिक मूल्य निर्धारित करने के लिए यहां अतिरिक्त इनपुट ले रहे हैं r, जिसकी अनुमति नहीं है।
— झबरा
1
@etene अच्छी तरह से देखा, धन्यवाद!
— OOBalance
2
@KevinCruijssen बेहतर अभी तक दूसरा n=जरूरी नहीं है f(n,r){n=n?f(n-1,r+n)+f(n-1,r-n):!r;}F(n){f(n,0);}:।
— क्रिस्टोफ़
2
@Oobalance चाल दो पूरक है । इसका मतलब है कि -x = ~x+1और इसलिए ~x = -x-1।
— क्रिस्टोफ़
5

05AB1E , 9 8 बाइट्स

बाइट बचाने के लिए एमिग्ना को धन्यवाद !

कोड:

LæO·sLO¢

05AB1E एन्कोडिंग का उपयोग करता है । इसे ऑनलाइन आज़माएं!

व्याख्या

L           # Create the list [1, 2, .., input]
 æ          # Compute the powerset of this list
  O         # Sum each list
   ·        # Double each element
    sLO     # Compute the sum of [1, 2, .., input]
       ¢    # Count the number of occurrences
— अदनान
स्रोत
4

MATL , 14 13 बाइट्स

[la]Z^G:!Y*~s

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

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें ।

व्याख्या

n = 3एक उदाहरण के रूप में विचार करें । स्टैक को उल्टा दिखाया जाता है, यानी नीचे सबसे नया दिखाई देता है।

[la]   % Push array [1 -1]
       % STACK: [1 -1]
Z^     % Cartesian power with inplicit input n
       % STACK: [ 1  1  1
                  1  1 -1
                  1 -1  1
                  1 -1 -1
                 -1  1  1
                 -1  1 -1
                 -1 -1  1
                 -1 -1 -1]
G:     % Push n, range: gives [1 2 ... n]
       % STACK: [ 1  1  1
                  1  1 -1
                  1 -1  1
                  1 -1 -1
                 -1  1  1
                 -1  1 -1
                 -1 -1  1
                 -1 -1 -1],
                 [1  2  3]
!      % Transpose
       % STACK: [ 1  1  1
                  1  1 -1
                  1 -1  1
                  1 -1 -1
                 -1  1  1
                 -1  1 -1
                 -1 -1  1
                 -1 -1 -1],
                 [1
                  2
                  3]
Y*     % Matrix multiplication
       % STACK: [6
                 0
                 2
                -4
                 4
                -2
                 0
                -6]
~      % Logical negation
       % STACK: [0
                 1
                 0
                 0
                 0
                 0
                 1
                 0]
s      % Sum of vector. Implicit display
       % STACK: 2
— लुइस मेंडो
स्रोत
4

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

ŒPS€ċÆṁ$

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

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

ŒPS€ċÆṁ$  Main link. Argument: n

ŒP        Take the powerset of [1, ..., n].
  S€      Take the sum of each subset.
       $  Combine the two links to the left into a monadic chain.
     Æṁ       Compute the median of the sums, i.e, (1 + ... + n)/2.
    ċ         Count the occurrences of the median.
— डेनिस
स्रोत
3

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

def f(n):l=k=1;exec"l+=l<<n*k;k+=1;"*n;return(l>>n*n*-~n/4)%2**n*(~-n%4>1)

एक मज़ेदार सबमिशन, डायरेक्ट जनरेटिंग फंक्शन कंप्यूटेशन।

— orlp
स्रोत
3

ऑक्टेव (संचार पैकेज के साथ), 39 बाइट्स

@(n)sum((2*de2bi(0:2^n-1)-1)*(1:n)'==0)

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

स्पष्टीकरण:

एक सीमा 0 ... n ^ 2-1 लें और इसे बाइनरी में बदलें। यह 0 और 1 के सभी संयोजनों के साथ एक मैट्रिक्स देता है । -1 और +1 के सभी संयोजनों के साथ एक मैट्रिक्स प्राप्त करने के लिए 2 से गुणा करें और 1 घटाएं ।

... 1 ± 2 ...। N के सभी संयोजनों को प्राप्त करने के लिए एक सीमा 1 ... n के साथ डॉट-उत्पाद लें । गिनती करें कि कितने शून्य हैं।

मूल रूप से एक ही बात, एक ही बाइट गिनती:

@(n)nnz(~((2*de2bi(0:2^n-1)-1)*(1:n)'))
— स्टीवी ग्रिफिन
स्रोत
3

पायथन 2 और 3, 50 बाइट्स

अधिकांश उत्तरों की तरह पुनरावर्ती दृष्टिकोण:

f=lambda n,r=0:f(n-1,r+n)+f(n-1,r-n)if n else r==0

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

डबल पुनरावर्ती कॉल बहुत अधिक बाइट्स लेता है ... संभवतः इसे सरल बनाने का एक तरीका है।

— etene
स्रोत
3

जावा 8, 72 71 70 बाइट्स

n->f(0,n)int f(int r,int n){return n>0?f(r+n,--n)+f(r+~n,n):r==0?1:0;}

पोर्ट ऑफ @Arnauld का जावास्क्रिप्ट (ES6) उत्तर ।
-2 बाइट्स @ ओलिवियरग्रेगायर के लिए धन्यवाद ।

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

स्पष्टीकरण:

n->                 // Method with integer parameter and integer return-type
  f(0,n)            //  Call the recursive method with 0 and this parameter

int f(int r,int n){ // Recursive method with integer as both two parameters and return-type
  return n>0?       //  If `n` is not 0 yet:
    f(r+n,--n)      //   Recursive call with `r+n` (and `n` lowered by 1 first with `--n`)
    +f(r+~n,n)      //   + Recursive call with `r-n` (and `n` also lowered by 1)
   :r==0?           //  Else-if `r` is 0
     1              //   Return 1
    :               //  Else:
     0;}            //   Return 0
— केविन क्रूज़सेन
स्रोत
3

हास्केल , 55 बाइट्स

उन सभी रकमों की गणना करने और कितने शून्य हैं इसकी जाँच करने का एक सीधा तरीका।

f 0=[0]
f n=[(n+),(n-)]>>=(<$>f(n-1))
g x=sum[1|0<-f x]

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

संपादित करें: @ H.PWiz का उपयोग करते हुए एक छोटा और अधिक सुरुचिपूर्ण समाधान है mapM!

— flawr
स्रोत
3

बैश + जीएनयू उपयोगिताओं, 63 बाइट्स

बैश संभवत: पुनरावर्ती कार्यों के साथ इससे बेहतर कर सकते हैं, लेकिन मैं इस तरह के eval/ भागने / विस्तार की गंभीरता का विरोध नहीं कर सकता :

p=eval\ printf\ %s
$p\\\\n \$[$($p \\\{+,-}{1..$1})]|grep -c ^0

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

अद्यतन: मुझे नहीं लगता कि बैश पुनरावर्ती कार्यों के साथ बेहतर कर सकता है। यह सबसे अच्छा मैं 90 के स्कोर के लिए कर सकता है । evalनरक तो यह है।

— डिजिटल आघात
स्रोत
2

ऑक्टेव , 42 बाइट्स

@(n)sum((dec2bin(0:2^n-1)*2-97)*(1:n)'==0)

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

— लुइस मेंडो
स्रोत
खैर, +1 मुझे लगता है। :) जब मैंने अपनी पोस्ट की तो यह नहीं देखा।
— स्टीवी ग्रिफिन
हे। मैंने तुम्हारा अब तक नहीं देखा था
— लुइस मेंडू
1

पायथ, 14 13 बाइट्स

lf!s.nT*F_BRS

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

व्याख्या

lf!s.nT*F_BRS
            SQ  Take the list [1, ..., <implicit input>].
         _BR    Get the pairs [[1, -1], [2, -2], ...].
       *F       Take the Cartesian product.
 f!s.nT         Find the ones where the flattened sum is 0.
l               Take the length.
1

स्टैक्स , 9 बाइट्स

è%é┐╬@₧╠¬

इसे चलाएं और डीबग करें

जेली द्वारा अब तक पराजित किए गए सबसे छोटे उत्तरों में से एक ।

मुझे लगता है कि स्पष्ट रूप से जाँच करना कि कौन सा राशि शून्य के बराबर है, बहुत अधिक गोल्फ नहीं है, इसलिए इसके बजाय मैं पॉवरसेट ले लेता हूं और जांचता हूं कि पॉवरसेट में कितने सेट में आधी एनटी त्रिकोणीय संख्या है। यह पद्धति आश्चर्यजनक रूप से नहीं, उसी समय की जटिलता के रूप में है, जिसमें यह जाँच की जाती है कि कौन सा चिन्ह शून्य है।

ASCII समकक्ष:

RS{|+Hmx|+#
— वीजुन झोउ
स्रोत
0

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

/mysdySQsS

इसे ऑनलाइन आज़माएं। वैकल्पिक रूप से, सभी परीक्षण मामलों को एक बार में सत्यापित करें ।

explaination:

/mysdySQsS    Implicit: Q=input()
      SQ      Generate range [1...Q]
     y        Generate powerset of above
 m            Map d in the above over...
  ysd         ... double the sum of d
        sS    Sum of range [1...Q] (final Q is implicit)
/             Count the matches (implicit output)
— सोक
स्रोत
0

जे , 28 बाइट्स

(*>:){1j3#1+//.@(*/)/@,.=@i.

अन्य परिभाषा का उपयोग करता है जहां OEIS से a(n) = coefficient of x^(n(n+1)/4) in Product_{k=1..n} (1+x^k) if n = 0 or 3 mod 4 else a(n) = 0।

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

व्याख्या

(*>:){1j3#1+//.@(*/)/@,.=@i.  Input: n
                          i.  Range [0, n)
                        =     Self-Classify. Forms an identity matrix of order n
          1           ,.      Stitch. Prepend 1 to each row
                    /         Reduce using
                                Convolution
                 */               Product table
           +//.                   Sum along anti-diagonals
      1j3#                    Copy each once, padding with 3 zeroes after
     {                        Index at n*(n+1)
  >:                            Increment n
 *                              Times n
— मील की दूरी पर
स्रोत
0

गोल> <> , 26 बाइट्स

:IFPlMF2K+}:@-}||0lMF$z+|h

इसे ऑनलाइन आज़माएं! या 1 से 16 तक परीक्षण मामलों को चलाएं!

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

:IFPlMF2K+}:@-}||0lMF$z+|h

Main outer loop
:IFPlMF ...... ||
:        Duplicate top; effectively generate two explicit zeroes
         Top is the loop counter `i`;
         the rest is the generated 2**i sums
 I       Take input as number
  F ........... |  Pop n and loop n times
   P     i++
    lM   Push stack length - 1, which is 2**(i-1)
      F ...... |   Loop 2**(i-1) times

Main inner loop: generate +i and -i from 2**(i-1) previous sums
2K+}:@-}
          Stack: [... x i]
2K        [... x i x i]    Copy top two
  +}      [x+i ... x i]    Add top two and move to the bottom
    :@    [x+i ... i i x]  Duplicate top and rotate top 3
      -}  [i-x x+i ... i]  Subtract and move to the bottom

Counting zeroes
0lMF$z+|h
0lM        Push zero (zero count) and 2**n (loop count)
   F...|   Loop 2**n times
    $z+    Swap top two; Take logical not; add to the count
        h  Print top as number and halt
— bubbler
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.