एक अनुक्रम से संग्रह जो एक पूर्ण वर्ग का गठन करता है

Question

अनुक्रम OEIS A033581 को देखते हुए , जो कि अनंत अनुक्रम है, n 'th टर्म (0-इंडेक्सिंग) को बंद फॉर्मूला 6 × n ² द्वारा दिया गया है ।

आपका कार्य कोड लिखना है, जो अनुक्रम में एन पहले नंबर के सेट के सभी सबसेट को आउटपुट करता है, जैसे कि सबसेट का योग एक पूर्ण वर्ग है।

नियम

• पूर्णांक Nइनपुट के रूप में दिया जाता है।
• आप पहले से ही राशि में उपयोग किए गए नंबर का पुन: उपयोग नहीं कर सकते। (अर्थात, प्रत्येक संख्या प्रत्येक सबसेट में एक बार दिखाई दे सकती है)
• उपयोग किए गए नंबर गैर-निरंतर हो सकते हैं।
• कम से कम आकार की जीत वाला कोड।

उदाहरण

दिया गया क्रम {0,6,24,54,96, ..., 15000} है

आवश्यक सबसेट में से एक {6,24,294} होगा, क्योंकि

6+24+294 = 324 = 18^2

आपको दिए गए रेंज में सभी संभव लंबाई के ऐसे सभी सेट खोजने की आवश्यकता है।

Comments

अच्छी पहली पोस्ट! आप उदाहरण और परीक्षण मामलों को जोड़ने पर विचार कर सकते हैं। भविष्य के संदर्भ के लिए, हमारे पास एक सैंडबॉक्स है जिसमें आप अपने विचारों का परीक्षण कर सकते हैं।

— urous

क्या यह हमें A033581 दिए गए N की गणना करने के लिए कह रहा है? या मैं इसे सही तरीके से नहीं समझ रहा हूं?

— ATaco

@ATaco एक अनुक्रम के लिए (1,9,35,39 ...) 1 + 9 + 39 = 49 एक पूर्ण वर्ग (यह 3 संख्याओं का उपयोग करता है), 35 + 1 = 36 एक और पूर्ण वर्ग लेकिन यह 2 संख्याओं का उपयोग करता है। इसलिए {1,35} आवश्यक सेट है।

— prog_SAHIL

@prog_SAHIL को जोड़ना, और कुछ और, उदाहरण के लिए पोस्ट के लिए उपयोगी होगा :)

— 9urous

आइए हम इस चर्चा को चैट में जारी रखते हैं ।

— prog_SAHIL

Answer 1

05AB1E , 10 बाइट्स

ݨn6*æʒOŲ

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

कैसे?

ݨn6 * æʒOŲ || पूरा कार्यक्रम। मैं इनपुट एन।

Ý || 0-आधारित समावेशी रेंज। धक्का [को ०, एन]]]।
 ¨ || अंतिम तत्व निकालें।
  एन || वर्ग (तत्व-वार)।
   6 * || 6 से गुणा करें।
     æ || सत्ता स्थापित।
      ʒ || जिनको संतुष्ट करना है उन्हें फ़िल्टर करें:
       ओ || --- | उनकी राशि ...
        | || --- | ... एक पूर्ण वर्ग है?

Answer 2

हास्केल , 114 104 103 86 बाइट्स

f n=[x|x<-concat<$>mapM(\x->[[],[x*x*6]])[0..n-1],sum x==[y^2|y<-[0..],y^2>=sum x]!!0]

अधिकांश गोल्फिंग के लिए लाइकोनी और अर्जन जोहान्सन को धन्यवाद ! :)

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

थोड़ा अधिक पठनीय संस्करण:

--  OEIS A033581
ns=map((*6).(^2))[0..]

-- returns all subsets of a list (including the empty subset)
subsets :: [a] -> [[a]]
subsets[]=[[]]
subsets(x:y)=subsets y++map(x:)(subsets y)

-- returns True if the element is present in a sorted list
t#(x:xs)|t>x=t#xs|1<2=t==x

