दिए गए मूलांक के साथ स्ट्रिंग करने के लिए पूर्णांक

Question

एक पूर्णांक को 2 और 62 के बीच एक मूलांक को संख्यात्मक प्रतिनिधित्व में बदलने के लिए सबसे छोटा कार्य लिखें। उदा:

to_string(351837066319, 31) => "codegolf"

Comments

उदाहरण से मैं इकट्ठा करता हूं कि निचले मामले के अक्षर पहले आते हैं, अर्थात आधार 62 में अंक 0-9, az, AZ उस क्रम में हैं?

— sepp2k

हाँ, बिल्कुल, यह बात है।

— मिचेल डी

at 0:00, खतरा, परिपूर्ण।

— ज़ाचारि

Answer 1

डीसी - 43 वर्ण

[sb[58-]s_[lb~dZ39*+dB3<_9+rd0<xrP]dsxxk]sf

हम इसे थोड़ा छोटा कर सकते हैं यदि हम मान लें कि स्टैक में केवल दो तर्क हैं।

[[58-]s_dSb~dZ39*+dB3<_9+SadLbr0<fLaPc]sf

एक स्टैंडअलोन कार्यक्रम के रूप में, हमें केवल 37 वर्ण चाहिए:

?o[58-]s_[O~dZ39*+dB3<_9+rd0<xrP]dsxx

उपयोग करने के बजाय [39+]sz9<z, हम बस उपयोग करते हैं Z39*+, जो एक एकल अंकों की संख्या के लिए 39 और दोहरे अंक की संख्या के लिए 78 जोड़ देगा। इसके बजाय 113, हम उपयोग B3( ADभी काम करता है)।

Answer 2

रूबी 1.8 - 75 अक्षर, पुनरावृत्ति के साथ।

f=proc{|n,b|(n<b ? "":f[n/b,b])+([*'0'..'9']+[*'a'..'z']+[*'A'..'Z'])[n%b]}

पुनरावृत्ति के बिना

f=proc{|n,b|d=[*'0'..'9']+[*'a'..'z']+[*'A'..'Z'];s=d[n%b];s=d[n%b]+s while(n/=b)>0;s}

(दोनों डॉगबर्ट के 1.9 समाधान पर आधारित हैं।)

Answer 3

अजगर - 86

from string import*
def t(n,r,s=''):
 while n:s=printable[n%r]+s;n/=r
 return s or'0'

स्ट्रिंग आयात चाल के लिए होआ लॉन्ग टैम के कारण क्रेडिट

Answer 4

पायथन, 93 99

from string import *
d=digits+letters
def t(n,b):
 s=''
 while n>0:s=d[n%b]+s;n/=b
 return s or '0'

EDIT : "या '0'" रिक्त स्ट्रिंग मामले के लिए जोड़ा गया

Comments

जब n = 0 होता है, तो '0' लौटने पर एक रिक्त स्ट्रिंग देता है। वैसे भी स्ट्रिंग चाल के लिए +1

— जुआन

Answer 5

डीसी, 61 वर्ण

[sr[lr~rd0<x]dsxxk[39+]sa[58-]sb[d9<ad78<b48+anz0<p]dspxIP]sf

ऐसे दोड़ो:

dc -e'[sr[lr~rd0<x]dsxxk[39+]sa[58-]sb[d9<ad78<b48+anz0<p]dspxIP]sf' -e'351837066319 31 lfx'

या:

dc -f base.dc -e '351837066319 31 lfx'

स्पष्टीकरण: हम स्टैक पर संख्या और आधार लेते हैं। srरजिस्टर आर में आधार बचाता है। पुनरावर्ती फ़ंक्शन आधार में [lr~rd0<x]dsxxसंख्या TOSको अपने अंकों में घटाता है register r। पहला अंक हमेशा 0 होता है, जिसे स्टैक से हटा दिया जाता है k(सटीक सेट करें, जो डिफ़ॉल्ट रूप से 0 भी है, इसलिए यह एक एनओपी के बराबर है)। फिर, पुनरावर्ती फ़ंक्शन [48+d57<ad122<banz0<p]dspxASCII में प्रत्येक अंक को फ़ंक्शंस ( [39+]sa) और बी ( [58-]sb) की मदद से आउटपुट करता है । IPएक नई रूपरेखा प्रस्तुत करता है। फ़ंक्शन को रजिस्टर में संग्रहीत किया जाता है f, और इसके द्वारा आमंत्रित किया जा सकता है lfx।

Comments

यदि आप 48+ को अंत तक स्थानांतरित करते हैं तो यह दो (57 और 122 दोनों को एक वर्ण छोड़ता है) बचाता है। इसके अलावा एक मामूली निरीक्षण यह है कि एक फ़ंक्शन के रूप में, आप यह नहीं मान सकते हैं कि स्टैक पर कुछ और नहीं है, लेकिन समस्या को हटा दिया जाएगा यदि आप लूप को मर्ज करते हैं (जो कुछ वर्णों को भी बचाएगा)।

— नब

Answer 6

रूबी - 72 70 59 वर्ण

f=->n,b{(n<b ? "":f[n/b,b])+[*?0..?9,*?a..?z,*?A..?Z][n%b]}

पुनरावृत्ति के बिना, 70 वर्ण

f=->n,b{d=*?0..?9,*?a..?z,*?A..?Z;s=d[n%b];s=d[n%b]+s while(n/=b)>0;s}

परीक्षा

