Steenrod बीजगणित एक महत्वपूर्ण बीजगणित है जो बीजगणितीय टोपोलॉजी में आता है। Steenrod बीजगणित "Steenrod चौकों" नामक ऑपरेटरों द्वारा उत्पन्न होता है, प्रत्येक सकारात्मक पूर्णांक i के लिए मौजूद है। स्क्वेर्रोड बीजगणित के लिए एक आधार है, जिसमें स्क्वेरिंग ऑपरेशन में "स्वीकार्य मोनोमियल" शामिल हैं। इस आधार को उत्पन्न करना हमारा लक्ष्य है।

सकारात्मक पूर्णांक के एक अनुक्रम को स्वीकार्य कहा जाता है यदि प्रत्येक पूर्णांक अगले एक से कम से कम दो बार हो। तो उदाहरण के लिए [7,2,1]स्वीकार्य है क्योंकि $7 \geq 2*2$ और $2 \geq 2*1$ । दूसरी ओर, [3,2]स्वीकार्य वजह से नहीं है $3 < 2*2$ । (टोपोलॉजी में हम अनुक्रम के लिए $\mathrm{Sq}^7 \mathrm{Sq}^2\mathrm{Sq}^1$ लिखेंगे [7,2,1])।

एक अनुक्रम की डिग्री यह प्रविष्टियों की कुल है। तो उदाहरण के लिए, की डिग्री [7,2,1]है $7 + 2 + 1 = 10$ । एक स्वीकार्य अनुक्रम की अधिकता पहला तत्व है शेष तत्वों की कुल संख्या, इसलिए [7,2,1]अतिरिक्त $7 - 2 - 1 = 4$ ।

कार्य

एक प्रोग्राम लिखें जो सकारात्मक पूर्णांक की एक जोड़ी लेता है (d,e)और डिग्री के सभी स्वीकार्य अनुक्रमों के सेट को आउटपुट करता है dऔर इससे अधिक या उससे कम होता है e। आउटपुट एक सेट है इसलिए स्वीकार्य अनुक्रमों का क्रम मायने नहीं रखता है।

उदाहरण:

 Input: 3,1
 Output: [[2,1]]

यहां हम कुल 3 के साथ स्वीकार्य अनुक्रमों की तलाश कर रहे हैं। दो विकल्प हैं, [3]और [2,1]। ( [1,1,1]और [1,2]3 राशि है, लेकिन स्वीकार्य नहीं हैं)। से अधिक [3]3 और से अधिक [2,1]है $2-1 = 1$ । इस प्रकार, अतिरिक्त $\leq1$ साथ एकमात्र अनुक्रम है [2,1]।

Input: 6, 6
Output: [[6], [5, 1], [4, 2]] (or any reordering, e.g., [[5,1],[4,2],[6]])

चूँकि अधिकता हमेशा डिग्री से कम या बराबर होती है, हमारी कोई अतिरिक्त स्थिति नहीं होती है। इस प्रकार, हम सिर्फ डिग्री 6. के सभी स्वीकार्य दृश्यों विकल्प हैं खोजने की कोशिश कर रहे हैं [6], [5, 1]और [4, 2]। (इनमें अतिरिक्त $6$ , $5-1 = 4$ , और ।) $4-2=2$

Input: 10, 5
Output: [[7,3], [7,2,1], [6,3,1]]

डिग्री 10 के स्वीकार्य अनुक्रम हैं:

[[10], [9,1], [8,2], [7,3], [7,2,1], [6,3,1]]

इनमें क्रमशः $10$ , $9-1 = 8$ , $8-2 = 6$ , $7-3 = 4$ , $7-2-1 = 4$ , और $6-3-1=2$ होते हैं, इसलिए अंतिम तीन सभी काम करते हैं।

स्कोरिंग

यह कोड गोल्फ है: बाइट्स जीत में सबसे छोटा समाधान।

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

आउटपुट का कोई भी रीऑर्डरिंग उतना ही अच्छा है, इसलिए इनपुट के लिए (3, 3), आउटपुट [[3],[2,1]]या [[2,1],[3]]समान रूप से स्वीकार्य हैं (हालांकि [[1,2],[3]]ऐसा नहीं है)।

Input: 1, 1
Output: [[1]]

Input: 3, 3
Output: [[2,1], [3]]

Input: 3, 1
Output: [[2,1]]

Input: 6, 6
Output: [[6], [5, 1], [4, 2]]

Input: 6, 4
Output: [[5,1], [4,2]]