-- the function that returns the square subsets
f :: Int -> [[Int]]
f n = filter (\l->sum l#(map(^2)[0..])) $ subsets (take n ns)

Comments

@ लिकोनी जो बहुत ही सरल है! धन्यवाद!

— क्रिस्टियन लुपस्कू

@ लायकोनी सही! धन्यवाद!

— क्रिस्टियन लुपस्कू

86 बाइट्स: इसे ऑनलाइन आज़माएं!

— अर्जन जोहान्सन

Answer 3

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

-2 बाइट्स मिस्टर एक्सकोडर की बदौलत

fsI@sT2ym*6*

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

हटाने के लिए 2 और बाइट्स जोड़ने की आवश्यकता है []और [0], लेकिन वे मुझे मान्य आउटपुट की तरह लगते हैं!

---

Explanataion

    fsI@sT2ym*6*
    f                  filter
           y           the listified powerset of
            m*6*ddQ    the listified sequence {0,6,24,...,$input-th result}
        sT             where the sum of the sub-list
     sI@  2            is invariant over int parsing after square rooting

Comments

12 बाइट्स: fsI@sT2ym*6*।

— श्री एक्सकोडर

कि मैं देख रहा था वर्ग जाँच गोल्फ है!

— डेव

Answer 4

क्लीन , 145 ... 97 बाइट्स

import StdEnv
@n=[[]:[[6*i^2:b]\\i<-[0..n-1],b<- @i]]
f=filter((\e=or[i^2==e\\i<-[0..e]])o sum)o@

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

पुनर्संरचना के प्रत्येक शब्द के साथ , और रिवर्स ऑर्डर में प्रत्येक अवधि को संक्षिप्त करके शब्दों @को सेट करने की शक्ति उत्पन्न करने के लिए सहायक फ़ंक्शन का उपयोग करता है ।n[[],[6*n^2],...][[],[6*(n-1)*2],...]

आंशिक फ़ंक्शन fतब रचना की जाती है (जहां रचना ->को दर्शाता oहै):
apply @ -> take the elements where -> the sum -> is a square

दुर्भाग्यवश f=आंशिक कार्य शाब्दिक को छोड़ना और प्रदान करना संभव नहीं है , क्योंकि इनलाइन होने पर पूर्ववर्ती नियमों के लिए कोष्ठक की आवश्यकता होती है।

Comments

बाह आपको एक चाल मिल गई है हास्केल जवाब चोरी करना चाहिए ...: पी

— अर्जन जोहान्सन

Answer 5

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

Ḷ²6׌PSƲ$Ðf

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

आउटपुट, 0एस और खाली उपसमूह सहित सबसेट की एक सूची है ।

Answer 6

वोल्फ्राम लैंग्वेज (मैथेमेटिका) , 49 बाइट्स

जानवर बल दृष्टिकोण

Select[Subsets[6Range[#]^2],Sqrt@Tr@#~Mod~1==0&]&

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

Answer 7

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

n=>[...Array(n)].reduce((a,_,x)=>[...a,...a.map(y=>[6*x*x,...y])],[[]]).filter(a=>eval(a.join`+`)**.5%1==0)

डेमो

let f =

n=>[...Array(n)].reduce((a,_,x)=>[...a,...a.map(y=>[6*x*x,...y])],[[]]).filter(a=>eval(a.join`+`)**.5%1==0)

console.log(f(6).map(a => JSON.stringify(a)).join('\n'))
console.log(f(10).map(a => JSON.stringify(a)).join('\n'))

टिप्पणी की गई

n =>                      // n = input
  [...Array(n)]           // generate a n-entry array
  .reduce((a, _, x) =>    // for each entry at index x:
    [                     //   update the main array a[] by:
      ...a,               //     concatenating the previous values with
      ...a.map(           //     new values built from the original ones
        y =>              //     where in each subarray y:
          [ 6 * x * x,    //       we insert a new element 6x² before
            ...y       ]  //       the original elements
      )                   //     end of map()
    ],                    //   end of array update
    [[]]                  //   start with an array containing an empty array
  )                       // end of reduce()
  .filter(a =>            // filter the results by keeping only elements for which:
    eval(a.join`+`) ** .5 //   the square root of the sum
    % 1 == 0              //   gives an integer
  )                       // end of filter()

Answer 8

जाप , 15 बाइट्स

ò_²*6Ãà k_x ¬u1

कोशिश करो

---

व्याख्या

0 से इनपुट तक के पूर्णांक के सरणी को उत्पन्न करें ( ò) और प्रत्येक को एक फंक्शन ( _ Ã) के माध्यम से पास करें , इसे स्क्वेर करें ( ²) और 6 से उत्परिवर्तित करें ( *6)। उस सरणी के सभी संयोजनों को प्राप्त करें ( à) और उन लोगों को हटा दें जो kएक फ़ंक्शन ( _) के माध्यम से पारित होने पर सच्चाई ( ) को वापस करते हैं जो उनके तत्वों को जोड़ता है ( x), परिणाम का वर्गमूल प्राप्त करता है ( ¬) और mods कि 1 ( u1) द्वारा