चुनौती

आइए N0 और Mसमावेशी के बीच पूर्णांकों के -tuple की कल्पना करें, और चलो इसे कॉल करें F।

कुल में (M + 1) ** Nसंभव हैं F।

ऐसे कितने लोग Fनिम्नलिखित सभी असमानताओं को पूरा करते हैं (सूचकांक एक-आधारित है)?

F[n] + F[n+1] <= M के लिये 1 <= n < N
F[N] + F[1] <= M

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

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

(N,M) => Answer

(1,1) => 1
(2,1) => 3
(3,1) => 4
(4,1) => 7

(1,2) => 2
(2,2) => 6
(3,2) => 11
(4,2) => 26

(10,3) => 39175
(10,4) => 286555
(10,5) => 1508401

(25,3) => 303734663372
(25,4) => 43953707972058
(25,5) => 2794276977562073

(100,3) => 8510938110502117856062697655362747468175263710
(100,4) => 3732347514675901732382391725971022481763004479674972370
(100,5) => 60964611448369808046336702581873778457326750953325742021695001

व्याख्या

M (max value of element) = 1

F[1] + F[1] <= 1; F = [0]
(1,1) => 1

F[1] + F[2] <= 1; F = [0,0], [0,1], [1,0]
(2,1) => 3

F = [0,0,0], [0,0,1], [0,1,0], [1,0,0]
(3,1) => 4

F = [0,0,0,0], [0,0,0,1], [0,0,1,0], [0,1,0,0], [0,1,0,1], [1,0,0,0], [1,0,1,0]
(4,1) => 7

---

M = 2

F[1] + F[1] <= 2; F = [0], [1]
(1,2) => 2

F = [0,0], [0,1], [0,2], [1,0], [1,1], [2,0]
(2,2) => 6

F = [0,0,0], [0,0,1], [0,0,2], [0,1,0], [0,1,1], [0,2,0], [1,0,0], [1,0,1],
[1,1,0], [1,1,1], [2,0,0]
(3,2) => 11

(4,2) => 26 (left as exercise for you)

नियम

यह एक प्रतिबंधित-जटिलता चुनौती है। अपने कोड के समय जटिलता में बहुपद होना चाहिए MऔरN (उदाहरण के लिए आप सभी उत्पन्न नहीं कर सकते (M + 1) ** Ntuples और उसके बाद हालत के लिए जाँच)। कृपया अपनी प्रविष्टि में अपना दृष्टिकोण स्पष्ट करें।
मानक कोड-गोल्फ नियम लागू होते हैं। बाइट्स जीत में सबसे छोटा जवाब।

code-golf restricted-complexity

— bubbler
स्रोत

7

सुन्न के साथ अजगर , 59 बाइट्स

lambda M,N:trace(mat(tri(M+1)[::-1])**N)
from numpy import*

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

रास्तों की गिनती करने के लिए मैट्रिक्स गुणा का उपयोग करता है। यदि फ्लोट प्रिसिजन एक समस्या है, तो matनिर्दिष्ट कर सकता है mat(...,int)।

— XNOR
स्रोत

का उपयोग करना मामलों के mat(...,int)लिए काम नहीं लगता है n=100। विधि सही है (उदाहरण के लिए, विशेषता बहुपद की जड़ों की शक्तियों का योग करने के लिए सहानुभूति का उपयोग करके), लेकिन संख्या में वृद्धि के रूप में कहीं न कहीं गलत होता है (शायद यह **शक्ति ऑपरेटर है?)

— जोनाथन एलन

4

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

.N?Ys:RTtYh-QNgQ+NTs:Rdtszh

प्रदर्शन

प्रारूप में इनपुट की उम्मीद है:

M
N

यह क्लासिक डायनेमिक प्रोग्रामिंग है, अब तक सेट किए गए मानों के बाएं छोर पर, दाईं ओर और अंतराल का वर्तमान आकार है।

यह कैसे काम करता है, pseudocode / Python में:

.N          | define memoized fill(left, right, gap):
?           | if cap > 0 then
s:RTtY      | sum(fill(i, right, gap - 1)
h-QN        |     for i in range(M - left + 1))
gQ+NT       | else M >= left + right
            | output:
s:Rdtsz     | sum(fill(i, i, N - 1)
h           |     for i in range(M + 1))

Qके लिए प्रयोग किया जाता है M, के zलिए प्रयोग किया जाता है N, :है fill, Nहै left, Tहै right, Yहै gap।

— isaacg
स्रोत

4

MATL , 13 12 बाइट्स

Q:&>~PiY^Xds

इसे ऑनलाइन आज़माएं! यह xnor के पायथन उत्तर और मेरे पहले MATL उत्तर का सीधा अनुवाद है , इसलिए यह सबसे अधिक संभावना नहीं है। जैसे वहाँ की तुलना में एक ऊपरी बाएँ त्रिकोणीय मैट्रिक्स पाने के लिए एक छोटा रास्ता होने की संभावना है t&lYRP। संपादित करें: और यह पता चला है कि वहाँ है, अर्थात् :&>~P। लुइस मेंडू के लिए धन्यवाद -1 बाइट के लिए!

               M is the first input and N the second
Q:             increment M and generate range from 1 to M+1
  &>           compare vector element wise with itself with greater-than function
               results in a upper-right triangular matrix
    ~          inverse to get lower-left triangular matrix
     P         flip rows to get upper-left triangular matrix
      i        input N
       Y^      take the matrix to the power of N
         Xds   compute the sum of the main diagonal

— Laikoni
स्रोत

@LuisMendo धन्यवाद! हालाँकि यह केवल एक बाइट है या कुछ और है जिसे गिराया जा सकता है?

— लकोनी

1

नहीं, यह बात है, मैं गिन नहीं सकता: -D

— लुइस मेंडो

2

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

°(√&╒íÆ½╨⌂'├╖▼1_Z

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

अनपैक्ड, अनगुल्फेड और टिप्पणी की गई, यह ऐसा दिखता है।

^1](    [1, 0, ... 0] with M zeroes
:)      get all rotations of the array
{       begin block
  {:+rm map each array to reverse(prefixSums(arr))
},v*    execute preceding block N-1 times
F       for each array, execute the rest of the program
  iT    remove the last i elements from the array, where i is the iteration index
  F+    add the remaining elements to the running total
        implicitly print output

इसको चलाओ

— पुनरावर्ती
स्रोत

2

आर , 72 बाइट्स

function(M,N)sum(diag(Reduce(`%*%`,rep(list(outer(0:M,0:M,"+")<=M),N))))

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

पोर्ट्स xnor का दृष्टिकोण।

आर के रूप में बड़े परीक्षण के मामलों में केवल 32-बिट पूर्णांक समर्थन है (वे doubleअधिकतम इंट मान तक पहुंचने के लिए डाली जाती हैं), इसलिए का उपयोग करgmp किसी अन्य मनमाने ढंग से सटीक अंकगणितीय पुस्तकालय का उपयोग करना आवश्यक होगा।

अजीब बात है, R में मैट्रिक्स पॉवर ऑपरेटर की कमी होती है, क्योंकि ^हमेशा एलिमेंट वाइज लागू होता है।

— ग्यूसेप
स्रोत

दरअसल, %^%पैकेज में ठीक से कार्यान्वित ऑपरेटर है expmजो -5 बाइट्स के लिए अनुमति देगा , लेकिन दुर्भाग्य से, यह टीआईओ पर उपलब्ध नहीं है (मुझे स्थानीय रूप से परीक्षण करना था)।

— किरिल एल

@KirillL। हाँ, मैंने उस पर विचार किया था, लेकिन मुझे लगता है कि मैं अपने आधार आर प्रतिक्रिया के साथ रहूँगा। इसके अलावा आप पूरे पैकेज में लोड न करके 60 बाइट्स तक नीचे जा सकते हैं:function(M,N)sum(diag(expm::`%^%`(outer(0:M,0:M,"+")<=M,N)))

— Giuseppe

परिपत्र लिमिटेड रकम