बड़ा आधार, छोटे अंक

स्थिरांक को निर्दिष्ट करने के लिए J भाषा में बहुत मूर्खतापूर्ण वाक्यविन्यास है । मैं विशेष रूप से एक शांत सुविधा पर ध्यान केंद्रित करना चाहता हूं: मनमाने ठिकानों में लिखने की क्षमता।

आप लिखते हैं XbYके लिए Xकिसी भी संख्या और Yअक्षर या अंक के किसी भी स्ट्रिंग, तो जम्मू की व्याख्या करेगा Yएक आधार के रूप Xनंबर है, जहां 0के माध्यम से 9अपने सामान्य अर्थ है और aके माध्यम से z35 के माध्यम से 10 प्रतिनिधित्व करते हैं।

और जब मैं Xकोई संख्या कहता हूं , तो मेरा मतलब किसी भी संख्या से है। इस प्रश्न के प्रयोजनों के लिए, मैं Xएक सकारात्मक पूर्णांक बनने के लिए विवश हूं , लेकिन जम्मू में आप कुछ भी उपयोग कर सकते हैं: नकारात्मक संख्या, भिन्न, जटिल संख्या, जो भी हो।

अजीब बात यह है कि आप केवल 0 से 35 तक के अंकों का उपयोग अपने आधार के रूप में कर सकते हैं-जो भी अंक हों, क्योंकि आपके प्रयोग करने योग्य प्रतीकों का संग्रह केवल 0-9 और az के होते हैं ।

समस्या

मैं इस पद्धति का उपयोग करके मुझे 2,933,774,030,998 जैसे गोल्फ मैजिक नंबर की मदद करने के लिए एक कार्यक्रम चाहता हूं । ठीक है, ठीक है, शायद इतना बड़ा नहीं है, मैं आप पर आसान हो जाऊंगा। इसलिए...

आपका काम एक कार्यक्रम या समारोह जो एक (आमतौर पर बड़े) दशमलव संख्या लेता है लिखना है N1 और +४२९४९६७२९५ (= 2 के बीच ³² इनपुट के रूप में -1), और आउटपुट / रिटर्न फार्म के कम से कम प्रतिनिधित्व XbYहै, जहां X, एक सकारात्मक पूर्णांक है Yहै अल्फ़ान्यूमेरिक्स (0-9 और az, केस असंवेदनशील) से युक्त एक स्ट्रिंग, और Yबेस Xबराबरी में व्याख्या की गई N।

यदि प्रत्येक प्रतिनिधित्व XbYप्रतिनिधित्व की लंबाई अंकों की संख्या से अधिक या उसके बराबर है N, तो Nइसके बजाय आउटपुट । अन्य सभी संबंधों में, आप कम से कम प्रतिनिधित्व के किसी भी गैर-रिक्त सबसेट का उत्पादन कर सकते हैं।

यह कोड गोल्फ है, इसलिए कम बेहतर है।

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

      Input | Acceptable outputs (case-insensitive)
------------+-------------------------------------------------------
          5 | 5
            |
   10000000 | 79bkmom  82bibhi  85bgo75  99bauua  577buld
            | 620bq9k  999baka
            |
   10000030 | 85bgo7z
            |
   10000031 | 10000031
            |
   12345678 | 76bs9va  79bp3cw  82bmw54  86bjzky  641buui
            |
   34307000 | 99bzzzz
            |
   34307001 | 34307001
            |
 1557626714 | 84bvo07e  87brgzpt  99bglush  420blaze
            |
 1892332260 | 35bzzzzzz  36bvan8x0  37brapre5  38bnxkbfe  40bij7rqk
            | 41bgdrm7f  42bek5su0  45bablf30  49b6ycriz  56b3onmfs
            | 57b38f9gx  62b244244  69b1expkf  71b13xbj3
            |
 2147483647 | 36bzik0zj  38br3y91l  39bnvabca  42bgi5of1  48b8kq3qv
 (= 2^31-1) | 53b578t6k  63b2akka1  1022b2cof  1023b2661  10922bio7
            | 16382b8wv  16383b8g7  32764b2gv  32765b2ch  32766b287
            | 32767b241
            |
 2147483648 | 512bg000  8192bw00
            |
 4294967295 | 45bnchvmu  60b5vo6sf  71b2r1708  84b12mxf3  112brx8iv
 (= 2^32-1) | 126bh5aa3  254b18owf  255b14640  1023b4cc3  13107bpa0
            | 16383bgwf  21844b9of  21845b960  32765b4oz  32766b4gf
            | 32767b483  65530b1cz  65531b1ao  65532b18f  65533b168
            | 65534b143  65535b120

