वास्तविक आधार रूपांतरण

Question

आधार रूपांतरण के लिए हमारे पास कुछ चुनौतियां हैं, लेकिन वे सभी पूर्णांक मानों पर लागू होती हैं। चलो वास्तविक संख्याओं के साथ करते हैं!

चुनौती

इनपुट:

• एक वास्तविक धनात्मक संख्या x , जिसे आधार 10 में व्यक्त किया गया है। इसे दोहरे-सटीक फ्लोट के रूप में या स्ट्रिंग के रूप में लिया जा सकता है। सटीक मुद्दों से बचने के लिए, संख्या को 10 ^less6 से अधिक और 10 ¹⁵ से कम माना जा सकता है ।
• एक लक्ष्य आधार b । यह 2 से 36 तक का पूर्णांक होगा।
• भिन्नात्मक अंकों की एक संख्या n । यह 1 से 20 तक पूर्णांक होगा।

आउटपुट: प्रतिनिधित्व की एक्स आधार में ख के साथ n दशमलव अंक।

आउटपुट अभिव्यक्ति की गणना करते समय, n -th से आगे के अंकों को छोटा किया जाना चाहिए (गोल नहीं)। उदाहरण के लिए, x = 3.141592653589793बेस में b = 3है 10.0102110122..., इसलिए n = 3आउटपुट के लिए 10.010(ट्रंकेशन) होगा, न कि 10.011(गोलाई)।

भिन्नात्मक भाग में अंकों की एक सीमित संख्या का उत्पादन करने वाले x और b के लिए, समान अनंत प्रतिनिधित्व ( n अंक में काट दिया गया ) की भी अनुमति है। उदाहरण के लिए, 4.5दशमलव के रूप में भी दर्शाया जा सकता है 4.49999...।

फ़्लोटिंग पॉइंट त्रुटियों के बारे में चिंता न करें ।

इनपुट और आउटपुट प्रारूप

x बिना अग्रणी शून्य के दिया जाएगा। यदि x एक पूर्णांक होता है, तो आप मान सकते हैं कि यह एक शून्य दशमलव भाग ( 3.0), या दशमलव भाग ( 3) के बिना दिया जाएगा ।

आउटपुट लचीला है। उदाहरण के लिए, यह हो सकता है:

• पूर्णांक और भिन्नात्मक भागों के बीच एक उपयुक्त विभाजक (दशमलव बिंदु) के साथ संख्या का प्रतिनिधित्व करने वाला एक स्ट्रिंग। अंक 11, 12आदि ( 10 से परे बी के लिए ) को अक्षरों Aके Bरूप में, सामान्य रूप से, या किसी अन्य विशिष्ट वर्ण के रूप में दर्शाया जा सकता है (कृपया निर्दिष्ट करें)।
• पूर्णांक भाग के लिए एक स्ट्रिंग और आंशिक भाग के लिए एक और स्ट्रिंग।
• दो सरणियाँ / सूचियाँ, प्रत्येक भाग के लिए एक, जिसमें अंकों से 0लेकर 35अंक तक होते हैं।

केवल प्रतिबंध यह है कि पूर्णांक और भिन्नात्मक भागों को अलग-अलग (उपयुक्त विभाजक) बताया जा सकता है और एक ही प्रारूप का उपयोग कर सकते हैं ( उदाहरण के लिए, [5, 11]पूर्णांक भाग का प्रतिनिधित्व करने वाली सूची के लिए नहीं और ['5', 'B']भिन्नात्मक भाग का प्रतिनिधित्व करने वाली सूची के लिए)।

अतिरिक्त नियम

• प्रोग्राम या फ़ंक्शंस की अनुमति है, किसी भी प्रोग्रामिंग भाषा में । मानक खामियों को मना किया जाता है।
• बाइट्स में सबसे छोटा कोड जीतता है।

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

आउटपुट अंकों के साथ एक स्ट्रिंग के रूप में दिखाया गया है 0, ..., 9, A, ..., Z, का उपयोग करते हुए .दशमलव विभाजक के रूप।

x, b, n                    ->  output(s)