Input: 6, 1
Output: []

Input: 7, 7
Output: [[7], [6,1], [4,2,1], [5,2]]

Input: 7,1
Output: [[4,2,1]]

Input: 10, 10
Output: [[10], [9,1], [7,2,1], [6,3,1], [8,2], [7,3]]

Input: 10, 5
Output: [[7,3], [7,2,1], [6,3,1]]

Input: 26, 4
Output: [15, 7, 3, 1]

Input: 26, 6
Output: [[16, 7, 2, 1], [16, 6, 3, 1], [15, 7, 3, 1], [16, 8, 2], [16, 7, 3]]

— हुड
स्रोत

1

ठीक है, मैं एक संक्षिप्त विवरण प्रदान करूंगा।

— हुड

6

05AB1E , 16 12 बाइट्स

ग्रेमी की बदौलत 4 बाइट्स बचाए

Åœíʒx¦@P}ʒÆ@

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

व्याख्या

Åœ              # integer partitions
  í             # reverse each
   ʒ    }       # filter, keep only elements true under:
    x           # each element doubled
     ¦          # remove the first element in the doubled list
      @         # compare with greater than or equal with the non-doubled
       P        # product
         ʒ      # filter, keep only elements true under:
          Æ     # reduce by subtraction
           @    # compare with greater than or equal to second input

— Emigna
स्रोत

ćsO-बिल्ट-इन है Æ।

— ग्रिमि

भी À@¨हो सकता है ¦@।

— ग्रमी

1

@Grimy: ओह वाह, मैं कैसे याद किया कि :) धन्यवाद!

— इग्ने

5

वोल्फ्राम लैंग्वेज (गणितज्ञ) , 67 62 बाइट्स

