उपयुक्त रकम के साथ मेट्रिसेस की संख्या की गणना करें

Question

जब स्टीनरोड बीजगणित के लिए मिलनोर आधार में मोनोमियल को गुणा करते हैं, तो एल्गोरिथ्म के हिस्से में कुछ "स्वीकार्य मैट्रिसेस" की गणना होती है।

Nonnegative integers r ₁ , ..., r _m और s ₁ , ..., s _n , nonnegative integers X का एक मैट्रिक्स

अगर स्वीकार्य है

1. Jth कॉलम का योग s _j से कम या बराबर है :

   

2. 2 की शक्तियों से भारित आईआईटी पंक्ति का योग r _i से कम या बराबर है :

   

कार्य

यह व्यवस्था एक जोड़ी लेता है सूचियों में से लिखें r ₁ , ..., आर _एम और एस ₁ , एस ₁ , ..., रों _n और इन सूचियों के लिए स्वीकार्य मैट्रिक्स की संख्या की गणना करता है। यदि आवश्यक हो तो आपका कार्यक्रम वैकल्पिक रूप से अतिरिक्त तर्क के रूप में एम और एन ले सकता है।

• इन नंबरों को किसी भी प्रारूप में पसंद किया जा सकता है, उदाहरण के लिए सूचियों में समूहीकृत या यूनेरी या कुछ और में एन्कोडेड।

• आउटपुट एक सकारात्मक पूर्णांक होना चाहिए

• मानक खामियां लागू होती हैं।

स्कोरिंग

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

उदाहरण:

के लिए [2]और [1], वहाँ दो स्वीकार्य मैट्रिक्स हैं:

के लिए [4]और [1,1]तीन स्वीकार्य मैट्रिक्स हैं:

के लिए [2,4]और [1,1]पाँच स्वीकार्य मैट्रिक्स हैं:

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

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

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

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

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

   Input: [3,5,7], [1,2]
   Output: 14

   Input: [7, 10], [1, 1, 1]
   Output: 15       

   Input: [3, 6, 16, 33], [0, 1, 1, 1, 1]
   Output: 38      

   Input: [7, 8], [3, 3, 1]
   Output: 44

   Input: [2, 6, 15, 18], [1, 1, 1, 1, 1]
   Output: 90       

   Input: [2, 6, 7, 16], [1, 3, 2]
   Output: 128

   Input: [2, 7, 16], [3, 3, 1, 1]
   Output: 175

Comments

IMO परिभाषा को समझना आसान होगा यदि आप पहली पंक्ति और स्तंभों का कॉलम खो देते हैं, 1 से सूचकांक, और == के बजाय <= का उपयोग करें।

— पीटर टेलर

ठीक है, कर लूंगा। मैंने सिर्फ एक गणित की पाठ्यपुस्तक की परिभाषा को कॉपी किया और इसका उन प्रविष्टियों के लिए एक वास्तविक उपयोग था।

— हूड

Answer 1

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

f=([R,...x],s)=>1/R?[...Array(R**s.length)].reduce((k,_,n)=>(a=s.map((_,i)=>n/R**i%R|0)).some(c=>(p+=c<<++j)>R,p=j=0)?k:k+f(x,s.map((v,i)=>v-a[i])),0):!/-/.test(s)

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

NB : मैंने इस स्निपेट से दो सबसे अधिक समय लेने वाले परीक्षण मामलों को हटा दिया है, लेकिन उन्हें भी पास होना चाहिए।

f=([R,...x],s)=>1/R?[...Array(R**s.length)].reduce((k,_,n)=>(a=s.map((_,i)=>n/R**i%R|0)).some(c=>(p+=c<<++j)>R,p=j=0)?k:k+f(x,s.map((v,i)=>v-a[i])),0):!/-/.test(s)

console.log(f([1],[2]))            // 1
console.log(f([2],[1]))            // 2
console.log(f([4],[1,1]))          // 3
console.log(f([2,4],[1,1]   ))     // 5      
console.log(f([3,5,7],[1,2]))      // 14
console.log(f([7,10],[1,1,1]))     // 15       
console.log(f([7,8],[3,3,1]))      // 44
console.log(f([2,6,7,16],[1,3,2])) // 128
console.log(f([2,7,16],[3,3,1,1])) // 175

टिप्पणी की गई

