40 लाठी का आदेश

Question

हमारे पास समान चौड़ाई की 40 छड़ें हैं लेकिन अलग-अलग ऊंचाइयां हैं। उन्हें एक-दूसरे के बगल में रखने के लिए कितने इंतजाम हैं ताकि जब हम दाईं ओर से देखें तो हमें 10 छड़ें दिखाई दें और जब हम बाईं ओर देखें तो हम फिर से ठीक 10 छड़ें देखें?

उदाहरण के लिए इस तरह के एक आदेश है:

काली छड़ियाँ छिपी हुई हैं, लाल छड़ें हैं जिन्हें आप बाईं ओर से देख सकते हैं, नीली छड़ें हैं जिन्हें आप देख सकते हैं जब आप दाएं और बैंगनी से दिखते हैं (यानी सबसे लंबा) वह है जिसे देखा जा सकता है दोनों तरफ से।

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

• अगर हमारे पास 2 से 2 देखने के लिए 3 क्रम संख्याएँ हैं और 2 दाएँ से 2 है
• यदि हमारे पास क्रम से 5 छड़ें हैं तो 3 बाईं ओर से और 3 दाईं ओर से 6 हैं
• यदि हमारे पास 10 स्टिक्स संख्याएँ हैं तो 4 बाईं ओर से और 4 दाईं ओर से 90720 है

Comments

आप निश्चित आउटपुट के साथ प्रश्नों से बचना चाह सकते हैं क्योंकि इष्टतम कोड-गोल्फ उत्तर शायद परिणाम की गणना किए बिना ही प्रिंट करेगा। मेरा सुझाव है कि सवाल बनाने के लिए कुछ चर इनपुट होते हैं, जैसे N चिपक जाता है जैसे कि आप उनमें से K को बाएँ / दाएँ से देखते हैं, जहाँ N और K इनपुट पूर्णांक हैं

— Sp3000

यदि आप ऐनक को बदलते हैं तो प्रोग्राम इनपुट में लेते हैं (मैं नहीं देखता - क्यों आपके पास पहले से ही परीक्षण के मामले हैं), आप इस बारे में सोचना चाहते हैं कि आप कार्यक्रमों पर समय सीमा लगाना चाहते हैं या नहीं।

— Sp3000

"40/10 मामले की गणना के लिए अपने पोस्ट किए गए प्रोग्राम का उपयोग करना चाहिए" एक अच्छा पर्याप्त समय सीमा होनी चाहिए।

— feersum

मैं इस तथ्य पर नहीं पहुँच सकता कि 10!/40 = 90720... क्या यह संयोग है?

— टिम

@ क्या 90720 का महत्व है? लॉस Alamitos, CA के लिए ज़िप कोड ?

— डिजिटल ट्रामा

Answer 1

PARI / जीपी, 80

f(n,v)=abs(sum(k=1,n-1,binomial(n-1,k)*stirling(k,v-1,1)*stirling(n-k-1,v-1,1)))

पेंसिल / ग्रिड गेम के बाद दिखाई देने वाली छड़ियों की संख्या को स्काईस्क्रेपर नंबर भी कहा जाता है । यह कोड OEIS A218531 से सूत्र (केवल थोड़ा परिवर्तित) पर आधारित है । मुझे ज्यादा PARI का पता नहीं है, लेकिन मुझे नहीं लगता कि यहाँ गोल्फ के लिए बहुत कुछ है।

टेस्ट केस सभी ideone.com पर दिखाए जाते हैं । के लिए परिणाम f(40,10)है:

192999500979320621703647808413866514749680

Comments

सूत्र का एक अच्छा कारण है। vवाम-दृश्य छड़ के साथ क्रमपरिवर्तन की संख्या स्टर्लिंग संख्या है s(n,v)। यदि सबसे ऊँची छड़ी स्थिति में है k, तो बाईं ओर की छड़ें उस छड़ी और बाईं-दृश्यमान छड़ें k-1, स्थिति के बाईं ओर के उप-क्रमांकन में उप-क्रमांकन में चिपक जाती हैं k। तो, vबाईं ओर दिखाई देने वाली छड़ें और vदाईं ओर की छड़ें देखने के लिए, किसी के पास s(k,v-1)बाईं आधी की अनुमति देने के लिए, s(n-k-1,v-1)दाईं ओर की आधी binomial(n-1,k)करने के लिए और दो हिस्सों में लाठी को विभाजित करने के लिए विकल्प हैं।

— xnor

@xnor वे मूल रूप से लिंक किए गए PDF में वह स्पष्टीकरण देते हैं, लेकिन आपका शब्द बेहतर IMO है।

— ज्योबिट्स

आप 11 बाइट्स बचा सकते हैं f(n,v,s=stirling)=abs(sum(k=1,n--,binomial(n,k)*s(k,v-1)*s(n-k,v-1))):। यह sterlingपुन: उपयोग के लिए एक चर में बचाता है, अपने अंतिम तर्क को छोड़ देता है, क्योंकि 1 डिफ़ॉल्ट है, और तीन बार के बजाय एक बार n से 1 घटाता है।

— चार्ल्स

Answer 2

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

इससे बहुत खुश नहीं हैं।

import itertools as i
x=input().split()
y,k=x
y=int(y)
c=0
x=list(i.permutations(list(range(1,y+1))))
for s in x:
 t=d=0;l=s[::-1]
 for i in range(y):
  if max(s[:i+1])==s[i]:t+=1
 for i in range(y):
  if max(l[:i+1])==l[i]:d+=1
 if t==d==int(k):c+=1
print(c)

उदाहरण इनपुट और आउटपुट:

10 4
90720

यह प्रदान की गई रेंज के सभी संभावित संयोजनों को उत्पन्न करता है, और फिर उनके माध्यम से लूप करता है, प्रत्येक संख्या की जांच करके यह देखने के लिए कि क्या यह पिछले संख्याओं के अधिकतम के बराबर है। यह फिर वही पीछे की ओर करता है, और यदि गिनती आगे (टी) = पीछे की ओर गिनती (डी) = दिए गए दृश्य संख्या (के) यह एक वैध है। यह इसे एक काउंटर (c) में जोड़ता है और अंत में प्रिंट करता है।

Answer 3

आर, 104

function(N,K)sum(sapply(combinat::permn(N),function(x)(z=function(i)sum(cummax(i)==i)==K)(x)&z(rev(x))))

डी-गोल्फ थोड़ा:

    function(N,K) {
      all_perm <- combinat::permn(N)
      can_see_K_from_left <- function(i)sum(cummax(i) == i) == K
      can_see_K_from_both <- function(x)can_see_K_from_left(x) &
                                        can_see_K_from_left(rev(x))
      return(sum(sapply(all_perm, can_see_K_from_both)))
    }

Answer 4

पायथ - 38 36 बाइट्स

मूल रूप से R उत्तर का एक बंदरगाह है। बहुत धीमी गति से, 10, 4ऑनलाइन भी पूरा नहीं कर सकते ।

AGHQLlfqhS<bhT@bTUGlf!-,yTy_TH.pr1hG

केवल चीजें पायथ में क्यूमैक्स और ==ओवर वैक्टर नहीं हैं, लेकिन उन लोगों ने केवल कुछ बाइट्स को लागू करने के लिए लिया।

स्पष्टीकरण और आगे गोल्फिंग जल्द ही आ रहा है।

इसे यहाँ ऑनलाइन प्रयास करें ।