Cases[IntegerPartitions@#,a_/;2a[[1]]-#<=#2>Max@Ratios@a<=.5]&

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

-4 बाइट्स @attinat द्वारा

IntegerPartitions@d : पूर्णांक के सभी सूचियों को समेटें d
Cases[,...]: निम्नलिखित शर्त द्वारा फ़िल्टर करें:
- 2#& @@# - d <= e &&: दो बार पहले तत्व का ऋण शून्य से कम है e, और ...
- Max@Ratios@#<=.5: सूची के क्रमिक तत्वों के अनुपात सभी 1/2 से कम हैं।

क्योंकि e.5 से कम है, हम इसे जंजीर असमानता में बदल सकते हैं।

कुछ अतिरिक्त बाइट्स के लिए, यह काफी तेज है: इसे ऑनलाइन आज़माएं!

— lirtosiast
स्रोत

1

63 बाइट्स

— अट्टिनट

5

जेली , 16 15 बाइट्स

-1 एग्री द आउटगर्फ़र (जाँच के लिए एक स्मार्ट समायोजन जो एकल फ़िल्टर की अनुमति देता है) के लिए धन्यवाद

:Ɲ;_/>¥’Ạ
ŒṗUçƇ

एक डायडिक लिंक एक सकारात्मक पूर्णांक को स्वीकार करता है, dबाईं तरफ और एक सकारात्मक पूर्णांक, eदाईं ओर जो सकारात्मक पूर्णांकों की सूची की एक पैदावार देता है।

इसे ऑनलाइन आज़माएं! (पाद लेख एक पूर्ण कार्यक्रम के रूप में जेली करता है अंतर्निहित सूची सूची से बचने के लिए परिणाम प्रारूपित करता है)

कैसे?

:Ɲ;_/>¥’Ạ - Link 1: admissible and within excess limit? descending list, L; excess limit, e
 Ɲ        - neighbour-wise:
:         -   integer division  -- admissible if all these are >1
      ¥   - last two links as a dyad - i.e. f(L,e):
    /     -   reduce (L) by:
   _      -     subtraction
     >    -   greater than (e)? (vectorises)  -- within excess if all these are ==0
  ;       - concatenate
       ’  - decrement (vectorises)
        Ạ - all (non-zero)?

ŒṗUçƇ - Main link: integer, d; integer, e
Œṗ    - partitions (of d)
  U   - reverse each
    Ƈ - filter keep those (v in that) for which:
   ç  -   call last Link (1) as a dyad - i.e. f(v, e)

— जोनाथन एलन
स्रोत

आप एक चतुर चाल के साथ एक बाइट बचा सकते हैं । यह समझने में थोड़ा समय लग सकता है कि यह क्यों काम करता है। : P

— आउटगोल्फर

@EriktheOutgolfer का कमाल, मैंने कुछ ऐसे ही तरीके आजमाए थे कि दो फिल्टरों को समेटना (समवर्ती सहित), लेकिन सब कुछ 16 के रूप में सामने आ रहा था क्योंकि मैंने एक ही समय में डीट्रिशन ट्रिक को नियोजित करने के बारे में नहीं सोचा था।

— जोनाथन एलन

4

हास्केल , 59 58 54 बाइट्स

1 बाइट ने निम्मी को धन्यवाद दिया

4 बाइट्स xnor के लिए धन्यवाद बचा लिया

0#_=[[]]
d#m=do i<-[1..div(m+d)2];(i:)<$>(d-i)#(2*i-d)

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

— पोस्ट रॉक गार्फ हंटर
स्रोत

1

आप #सीधे परिभाषित करके कुछ बाइट्स बचा सकते हैं: इसे ऑनलाइन आज़माएं!

— xnor

3

जावास्क्रिप्ट (V8) , 88 87 81 बाइट्स

के रूप में इनपुट लेता है (e)(d)। अनुक्रम को STDOUT में प्रिंट करता है।

e=>g=(d,s=x=d,a=[])=>s>0?d&&g(d-1,s,a,g(d>>1,s-d,[...a,d])):a[s]*2-x<=e&&print(a)

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

टिप्पणी की गई

e =>                  // e = maximum excess
  g = (               // g is a recursive function taking:
    d,                //   d   = expected degree; actually used as the next candidate
                      //         term of the sequence in the code below
    s =               //   s   = current sum, initialized to d; we want it to be equal
                      //         to 0 when a sequence is complete
    x = d,            //   x   = copy of the expected degree
    a = []            //   a[] = current sequence
  ) =>                //
    s > 0 ?           // if s is positive:
      d &&            //   if d is not equal to 0:
        g(            //     outer recursive call:
          d - 1,      //       decrement d
          s,          //       leave s unchanged
          a,          //       leave a[] unchanged
          g(          //       inner recursive call:
            d >> 1,   //         update d to floor(d / 2)
            s - d,    //         subtract d from s
            [...a, d] //         append d to a[]
          )           //       end of inner recursive call
        )             //     end of outer recursive call
    :                 //   else:
      a[s] * 2 - x    //     s if either 0 (success) or negative (failure)
                      //     if s is negative, a[s] is undefined and this expression
                      //     evaluates to NaN, forcing the test to fail
      <= e            //     otherwise, we test whether the excess is valid
      && print(a)     //     and we print a[] if it is

— Arnauld
स्रोत

3

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

f!>-FTvzf!<#2/MCtBT_M./

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

f!>-FTvzf!<#2/MCtBT_M./Q   Implicit: Q=input 1, vz=input 2
                           Trailing Q inferred
                     ./Q   Generate partitions of Q (ordered lists of integers which sum to Q)
                   _M      Reverse each
        f                  Filter keep elements of the above, as T, where:
               CtBT          Pair the set with itself without the first element and transpose
                             This yields all adjacent pairs of values
             /M              Integer divide each pair
           #                 Filter keep elements...
          < 2                ... less than 2
                             For admissible sequences this will be empty
         !                   Logical NOT - maps [] to true, populated lists to false
                           Result of filter are all admissible sequences
f                          Filter keep the above, as T, where:
   -FT                       Reduce T by subtraction to get degree
 !>   vz                     Is the above not greater than vz?
                           Implicit print

— सोक
स्रोत

3

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

विशालकाय सूची समझ। सबसे अधिक संभावना है कि ऐसा करने का सबसे अच्छा तरीका नहीं है, लेकिन मैं यह पता नहीं लगा सकता कि अगर बयानों को कैसे छोड़ें

import itertools as z
f=lambda d,e:[c for c in [[b for b in list(z.permutations(range(1,d+1),i)) if sum(b)==d and b[0]-sum(b[1:i])<=e and all([b[i]>=b[i+1]*2 for i in range(len(b)-1)])] for i in range(1,5)] if c]

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

from itertools import*
r=range
f=lambda d,e:filter(len,[[b for b in permutations(r(1,d+1),i)if d==sum(b)and~e<d-2*b[0]and all(i>=j*2for i,j in zip(b,b[1:]))]for i in r(5)])

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

जैसा कि @Jonas Ausevicius द्वारा संपादन के अनुसार

— OrangeCherries
स्रोत

2

साइट पर आपका स्वागत है। कुछ सुझाव: मुझे लगता है कि आप सुपर परिचित नहीं हैं जहां अजगर में रिक्ति की आवश्यकता होती है। आपके पास कुछ ऐसे स्थान हैं जहाँ रिक्त स्थान को ठीक हटाया जा सकता है, इसलिए मैं उस पर गौर करूँगा। इसके अलावा कार्य allएक जनरेटर ले सकते हैं ताकि आप all(...)इसके बजाय बस कर सकें all([...])। अंतिम रूप से आपका सबमिशन पूरी तरह से एक गुमनाम फंक्शन है जिसे आप असाइनमेंट ( f=) के लिए दंडित नहीं कर रहे हैं और इस तरह इसे अपने स्कोर (-2 बाइट्स) से घटा सकते हैं।

— पोस्ट रॉक गार्फ हंटर

उन परिवर्तनों के साथ आपका उत्तर 201 बाइट्स तक है

— पोस्ट रॉक गार्फ हंटर

ओह और यह भी python3 में आप के साथ सूची में डाल सकते हैं जिसके [*(...)]बजाय list(...)आम तौर पर एक बाइट बचाता है, लेकिन आपके मामले में 2 बचाता है क्योंकि यह आपको एक स्थान को हटाने की भी अनुमति देता है।

— पोस्ट रॉक गार्फ हंटर

2

189 बाइट्स यदि फ़िल्टर ऑब्जेक्ट को वापस करना ठीक है, अन्यथा 192 के साथ [*filter(...)]। स्वागत भी :)