f = (                               // f = recursive function taking:
  [R,                               //   - the input array r[] splitted into:
      ...x],                        //     R = next element / x = remaining elements
  s                                 //   - the input array s[]
) =>                                //
  1 / R ?                           // if R is defined:
    [...Array(R**s.length)]         //   for each n in [0, ..., R**s.length - 1],
    .reduce((k, _, n) =>            //   using k as an accumulator:
      (a =                          //     build the next combination a[] of
        s.map((_, i) =>             //     N elements in [0, ..., R - 1]
          n / R**i % R | 0          //     where N is the length of s[]
        )                           //
      ).some(c =>                   //     for each element c in a[]:
        (p += c << ++j)             //       increment j; add c * (2**j) to p
        > R,                        //       exit with a truthy value if p > R
        p = j = 0                   //       start with p = j = 0
      ) ?                           //     end of some(); if truthy:
        k                           //       just return k unchanged
      :                             //     else:
        k +                         //       add to k the result of
        f(                          //       a recursive call to f() with:
          x,                        //         the remaining elements of r[]
          s.map((v, i) => v - a[i]) //         s[] updated by subtracting the values of a[]
        ),                          //       end of recursive call
      0                             //     initial value of the accumulator k
    )                               //   end of reduce()
  :                                 // else:
    !/-/.test(s)                    //   return true if there's no negative value in s[]

Answer 2

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

UḄ€Ḥ>⁴
0rŒpṗ⁴L¤µS>³;ÇẸµÐḟL

एक पूर्ण कार्यक्रम एस , आर ले रहा है जो गिनती प्रिंट करता है

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

कैसे?

UḄ€Ḥ>⁴ - Link 1, row-wise comparisons: list of lists, M
U      - upend (reverse each)
 Ḅ€    - convert €ach from binary (note bit-domain is unrestricted, e.g. [3,4,5] -> 12+8+5)
   Ḥ   - double (vectorises) (equivalent to the required pre-bit-shift by one)
     ⁴ - program's 2nd input, R
    >  - greater than? (vectorises)

0rŒpṗ⁴L¤µS>³;ÇẸµÐḟL - Main link: list S, list R
0r                  - inclusive range from 0 to s for s in S
  Œp                - Cartesian product of those lists
       ¤            - nilad followed by link(s) as a nilad:
     ⁴              -   program's 2nd input, R
      L             -   length
    ṗ               - Cartesian power = all M with len(R) rows & column values in [0,s]
        µ      µÐḟ  - filter discard if:
         S          -   sum (vectorises) = column sums
           ³        -   program's 1st input, S
          >         -   greater than? (vectorises) = column sum > s for s in S
             Ç      -   call the last link (1) as a monad = sum(2^j × row) > r for r in R
            ;       -   concatenate
              Ẹ     -   any truthy?
                  L - length

Answer 3

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

गणितज्ञों को पूर्णांकों पर असमानताओं की प्रणाली के रूप में हल करने दें। मैंने fविषमता के तीन सेटों में एक प्रतीकात्मक सरणी और थ्रेड सेट किया। Join@@बस के लिए सूची समतल Solve।

Length@Solve[Join@@Thread/@{Tr/@(t=f~Array~{q=(l=Length)@#2,l@#})<=#2,2^Range@q.t<=#,t>=0},Integers]&

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

Answer 4

गणितज्ञ 139 बाइट्स

Tr@Boole[k=Length[a=#]+1;AllTrue[a-Rest[##+0],#>=0&]&@@@Tuples[BinCounts[#,{2r~Prepend~0}]&/@IntegerPartitions[#,All,r=2^Range@k/2]&/@#2]]&

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

स्पष्टीकरण: विभाजन के प्रत्येक आर _मैं 2 की शक्तियों में और उसके बाद प्रत्येक पूर्णांक के लिए दो की शक्तियों में से एक अपघटन के साथ सभी tuples बनाता है, सूची से स्तंभ योग घटाना की है _मैं । सभी शेष प्रविष्टियों को बनाने वाले ट्यूपल्स की संख्या को सकारात्मक मानें।

Comments

आमतौर पर यह अपनी चुनौती का जवाब देने के लिए हतोत्साहित किया जाता है जब तक कि दूसरों ने पहले से ही उस भाषा में प्रस्तुत नहीं किया हो।

— हाइपरएनुट्रीनो

@HyperNeutrino मैं इसे हटा सकता हूं अगर आपको लगता है कि यह एक अच्छा विचार है। यह सुपर ध्यान से गोल्फ नहीं है, इसलिए यह बहुत संभावना है कि अन्य बेहतर कर सकते हैं।

— हुड

हालांकि यह साबित करने में सक्षम होने के लिए एक बुरी बात नहीं है, मैं समाधान को इतनी जल्दी खराब करने की सलाह नहीं देता। शायद एक हफ्ते पहले या कुछ और इंतजार करें।

— एर्गेल आउटफर

तो क्या मुझे इसे हटा देना चाहिए या इसे अभी छोड़ देना चाहिए कि मैंने इसे पोस्ट किया है?

— हूड

मैं इसे छोड़ दूंगा। पेस एरिक मुझे नहीं लगता कि यह कुछ भी खराब करता है: एक समाधान का अस्तित्व इस तथ्य से स्पष्ट है कि स्तंभ राशि बाधा का सम्मान करने वाले मेट्राइट्स परिमित और आसानी से उत्पन्न होते हैं।

— पीटर टेलर