एक नमूने को एक सूचकांक में परिवर्तित करें

Question

हम गेंदों को एक निश्चित संख्या में डिब्बे में डाल रहे हैं । ये डिब्बे खाली होने लगते हैं।

Empty bin (a=4): 0 0 0 0 

और एक-एक करके हम गेंदों को डिब्बे में जोड़ते हैं।

0 0 0 1  or
0 0 1 0  or
0 1 0 0  or
1 0 0 0

हमें डुप्लिकेट के बिना और बिना किसी छूट के सभी संभावित राज्यों को लूप करने के लिए एक त्वरित तरीके की आवश्यकता है, और हम सभी संभव डिब्बे की गणना नहीं करना चाहते हैं। इसलिए इसके बजाय हम प्रत्येक बिन-विन्यास को एक सूचकांक प्रदान करते हैं।

हम एक विशिष्ट तरीके से संभावित विन्यासों को छाँटकर सूचकांक निर्दिष्ट करते हैं:

1. योग से आरोही क्रमबद्ध करें: तो पहले 0 0 0 0, फिर 1 गेंद के साथ संभावित विन्यास, फिर 2, आदि।

2. फिर आरोही क्रम में प्रत्येक योग के अनुसार, पहले बिन से अंतिम तक:

   0 0 0 2
   0 0 1 1
   0 0 2 0 
   0 1 0 1
   0 1 1 0 
   0 2 0 0 
   etc
   

3. सूचकांक को इस सूची के माध्यम से आरोही किया जाता है:

   0 0 0 0  -> 1
   0 0 0 1  -> 2
   0 0 1 0  -> 3
   0 1 0 0  -> 4
   1 0 0 0  -> 5
   0 0 0 2  -> 6
   0 0 1 1  -> 7
   0 0 2 0  -> 8
   0 1 0 1  -> 9
   0 1 1 0  -> 10
   0 2 0 0  -> 11 
   

नियम

एक फ़ंक्शन या प्रोग्राम बनाएं जो गैर-नकारात्मक पूर्णांक के साथ किसी भी आकार की सूची लेता है और इसके सूचकांक को प्रिंट या आउटपुट करता है। आप मान सकते हैं एक कम से कम 2. सबसे छोटा कोड जीत हो। आप 0-अनुक्रमित आउटपुट या 1-अनुक्रमित का उपयोग कर सकते हैं, लेकिन निर्दिष्ट करें कि आप किसका उपयोग करते हैं। एनबी: यहां सभी उदाहरण 1-अनुक्रमित हैं।

उदाहरण कोड

गोल्फ में नहीं, R में:

nodetoindex <- function(node){
  a <- length(node)
  t <- sum(node)
  if(t == 0) return(1)

  index <- choose(t-1 + a, a)

  while(sum(node) != 0){
    x <- node[1]
    sumrest <- sum(node)
    if(x == 0){
      node <- node[-1]
      next
    }
    a <- length(node[-1])
    index <- index + choose(sumrest + a, a) - choose(sumrest - x + a, a)
    node <- node[-1]
  }
  return(index + 1)
} 

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

10 10 10 10 -> 130571
3 1 4 1 5 9 -> 424407
2 9 -> 69
0 0 0 -> 1
0 0 1 -> 2
0 0 0 0 0 0 -> 1
1 0 0 0 0 1 -> 23

Comments

जब संख्याओं के अलग-अलग अंक होते हैं, तो समवर्ती कार्य के संख्यात्मक मूल्य के माध्यम से छंटाई कैसे होती है?

— बाइकिंग लंबी पैदल यात्रा

@ TheBikingViking hmm, उस के बारे में नहीं सोचा था, मैंने उदाहरण कोड और परीक्षण मामलों को प्रतिबिंबित करने के लिए शब्द बदल दिया। प्रत्येक राशि के भीतर, कॉन्फ़िगरेशन पहले बिन में पहले, फिर दूसरे में, और इसके बाद में क्रमबद्ध होते हैं।

— JAD

Answer 1

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

S0rṗLSÞi

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