यदि आप कभी इस बारे में अनिश्चित हैं कि क्या कुछ प्रतिनिधित्व कुछ संख्या के बराबर है, तो आप किसी भी जे इंटरप्रेटर का उपयोग कर सकते हैं, जैसे कि यह ऑनलाइन प्रयास करें । बस टाइप करें stdout 0":87brgzptऔर जम्मू वापस थूक देगा 1557626714। ध्यान दें कि J केवल लोअरकेस को स्वीकार करता है, भले ही यह समस्या केस-असंवेदनशील हो।

कुछ संभवतः सहायक सिद्धांत

N10,000,000 से कम सभी के लिए , दशमलव प्रतिनिधित्व किसी भी अन्य के रूप में छोटा है और इसलिए केवल स्वीकार्य आउटपुट है। किसी भी चीज़ को सहेजने के लिए आपको नए आधार में कम से कम चार अंक कम होने चाहिए, और इससे भी अधिक यदि आधार 99 से अधिक हो।
यह वर्गमूल की छत तक आधारों की जांच करने के लिए पर्याप्त है N। किसी भी बड़े आधार के लिए बी , Nआधार में सबसे अधिक दो अंक पर होगा बी , तो पहली बार जब आप एक वैध पहले अंक के साथ कुछ चारों ओर पर है मिल जाएगा बी ≈ N/ 35। लेकिन उस आकार में आप हमेशा दशमलव प्रतिनिधित्व के रूप में कम से कम बड़े होंगे, इसलिए कोशिश करने का कोई मतलब नहीं है। यह ध्यान में रखते हुए, छत (sqrt (सबसे बड़ी संख्या मैं आपको इस समस्या को हल करने के लिए कहूंगा) = 65536।
यदि आपके पास 36 से कम आधार में कोई प्रतिनिधित्व है, तो आधार 36 का प्रतिनिधित्व कम से कम होगा। इसलिए आपको 36 से कम आधारों में गलती से कम समाधान के बारे में चिंता करने की ज़रूरत नहीं है। उदाहरण के लिए, 35bzzzzzz1,892,332,260 के लिए प्रतिनिधित्व उस आधार के लिए एक असामान्य अंक का उपयोग करता है, लेकिन 36bvan8x0इसकी लंबाई समान है।

code-golf base-conversion

— algorithmshark
स्रोत

लोल, 1557626714 = 420blaze ^ _ ^

— DrQuarius

जवाबों:

जावास्क्रिप्ट (ईएस 6), 103 101 बाइट्स

एक स्ट्रिंग के रूप में इनपुट लेता है।

n=>[...Array(7e4)].reduce(p=>p[(r=++b+(g=x=>x?g(x/b|0)+(x%b).toString(36):'b')(n)).length]?r:p,n,b=2)

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

एनबी: स्निपेट फ़ंक्शन में पुनरावृत्तियों की संख्या 600 तक सीमित है ताकि परीक्षण के मामले तेजी से पूरा हो सकें। (यह अन्यथा कुछ सेकंड लगेंगे।)

कोड स्निपेट दिखाएं

let f =

n=>[...Array(6e2)].reduce(p=>p[(r=++b+(g=x=>x?g(x/b|0)+(x%b).toString(36):'b')(n)).length]?r:p,n,b=2)

console.log(f("5"))
console.log(f("10000000"))
console.log(f("10000030"))
console.log(f("10000031"))
console.log(f("12345678"))
console.log(f("34307000"))
console.log(f("34307001"))
console.log(f("1557626714"))
console.log(f("1892332260"))
console.log(f("2147483647"))
console.log(f("2147483648"))
console.log(f("4294967295"))

स्निपेट का विस्तार करें

— Arnauld
स्रोत

यदि इसके साथ काम करने के लिए मेरी संख्या बहुत बड़ी है, तो मैं इसे कैसे ठीक करूंगा? पुनरावृत्तियों को बढ़ाने से मदद नहीं मिलती है।

— FrownyFrog

N < 2^{32}

$N<2^{32}$

"चमकदार संख्या" देखने के लिए, 2136894800297704.

— FrownyFrog

@FrownyFrog आप इसे पुनरावृत्तियों की संख्या बढ़ाकर औरMath.floor(x/b) इसके बजाय उपयोग करके संसाधित कर सकते हैं x/b|0। (लेकिन मैंने इसका परीक्षण नहीं किया।)

— अरनौल्ड

इसने काम कर दिया! धन्यवाद।

— FrownyFrog

रूबी , 118 बाइट्स

यह एक और प्रश्न में जुड़ा हुआ था और मैंने देखा कि यहाँ कई उत्तर नहीं हैं, इसलिए मैंने इसे शॉट देने का फैसला किया।

के माध्यम से चलो सभी ठिकानों को और सभी वैध जम्मू संख्या निर्माण के निर्माण के लिए इनपुट सहित। हालांकि यह 1-8 से आगे निकल जाता है, क्योंकि कोई रास्ता नहीं है जो बेस -10 प्रतिनिधित्व वैसे भी कम होगा। यह एक बहुत अच्छा समाधान है, सभी बातों पर विचार किया जाता है, क्योंकि यह digitsअंकों को प्राप्त करने के लिए बिलिन को बुलाता है , लेकिन चूंकि यह कम से कम महत्वपूर्ण अंक से शुरू होता है reverse, इसलिए हमें वास्तविक संख्या प्राप्त करने के लिए इसे करना होगा, इसलिए यह संभवतः बेहतर हो सकता है।

ये धीमा है। तो, soooooo अविश्वसनीय रूप से धीमा। उदाहरण के लिए, 34307000 पर TIO बार। हम सकता है वर्गमूल के साथ जाने या यहाँ तक कि के Arnauld की पसंद 7e4समय बचाने के लिए, लेकिन यह लागत अतिरिक्त बाइट्स, तो क्यों परेशान?

->n{([n.to_s]+(9..n).map{|b|d=n.digits b;"#{b}b"+d.reverse.map{|i|i.to_s 36}*''if d.all?{|i|i<36}}-[p]).min_by &:size}

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

इसे w / sqrt ऑनलाइन आज़माएं ताकि सब कुछ समय पर पूरा हो जाए

— मूल्य स्याही
स्रोत

05AB1E , 37 बाइट्स

[¼35Ý¾ãvtîEyNβQižhA«yèJ'bìNìDgIg@i\}q

10000000ã $\geq4$

अंतिम इफ-स्टेटमेंट के बिना DgIg@i\}यह अभी भी निचले मूल्यों के लिए परीक्षण किया जा सकता है, यह सत्यापित करने के लिए कि यह वास्तव में काम करता है: इसे ऑनलाइन आज़माएं।

देखेंगे कि क्या मैं बाद में (शायद अधिक लंबा लेकिन) अधिक कुशल समाधान के साथ आ सकता हूं।

स्पष्टीकरण:

[              # Start an infinite loop:
 ¼             #  Increase the counter variable by 1 (0 by default)
 35Ý           #  Push a list in the range [0, 35]
 ¾ã            #  Take the cartesian product of this list with itself,
               #  with chunks-sizes equal to the counter variable
 v             #  Loop `y` over each of these lists:
  t            #   Take the square-root of the (implicit) input-integer
   î           #   Ceil it
  E            #   Loop `N` in the range [1, ceil(square(input))]:
   yNβ         #    Convert list `y` to base-`N`
   Qi          #    If it's equal to the (implicit) input-integer:
     žh        #     Push string "0123456789"
       A«      #     Append the lowercase alphabet
     yè        #     Index each value in list `y` into this string
     J         #     Join the characters to a single string
     'bì      '#     Prepend a "b"
        Nì     #     Prepend the number `N`
     D         #     Duplicate it
      g        #     And pop and push the length of this string
       Ig      #     Also push the length of the input
         @i }  #     If the length of the string is >= the input-length:
           \   #      Discard the duplicated string
     q         #     Stop the program
               #     (after which the result is output implicitly;
               #      or if the string was discarded and the stack is empty, it will
               #      implicitly output the implicit input as result instead)

— केविन क्रूज़सेन
स्रोत

प्रभावशाली उत्तर! मुझे लगता है कि आप एक नियम को याद कर रहे हैं, हालांकि: "यदि प्रत्येक प्रतिनिधित्व XbYप्रतिनिधित्व की लंबाई अंकों की संख्या से अधिक या उसके बराबर है N, तो Nइसके बजाय आउटपुट ।" जब आपके पास पहले 10 मिलियन नंबर शामिल होते हैं, मुझे संदेह है कि इनपुट का इनपुट 10000031कुछ ऐसा वापस देगा 26blmoof। संख्या मान्य है, लेकिन लंबाई इनपुट के समान है, इसलिए इसे इनपुट वापस करना चाहिए।

— वैल्यू इंक

@ValueInk आह उफ़। ध्यान देने के लिए धन्यवाद! अब कुछ बाइट्स की कीमत पर तय किया जाना चाहिए।

— केविन क्रूज़सेन