4.5, 10, 5                 ->  4.50000 or 4.49999
42, 13, 1                  ->  33.0 or 32.C
3.141592653589793, 3, 8    ->  10.01021101
3.141592653589793, 5, 10   ->  3.0323221430
1.234, 16, 12              ->  1.3BE76C8B4395
10.5, 2, 8                 ->  1010.10000000 or 1010.01111111
10.5, 3, 8                 ->  101.11111111
6.5817645, 20, 10          ->  6.BCE2680000 or 6.BCE267JJJJ
0.367879441171442, 25, 10  ->  0.94N2MGH7G8
12944892982609, 29, 9      ->  PPCGROCKS.000000000

Comments

आइए हम इस चर्चा को चैट में जारी रखते हैं ।

— एरिक आउटगॉल्फ

के बदले 42, 13, 1हम कर सकते 33हैं 33.0?

— LiefdeWen

@LiefdeWen नहीं, चुनौती का एक अनिवार्य हिस्सा यह है कि आउटपुट में nदशमलव अंक होने चाहिए

— लुइस मेंडू

Answer 1

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

*×⁵b⁸ḞðṖḣ⁹,ṫø⁹N‘

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

ध्यान दें कि आउटपुट में सिंगलेट्स तत्व के रूप में मुद्रित होते हैं।

Comments

अरे, आपकी तस्वीर का क्या हुआ?

— लुइस मेंडू

@LuisMendo कुछ लोग इसे प्रस्तुत नहीं कर सकते, क्योंकि यह फेसबुक से जुड़ा था

— लीक

तुम्हें पता है कि तुम यहाँ एक तस्वीर अपलोड कर सकते हैं, है ना? वे डिफ़ॉल्ट बहुत अवैयक्तिक हैं

— लुइस मेंडू

Answer 2

जावास्क्रिप्ट (ईएस 8), 81 74 71 बाइट्स

f=
(x,b,n,g=x=>x.toString(b))=>g(x-x%1)+'.'+g(x%1).substr(2,n).padEnd(n,0)

<div oninput=o.textContent=f(+x.value,b.value,n.value)><input id=x><input type=number min=2 max=36 value=10 id=b><input type=number min=1 max=20 value=10 id=n><pre id=o>

के लिए काम करता है xके बीच 1e-6और 1e21, bसे 2करने के लिए 36(बिल्कुल के रूप में) की आवश्यकता और nसे 1से कुछ भी करने के लिए 10करने के लिए 48फ्लोटिंग प्वाइंट से पहले बेस के आधार पर त्रुटियों में रेंगना संपादित करें:। सहेजी गयी @Birjolaxew की मदद से 7 बाइट्स। @Tsh की मदद से एक और 3 बाइट्स को बचाया। पिछले 74-बाइट संस्करण ने भी नकारात्मक संख्याओं के साथ काम किया:

f=
(x,b,n,[i,d]=`${x.toString(b)}.`.split`.`)=>i+`.`+d.slice(0,n).padEnd(n,0)

<div oninput=o.textContent=f(+x.value,b.value,n.value)><input id=x><input type=number min=2 max=36 value=10 id=b><input type=number min=1 max=20 value=10 id=n><pre id=o>

Comments

रेगेक्स के साथ आधार रूपांतरण कैसे होता है?

— एरिक आउटगॉल्फ

@EriktheOutgolfer मैं नहीं हूं, यह nएक स्ट्रिंग से "अंक" तक निकालने का सिर्फ एक गोल्फर (उम्मीद है) तरीका है ।

— नील

फिर आपके फ़ंक्शन का मुख्य तर्क क्या है ?

— एरिक आउटगॉल्फ

@EriktheOutgolfer क्यों, जावास्क्रिप्ट बिल्ट-इन बेस रूपांतरण समारोह। (संकेत: जहां मैं आधार पैरामीटर का उपयोग करता हूं, उसे देखो।)

— नील

ओह, यह कहता है .toString(b)... मुझे गूंगा> _ <

— आउटगोल्फर

Answer 3

पायथन 2 , 153 149 144 137 135 109 बाइट्स

def f(x,b,m):
 i=int(x);s=[];t=[]
 while i:s=[i%b]+s;i/=b
 while m:m-=1;x=x%1*b;t+=[int(x)]
 return s or[0],t

ध्यान नहीं दिया गया था कि मैं अंकों को अंकों के रूप में वापस कर सकता हूं, जिससे यह बहुत सरल हो जाता है। अंकों की दो सूचियाँ लौटाता है, पहला पूर्णांक भाग के लिए, दूसरा भिन्नात्मक के लिए।

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