जानवर बल समाधान। पहला परीक्षण मामला TIO के लिए बहुत अधिक है, लेकिन मैंने इसे अपने लैपटॉप पर स्थानीय रूप से सत्यापित किया है। मेरे डेस्कटॉप कंप्यूटर के लिए दूसरे परीक्षण के मामले में बहुत अधिक रैम की आवश्यकता होती है।

यह काम किस प्रकार करता है

S0rṗLSÞi  Main link. Argument: A (array)

S         Compute the sum s of A.
 0r       Create the range [0, ..., s].
    L     Yield the length l of A.
   ṗ      Cartesian power; yield the array of all l-tuples over [0, ..., s], in
          lexicographical order.
     SÞ   Sort the l-tuples by their sums. The sorting mechanism is stable, so
          l-tuples with the same sum are still ordered lexicographically.
       i  Find the index of A in the generated array of tuples.

Comments

अच्छा लगा। रैम के बारे में आपकी टिप्पणी ने मुझे इस चुनौती के स्रोत की याद दिला दी। अपनी थीसिस के लिए मुझे कुछ = 8 के लिए सभी संभावित सरणियों पर लूप करने की आवश्यकता थी और जितना संभव हो उतनी ऊंची गेंदें। सरणियों को सूचकांकों में बदलने और सिर्फ उन पर लूप करने का विचार RAM की सीमा से आया: P

— JAD

यह भी कि उदाहरण कोड इतना चिंताजनक क्यों है: P

— JAD

Answer 2

क्लोजर, 152 बाइट्स

#(loop[v[(vec(repeat(count %)0))]i 1](if-let[r((zipmap v(range))%)](+ r i)(recur(sort(set(for[v v i(range(count v))](update v i inc))))(+ i(count v)))))

जितना मैंने सोचा था उतना आसान नहीं है। कम गोल्फ वाला संस्करण:

(def f (fn[t](loop[v[(vec(repeat(count t)0))]i 1]
               (if-let[r((zipmap v(range))t)](+ r i)
                 (recur (sort-by (fn[v][(apply + v)v]) (set(for[v v i(range(count v))](update v i inc))))
                        (+ i(count v)))))))

वर्तमान स्थिति पर लूप v, vउनकी रैंक के तत्वों से एक हैश-मैप बनाता है , यदि खोजा गया राज्य मिल जाता है, तो उसकी रैंक वापस आ जाती है (+ पहले देखे गए राज्यों की संख्या)। यदि नहीं मिला है, तो संभव राज्यों के एक नए सेट के साथ पुनरावृत्ति करता है।

ओह वास्तव में हम उस कस्टम छँटाई समारोह की जरूरत नहीं है क्योंकि सभी राज्यों में प्रत्येक लूप के भीतर समान राशि है। यह उतना धीमा नहीं है जितना मुझे उम्मीद थी कि [3 1 4 1 5 9]केवल 2.6 सेकंड का समय लगेगा।

Answer 3

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

डेनिस के जेली जवाब का एक बंदरगाह ।

0~Range~Tr@#~Tuples~Length@#~SortBy~Tr~Position~#&

इनपुट के रूप में पूर्णांकों की एक सूची ले रहा है, और आउटपुट के रूप में एक पूर्णांक के साथ गहराई -2 सूची लौटा रहा है; उदाहरण के लिए, अंतिम परीक्षण मामले के लिए इनपुट है {1,0,0,0,0,1}और आउटपुट है {{23}}।

थोड़ा असम्बद्ध संस्करण है:

Position[SortBy[Tuples[Range[0,Tr[#]],Length[#]],Tr],#]&

अक्सर हम उपसर्ग संकेतन (के function@nबजाय function[n]) और infix संकेतन (के a~function~bबजाय ) का उपयोग करके Mathematica में व्यक्तिगत बाइट्स को बचा सकते हैं function[a,b]। यह केवल तभी काम करता है, जब परिणामी कोड मैथमेटिका के आंतरिक कार्य प्रक्रिया के लिए पूर्व आदेश के साथ अच्छी तरह से जाली हो जाता है। मैं यहाँ चकित था कि, चौकोर कोष्ठक के छह सेटों के साथ, इसने वास्तव में उन सभी को हटाने और छह बाइट्स को (सुखद रूप से ब्रैकेटलेस) प्रस्तुत कोड के साथ सहेजने का काम किया ।