— मोनिका

2

172 बाइट्स

— जोनास ऑसेविसियस

2

चारकोल , 42 बाइट्स

Ｆθ⊞υ⟦⊕ι⟧ＦυＦ…·⊗§ι⁰θ⊞υ⁺⟦κ⟧ιＩΦυ›⁼Σιθ‹η⁻⊗§ι⁰Σι

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। स्पष्टीकरण:

Ｆθ⊞υ⟦⊕ι⟧

पहले सूचियों की एक सूची बनाएं [1]..[d]।

ＦυＦ…·⊗§ι⁰θ⊞υ⁺⟦κ⟧ι

प्रत्येक सूची के लिए, पहले नंबर से दोगुनी संख्या तक सभी नंबरों को उपसर्ग करके नई सूचियां बनाएं dऔर उन सूचियों को संसाधित की जाने वाली सूचियों की सूची में जोड़ दें। यह सुनिश्चित करता है कि संख्या से अधिक नहीं होने वाले सभी स्वीकार्य अनुक्रम dबनाए जाते हैं।

ＩΦυ›⁼Σιθ‹η⁻⊗§ι⁰Σι

आउटपुट केवल उन सूचियों का है जिनकी डिग्री है dऔर अतिरिक्त से अधिक नहीं है e। (डिग्री और अधिकता का योग सूची की पहली संख्या के दोगुने के बराबर है।)

— नील
स्रोत

2

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

lambda d,e:[x for y in range(5)for x in permutations(range(1,d+1),y)if all(i>=j*2for i,j in zip(x,x[1:]))and d==sum(x)and~e<d-2*x[0]]
from itertools import*

d,eइनपुट के रूप में लेता है ; आउटपुट टुपल्स की सूची

@OrangeCherries के जवाब के समान और टिप्पणियों से मदद; लेकिन अधिक बाइट्स बचाए गए

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

— जोनास ऑसेविसियस
स्रोत

1

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

ŒṗU:Ɲ’ẠƊƇUṪ_SƊ’<ʋƇ

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

— निक केनेडी
स्रोत

1

रूबी , 78 बाइट्स

g=->(d,e,m=1){d<m ?[]:g[d-m,e+m,m*2].map{|q|q+[m]}+g[d,e,m+1]|(d>e ?[]:[[d]])}

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

— MegaTom
स्रोत

Steenrod बीजगणित के आधार तत्व उत्पन्न करें

कार्य

उदाहरण:

स्कोरिंग

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

05AB1E , 16 12 बाइट्स

वोल्फ्राम लैंग्वेज (गणितज्ञ) , 67 62 बाइट्स

जेली , 16 15 बाइट्स

कैसे?

हास्केल , 59 58 54 बाइट्स

जावास्क्रिप्ट (V8) , 88 87 81 बाइट्स

टिप्पणी की गई

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

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

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

चारकोल , 42 बाइट्स

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

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

रूबी , 78 बाइट्स