irb(main):080:0> f[351837066319, 31]
=> "codegolf"
irb(main):081:0> f[0, 31]
=> "0"

Answer 7

हास्केल, 109 वर्ण

m=divMod
d(0,x)b=[f x]
d(r,x)b=f x:d(m r b)b
f=(!!)$['0'..'9']++['a'..'z']++['A'..'Z']
s x b=reverse$d(m x b)b

Answer 8

Befunge - 53 x 2 = 106 वर्ण

या 53 + 46 = 99 वर्ण यदि आप अपने प्रोग्राम के अन्य भागों को नीचे बाईं ओर से मार्ग में लाना चाहते हैं।

11p01-\>:11g%\11g/:#v_$>:1+!#v_:45+`!#v_:75*`!#v_   v
       ^            <  ^,    $# +"0"  < +"'"   <-":"<

पहले नंबर को स्टैक पर रूपांतरित करने के लिए रखें, फिर मूलांक और इस फ़ंक्शन को ऊपर-बाएँ दाएँ से प्रवेश करें। आपके लिए स्ट्रिंग का उत्पादन करेगा (क्योंकि Befunge स्ट्रिंग चर का समर्थन नहीं करता है) और नीचे $जाने से नीचे की ओर छोड़ें । (1,1)मूलांक भंडारण के लिए सेल की आवश्यकता होती है ।

उदाहरण के लिए 351837066319इनपुट और रन में दिए गए उदाहरण के लिए :

&56*1+    11p01-\>:11g%\11g/:#v_$>:1+!#v_:45+`!#v_:75*`!#v_   v
                 ^            <  ^,    $# +"0"  < +"'"   <-":"<
                                       @

Answer 9

गोल्फस्क्रिप्ट - 32 वर्ण

{base{.9>39*+.74>58*48--}%''+}:f

Answer 10

रूबी 1.9 - 80 74 68

t = -> n, b {d = ? 0 ..? 9? ;? a .. z; *? A ..? z? s = ''? (s = d [n% b] + s; n / = b) जबकि n> 0;

खाली स्ट्रिंग के लिए '0' के साथ, 95 89 82 वर्ण:

t=->n,b,s=''{d=*?0..?9,*?a..?z,*?A..?Z;(s=d[n%b]+s;n/=b)while n>0;s.empty?? ?0: s}

रूबी 1.9 - दुर्भाग्य से केवल बेस 36 तक काम करता है:

t=->n,b{n.to_s(b)}

Comments

आप के ]+[साथ बदल सकते हैं ,।

— निमो 157

Answer 11

बैश, 79 चार

f(){
dc<<<$2o$1p|perl -pe"y/A-Z/a-z/;s/ \d+/chr$&+($&<10?48:$&<36?87:29)/ge"
}

Comments

BC_BASE_MAX को 16 के रूप में प्रलेखित किया गया है। मुझे नहीं पता कि चमत्कार क्या नमूना इनपुट पर आउटपुट को सही बनाता है, लेकिन यह अधिकांश अन्य ठिकानों के लिए कचरा (यानी गैर अल्फ़ान्यूम वर्ण) आउटपुट करता है।

— जेबी

@ जेबी: आप किस बीसी का उपयोग कर रहे हैं? जीएनयू बीसी को काम करना चाहिए। sysconf(_SC_BC_BASE_MAX)मेरे सिस्टम पर 99 रिटर्न, 16 न्यूनतम आवश्यक है।

— नन्हलज

@ जेबी: यह भी ध्यान दें कि पिछले संशोधन, जहां छोटी गाड़ी है, मुझे सवाल आवश्यकताओं पर ध्यान नहीं दिया गया था।

— नंजलज

बीसी 1.06। अब आप इसका उल्लेख करते हैं, मुझे मैनपेज से यह आंकड़ा मिला है, लेकिन इसे गलत समझा। 16 इनपुट बेस लिमिट है। आउटपुट बेस की सीमा 999 है। मैंने पहले पुराने संस्करण पर प्रयास किया था, चलो अब फिर से देखते हैं।

— JB

मुझे लगता है कि यह एक निचले मामले के बजाय 11-16 आधारों के लिए अपरकेस अक्षरों को आउटपुट करता है। आप dcइसके बजाय का उपयोग करके आधार रूपांतरण में कुछ बचा सकते हैं bc।

— नबंवर

Answer 12

पायथन 2 , 66 बाइट्स

from string import*
f=lambda n,b:n and f(n/b,b)+printable[n%b]or''

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

Answer 13

बर्लेस्क , 4 बाइट्स

peB!

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

सौभाग्य से एक निर्मित में बर्लेस्क

pe # Parse and push
B! # Convert base

Answer 14

पर्ल 5 -Minteger -ap , 52 बाइट्स

do{$\=(0..9,a..z,A..Z)[$_%$F[1]].$\}while$_/=$F[1]}{

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

Answer 15

जावास्क्रिप्ट 170 बाइट्स

function f1(ni,nr){
let s1='0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
let s2='';
while(ni>0){
s2=s1[ni%nr]+s2;
ni=Math.floor(ni/nr);
}
return s2;
}

Comments

यह बहुत अधिक तरीकों से तैयार किया जा सकता है, उदाहरण के लिए व्हाट्सएप को हटाने, चर नामों को छोटा करने, बेकार कोड को हटाने (जैसे let) और उस लंबे स्ट्रिंग को कम करने के लिए

— जो किंग

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

— Jo King

@JoKing कोई धन्यवाद नहीं।

— स्टीवन पेनी