संख्याओं को "बहुत जगह-मूल्य प्रणाली नहीं" में बदलना

Question

चलो संख्याओं की एक प्रणाली बनाते हैं जहाँ nth स्थान मान का सबसे बड़ा अंक (संख्या से दाएं से बाएं) की लंबाई हमेशा m - n + 1 के बराबर होती है। उदाहरण के लिए इस प्रणाली में सबसे बड़ी 5 अंकों की संख्या व्यक्त करने के लिए 12345 लिखा है। एक विशेष स्थान पर प्रतिबंधित होने के लिए उपलब्ध अंकों की संख्या के अलावा, अन्य सभी वृद्धि मानक है। अर्थात् जब कोई अंक अपनी अंकों की सीमा को पार कर जाता है तो हम अगले अंक में एक जोड़ देते हैं।

यहाँ बताया गया है कि इस प्रणाली में गिनती का प्रतिनिधित्व कैसे किया जाएगा:

1; 10; 11; 12; 100; 101; 102; 103; 110; 111; 112; 113; 120; 121; 122; 123; 1000; 1001 ...

आपका कार्य एक फ़ंक्शन लिखना है जो एक मानक आधार 10 नंबर लेता है और इसे मेरी संख्या प्रणाली में परिवर्तित करता है।

कम कोड बेहतर है। सौभाग्य!

** यदि आपको 9 के बाद अंकों की आवश्यकता है (आपको चाहिए) तो आप अक्षरों का उपयोग करना चुन सकते हैं, या आप सूची के एक तत्व के रूप में 2 अंकों की संख्या वापस कर सकते हैं।

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

10 -> 111
20 -> 1003
30 -> 1023
50 -> 1123
100 -> 10035
23116 -> 1234567
21977356 -> 123456789A

अंतिम मामला आपके द्वारा कार्यान्वित किए जाने के आधार पर चलाने के लिए अविश्वसनीय रूप से धीमा हो सकता है। यदि आपको बहुत अधिक समय लगता है या बहुत अधिक मेमोरी का उपयोग करना है तो आपको इसे चलाने की आवश्यकता नहीं है। हालांकि ध्यान दें कि वहाँ मौजूद तरीके हैं कि यह जल्दी से चले और छोटी मेमोरी का उपयोग करें।

Comments

आपकी पिछली टिप्पणी को देखते हुए, क्या यह ठीक है कि हम हमेशा अंकों के साथ सूची लौटाते हैं?

— ग्रेग मार्टिन

हां, यह आउटपुट देने का एक उचित तरीका है, जब तक कि संख्या सही हो

— Ando Bando

मैं इसके 100 -> 10035बजाय मिल रहा हूं 100 -> 10033, क्या आप सत्यापित कर सकते हैं?

— ग्रेग मार्टिन

@GregMartin 10035 सही लगता है। मैंने अपनी गणना कलम से की, कार्यक्रम से नहीं और इसलिए गणना में त्रुटि की। मुझे लगता है कि हमारे पास एक फिरौती के लिए कंप्यूटर हैं

— Ando Bando

शायद नकल? codegolf.stackexchange.com/questions/11735/…

— जीबी

Answer 1

मैथेमेटिका, 64 बाइट्स

