Schreiben Sie die kürzeste Funktion, um eine Ganzzahl in eine numerische Darstellung mit einem Radix zwischen 2 und 62 umzuwandeln. Beispiel:

to_string(351837066319, 31) => "codegolf"

Ruby 1,8 - 75 Zeichen, mit Rekursion.

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

Ohne Rekursion

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}

(Beide basieren auf der 1.9-Lösung von Dogbert.)

Python - 86

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

Dank an Hoa Long Tam für den String-Import-Trick

Gleichstrom - 43 Zeichen

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

Wir können dies ein wenig verkürzen, wenn wir annehmen, dass der Stack nur die beiden Argumente enthält.

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

Als eigenständiges Programm benötigen wir nur 37 Zeichen:

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

Anstatt zu verwenden [39+]sz9<z, verwenden wir einfach Z39*+, was 39 für eine einstellige Zahl und 78 für eine zweistellige Zahl addiert. Stattdessen verwenden 113wir B3( ADfunktioniert auch).

Python, 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'

BEARBEITEN : "oder '0'" für leere Zeichenketten hinzugefügt

dc, 61 Zeichen

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

Rennen wie:

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

oder:

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

Erklärung: Wir nehmen die Nummer und die Basis auf dem Stapel. srspeichert die Basis in Register r. Die rekursive Funktion [lr~rd0<x]dsxxzerlegt eine Zahl TOSin ihre Basisziffern register r. Die erste Ziffer ist immer 0, vom Stapel entfernt um k(Genauigkeit festlegen, die standardmäßig auch 0 ist, entspricht also einem NOP). Die rekursive Funktion [48+d57<ad122<banz0<p]dspxgibt dann mit Hilfe der Funktionen a ( [39+]sa) und b ( [58-]sb) jede Ziffer in ASCII aus . IPgibt einen Zeilenumbruch aus. Die Funktion wird im Register gespeichert fund kann von aufgerufen werden lfx.

Ruby - 72 70 59 Zeichen

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

Ohne Rekursion 70 Zeichen

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

Prüfung

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

Haskell, 109 Zeichen

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

Befunge - 53 x 2 = 106 Zeichen

Oder 53 + 46 = 99 Zeichen, wenn Sie andere Teile Ihres Programms unten links weiterleiten möchten.

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

Platzieren Sie zuerst die umzurechnende Zahl auf dem Stapel, dann die Basis und geben Sie diese Funktion von links oben nach rechts ein. Gibt die Zeichenfolge für Sie aus (da Befunge keine Zeichenfolgenvariablen unterstützt) und geht von unten $nach unten. Benötigt die (1,1)Zelle für die Radix-Speicherung.

ZB für das angegebene Beispiel 351837066319in die Eingabe eingeben und ausführen:

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

Golfscript - 32 Zeichen

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

Ruby 1.9 - 80 74 68

t = -> n, b {d = 0 ... 9, & Dgr; a ... & Dgr; z, * & Dgr; A ... & Dgr; Z; s = ''; (s = d [n% b] + s; n / = b) solange n> 0 ist; s}

Mit '0' für leere Zeichenfolge, 95 89 82 Zeichen:

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}

Ruby 1.9 - funktioniert leider nur bis zur Basis 36:

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

Bash, 79 Zeichen

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