Comments

मामले में यह मदद करता है: मैंने एक नोट जोड़ा है कि आपको केवल 1e-6(और 1e15पहले की तुलना में कम) से अधिक संख्याओं का समर्थन करने की आवश्यकता है

— लुइस मेंडो

Answer 4

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

->\x,\b,\n{+x .base(b,n)}

कोशिश करो

विस्तारित:

-> \x, \b, \n {
  +x            # make sure it is a Numeric
  .base( b, n ) # do the base conversion
}

ध्यान दें कि अंतरिक्ष इतना है कि इसे पार (+x).base(b,n)
नहीं किया गया है +( x.base(b,n) )।

Comments

मामले में यह मदद करता है: मैंने एक नोट जोड़ा है कि आपको केवल 1e-6(और 1e15पहले की तुलना में कम) से अधिक संख्याओं का समर्थन करने की आवश्यकता है

— लुइस मेंडो

Answer 5

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

चूंकि यह चुनौती पहले ही @KellyLowder द्वारा गणित में बहुत अच्छा जवाब मिल गया, इसलिए मैंने परीक्षण के मामलों में दिखाए गए सटीक परिणामों (अलग दृष्टिकोण के साथ) का उत्पादन करने की कोशिश की

ToUpperCase[""<>Insert[StringReplace[ToString@BaseForm[#,p]&/@PadRight[#&@@(d=RealDigits[#,p=#2]),w=(#3+d[[2]])][[;;w]],"\n "<>ToString@p->""],".",d[[2]]+1]]&

इनपुट

[12944892982609, 29, 9]

उत्पादन

PPCGROCKS.000000000

Answer 6

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

->x,b,n{(x*b**n).round.to_s(b).insert(~n,?.)}

क्यों?

चूँकि b ^ n में आधार b 10 ^ n है, हम x को उस संख्या से गुणा करते हैं, और फिर दशमलव बिंदु को जोड़ते हैं जहाँ वह है।

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

Comments

के .roundसाथ प्रतिस्थापित करके -1 बाइट + बगफिक्स .to_i; यह उन लोगों के लिए आउटपुट के अंतिम अंक को ठीक करता है जहां यह परीक्षण आउटपुट से मेल नहीं खाता है। -1 और बाइट का उपयोग करके .insert ~n,?., कोष्ठक के बिना।

— Nnnes

Answer 7

सी (जीसीसी) ,157 152 बाइट्स

long intबड़े परीक्षण मामलों के साथ काम करने के लिए इसके लिए 64 बिट्स की आवश्यकता होती है।

पीटर बर्ड्स के लिए -5 बाइट्स धन्यवाद

#define P r=99;i=l=x;do{z[--r]=48+7*(l%b>9)+l%b;}while(l/=b);printf(z+r)
long i,r,l;char z[99];f(x,b,n)double x;{P;putchar(46);while(n--){x=(x-i)*b;P;}}

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

संपादित करें: कुछ बाइट्स का मुंडन किया जा सकता है यदि इसे एक नई लाइन विभाजक द्वारा अलग किए गए दो तारों को आउटपुट करने की अनुमति दी जाए:

149 बाइट्स:

#define P r=99;i=l=x;do{z[--r]=48+7*(l%b>9)+l%b;}while(l/=b);printf(z+r)
long i,r,l;char z[99];f(x,b,n)double x;{P;puts("");while(n--){x=(x-i)*b;P;}}

संपादित करें: यह सबमिशन सबसे लंबा नहीं है, याय!

Comments

printf(z+r)यदि इसमें कोई %वर्ण नहीं है तो आप इसका उपयोग कर सकते हैं । (यह कोड-गोल्फ है; सुरक्षा और अच्छे अभ्यास खिड़की से बाहर जाते हैं: पी)। आप puts(z+r)मुफ्त puts("")में एक दूसरी पंक्ति प्राप्त करने के लिए भी उपयोग कर सकते हैं ( दूसरे संस्करण में बचत )।

— पीटर कॉर्ड्स

धन्यवाद! मैं एक पैटर्न के रूप में सीधे एक चार * प्रदान करने के बारे में भूल गया, यह वास्तव में काफी कुछ बाइट्स बचाता है :-) मैं दूसरे संस्करण में पुट (z + r) का उपयोग नहीं कर सकता क्योंकि इसका मतलब होगा कि प्रत्येक दशमलव को एक नई

— रेखा

आह, वह आखिरी हिस्सा टिप्पणियों के साथ एक अन-गोल्ड संस्करण के बिना स्पष्ट नहीं था।

— पीटर कॉर्ड्स

float से छोटा है double , लेकिन ऐसा लगता है कि प्रश्न को एक doubleया स्ट्रिंग इनपुट की आवश्यकता है ।

— पीटर कॉर्ड्स

उसकी कोई ज़रूरत नहीं। C के कुछ सामान्य कार्यान्वयन में 64-बिट होते हैं long, और कोड-गोल्फ नियमों के अनुसार आपके उत्तर के मान्य होने के लिए आपको सभी की आवश्यकता होती है। (इसके अलावा, यह C और C ++ कोड-गोल्फ उत्तरों के लिए 64-बिट मानने के लिए सामान्य है long, क्योंकि यह कोशिश ऑनलाइन उपयोग करता है।) मैं आपको अपना संपादन वापस करने का सुझाव दूंगा, और बस "जैसे long64-बिट " के लिए एक नोट जोड़ना चाहिए यह बड़े परीक्षण-मामलों का समर्थन करने के लिए है। "

— पीटर कॉर्ड्स

Answer 8

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

TakeDrop@@r[#,#2,#3+Last@(r=RealDigits)[#,#2]]&

RealDigitsदशमलव के बाईं ओर अंकों की संख्या का पता लगाने के लिए दो बार कॉलिंग ।

Comments

मामले में यह मदद करता है: मैंने एक नोट जोड़ा है कि आपको केवल 1e-6(और 1e15पहले की तुलना में कम) से अधिक संख्याओं का समर्थन करने की आवश्यकता है

— लुइस मेंडो

मैंने सोचा था कि सवाल सिर्फ TakeDrop@@RealDigits[##]और सिर्फ पूछ रहा था, लेकिन तब मुझे महसूस हुआ कि मुझे गलतफहमियां हैं - आपका समाधान इष्टतम लगता है।

— मार्क एस।

Answer 9

सेजमैथ , 68 बाइट्स

def f(n,b,k):y=n.str(b).split('.')+[''];return y[0],(y[1]+'0'*k)[:k]

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

Comments

मामले में यह मदद करता है: मैंने एक नोट जोड़ा है कि आपको केवल 1e-6(और 1e15पहले की तुलना में कम) से अधिक संख्याओं का समर्थन करने की आवश्यकता है

— लुइस मेंडो

Answer 10

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

f=fromIntegral
g 0 _=[]
g n p=g(div n p)p++[mod n p]
z=(!!)(['0'..'9']++['A'..'Z']++['.'])
h x p l|(i,d)<-properFraction x=z<$>(g i p++[36]++(last$g(floor$d*(f p**f l))p:[0<$[1..l]|d==0]))

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

g किसी संख्या को किसी दिए गए आधार में उस संख्या का प्रतिनिधित्व करने वाली सूची में परिवर्तित करता है

zअक्षरों के लिए नक्शे पूर्णांक ( 36 = .)

h किसी संख्या के पूर्णांक और भिन्नात्मक भाग पर पिछले कार्यों को लागू करता है।

Answer 11

Axiom, 566 बाइट्स

c:=alphanumeric()::List Character
f(a:INT,b:PI):List Character==(r:=[];repeat(y:=a rem b;r:=cons(c.(y+1),r);a:=a quo b;a=0=>break);r)
g(x)==floor(x)::INT
F(x)==>for i in 1..#x repeat z:=concat(z,x.i)
w(a:Float,b:PI,n:NNI):String==
  z:="";b<2 or b>36 or a<0=>z
  ip:=g(a);    fp:=g((a-ip)*b^n)
  ipb:=f(ip,b);fpb:=f(fp,b);cnt:=n-#fpb
  for i in 1..cnt repeat fpb:=cons(c.1,fpb)
  F(ipb);z:=concat(z,".");F(fpb)
  z

h(a,b,n)==>(n>=0 and b>0=>(nd123:=10+g(n*log_2(b)/log_2(10));mxv123456:=digits(nd123::PI);res78484:=w(a,b,n);digits(mxv123456);res78484);"")

यह प्रश्न विशेष रूप से कठिन था; कुछ लिखने में कुछ समय, सही परिणाम यह लगता है कि संरक्षित अंकों () के लिए एक मैक्रो का उपयोग करके उत्पन्न होता है ... यह बहुत ज्यादा गोल्फ नहीं है ... परिणाम:

(7) -> h(4.5,10,5)
   (7)  "4.50000"
                                                             Type: String
(8) -> h(42,13,1)
   (8)  "33.0"
                                                             Type: String
(9) -> h(%pi,3,8)
   (9)  "10.01021101"
                                                             Type: String
(10) -> h(%pi,5,10)
   (10)  "3.0323221430"
                                                             Type: String
(11) -> h(1.234,16,12)
   (11)  "1.3BE76C8B4395"
                                                             Type: String
(12) -> h(0.367879441171442,25,10)
   (12)  "0.94N2MGH7G8"
                                                             Type: String
(13) -> h(12944892982609,29,9)
   (13)  "PPCGROCKS.000000000"
                                                             Type: String
(14) -> h(6.5817645,20,10)
   (14)  "6.BCE267JJJJ"
                                                             Type: String

वास्तविक लक्ष्य एक फ़ंक्शन है जो बेस में परिवर्तित होता है 2..36 प्रत्येक फ्लोट [जिसमें k: = digits ()] या प्रत्येक परिकलित संख्या% pi या% e या दो फ्लोट के विभाजन / int के रूप में 1./3 है। । ['ऊ' अंक]

(15) -> h(%pi,13,800)
   (15)
  "3.1AC1049052A2C77369C0BB89CC9883278298358B370160306133CA5ACBA57614B65B410020
  C22B4C71457A955A5155B04A6CB6CC2C494843A8BBBBA9A039B77B34CB0C036CAC761129B3168
  B8BAB860134C419787C911812985646C7AAA3025BAA118B3AB8265CB347852065667291482145
  6C533447BC53A5262177C9985455C395626091A2CC3126B395C91B65B654A1804226197528410
  29A8A4A55CC7937B347B77B5A914127B11C6A57A84510775A9A467819A468B6B74339CC1290B2
  24921C6A771BC2AB6AB41735119C2231545A86399483119AAA5AC34B46B7B5C9089946A364860
  9B26CB0BAC0ABCBA182C12881933AA93C3942C71AA664753989A3C82166BA2109796C4A134607
  59725A72C9117AC980556A147557C319438287226C94725B125753B009387A48AA45CB1960A04
  A064052C00A6069371949872B14590895C555CB01A39B7589824B8621618A8B1971841201A2AB
  B04B80C7534CC1CB079581491995B46C679555316288C82665645A1A600C1A669B865651B6B842470C018B03C1115B3C4306C015C0B45C"
                                                             Type: String

Answer 12

Axiom, 127 बाइट्स

g(a)==floor(a)::INT;f(a:Float,b:PI,n:NNI):Any==(b<2 or n>28=>%i;x:=g(a);radix(x,b)+radix(g((a-x)*b^n),b)::RadixExpansion b/b^n)

परिणाम

(4) -> f(%e,2,10)
   (4)  10.1011011111
                                                   Type: RadixExpansion 2
(5) -> f(%e,3,10)
   (5)  2.2011011212
                                                   Type: RadixExpansion 3
(6) -> f(%e,35,10)
   (6)  2.P4VBNEB51S
                                                  Type: RadixExpansion 35
(7) -> f(1.4,35,10)
   (7)  1.DYYYYYYYYY
                                                  Type: RadixExpansion 35
(8) -> f(%pi,3,8)
   (8)  10.01021101
                                                   Type: RadixExpansion 3
(9) -> f(%pi,5,10)
   (9)  3.032322143
                                                   Type: RadixExpansion 5
(10) -> f(1.234,16,12)
   (10)  1.3BE76C8B4395
                                                  Type: RadixExpansion 16

अंतिम शून्य उदाहरण के लिए इसमें थोड़ी समस्या है

 f(4.5,10,5)

'4.5' लौटाएगा और '4.50000' नहीं