Part[Join@@Array[Tuples@Join[{{1}},Array[Range,#-1,3]-1]&,#],#]&

एक सकारात्मक पूर्णांक तर्क ले रहा है और पूर्णांकों की सूची लौटा रहा है।

Join[{{1}},Array[Range,#-1,3]-1]नेस्टेड सूची देता है { {1}, {0,1,2}, {0,1,2,3}, ..., {0,1,...,#} }। फिर Tuplesसभी टुपल्स का सेट (सॉर्ट किया गया) जिसका पहला तत्व निहित है {1}, जिसका दूसरा तत्व निहित है {0,1,2}और इसी तरह; ये हैं #इस नंबर प्रणाली में -digit संख्या। Join@@Array[...,#]इस #अंक प्रणाली में अधिकांश अंकों के साथ सभी संख्याओं की एक सरणी देता है , और वें को ऐसी संख्या Part[...,#]निकालता है #।

यह निराशाजनक रूप से धीमा है! यह 9 तक इनपुट के लिए ठीक चलता है। बड़े इनपुट के लिए, इसे अंत के ,#],#]&साथ बदलकर परीक्षण करें ,Ceiling[0.9Log[#]]],#]&; यह अंकों की संख्या पर अधिक यथार्थवादी टोपी डालता है जो हम चाहते हैं कि खोजने के लिए नंबरिंग सिस्टम में बहुत दूर जाने के लिए आवश्यक है।

Answer 2

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

Nest[#/.{x___,y_}:>{x,y+1}//.x:{y___,z_:0,w_,v___}/;w>Tr[1^x]-Tr[1^{v}]:>{y,z+1,0,v}&,{0},#]&

पहले तर्क के साथ शुद्ध कार्य #। यदि एक nonnegative पूर्णांक दिया जाता है, तो यह अंकों की सही सूची का उत्पादन करेगा (यहां तक ​​कि 0सही ढंग से संभालता है!)।

व्याख्या

Nest[f,expr,n]समय पर आवेदन fकरने का परिणाम देता है expr n। इस मामले में, exprसूची है {0}और nइनपुट पूर्णांक है #। समारोह fजटिल है:

# (* Starting with the input # *)
 /. (* Apply the following rule *)
   {x___,y_} (* If you see a list of the form {x___,y} *)
            :> (* replace it with *)
              {x,y+1} (* this *)
                     //. (* Now apply the following rule repeatedly until nothing changes *)
                        x:{y___,z_:0,w_,v___} (* If you see a list x starting with a sequence y of 0 or more elements, 
                                                 followed by an optional element z (default value of 0),
                                                 followed by an element w,
                                                 followed by a sequence v of 0 or more elements *)
                                             /; (* such that *)
                                               w>Tr[1^x]-Tr[1^{v}] (* w is greater than the length of x minus the length of {v} *)
                                                                  :> (* replace it with *)
                                                                    {y,z+1,0,v}& (* this *)

Comments

y___,z_:0सूची की लंबाई बढ़ाने के लिए अच्छा उपयोग !

— ग्रेग मार्टिन

@GregMartin JungHwan Min ने कल इसी तरह की समस्या में इसका इस्तेमाल किया था ।

— ngenisis

Answer 3

पर्ल 6 , 38 बाइट्स

{map({|[X] 1,|map ^*,3..$_},1..*)[$_]}

एक सकारात्मक पूर्णांक लेता है, और अंकों का प्रतिनिधित्व करने वाले पूर्णांकों की सूची को आउटपुट करता है।

स्पष्टीकरण:

{                                    }  # a lambda

 map({                    },1..*)       # for each number length from 0 to infinity,
                                        # offset by 1 to avoid a +1 in next step...

           1,|map ^*,3..$_              # generate the digit ranges, e.g.:
                                        #     length 0  ->  (1)  # bogus, but irrelevant
                                        #     length 1  ->  (1)
                                        #     length 2  ->  (1, 0..2)
                                        #     length 3  ->  (1, 0..2, 0..3)
                                        #     length 4  ->  (1, 0..2, 0..3, 0..4)

       [X]                              # take the cartesian product

      |                                 # slip the results into the outer sequence

                                 [$_]   # Index the sequence generated this way

Answer 4

पायथ - 14 बाइट्स

बस वह nthमान लौटाता है जो "स्थान मान पैटर्न से कम" फिट बैठता है।

e.f.A.eghkbjZT

टेस्ट सूट ।

Comments

क्या यह इनपुट पर काम करता है 2018967, जहां अंतिम अंक 10 के बराबर है?

— ग्रेग मार्टिन

Answer 5

हास्केल, 65 बाइट्स

i(x:r)|x>length r=0:i r|1<2=1+x:r
i[]=[1]
reverse.(iterate i[]!!)

iसंख्या प्रणाली में संख्याओं को उल्टे क्रम में अंकों के साथ बढ़ाता है। iterateइन सभी नंबरों की अनंत सूची बनाता है जो शून्य से शुरू होती है जो कि प्रतिनिधित्व करती है []। फिर जो कुछ करना बाकी है, वह है ( !!) मांगे गए नंबर और reverseइसे।

अंतिम पंक्ति एक फ़ंक्शन है, फ़ंक्शन परिभाषा नहीं है, इसलिए यह प्रकट नहीं हो सकता है जैसा कि स्रोत कोड फ़ाइल में है। इसके बजाय, केवल अन्य पंक्तियों को स्रोत कोड में डालें और दुभाषिया पर अंतिम पंक्ति का उपयोग करें (या f=अंतिम पंक्ति के लिए प्रीपेडिंग करके किसी नाम पर फ़ंक्शन को बांधें )।

उदाहरण का उपयोग करें:

*Main> reverse.(iterate i[]!!) $ 100
[1,0,0,3,5]

(8 बाइट्स को बचाया जा सकता है अगर [5,3,0,0,1]परिणाम की अनुमति दी गई हो ।)

Answer 6

हास्केल, 49 बाइट्स

x=[1]:[n++[d]|n<-x,d<-[0..length n+1]]
(x!!).pred

पहली पंक्ति एक सहायक परिभाषा है, और दूसरी एक फ़ंक्शन का मूल्यांकन करती है। यह एक पूर्णांक लेता है और पूर्णांकों की सूची देता है। इसे ऑनलाइन आज़माएं!

व्याख्या

मैं xचुनौती पाठ में वर्णित अभ्यावेदन की अनंत सूची के रूप में परिभाषित करता हूं ; मुख्य कार्य केवल अपने तर्क को घटाता है और अनुक्रमित करता है x। पहली पंक्ति इस तरह काम करती है:

x=                     -- The list of lists x contains
 [1]:                  -- the list [1], followed by
 [n++[d]|              -- integer d appended to list n, where
  n<-x,                -- n is drawn from x, and
  d<-[0..length n+1]]  -- the new "digit" d is drawn from this range.

आप देखते हैं कि xस्वयं के संदर्भ में परिभाषित किया गया है, लेकिन हास्केल आलसी है, इसलिए यह कोई मुद्दा नहीं है।