पहले 'n' नंबरों से शून्य बनाएं

Question

चुनौती

चुनौती एक कोड लिखने की है जो एक इनपुट के रूप में एक सकारात्मक पूर्णांक 'एन' लेता है और सभी संभावित तरीकों को प्रदर्शित करता है जिसमें 1 - n से संख्याओं को लिखा जा सकता है, बीच में सकारात्मक या नकारात्मक संकेत, जैसे कि उनका योग। शून्य के बराबर। कृपया याद रखें कि आप केवल जोड़ या घटाव का उपयोग कर सकते हैं।

उदाहरण के लिए, यदि इनपुट 3 है, तो योग 0 बनाने के 2 तरीके हैं:

 1+2-3=0
-1-2+3=0

ध्यान दें कि, संख्याएं क्रम में हैं, 1 से शुरू होकर n तक (जो इस मामले में 3 है)। जैसा कि यह उदाहरण से स्पष्ट है, पहली संख्या का संकेत नकारात्मक भी हो सकता है, इसलिए सावधान रहें।

अब, 3 बहुत सरल था। जब हम संख्या 7 पर विचार करते हैं तो हम सभी तरीकों को सूचीबद्ध करते हैं।

 1+2-3+4-5-6+7=0
 1+2-3-4+5+6-7=0
 1-2+3+4-5+6-7=0
 1-2-3-4-5+6+7=0
-1+2+3+4+5-6-7=0
-1+2-3-4+5-6+7=0
-1-2+3+4-5-6+7=0
-1-2+3-4+5+6-7=0

तो यहां, हमें कुल 8 संभावित तरीके मिले हैं।

---

इनपुट और आउटपुट

जैसा कि पहले कहा गया था, इनपुट एक सकारात्मक पूर्णांक होगा । आपके आउटपुट में सभी संभावित तरीके शामिल होने चाहिए जिसमें संख्याएँ शून्य का योग दें। यदि ऐसा करने का कोई संभव तरीका नहीं है , तो आप अपनी पसंद के अनुसार कुछ भी आउटपुट कर सकते हैं।

इसके अलावा, आप आउटपुट को अपने पसंद के किसी भी प्रारूप में प्रिंट कर सकते हैं । लेकिन, इसे समझना चाहिए । उदाहरण के लिए, आप इसे उपरोक्त उदाहरण में प्रिंट कर सकते हैं। या, आप क्रम में संख्याओं के संकेत मुद्रित कर सकते हैं। अन्यथा, आप '0' और '1' क्रम में भी प्रिंट कर सकते हैं, जहाँ '0' नकारात्मक चिन्ह प्रदर्शित करेगा और '1' सकारात्मक चिन्ह (या इसके विपरीत) प्रदर्शित करेगा।

उदाहरण के लिए, आप 1 + 2-3 = 0 का प्रतिनिधित्व कर सकते हैं:

1+2-3=0
1+2-3
[1,2,-3]
++-
110
001    

हालांकि, मैं सादगी के लिए पहले तीन प्रारूपों में से किसी का उपयोग करने की सलाह दूंगा। आप मान्य होने के लिए सभी इनपुट मान सकते हैं।

---

उदाहरण

7 ->

 1+2-3+4-5-6+7=0
 1+2-3-4+5+6-7=0
 1-2+3+4-5+6-7=0
 1-2-3-4-5+6+7=0
-1+2+3+4+5-6-7=0
-1+2-3-4+5-6+7=0
-1-2+3+4-5-6+7=0
-1-2+3-4+5+6-7=0

4 ->

 1-2-3+4=0
-1+2+3-4=0

2 -> -

8 ->

 1+2+3+4-5-6-7+8=0
 1+2+3-4+5-6+7-8=0
 1+2-3+4+5+6-7-8=0
 1+2-3-4-5-6+7+8=0
 1-2+3-4-5+6-7+8=0
 1-2-3+4+5-6-7+8=0
 1-2-3+4-5+6+7-8=0
-1+2+3-4+5-6-7+8=0
-1+2+3-4-5+6+7-8=0
-1+2-3+4+5-6+7-8=0
-1-2+3+4+5+6-7-8=0
-1-2+3-4-5-6+7+8=0
-1-2-3+4-5+6-7+8=0
-1-2-3-4+5+6+7-8=0

