Écrivez la fonction la plus courte pour convertir un entier en une représentation numérique avec un radix compris entre 2 et 62. Par exemple:

to_string(351837066319, 31) => "codegolf"

Ruby 1,8 - 75 caractères, avec récursivité.

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

Sans récursivité

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}

(tous deux basés sur la solution 1.9 de Dogbert.)

Python - 86

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

Crédit dû à Hoa Long Tam pour l'astuce d'importation de cordes

dc - 43 caractères

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

Nous pouvons raccourcir cela un peu si nous supposons que la pile ne contient que les deux arguments.

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

En tant que programme autonome, nous n'avons besoin que de 37 caractères:

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

Au lieu d'utiliser [39+]sz9<z, nous utilisons simplement Z39*+, qui ajoutera 39 pour un numéro à un chiffre et 78 pour un numéro à deux chiffres. Au lieu de 113, nous utilisons B3( ADfonctionne également).

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'

EDIT : "ou '0'" ajouté pour le cas de chaîne vide

dc, 61 caractères

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

Courir comme:

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

ou:

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

Explication: Nous prenons le nombre et la base sur la pile. srenregistre la base dans le registre r. La fonction récursive [lr~rd0<x]dsxxdécompose un nombre TOSen ses chiffres en base register r. Le premier chiffre est toujours 0, supprimé de la pile par k(définir la précision, qui par défaut est également 0, il est donc équivalent à un nop). Ensuite, la fonction récursive [48+d57<ad122<banz0<p]dspxgénère chaque chiffre en ASCII, à l'aide des fonctions a ( [39+]sa) et b ( [58-]sb). IPaffiche une nouvelle ligne. La fonction est stockée dans le registre fet peut être invoquée par lfx.

Rubis - 72 70 59 caractères

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

Sans récursivité, 70 caractères

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

Tester

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

Haskell, 109 caractères

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 caractères

Ou 53 + 46 = 99 caractères si vous souhaitez acheminer d'autres parties de votre programme en bas à gauche.

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

Placez d'abord le nombre à convertir sur la pile, puis le radix et entrez cette fonction en haut à gauche en allant vers la droite. Sortira la chaîne pour vous (puisque Befunge ne prend pas en charge les variables de chaîne) et partira du bas $vers le bas. Nécessite la (1,1)cellule pour le stockage Radix.

Par exemple, pour l'exemple donné, mettez 351837066319dans l'entrée et exécutez:

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

Golfscript - 32 caractères

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

Rubis 1,9 - 80 74 68

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

Avec '0' pour une chaîne vide, 95 89 82 caractères:

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 - ne fonctionne malheureusement que jusqu'à la base 36:

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

Bash, 79 caractères

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