---

स्कोरिंग

यह कोड-गोल्फ है , इसलिए सबसे छोटा कोड जीतता है!

Comments

कृपया ध्यान दें कि यह codegolf.stackexchange.com/questions/8655/… का डुप्लिकेट नहीं है , क्योंकि यह चुनौती इनपुट के रूप में केवल n लेने के लिए है और क्रम में सभी नंबर 1-n का उपयोग करने के लिए है।

— मनीष कुंडू

हम प्रतिनिधित्व कर सकते हैं +के रूप में Nऔर -के रूप में -N, या कि यह बहुत दूर ले जा रहा है? (उदाहरण 3-> [[-3,-3,3], [3,3,-3]])

— जोनाथन एलन

@JonathanAllan आउटपुट प्रारूपों की सूची में उल्लिखित नहीं है? या मैंने आपके प्रश्न की गलत व्याख्या की?

— मनीष कुंडू

मेरा मतलब है 0और 1विकल्प की तरह लेकिन उपयोग करना Nऔर -N(ऊपर मेरा संपादन देखें)

— जोनाथन एलन

@JonathanAllan हाँ thats निश्चित रूप से अनुमति दी। सुनिश्चित करें कि आपने उत्तर में इसका उल्लेख किया है।

— मनीष कुंडू

Answer 1

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

f n=[l|l<-mapM(\i->[i,-i])[1..n],0==sum l]

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

Comments

४२ ।

— user202729

यह नहीं होना चाहिए 0==?

— लकोनी

Answer 2

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

1,-ṗ×RSÐḟ

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

ऍक्स्प

1,-ṗ×RSÐḟ  Main link. Input = n. Assume n=2.
1,-        Literal list [1, -1].
   ṗ       Cartesian power n. Get [[1, 1], [1, -1], [-1, 1], [-1, -1]]
    ×R     Multiply (each list) by Range 1..n.
       Ðḟ  ḟilter out lists with truthy (nonzero)
      S      Sum.

---

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

जोनाथन एलन का सुझाव, संकेतों की एक सूची का उत्पादन।

1,-ṗæ.ÐḟR

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

Comments

कैसे के बारे में (एबी?) के साथ lax उत्पादन प्रारूप का उपयोग कर ,Nṗæ.ÐḟR?

— जोनाथन एलन

या वैकल्पिक रूप से, यह आउटपुट आउटपुट को कई गुना बढ़ा देता है n।

— user202729

Nऔर -Nउत्पादन मैं सुझाव दिया, अनुमति दी गई है, ताकि एक बाइट :) (बस जवाब में प्रारूप का उल्लेख करने की जरूरत है) की बचत होती है

— जोनाथन एलन

Answer 3

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

f=lambda n,*l:f(n-1,n,*l)+f(n-1,-n,*l)if n else[l]*(sum(l)==0)

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

मिस्टर एक्सकोडर ने तारांकित तर्कों के निफ्टी उपयोग के साथ 4 बाइट्स बचाए।

Comments

के*l बजाय 62 बाइट्स का उपयोग करl=[]

— श्री Xcoder

Answer 4

पर्ल, 37 36 बाइट्स

perl -E 'map eval||say,glob join"{+,-}",0..<>' <<< 7

Comments

अच्छी तरह से किया। आप ड्रॉप कर सकते हैं -nऔर <<<यदि आप के $_साथ प्रतिस्थापित करते हैं pop। यह वास्तव में आपके स्कोर में सुधार नहीं करता है, लेकिन यह समग्र अभिव्यक्ति को कम कर देता है;)

— क्रिस

Answer 5

05AB1E , 11 बाइट्स

®X‚¹ãʒ¹L*O_

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

उदाहरण के इनपुट के लिए आउटपुट स्वरूप 3है:

[[-1, -1, 1], [1, 1, -1]]

यही कारण है, -1-2+3, 1+2-3।

Answer 6

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

Pick[p={1,-1}~Tuples~#,p.Range@#,0]&

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

Answer 7

भूसी , 10 बाइट्स

fo¬ΣΠmSe_ḣ

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

व्याख्या

बहुत जटिल नहीं है।

fo¬ΣΠmSe_ḣ  Implicit input, say n=4
         ḣ  Range: [1,2,3,4]
     m      Map over the range:
      Se     pair element with
        _    its negation.
            Result: [[1,-1],[2,-2],[3,-3],[4,-4]]
    Π       Cartesian product: [[1,2,3,4],[1,2,3,-4],..,[-1,-2,-3,-4]]
f           Keep those
   Σ        whose sum
 o¬         is falsy (equals 0): [[-1,2,3,-4],[1,-2,-3,4]]

Answer 8

पायथन 3 , 105 बाइट्स

lambda n:[k for k in product(*[(1,-1)]*n)if sum(-~n*s for n,s in enumerate(k))==0]
from itertools import*

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

Answer 9

स्विफ्ट , 116 बाइट्स

func f(n:Int){var r=[[Int]()]
for i in 1...n{r=r.flatMap{[$0+[i],$0+[-i]]}}
print(r.filter{$0.reduce(0){$0+$1}==0})}

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

व्याख्या

func f(n:Int){
  var r=[[Int]()]                         // Initialize r with [[]]
                                          // (list with one empty list)
  for i in 1...n{                         // For i from 1 to n:
    r=r.flatMap{[$0+[i],$0+[-i]]}         //   Replace every list in r with the list
  }                                       //   prepended with i and prepended with -i
  print(r.filter{$0.reduce(0){$0+$1}==0}) // Print all lists in r that sums to 0
}

Answer 10

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

lambda x:[s for s in[[~j*[1,-1][i>>j&1]for j in range(x)]for i in range(2**x)]if sum(s)==0]

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

संतोषजनक सूची की सूची लौटाता है (जैसे, f (3) = [[- 1, -2,3], [1,2, -3]])

Answer 11

APL (Dyalog) , 38 बाइट्स

{k/⍨0=+/¨k←((,o∘.,⊢)⍣(⍵-1)⊢o←¯1 1)×⊂⍳⍵}

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

Answer 12

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

f!sT.nM*F_BMS

यहाँ यह कोशिश करो!

Answer 13

सी (जीसीसी) , 171 बाइट्स

k,s;f(S,n,j)int*S;{if(j--)S[j]=~0,f(S,n,j),S[j]=1,f(S,n,j);else{for(s=k=0;k<n;k++)s+=S[k]*-~k;if(!s&&puts(""))for(k=0;k<n;)printf("%d",S[k++]+1);}}F(n){int S[n];f(S,n,n);}

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

Answer 14

क्लीन , 79 बाइट्स

import StdEnv
$n=[k\\k<-foldr(\i l=[[p:s]\\s<-l,p<-[~i,i]])[[]][1..n]|sum k==0]

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

Answer 15

पायथन 3 + सुन्न, 104 103 बाइट्स

import itertools as I,numpy as P
lambda N:[r for r in I.product(*[[-1,1]]*N)if sum(P.arange(N)*r+r)==0]

संकेत के अनुरूप आउटपुट [-1, 1] है।

Comments

आप if1 बाइट से पहले स्पेस निकाल सकते हैं

— ov

Answer 16

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

@Neil द्वारा सुझाए अनुसार k से छुटकारा पाने के लिए 8 बाइट्स बचाए

अलर्ट के साथ सभी समाधान प्रिंट करता है () ।

f=(n,o='')=>n?f(n-1,o+'+'+n)&f(n-1,o+'-'+n):eval(o)||alert(o)

परीक्षण के मामलों

उपयोगकर्ता-मित्रता के लिए अलर्ट () के बजाय कंसोल.लॉग () का उपयोग करना ।

f=(n,o='')=>n?f(n-1,o+'+'+n)&f(n-1,o+'-'+n):eval(o)||alert(o)

alert = console.log;

console.log('[7]');f(7)
console.log('[4]');f(4)
console.log('[2]');f(2)
console.log('[8]');f(8)

Comments

क्या आपको जरूरत है k? कुछ इस तरह से:f=(n,o='')=>n?['+','-'].map(c=>f(n-1,c+n+o)):eval(o)||alert(o)

— नील

@ नील मैं सच में नहीं ... धन्यवाद।

— अरनौलड

Answer 17

रेटिना , 73 बाइट्स

.+
*
_
=_$`
+0`=
-$%"+
(-(_)+|\+(_)+)+
$&=$#2=$#3=
G`(=.+)\1=
=.*

_+
$.&

इसे ऑनलाइन आज़माएं! स्पष्टीकरण:

.+
*

इनपुट को unary में बदलें।

_
=_$`

संख्या को =-prefixed संख्याओं की सूची में कनवर्ट करें।

+0`=
-$%"+

प्रत्येक =बार बदले में दोनों को बदलें -और +हर बार लाइनों की संख्या को दोहराएं।

(-(_)+|\+(_)+)+
$&=$#2=$#3=

अलग से s और s के _बाद -s की संख्या को गिनें +। यह ऋणात्मक और धनात्मक संख्याओं को दर्शाता है।

G`(=.+)\1=

केवल उन पंक्तियों को रखें जहाँ -s और +s रद्द करें।

=.*

गिनती हटाएं।

_+
$.&

दशमलव में परिवर्तित करें।

Answer 18

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

{grep *.sum==0,[X] (1..$_ X*1,-1).rotor(2)}

कोशिश करो
सूची का एक क्रम देता है

विस्तारित:

{  # bare block lambda with implicit parameter ｢$_｣

  grep              # only return the ones
    *.sum == 0,     # that sum to zero

    [X]             # reduce with cross meta operator

      (
          1 .. $_   # Range from 1 to the input

        X*          # cross multiplied by

          1, -1

      ).rotor(2)    # take 2 at a time (positive and negative)
}

1..$_ X* 1,-1⇒ (1, -1, 2, -2)
(…).rotor(2)स्वभाव ((1, -1), (2, -2))
[X] …⇒((1, 2), (1, -2), (-1, 2), (-1, -2))

Answer 19

जे , 35 30 बाइट्स

-5 बाइट्स FrownyFrog के लिए धन्यवाद!

>:@i.(]#~0=1#.*"1)_1^2#:@i.@^]

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

मूल:

जे , 35 बाइट्स

[:(#~0=+/"1)>:@i.*"1(_1^[:#:@i.2^])

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

मैं सूची को 1. गुणांक 1 / -1 के सभी संभावित सूचियों के साथ गुणा करता हूं और उन लोगों को खोजता हूं जो शून्य तक जोड़ते हैं।

                    (             ) - the list of coefficients
                             i.     - list 0 to 
                               2^]  - 2 to the power of the input
                     _1^[:          - -1 to the power of 
                          #:@       - each binary digit of each number in 0..n-1 to 
                 *"1                - each row multiplied by
            >:@i.                   - list 1..n
  (#~      )                        - copy those rows
     0=+/"1                         - that add up to 0
[:                                  - compose   

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

एक विकल्प के रूप में मैंने +/-: के कार्टेशियन उत्पाद के दृष्टिकोण का उपयोग करके एक स्पष्ट क्रिया की कोशिश की:

जे , 37 बाइट्स

3 :'(#~0=+/"1)(-y)]\;{(<"1@,.-)1+i.y'

{(<"1@,.-) उदाहरण के लिए कार्टेशियन उत्पाद पाता है:

{(<"1@,.-) 1 2 3
┌───────┬────────┐
│1 2 3  │1 2 _3  │
├───────┼────────┤
│1 _2 3 │1 _2 _3 │
└───────┴────────┘

┌───────┬────────┐
│_1 2 3 │_1 2 _3 │
├───────┼────────┤
│_1 _2 3│_1 _2 _3│
└───────┴────────┘

बहुत बुरा है कि यह परिणाम को बॉक्स करता है, इसलिए मैंने मूल्यों को अनबॉक्स करने के लिए कुछ बाइट्स खर्च किए

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

Comments

@FrownyFrog धन्यवाद, मैं अपने कोड के दाईं ओर खुश नहीं था।

— गैलेन इवानोव