Hey, it's the holidays, and some of our mods won't be available as much as they'd like to be. Those of you with mod powers, now would be a good time to help step in and stem the constant flood of spam... --Michael Mol

Non-decimal radices/Convert

From Rosetta Code
(Redirected from Number base conversion)
Jump to: navigation, search
Task
Non-decimal radices/Convert
You are encouraged to solve this task according to the task description, using any language you may know.
Number base conversion is when you express a stored integer in an integer base, such as in octal (base 8) or binary (base 2). It also is involved when you take a string representing a number in a given base and convert it to the stored integer form. Normally, a stored integer is in binary, but that's typically invisible to the user, who normally enters or sees stored integers as decimal.

Write a function (or identify the built-in function) which is passed a non-negative integer to convert, and another integer representing the base. It should return a string containing the digits of the resulting number, without leading zeros except for the number 0 itself. For the digits beyond 9, one should use the lowercase English alphabet, where the digit a = 9+1, b = a+1, etc. The decimal number 26 expressed in base 16 would be 1a, for example.

Write a second function which is passed a string and an integer base, and it returns an integer representing that string interpreted in that base.

The programs may be limited by the word size or other such constraint of a given language. There is no need to do error checking for negatives, bases less than 2, or inappropriate digits.

Contents

[edit] ACL2

(defun digit-value (chr)
(cond ((and (char>= chr #\0)
(char<= chr #\9))
(- (char-code chr) (char-code #\0)))
((and (char>= chr #\A)
(char<= chr #\Z))
(+ (- (char-code chr) (char-code #\A)) 10))
((and (char>= chr #\a)
(char<= chr #\z))
(+ (- (char-code chr) (char-code #\a)) 10))))
 
(defun value-digit (n)
(if (< n 10)
(code-char (+ n (char-code #\0)))
(code-char (+ (- n 10) (char-code #\A)))))
 
(defun num-from-cs (cs base)
(if (endp cs)
0
(+ (digit-value (first cs))
(* base (num-from-cs (rest cs) base)))))
 
(defun parse-num (str base)
(num-from-cs (reverse (coerce str 'list)) base))
 
(include-book "arithmetic-3/top" :dir :system)
 
(defun num-to-cs (num base)
(if (or (zp num) (zp base) (= base 1))
nil
(cons (value-digit (mod num base))
(num-to-cs (floor num base) base))))
 
(defun show-num (num base)
(coerce (reverse (num-to-cs num base)) 'string))

[edit] Ada

Ada provides built-in capability to convert between all bases from 2 through 16. This task requires conversion for bases up to 36. The following program demonstrates such a conversion using an iterative solution.

with Ada.Text_Io; use Ada.Text_Io;
with Ada.Strings.Fixed;
With Ada.Strings.Unbounded;
 
procedure Number_Base_Conversion is
Max_Base : constant := 36;
subtype Base_Type is Integer range 2..Max_Base;
Num_Digits : constant String := "0123456789abcdefghijklmnopqrstuvwxyz";
Invalid_Digit : exception;
 
function To_Decimal(Value : String; Base : Base_Type) return Integer is
use Ada.Strings.Fixed;
Result : Integer := 0;
Decimal_Value : Integer;
Radix_Offset : Natural := 0;
begin
for I in reverse Value'range loop
Decimal_Value := Index(Num_Digits, Value(I..I)) - 1;
if Decimal_Value < 0 then
raise Invalid_Digit;
end if;
Result := Result + (Base**Radix_Offset * Decimal_Value);
Radix_Offset := Radix_Offset + 1;
end loop;
return Result;
end To_Decimal;
 
function To_Base(Value : Natural; Base : Base_Type) return String is
use Ada.Strings.Unbounded;
Result : Unbounded_String := Null_Unbounded_String;
Temp : Natural := Value;
Base_Digit : String(1..1);
begin
if Temp = 0 then
return "0";
end if;
while Temp > 0 loop
Base_Digit(1) := Num_Digits((Temp mod Base) + 1);
if Result = Null_Unbounded_String then
Append(Result, Base_Digit);
else
Insert(Source => Result,
Before => 1,
New_Item => Base_Digit);
end if;
Temp := Temp / Base;
end loop;
return To_String(Result);
end To_Base;
 
begin
Put_Line("26 converted to base 16 is " & To_Base(26, 16));
Put_line("1a (base 16) is decimal" & Integer'image(To_Decimal("1a", 16)));
end Number_Base_Conversion;

[edit] Aime

o_text(bfxa(0, 0, 16, 1000000));
o_byte('\n');
o_text(bfxa(0, 0, 5, 1000000));
o_byte('\n');
o_text(bfxa(0, 0, 2, 1000000));
o_byte('\n');
 
o_integer(alpha("f4240", 16));
o_byte('\n');
o_integer(alpha("224000000", 5));
o_byte('\n');
o_integer(alpha("11110100001001000000", 2));
o_byte('\n');

[edit] ALGOL 68

[edit] Built in or standard distribution routines

Works with: ALGOL 68 version Standard - no extensions to language used
Works with: ALGOL 68G version Any - tested with release mk15-0.8b.fc9.i386

The formatted transput in ALGOL 68 uses the format type (mode). This format type has many similarities with modern regular expressions and can be used to convert string patterns to and from many of the built in types (modes) in ALGOL 68. Here is an example converting a numbers base.

INT base = 16, from dec = 26;
BITS to bits;
 
FORMAT hex repr = $n(base)r2d$;
 
FILE f; STRING str;
 
associate(f, str);
putf(f, (hex repr, BIN from dec));
print(("Hex: ",str, new line));
 
reset(f);
getf(f, (hex repr, to bits));
print(("Int: ",ABS to bits, new line))

Output:

Hex: 1a
Int:         +26

Note that the only conversions "officially" available are for the bases 2r, 4r, 8r and 16r. But ALGOL 68G allows formatting for all numbers in the range 2r to 16r.

[edit] Implementation example

Handles signed and unsigned numbers from all bases.

Translation of: python
Works with: ALGOL 68 version Standard - no extensions to language used
Works with: ALGOL 68G version Any - tested with release mk15-0.8b.fc9.i386
Works with: ELLA ALGOL 68 version Any (with appropriate job cards) - tested with release 1.8.8d.fc9.i386
STRING numeric alpha = "0123456789abcdefghijklmnopqrstuvwxyz";
 
PROC raise value error = ([]STRING args)VOID: (
put(stand error, "Value error");
STRING sep := ": ";
FOR index TO UPB args - 1 DO put(stand error, (sep, args[index])); sep:=", " OD;
new line(stand error);
stop
);
 
PROC base n = (INT num, base)STRING: (
PROC base n = (INT num, base)STRING:
( num = 0 | "" | base n(num OVER base, base) + numeric alpha[@0][num MOD base]);
( num = 0 | "0" |: num > 0 | base n(num, base) | "-" + base n(-num, base) )
);
 
PROC unsigned int = (STRING repr, INT base)INT:
IF UPB repr < LWB repr THEN 0 ELSE
INT pos;
IF NOT char in string(repr[UPB repr], pos, numeric alpha) THEN
raise value error("CHAR """+repr[UPB repr]+""" not valid")
FI;
unsigned int(repr[:UPB repr-1], base) * base + pos - 1
FI
;
 
PROC int = (STRING repr, INT base)INT:
( repr[LWB repr]="-" | -unsigned int(repr[LWB repr + 1:], base) | unsigned int(repr, base) );
 
[]INT test = (-256, -255, -26, -25, 0, 25, 26, 255, 256);
FOR index TO UPB test DO
INT k = test[index];
STRING s = base n(k,16); # returns the string 1a #
INT i = int(s,16); # returns the integer 26 #
print((k," => ", s, " => ", i, new line))
OD

Output:

       -256 => -100 =>        -256
       -255 => -ff =>        -255
        -26 => -1a =>         -26
        -25 => -19 =>         -25
         +0 => 0 =>          +0
        +25 => 19 =>         +25
        +26 => 1a =>         +26
       +255 => ff =>        +255
       +256 => 100 =>        +256

[edit] Other libraries or implementation specific extensions

As of February 2009 no open source libraries to do this task have been located.

[edit] AutoHotkey

MsgBox % number2base(200, 16) ; 12
MsgBox % parse(200, 16) ; 512
 
number2base(number, base)
{
While, base < digit := floor(number / base)
{
result := mod(number, base) . result
number := digit
}
result := digit . result
Return result
}
 
parse(number, base)
{
result = 0
pos := StrLen(number) - 1
Loop, Parse, number
{
result := ((base ** pos) * A_LoopField) + result
base -= 1
}
Return result
}

alternate implementation contributed by Laszlo on the ahk forum

MsgBox % ToBase(29,3)
MsgBox % ToBase(255,16)
 
MsgBox % FromBase("100",8)
MsgBox % FromBase("ff",16)
 
ToBase(n,b) { ; n >= 0, 1 < b <= 36
Return (n < b ? "" : ToBase(n//b,b)) . ((d:=mod(n,b)) < 10 ? d : Chr(d+87))
}
 
FromBase(s,b) { ; convert base b number s=strings of 0..9,a..z, to AHK number
Return (L:=StrLen(s))=0 ? "":(L>1 ? FromBase(SubStr(s,1,L-1),b)*b:0) + ((c:=Asc(SubStr(s,0)))>57 ? c-87:c-48)
}

[edit] AWK

function strtol(str, base)
{
symbols = "0123456789abcdefghijklmnopqrstuvwxyz"
res = 0
str = tolower(str)
for(i=1; i < length(str); i++) {
res += index(symbols, substr(str, i, 1)) - 1
res *= base
}
res += index(symbols, substr(str, length(str), 1)) - 1
return res
}
 
function ltostr(num, base)
{
symbols = "0123456789abcdefghijklmnopqrstuvwxyz"
res = ""
do {
res = substr(symbols, num%base + 1, 1) res
num = int(num/base)
} while ( num != 0 )
return res
}
 
BEGIN {
print strtol("7b", 16)
print ltostr(123, 16)
}

[edit] BBC BASIC

      PRINT "  0 (decimal) -> " FNtobase(0, 16) " (base 16)"
PRINT " 26 (decimal) -> " FNtobase(26, 16) " (base 16)"
PRINT "383 (decimal) -> " FNtobase(383, 16) " (base 16)"
PRINT " 26 (decimal) -> " FNtobase(26, 2) " (base 2)"
PRINT "383 (decimal) -> " FNtobase(383, 2) " (base 2)"
PRINT " 1a (base 16) -> " ;FNfrombase("1a", 16) " (decimal)"
PRINT " 1A (base 16) -> " ;FNfrombase("1A", 16) " (decimal)"
PRINT "17f (base 16) -> " ;FNfrombase("17f", 16) " (decimal)"
PRINT "101111111 (base 2) -> " ;FNfrombase("101111111", 2) " (decimal)"
END
 
DEF FNtobase(N%, B%)
LOCAL D%,A$
REPEAT
D% = N% MOD B%
N% DIV= B%
A$ = CHR$(48 + D% - 39*(D%>9)) + A$
UNTIL N% = FALSE
=A$
 
DEF FNfrombase(A$, B%)
LOCAL N%
REPEAT
N% *= B%
N% += ASC(A$) - 48 + 7*(ASCA$>64) + 32*(ASCA$>96)
A$ = MID$(A$,2)
UNTIL A$ = ""
= N%

Output:

  0 (decimal) -> 0 (base 16)
 26 (decimal) -> 1a (base 16)
383 (decimal) -> 17f (base 16)
 26 (decimal) -> 11010 (base 2)
383 (decimal) -> 101111111 (base 2)
 1a (base 16) -> 26 (decimal)
 1A (base 16) -> 26 (decimal)
17f (base 16) -> 383 (decimal)
101111111 (base 2) -> 383 (decimal)

[edit] Bracmat

  ( display
=
.  !arg:<10
| !arg:<36&chr$(asc$a+!arg+-10)
| "Base too big"
)
& ( base
= n b
.  !arg:(?n.?b)
& !n:<!b
& ( !n:~<0&display$!n
| NOTSUPPORTED
)
| base$(div$(!n.!b).!b) display$(mod$(!n.!b))
)
& whl
' ( put
$ "Enter non-negative integer in decimal notation (or something else to stop):"
& get':~/#>-1:?n
& put$"Enter base (less than 37):"
& get$:~/#>1:~>36:?b
& out$(!n " in base " !b " is " str$(base$(!n.!b)))
);

[edit] C

#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <stdint.h>
 
char *to_base(int64_t num, int base)
{
char *tbl = "0123456789abcdefghijklmnopqrstuvwxyz";
char buf[66] = {'\0'};
char *out;
uint64_t n;
int i, len = 0, neg = 0;
if (base > 36) {
fprintf(stderr, "base %d too large\n", base);
return 0;
}
 
/* safe against most negative integer */
n = ((neg = num < 0)) ? (~num) + 1 : num;
 
do { buf[len++] = tbl[n % base]; } while(n /= base);
 
out = malloc(len + neg + 1);
for (i = neg; len > 0; i++) out[i] = buf[--len];
if (neg) out[0] = '-';
 
return out;
}
 
long from_base(const char *num_str, int base)
{
char *endptr;
/* there is also strtoul() for parsing into an unsigned long */
/* in C99, there is also strtoll() and strtoull() for parsing into long long and
* unsigned long long, respectively */

int result = strtol(num_str, &endptr, base);
return result;
}
 
int main()
{
int64_t x;
x = ~(1LL << 63) + 1;
printf("%lld in base 2: %s\n", x, to_base(x, 2));
x = 383;
printf("%lld in base 16: %s\n", x, to_base(x, 16));
return 0;
}
output
-9223372036854775808 in base 2: -1000000000000000000000000000000000000000000000000000000000000000
383 in base 16: 17f

[edit] C++

#include <string>
#include <cstdlib>
#include <algorithm>
#include <cassert>
 
std::string const digits = "0123456789abcdefghijklmnopqrstuvwxyz";
 
std::string to_base(unsigned long num, int base)
{
if (num == 0)
return "0";
 
std::string result;
while (num > 0) {
std::ldiv_t temp = std::div(num, (long)base);
result += digits[temp.rem];
num = temp.quot;
}
std::reverse(result.begin(), result.end());
return result;
}
 
unsigned long from_base(std::string const& num_str, int base)
{
unsigned long result = 0;
for (std::string::size_type pos = 0; pos < num_str.length(); ++pos)
result = result * base + digits.find(num_str[pos]);
return result;
}

[edit] C#

 
public static class BaseConverter {
 
/// <summary>
/// Converts a string to a number
/// </summary>
/// <returns>The number.</returns>
/// <param name="s">The string to convert.</param>
/// <param name="b">The base number (between 2 and 36).</param>
public static long stringToLong(string s, int b) {
 
if ( b < 2 || b > 36 )
throw new ArgumentException("Base must be between 2 and 36", "b");
 
checked {
 
int slen = s.Length;
long result = 0;
bool isNegative = false;
 
for ( int i = 0; i < slen; i++ ) {
 
char c = s[i];
int num;
 
if ( c == '-' ) {
// Negative sign
if ( i != 0 )
throw new ArgumentException("A negative sign is allowed only as the first character of the string.", "s");
 
isNegative = true;
continue;
}
 
if ( c > 0x2F && c < 0x3A )
// Numeric character (subtract from 0x30 ('0') to get numerical value)
num = c - 0x30;
else if ( c > 0x40 && c < 0x5B )
// Uppercase letter
// Subtract from 0x41 ('A'), then add 10
num = c - 0x37; // 0x37 = 0x41 - 10
else if ( c > 0x60 && c < 0x7B )
// Lowercase letter
// Subtract from 0x61 ('a'), then add 10
num = c - 0x57; // 0x57 = 0x61 - 10
else
throw new ArgumentException("The string contains an invalid character '" + c + "'", "s");
 
// Check that the digit is allowed by the base.
 
if ( num >= b )
throw new ArgumentException("The string contains a character '" + c + "' which is not allowed in base " + b, "s");
 
// Multiply the result by the base, then add the next digit
 
result *= b;
result += num;
 
}
 
if ( isNegative )
result = -result;
 
return result;
 
}
 
}
 
/// <summary>
/// Converts a number to a string.
/// </summary>
/// <returns>The string.</returns>
/// <param name="n">The number to convert.</param>
/// <param name="b">The base number (between 2 and 36).</param>
public static string longToString(long n, int b) {
 
// This uses StringBuilder, so it only works with .NET 4.0 or higher. For earlier versions, the StringBuilder
// can be replaced with simple string concatenation.
 
if ( b < 2 || b > 36 )
throw new ArgumentException("Base must be between 2 and 36", "b");
 
// If the base is 10, call ToString() directly, which returns a base-10 string.
 
if ( b == 10 )
return n.ToString();
 
checked {
long longBase = b;
 
StringBuilder sb = new StringBuilder();
 
if ( n < 0 ) {
// Negative numbers
n = -n;
sb.Append('-');
}
 
long div = 1;
while ( n / div >= b )
// Continue multiplying the dividend by the base until it reaches the greatest power of
// the base which is less than or equal to the number.
div *= b;
 
while ( true ) {
byte digit = (byte) (n / div);
 
if ( digit < 10 )
// Numeric character (0x30 = '0')
sb.Append((char) (digit + 0x30));
else
// Alphabetic character (for digits > 10) (0x61 = 'a')
sb.Append((char) (digit + 0x57)); // 0x61 - 10
 
if ( div == 1 )
// Stop when the dividend reaches 1
break;
 
n %= div;
div /= b;
}
 
return sb.ToString();
}
 
}
 
}
 

[edit] Caché ObjectScript

Class Utils.Number [ Abstract ]
{
 
ClassMethod ConvertBase10ToN(pNum As %Integer = "", pBase As %Integer = "", pBaseStr As %String = "", pPos As %Integer = 0) As %String
{
If pNum=0 Quit ""
Set str=..ConvertBase10ToN(pNum\pBase, pBase, pBaseStr, pPos+1)
Quit str_$Extract(pBaseStr, pNum#pBase+1)
}
 
ClassMethod ConvertBaseNTo10(pStr As %String = "", pBase As %Integer = "", pBaseStr As %String = "", pPos As %Integer = 0) As %Integer
{
If pStr="" Quit 0
Set num=..ConvertBaseNTo10($Extract(pStr, 1, *-1), pBase, pBaseStr, pPos+1)
Set dec=$Find(pBaseStr, $Extract(pStr, *))-2
Quit num+(dec*(pBase**pPos))
}
 
ClassMethod ConvertBase(pStr As %String = "", pFrom As %Integer = 10, pTo As %Integer = 10, pBaseStr As %String = "", pLen As %Integer = 0) As %String
{
// some initialisation
If pBaseStr="" Set pBaseStr="0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
 
// check input values
If pFrom=10 Set pStr=$Number(pStr, "i", 0) If pStr="" Quit ""
Set pFrom=$Number(pFrom, "i", 2, 94) If pFrom="" Quit ""
Set pTo=$Number(pTo, "i", 2, 94) If pTo="" Quit ""
Set pLen=$Number(pLen, "i", 0, 32) If pLen="" Quit ""
 
// does base number exceed base string?
If pFrom>$Length(pBaseStr) Quit ""
If pTo>$Length(pBaseStr) Quit ""
 
// allow for upper/lowercase values
If pTo=10 {
If $Match(pStr, "^[0-9a-z]+$"), $Match($Extract(pBaseStr, 1, pFrom), "^[0-9A-Z]+$") {
Set pStr=$ZConvert(pStr, "U")
}
If $Match(pStr, "^[0-9A-Z]+$"), $Match($Extract(pBaseStr, 1, pFrom), "^[0-9a-z]+$") {
Set pStr=$ZConvert(pStr, "L")
}
}
 
// do the conversion
If pFrom=pTo {
Set pStr=pStr
} ElseIf pFrom=10 {
Set pStr=..ConvertBase10ToN($Select(pStr=0: "", 1: pStr), pTo, pBaseStr)
} ElseIf pTo=10 {
Set pStr=..ConvertBaseNTo10(pStr, pFrom, pBaseStr)
} Else {
Set pStr=..ConvertBase10ToN(..ConvertBaseNTo10(pStr, pFrom, pBaseStr), pTo, pBaseStr)
}
 
// return value
If pLen=0 Quit pStr
If pTo'=10 Quit ..PadStr(pStr, pLen, $Extract(pBaseStr))
Quit ..PadStr(pStr, pLen)
}
 
ClassMethod PadStr(pStr As %String, pLen As %Integer, pZero As %String = 0) As %String [ Private ]
{
If $Length(pStr)>pLen Quit pStr
Quit $Translate($Justify(pStr, pLen), " ", pZero)
}
 
}
Examples:
USER>Write ##class(Utils.Number).ConvertBase(1010101111001101, 2, 16)
ABCD

USER>Write $ZHex(26)
1A
USER>Write $ZHex("1A")
26

USER>Write ##class(Utils.Number).ConvertBase(26, 10, 16)
1A
USER>Write ##class(Utils.Number).ConvertBase("1A", 16, 10)
26

USER>Write ##class(Utils.Number).ConvertBase(6234900123456700, 10, 42, "!$%-0123456789@ABCDEFGHIJKLMNOPQRSTUVWXYZ_")
A9XUCDBHK6
USER>Write ##class(Utils.Number).ConvertBase("A9XUCDBHK6", 42, 10, "!$%-0123456789@ABCDEFGHIJKLMNOPQRSTUVWXYZ_")
6234900123456700

[edit] Common Lisp

(parse-integer "1a" :radix 16) ; returns multiple values: 26, 2
(write-to-string 26 :base 16) ; also "1A"

[edit] D

[edit] Using Standard Functions

import std.stdio, std.conv, std.string, std.ascii;
 
void main() {
"1abcd".to!int(16).writeln;
 
writeln(60_272_032_366.to!string(36, LetterCase.lower), ' ',
591_458.to!string(36, LetterCase.lower));
}
Output:
109517
rosetta code

[edit] One Implementation

import std.stdio, std.array, std.ascii;
 
immutable string mDigits = digits ~ lowercase;
 
ulong atoiRadix(in string str, in uint radix=10, int* consumed=null)
nothrow {
static int dtoi(in char dc, in uint radix) nothrow {
static int[immutable char] digit;
immutable char d = dc.toLower;
if (digit.length == 0) // Not init yet.
foreach (i, c; mDigits)
digit[c] = i;
if (radix > 1 && radix <= digit.length &&
d in digit && digit[d] < radix)
return digit[d];
return int.min; // A negative for error.
}
 
ulong result;
int sp;
for (; sp < str.length; sp++) {
immutable int d = dtoi(str[sp], radix);
if (d >= 0) // Valid digit char.
result = radix * result + d;
else
break;
}
if (sp != str.length) // Some char in str not converted.
sp = -sp;
if (consumed !is null) // Signal error if not positive.
*consumed = sp;
return result;
}
 
string itoaRadix(ulong num, in uint radix=10) pure nothrow
in {
assert(radix > 1 && radix <= mDigits.length);
} body {
string result;
while (num > 0) {
immutable uint d = num % radix;
result = mDigits[d] ~ result;
num = (num - d) / radix;
}
return result.empty ? "0" : result;
}
 
void main() {
immutable string numStr = "1ABcdxyz???";
 
int ate;
writef("'%s' (base %d) = %d", numStr, 16,
atoiRadix(numStr, 16, &ate));
 
if (ate <= 0)
writefln("\tConverted only: '%s'", numStr[0 .. -ate]);
else
writeln();
 
writeln(itoaRadix(60_272_032_366, 36), " ",
itoaRadix(591_458, 36));
}
Output:
'1ABcdxyz???' (base 16) = 109517    Converted only: '1ABcd'
rosetta code

[edit] Alternative Implementation

Translation of: Haskell
import std.stdio, std.algorithm, std.ascii, std.array, std.string;
 
alias Digits = ubyte[];
 
Digits toBase(ulong number, in ubyte base) pure nothrow @safe {
Digits result;
while (number) {
result = number % base ~ result;
number /= base;
}
return result;
}
 
enum fromBase = (in Digits digits, in ubyte base) pure nothrow @safe @nogc =>
reduce!((n, k) => n * base + k)(0UL, digits);
 
immutable myDigits = digits ~ lowercase;
 
enum fromDigits = (in Digits digits) pure nothrow /*@safe*/ =>
digits.map!(d => myDigits[d]).array;
 
enum convert = (in dchar d) pure nothrow @safe @nogc =>
cast(ubyte)(d.isDigit ? d - '0' : std.ascii.toLower(d) - 'a' + 10);
 
enum toDigits = (in string number) pure nothrow @safe =>
number.representation.map!convert.array;
 
void main() {
"1ABcd".toDigits.fromBase(16).writeln;
}
Output:
109517

[edit] E

def stringToInteger := __makeInt
def integerToString(i :int, base :int) {
return i.toString(base)
}
? stringToInteger("200", 16)
# value: 512
 
? integerToString(200, 16)
# value: "c8"

[edit] Erlang

Output:
12> erlang:list_to_integer("ffff", 17).
78300
13> erlang:integer_to_list(63, 3).
"2100"

[edit] Euphoria

function to_base(integer i, integer base)
integer rem
sequence s
s = ""
while i > 0 do
rem = remainder(i,base)
if rem < 10 then
s = prepend(s, '0'+rem)
else
s = prepend(s, 'a'-10+rem)
end if
i = floor(i/base)
end while
 
if length(s) = 0 then
s = "0"
end if
 
return s
end function
 
function from_base(sequence s, integer base)
integer i,d
i = 0
for n = 1 to length(s) do
i *= base
if s[n] >= '0' and s[n] <= '9' then
d = s[n]-'0'
elsif s[n] >= 'a' then
d = s[n]-'a'+10
end if
i += d
end for
return i
end function

[edit] Factor

USE: math.parser
 
12345 16 >base .
"3039" 16 base> .

[edit] Forth

Forth has a global user variable, BASE, which determines the radix used for parsing, interpretation, and printing of integers. This can handle bases from 2-36, but there are two words to switch to the most popular bases, DECIMAL and HEX.

42 dup
2 base !
. \ 101010
hex
. \ 2A
decimal

Many variants of Forth support literals in some bases, such as hex, using a prefix

$ff .   \ 255

[edit] Fortran

Works with: Fortran version 90 and later
MODULE Conversion
IMPLICIT NONE
CHARACTER(36) :: alphanum = "0123456789abcdefghijklmnopqrstuvwxyz"
 
CONTAINS
 
FUNCTION ToDecimal(base, instr)
INTEGER :: ToDecimal
INTEGER :: length, i, n, base
CHARACTER(*) :: instr
 
ToDecimal = 0
length = LEN(instr)
DO i = 1, length
n = INDEX(alphanum, instr(i:i)) - 1
n = n * base**(length-i)
Todecimal = ToDecimal + n
END DO
END FUNCTION ToDecimal
 
FUNCTION ToBase(base, number)
CHARACTER(31) :: ToBase
INTEGER :: base, number, i, rem
 
ToBase = " "
DO i = 31, 1, -1
IF(number < base) THEN
ToBase(i:i) = alphanum(number+1:number+1)
EXIT
END IF
rem = MOD(number, base)
ToBase(i:i) = alphanum(rem+1:rem+1)
number = number / base
END DO
ToBase = ADJUSTL(ToBase)
END FUNCTION ToBase
 
END MODULE Conversion
 
PROGRAM Base_Convert
USE Conversion
 
WRITE (*,*) ToDecimal(16, "1a")
WRITE (*,*) ToBase(16, 26)
 
END PROGRAM

[edit] FunL

Converting from integer to string:

$stdout = int( '1a', 16 )
Output:
26

Converting from string to integer:

$stdout = str( 26, 16 )
Output:
1a

[edit] Go

The standard strconv package functions ParseInt, ParseUint, FormatInt, FormatUint, and the standard math/big package method SetString, all accept a base argument 2 ≤ base ≤ 36.

Note, there is no equivalent formatting function provided for a big.Int, only the standard bases are available via fmt integer formatting verbs (binary %b, octal %o, decimal %d, and hexidecimal %x or %X).

package main
 
import (
"fmt"
"math/big"
"strconv"
)
 
func main () {
s := strconv.FormatInt(26, 16) // returns the string "1a"
fmt.Println(s)
 
i, err := strconv.ParseInt("1a", 16, 64) // returns the integer (int64) 26
if err == nil {
fmt.Println(i)
}
b, ok := new(big.Int).SetString("1a", 16) // returns the big integer 26
if ok {
fmt.Println(b)
}
}

[edit] Groovy

Solution:

def radixParse = { s, radix -> Integer.parseInt(s, radix) }
def radixFormat = { i, radix -> Integer.toString(i, radix) }

Test Program:

def numString = '101'
(2..Character.MAX_RADIX).each { radix ->
def value = radixParse(numString, radix)
assert value == radix**2 + 1
printf ("  %3s (%2d) == %4d (10)\n", numString, radix, value)
 
def valM2str = radixFormat(value - 2, radix)
def biggestDigit = radixFormat(radix - 1, radix)
assert valM2str == biggestDigit + biggestDigit
printf ("%3s (%2d) - 2 (10) == %4s (%2d)\n", numString, radix, valM2str, radix)
}

Output:

         101 ( 2) ==    5 (10)
101 ( 2) - 2 (10) ==   11 ( 2)
         101 ( 3) ==   10 (10)
101 ( 3) - 2 (10) ==   22 ( 3)
         101 ( 4) ==   17 (10)
101 ( 4) - 2 (10) ==   33 ( 4)
         101 ( 5) ==   26 (10)
101 ( 5) - 2 (10) ==   44 ( 5)
         101 ( 6) ==   37 (10)
101 ( 6) - 2 (10) ==   55 ( 6)
         101 ( 7) ==   50 (10)
101 ( 7) - 2 (10) ==   66 ( 7)
         101 ( 8) ==   65 (10)
101 ( 8) - 2 (10) ==   77 ( 8)
         101 ( 9) ==   82 (10)
101 ( 9) - 2 (10) ==   88 ( 9)
         101 (10) ==  101 (10)
101 (10) - 2 (10) ==   99 (10)
         101 (11) ==  122 (10)
101 (11) - 2 (10) ==   aa (11)
         101 (12) ==  145 (10)
101 (12) - 2 (10) ==   bb (12)
         101 (13) ==  170 (10)
101 (13) - 2 (10) ==   cc (13)
         101 (14) ==  197 (10)
101 (14) - 2 (10) ==   dd (14)
         101 (15) ==  226 (10)
101 (15) - 2 (10) ==   ee (15)
         101 (16) ==  257 (10)
101 (16) - 2 (10) ==   ff (16)
         101 (17) ==  290 (10)
101 (17) - 2 (10) ==   gg (17)
         101 (18) ==  325 (10)
101 (18) - 2 (10) ==   hh (18)
         101 (19) ==  362 (10)
101 (19) - 2 (10) ==   ii (19)
         101 (20) ==  401 (10)
101 (20) - 2 (10) ==   jj (20)
         101 (21) ==  442 (10)
101 (21) - 2 (10) ==   kk (21)
         101 (22) ==  485 (10)
101 (22) - 2 (10) ==   ll (22)
         101 (23) ==  530 (10)
101 (23) - 2 (10) ==   mm (23)
         101 (24) ==  577 (10)
101 (24) - 2 (10) ==   nn (24)
         101 (25) ==  626 (10)
101 (25) - 2 (10) ==   oo (25)
         101 (26) ==  677 (10)
101 (26) - 2 (10) ==   pp (26)
         101 (27) ==  730 (10)
101 (27) - 2 (10) ==   qq (27)
         101 (28) ==  785 (10)
101 (28) - 2 (10) ==   rr (28)
         101 (29) ==  842 (10)
101 (29) - 2 (10) ==   ss (29)
         101 (30) ==  901 (10)
101 (30) - 2 (10) ==   tt (30)
         101 (31) ==  962 (10)
101 (31) - 2 (10) ==   uu (31)
         101 (32) == 1025 (10)
101 (32) - 2 (10) ==   vv (32)
         101 (33) == 1090 (10)
101 (33) - 2 (10) ==   ww (33)
         101 (34) == 1157 (10)
101 (34) - 2 (10) ==   xx (34)
         101 (35) == 1226 (10)
101 (35) - 2 (10) ==   yy (35)
         101 (36) == 1297 (10)
101 (36) - 2 (10) ==   zz (36)

[edit] Haskell

Using built-in functions to convert integer into string, and vice versa, at any base up to 16:

Prelude> Numeric.showIntAtBase 16 Char.intToDigit 42 ""
"2a"
Prelude> fst $ head $ Numeric.readInt 16 Char.isHexDigit Char.digitToInt "2a"
42

It's actually more useful to represent digits internally as numbers instead of characters, because then one can define operations that work directly on this representation.

So conversion to and from digits represented as 0-9 and a-z is done in an additional step.

import Data.List
import Data.Char
 
toBase :: Int -> Int -> [Int]
toBase b v = toBase' [] v where
toBase'
a 0 = a
toBase' a v = toBase' (r:a) q where (q,r) = v `divMod` b
 
fromBase :: Int -> [Int] -> Int
fromBase b ds = foldl' (\n k -> n * b + k) 0 ds
 
toAlphaDigits :: [Int] -> String
toAlphaDigits = map convert where
convert n | n < 10 = chr (n + ord '
0')
| otherwise = chr (n + ord '
a' - 10)
 
fromAlphaDigits :: String -> [Int]
fromAlphaDigits = map convert where
convert c | isDigit c = ord c - ord '
0'
| isUpper c = ord c - ord '
A' + 10
| isLower c = ord c - ord '
a' + 10

Example:

*Main> toAlphaDigits $ toBase 16 $ 42
"2a"
*Main> fromBase 16 $ fromAlphaDigits $ "2a"
42

[edit] HicEst

CHARACTER txt*80
 
num = 36^7 -1 ! 7836416410
CALL DecToBase(num, txt, 36)
WRITE(ClipBoard, Name) num, txt, BaseToDec(36, txt)
END
 
FUNCTION BaseToDec(base, string)
CHARACTER string
BaseToDec = 0
length = LEN_TRIM(string)
DO i = 1, length
n = INDEX("0123456789abcdefghijklmnopqrstuvwxyz", string(i)) - 1
BaseToDec = BaseToDec + n * base^(length-i)
ENDDO
END
 
SUBROUTINE DectoBase(decimal, string, base)
CHARACTER string
string = '0'
temp = decimal
length = CEILING( LOG(decimal+1, base) )
DO i = length, 1, -1
n = MOD( temp, base )
string(i) = "0123456789abcdefghijklmnopqrstuvwxyz"(n+1)
temp = INT(temp / base)
ENDDO
END
num=7836416410; txt=zzzzzzz; 7836416410;

[edit] Icon and Unicon

Icon and Unicon natively take integers in radix form for bases 2 through 36. There is no need to convert to integer as the value will be coerced when needed. However, a conversion routine is needed to convert integers back into radix form.

procedure main()
every ( ns := "16r5a" | "-12r1a" ) &
( b := 8 | 12 | 16 ) do {
ns2 := convert(n := numeric(ns),b)
printf("ns=%s -> n=%d -> %s\n",ns,n,ns2)
}
end
 
link printf
 
procedure convert(i,b) #: convert i to base b radix representation
static digits
initial digits := &digits || &lcase
 
i := integer(i) | runerr(101, i) # arg/error checking
/b := 10 | ( 2 < (b := integer(b)) <= *digits ) | runerr(205,b)
 
if b = 10 then return i
else {
p := (s := "", (i := -(0 > i),"-")|"") || b || "r" # prefix/setup
until i = 0 & *s > 0 do
s ||:= digits[1 + 1( i % b, i /:= b)]
 
return p || reverse(s)
}
end

printf.icn provides printf There are several conversion routines for bases in the IPL, however, none returns the input radix form.

Output:
ns=16r5a -> n=90 -> 8r132
ns=16r5a -> n=90 -> 12r76
ns=16r5a -> n=90 -> 16r5a
ns=-12r1a -> n=-22 -> -8r26
ns=-12r1a -> n=-22 -> -12r1a
ns=-12r1a -> n=-22 -> -16r16

[edit] J

J supports direct specification of integers by base. The numbers are expressed as the base to be used (using base 10), the letter b, followed by the number itself. Following the initial letter b, other (lower case) letters represent "digts" 10 (a) through 35 (z), as in these examples:

   2b100 8b100 10b_100 16b100 36b100 36bzy
4 64 _100 256 1296 1294

Additionally, J has primitives #. and #: for dealing with base conversion issues.

Here are programs for conversion of numeric values to literals, and of literals to numbers:

numerals=: '0123456789abcdefghijklmnopqrstuvwxyz'
baseNtoL=: numerals {~ #.inv
baseLtoN=: [ #. numerals i. ]

Examples of use:

   2 baseNtoL 100 101
1100100
1100101
16 baseNtoL 26
1a
36 baseLtoN 'zy'
1294

These may be combined so the conversion performed is derived from the type of argument received.

   base=: baseNtoL :: baseLtoN
 
16 base 'aa'
170
16 base 170
aa

See also primary verbs Base and Antibase.

[edit] Java

for long's:

public static long backToTen(String num, int oldBase){
return Long.parseLong(num, oldBase); //takes both uppercase and lowercase letters
}
 
public static String tenToBase(long num, int newBase){
return Long.toString(num, newBase);//add .toUpperCase() for capital letters
}

for BigInteger's:

public static BigInteger backToTenBig(String num, int oldBase){
return new BigInteger(num, oldBase); //takes both uppercase and lowercase letters
}
 
public static String tenBigToBase(BigInteger num, int newBase){
return num.toString(newBase);//add .toUpperCase() for capital letters
}

[edit] JavaScript

k = 26
s = k.toString(16) //gives 1a
i = parseInt('1a',16) //gives 26
//optional special case for hex:
i = +('0x'+s) //hexadecimal base 16, if s='1a' then i=26.

[edit] jq

# Convert the input integer to a string in the specified base (2 to 36 inclusive)
def convert(base):
def stream:
recurse(if . > 0 then ./base|floor else empty end) | . % base ;
if . == 0 then "0"
else [stream] | reverse | .[1:]
| if base < 10 then map(tostring) | join("")
elif base <= 36 then map(if . < 10 then 48 + . else . + 87 end) | implode
else error("base too large")
end
end;
 
# input string is converted from "base" to an integer, wihtin limits
# of the underlying arithmetic operations, and without error-checking:
def to_i(base):
explode
| reverse
| map(if . > 96 then . - 87 else . - 48 end) # "a" ~ 97 => 10 ~ 87
| reduce .[] as $c
# state: [power, ans]
([1,0]; (.[0] * base) as $b | [$b, .[1] + (.[0] * $c)])
| .[1];

Example:

(255 | convert(16)),
("ff" | to_i(16)),
("10" | to_i(10))
Output:
$jq -M -r -n -f Non-decimal_radices.jq
ff
255
10

[edit] LFE

Converting decimal numbers 26 and 3000 in LFE, using some different mechanisms:

 
> (: erlang list_to_integer '"1a" 16)
26
> #x1a
26
> (: erlang integer_to_list 26 16)
"1A"
> (: erlang list_to_integer '"101110111000" 2)
3000
> #b101110111000
3000
> (: erlang integer_to_list 3000 2)
"101110111000"
 

[edit] Liberty BASIC

   '   Base Converter v6
 
global alphanum$
alphanum$ ="0123456789abcdefghijklmnopqrstuvwxyz"
 
for i =1 to 20
RandNum = int( 100 *rnd( 1))
base =2 +int( 35 *rnd( 1))
 
print "Decimal "; using( "###", RandNum); " to base "; using( "###", base);_
" is "; toBase$( base, RandNum),_
" back to dec. "; toDecimal( base, toBase$( base, RandNum))
next i
 
end ' ___________________________________________________________
 
function toBase$( base, number) ' Convert decimal variable to number string.
toBase$ =""
for i =10 to 1 step -1
remainder =number mod base
toBase$ =mid$( alphanum$, remainder +1, 1) +toBase$
number =int( number /base)
if number <1 then exit for
next i
end function
 
function toDecimal( base, s$) ' Convert number string to decimal variable.
toDecimal =0
for i =1 to len( s$)
toDecimal =toDecimal *base +instr( alphanum$, mid$( s$, i, 1), 1) -1
next i
end function
 

[edit] M4

eval(26,16)
define(`frombase',`eval(0r$2:$1)')
frombase(1a,16)

Output:

1a

26

[edit] Mathematica

Use the built-in functions IntegerString[] and FromDigits[]:

IntegerString[26,16]
FromDigits["1a", 16])

Output:

"1a"

26

[edit] MATLAB / Octave

Use the built-in functions base2dec() and dec2base():

dec2base(26,16)
base2dec('1a', 16)

Output:

1A

26

[edit] МК-61/52

П8	->	1	0	П0	ПП	13	ИП7	П0	ИП8
ПП	13	С/П	П7	->	П6	->	1	П4	П5
Сx	<->	^	ПП	68	П3	-	ИП7	*	П2
ПП	68	ИП4	ИП6	*	П4	/	+	ИП2	ИП1
-	x#0	45	L0	27	->	ИП3	^	ИП7	/
ПП	68	ИП7	*	-	ИП5	*	+	ИП5	ИП6
*	П5	->	ИП1	x=0	47	->	В/О	1	+
П1	КИП1	->	->	ИП1	В/О

Input: Nm ^ m ^ n В/О С/П.

Output: Nn -> PX.

[edit] NetRexx

In NetRexx numbers are held as Rexx strings so you can take advantage of Java's BigInteger to do radix conversions.

/* NetRexx */
options replace format comments java crossref symbols nobinary
 
import java.math.BigInteger
 
numeric digits 200
 
parse arg input -- input should be val, radix; no input results in using default test data
-- test data - number pairs where 1st is value and 2nd is target radix
inputs = [ -
'1234, 10', '01234, 8', 'fe, 16', 'f0e, 16', -
'0, 10', '00, 2', '11, 2', '070, 8', -
'77, 8', 'f0e, 16', '070, 16', '0xf0e, 36', -
'000999ABCXYZ, 36', 'ff, 36', 'f, 16', 'z, 37' -
]
if input.length() > 0 then inputs = [input] -- replace test data with user input
 
loop i_ = 0 to inputs.length - 1
do
in = inputs[i_]
parse in val . ',' radix .
valB = toDecimal(val, radix) -- NetRexx default is to store digits as Rexx strings
valD = fromDecimal(valB + 0, radix) -- Add zero just to prove the result treated as a number
say val.right(16)'['radix.right(2, 0)']:' valB.right(16)'[10] ==' valD.right(16)'['radix.right(2, 0)']'
catch nx = NumberFormatException
say 'Error -- Input:' val', radix:' radix
nx.printStackTrace()
end
end i_
 
return
 
method toDecimal(val = String, radix = int 10) public static returns Rexx
bi = BigInteger(val, radix)
return bi.toString()
 
method fromDecimal(val = String, radix = int 10) public static returns Rexx
bi = BigInteger(val.toString(), 10)
return bi.toString(radix)
 

Output:

            1234[10]:             1234[10] ==             1234[10]
           01234[08]:              668[10] ==             1234[08]
              fe[16]:              254[10] ==               fe[16]
             f0e[16]:             3854[10] ==              f0e[16]
               0[10]:                0[10] ==                0[10]
              00[02]:                0[10] ==                0[02]
              11[02]:                3[10] ==               11[02]
             070[08]:               56[10] ==               70[08]
              77[08]:               63[10] ==               77[08]
             f0e[16]:             3854[10] ==              f0e[16]
             070[16]:              112[10] ==               70[16]
           0xf0e[36]:          1559102[10] ==             xf0e[36]
    000999ABCXYZ[36]:   26115481426427[10] ==        999abcxyz[36]
              ff[36]:              555[10] ==               ff[36]
               f[16]:               15[10] ==                f[16]
Error -- Input: z, radix: 37
java.lang.NumberFormatException: Radix out of range
	at java.math.BigInteger.<init>(BigInteger.java:294)
	at RNonDecRadixConvert.toDecimal(RNonDecRadixConvert.nrx:77)
	at RNonDecRadixConvert.main(RNonDecRadixConvert.nrx:57)

[edit] Nimrod

import strutils
 
proc reverse(a: string): string =
result = newString(a.len)
for i, c in a:
result[a.high - i] = c
 
const digits = "0123456789abcdefghijklmnopqrstuvwxyz"
 
proc toBase[T](num: T, base: range[2..36]): string =
if num == 0: return "0"
result = ""
if num < 0: result.add '-'
var tmp = abs(num)
var s = ""
while tmp > 0:
s.add digits[int(tmp mod base)]
tmp = tmp div base
result.add s.reverse
 
proc fromBase(str: string, base: range[2..36]): BiggestInt =
var str = str
let first = if str[0] == '-': 1 else: 0
 
for i in first .. str.high:
let c = str[i].toLower
assert c in digits[0 .. <base]
result = result * base + digits.find c
 
if first == 1: result *= -1
 
echo 26.toBase 16
echo "1a".fromBase 16

Output:

1a
26

[edit] OCaml

let int_of_basen n str =
match n with
| 16 -> int_of_string("0x" ^ str)
| 2 -> int_of_string("0b" ^ str)
| 8 -> int_of_string("0o" ^ str)
| _ -> failwith "unhandled"
 
let basen_of_int n d =
match n with
| 16 -> Printf.sprintf "%x" d
| 8 -> Printf.sprintf "%o" d
| _ -> failwith "unhandled"
# basen_of_int 16 26 ;;
- : string = "1a"

# int_of_basen 16 "1a" ;;
- : int = 26
A real base conversion example:
Translation of: Haskell
let to_base b v =
let rec to_base' a v =
if v = 0 then
a
else
to_base' (v mod b :: a) (v / b)
in
to_base' [] v
 
let from_base b ds =
List.fold_left (fun n k -> n * b + k) 0 ds
 
let to_alpha_digit n =
if n < 10 then
char_of_int (n + int_of_char '0')
else
char_of_int (n + int_of_char 'a' - 10)
 
let to_alpha_digits ds =
let buf = Buffer.create (List.length ds) in
List.iter (fun i -> Buffer.add_char buf (to_alpha_digit i)) ds;
Buffer.contents buf
 
let from_alpha_digit c = match c with
'0'..'9' -> int_of_char c - int_of_char '0'
| 'A'..'Z' -> int_of_char c - int_of_char 'A' + 10
| 'a'..'z' -> int_of_char c - int_of_char 'a' + 10
 
let from_alpha_digits s =
let result = ref [] in
String.iter (fun c -> result := from_alpha_digit c :: !result) s;
List.rev !result

Example:

# to_alpha_digits (to_base 16 42);;
- : string = "2a"
# from_base 16 (from_alpha_digits "2a");;
- : int = 42

[edit] PARI/GP

toBase(n,b)={
my(s="",t);
while(n,
t=n%b;
n\=b;
s=Str(if(t<=9,t,Strchr(Vecsmall([87+t]))),s)
);
if(#s,s,"0")
};
fromBase(s,b)={
my(t=0);
s=Vecsmall(s);
forstep(i=#s,1,-1,
t=b*t+s[i]-if(s[i]<58,48,87)
);
t
};

[edit] Pascal

Works with: Free_Pascal
Program ConvertDemo(output);
 
uses
Math, SysUtils;
 
const
alphanum = '0123456789abcdefghijklmnopqrstuvwxyz';
 
function ToDecimal(base: integer; instring: string): integer;
var
inlength, i, n: integer;
begin
ToDecimal := 0;
inlength := length(instring);
for i := 1 to inlength do
begin
n := pos(instring[i], alphanum) - 1;
n := n * base**(inlength-i);
Todecimal := ToDecimal + n;
end;
end;
 
function ToBase(base, number: integer): string;
var
i, rem: integer;
begin
ToBase :=' ';
for i := 31 downto 1 do
begin
if (number < base) then
begin
ToBase[i] := alphanum[number+1];
break;
end;
rem := number mod base;
ToBase[i] := alphanum[rem+1];
number := number div base;
end;
ToBase := trimLeft(ToBase);
end;
 
begin
writeln ('1A: ', ToDecimal(16, '1a'));
writeln ('26: ', ToBase(16, 26));
end.
 

Output:

% ./Convert
1A: 26
26: 1a

[edit] Perl

To parse from a base:

use POSIX;
 
my ($num, $n_unparsed) = strtol('1a', 16);
$n_unparsed == 0 or die "invalid characters found";
print "$num\n"; # prints "26"

To format into a base:

sub digitize
# Converts an integer to a single digit.
{my $i = shift;
$i < 10
? $i
: ('a' .. 'z')[$i - 10];}
 
sub to_base
{my ($int, $radix) = @_;
my $numeral = '';
do {
$numeral .= digitize($int % $radix);
} while $int = int($int / $radix);
scalar reverse $numeral;}

Math::BaseCnv can convert an integer to or from an arbitrary other base. Its normal output is upper-case but the usual lc() can convert (cf String case).

use Math::BaseCnv 'cnv';
print cnv("1a", 16, 10),"\n"; # "1a" from hex to decimal prints 26
print lc(cnv(26, 10, 16)),"\n"; # 26 from decimal to hex prints "1a"

Math::BaseCalc can do similar conversions with an arbitrary set of characters for digits.

[edit] Perl 6

sub from-base(Str $str, Int $base) {
+":$base\<$str>";
}
 
sub to-base(Real $num, Int $base) {
$num.base($base);
}

These work on any real type including integer types.

[edit] PHP

PHP has a base_convert() function that directly converts between strings of one base and strings of another base:

base_convert("26", 10, 16); // returns "1a"

If you want to convert a string to an integer, the intval() function optionally takes a base argument when given a string:

intval("1a", 16); // returns 26

To go the other way around, I guess you can use base_convert() again; I am unaware of a better way:

base_convert(26, 10, 16); // returns "1a"

In addition, there are specialized functions for converting certain bases:

// converts int to binary string
decbin(26); // returns "11010"
// converts int to octal string
decoct(26); // returns "32"
// converts int to hex string
dechex(26); // returns "1a"
// converts binary string to int
bindec("11010"); // returns 26
// converts octal string to int
octdec("32"); // returns 26
// converts hex string to int
hexdec("1a"); // returns 26

[edit] PL/I

 
convert: procedure (N, base) returns (character (64) varying) recursive;
declare N fixed binary (31), base fixed binary;
declare table (0:15) character (
'0', '1', '2', '3', '4', '5', '6', '7',
'8', '9', 'a', 'b', 'c', 'd', 'e', 'f');
declare s character (64) varying;
 
if N = 0 then return ('');
 
s = convert(N/base, base);
return (s || table(mod(N, base)) );
end convert;
 

[edit] PicoLisp

(de numToString (N Base)
(default Base 10)
(let L NIL
(loop
(let C (% N Base)
(and (> C 9) (inc 'C 39))
(push 'L (char (+ C `(char "0")))) )
(T (=0 (setq N (/ N Base)))) )
(pack L) ) )
 
(de stringToNum (S Base)
(default Base 10)
(let N 0
(for C (chop S)
(when (> (setq C (- (char C) `(char "0"))) 9)
(dec 'C 39) )
(setq N (+ C (* N Base))) )
N ) )
 
(prinl (numToString 26 16))
(prinl (stringToNum "1a" 16))
(prinl (numToString 123456789012345678901234567890 36))

Output:

"1a"
26
"byw97um9s91dlz68tsi"

[edit] Pop11

Pop11 can input and output routines can use any base up to 36 (depending on value 'pop_pr_radix' variable). 'radix_apply' runs i/o routine temporarly setting 'pop_pr_radix' to given value. 'sprintf' procedure instead of printing returns string. So, to convert number to given value we just compose built-in procedures:

define number_to_base(n, base);
radix_apply(n, '%p', sprintf, base);
enddefine;

In input base optionally preceeds the number, for example 8:15 is 13. So, to convert string in given base we need to prepend base prefix and read number from string:

define string_in_base_to_number(s, base);
incharitem(stringin(base >< ':' >< s))();
enddefine;

[edit] PureBasic

Global alphanum$ = "0123456789abcdefghijklmnopqrstuvwxyz" ;36 digits
#maxIntegerBitSize = SizeOf(Integer) * 8
 
Procedure toDecimal(base, s.s)
Protected length, i, toDecimal
 
length = Len(s)
If length: toDecimal = FindString(alphanum$, Left(s, 1), 1) - 1: EndIf
 
For i = 2 To length
toDecimal * base + FindString(alphanum$, Mid(s, i, 1), 1) - 1
Next
ProcedureReturn toDecimal
EndProcedure
 
Procedure.s toBase(base, number)
Protected i, rem, toBase.s{#maxIntegerBitSize} = Space(#maxIntegerBitSize)
 
For i = #maxIntegerBitSize To 1 Step -1
rem = number % base
PokeC(@toBase + i - 1, PeekC(@alphanum$ + rem))
If number < base: Break: EndIf
number / base
Next
ProcedureReturn LTrim(toBase)
EndProcedure
 
If OpenConsole()
PrintN( Str(toDecimal(16, "1a")) )
 
PrintN( toBase(16, 26) )
 
Print(#CRLF$ + #CRLF$ + "Press ENTER to exit")
Input()
CloseConsole()
EndIf

Sample output:

26
1a

[edit] Python

Converting from string to number is easy:

i = int('1a',16)  # returns the integer 26

Converting from number to string is harder:

digits = "0123456789abcdefghijklmnopqrstuvwxyz"
def baseN(num,b):
return (((num == 0) and "0" )
or ( baseN(num // b, b).lstrip("0")
+ digits[num % b]))
 
# alternatively:
def baseN(num,b):
if num == 0: return "0"
result = ""
while num != 0:
num, d = divmod(num, b)
result += digits[d]
return result[::-1] # reverse
 
k = 26
s = baseN(k,16) # returns the string 1a

[edit] Racket

 
#lang racket
 
;; Both assume valid inputs
(define (num->str N r)
(let loop ([N N] [digits '()])
(define-values [N1 d] (quotient/remainder N r))
(define digits1 (cons (integer->char (+ d (if (< d 10) 48 55))) digits))
(if (zero? N) (list->string digits1) (loop N1 digits1))))
(define (str->num S r)
(for/fold ([N 0])
([B (string->bytes/utf-8 (string-upcase S))])
(+ (* N r) (- B (if (< 64 B) 55 48)))))
 
;; To try it out:
(define (random-test)
(define N (random 1000000))
(define r (+ 2 (random 35)))
(define S (num->str N r))
(define M (str->num S r))
(printf "~s -> ~a#~a -> ~a => ~a\n" N S r M (if (= M N) 'OK 'BAD)))
;; (random-test)
 

[edit] REXX

Instead of writing two seperate routines, only one was written to handle both tasks.
This routine was ripped out from a bigger version of mine that allowed any number as input, including decimal fractions (or whatever base).
Illegal numerals/digits are detected as well as illegal (or unsupported) bases.

  ┌────────────────────────────────────────────────────────────────────┐
┌─┘ Input to this program (bases must be positive integers > 1): └─┐
│ │
│ x is required (it may have a sign). │
│ toBase the base to convert X to. │
│ inBase the base X is expressed in. │
│ │
│ If X has a leading sign, it is maintained (kept) after conversion. │
│ │
│ toBase or inBase can be a comma (,) which causes the default │
└─┐ of 10 to be used. The limits of bases are: 2 ──► 90. ┌─┘
└────────────────────────────────────────────────────────────────────┘
/*REXX pgm converts integers from one base to another  (base 2 ──► 90). */
@abc = 'abcdefghijklmnopqrstuvwxyz' /*the lowercase (Latin) alphabet.*/
parse upper var @abc @abcU /*uppercase a version of @abc. */
@@ = 0123456789 || @abc || @abcU /*prefix 'em with numeric digits.*/
@@ = @@'<>[]{}()?~!@#$%^&*_=|\/;:¢¬≈' /*add some special chars as well.*/
/* [↑] all chars must be viewable*/
numeric digits 3000 /*what da hey, support gihugeics.*/
maxB=length(@@) /*max base (radix) supported here*/
parse arg x toB inB 1 ox . 1 sigX 2 x2 . /*get: 3 args, origX, sign···*/
if pos(sigX,"+-")\==0 then x=x2 /*Does X have a leading sign? */
else sigX= /*Nope. No leading sign for X. */
if x=='' then call erm /*if no X number, issue error.*/
if toB=='' | toB=="," then toB=10 /*if skipped, assume default (10)*/
if inB=='' | inB=="," then inB=10 /* " " " " " */
if inB<2 | inb>maxB | \datatype(inB,'W') then call erb 'inBase ' inB
if toB<2 | toB>maxB | \datatype(toB,'W') then call erb 'toBase ' toB
#=0 /*result of converted X (base 10)*/
do j=1 for length(x) /*convert X, base inB ──► base 10*/
 ?=substr(x,j,1) /*pick off a numeral/digit from X*/
_=pos(?, @@) /*calculate this numeral's value.*/
if _==0 | _>inB then call erd x /*_ character an illegal numeral?*/
#=#*inB+_-1 /*build a new number, dig by dig.*/
end /*j*/ /* [↑] this also verifies digits*/
y= /*the value of X in base B. */
do while # >= toB /*convert #, base 10 ──► base toB*/
y=substr(@@, (#//toB)+1, 1)y /*construct the output number. */
#=#%toB /*··· and whittle # down also. */
end /*while*/ /* [↑] process leaves a residual*/
/* [↓] Y is the residual*/
y=sigX || substr(@@, #+1, 1)y /*prepend the sign if it existed.*/
say ox "(base" inB')' center('is',20) y "(base" toB')'
exit /*stick a fork in it, we're done.*/
/*──────────────────────────────────one─liner subroutines───────────────*/
erb: call ser 'illegal' arg(1)", it must be in the range: 2──►"maxB
erd: call ser 'illegal digit/numeral ['?"] in: " x
erm: call ser 'no argument specified.'
ser: say; say '***error!***'; say arg(1); exit 13

output when input is (maximum positive integer in a signed 32-bit word): 7fffffff , 16

7fffffff (base 16)          is          2147483647 (base 10)

output when input is: 4095 2

4095 (base 10)          is          111111111111 (base 2)

output when input is: 100 3 2

100 (base 2)          is          11 (base 3)

output when input is: zombieseatingdeadvegetables 10 36

zombieseatingdeadvegetables (base 36)          is          1038334289300125869792154778345043071467300 (base 10)

[edit] Ruby

This converts strings from any base to any base up to base 36.

class String
def convert_base(from, to)
Integer(self, from).to_s(to)
# self.to_i(from).to_s(to) #if you don't want exceptions
end
end
 
# first three taken from TCL
p "12345".convert_base(10, 23) # => "107h"
p "107h".convert_base(23, 7) # =>"50664"
p "50664".convert_base(7, 10) # =>"12345"
p "1038334289300125869792154778345043071467300".convert_base(10, 36) # =>"zombieseatingdeadvegetables"
p "ff".convert_base(15, 10) # => ArgumentError

[edit] Run BASIC

global    basCvt$
basCvt$ ="0123456789abcdefghijklmnopqrstuvwxyz"
html "<table border=1><tr bgcolor=wheat align=center><td>Decimal</td><td>To Base</td><td>Num</td><td>to Dec</td></tr>"
 
for i =1 to 10
RandNum = int(100 * rnd(1))
base = 2 +int(35 * rnd(1))
 
html "<tr align=right><td>";using("###", RandNum);"</td><td>";using("###", base);"</td><td>";toBase$(base,RandNum);"</td><td>";toDecimal( base, toBase$( base, RandNum));"</td></tr>"
next i
html "</table>"
end
 
function toBase$(b,n) ' b=base n=nmber
toBase$ =""
for i =10 to 1 step -1
toBase$ =mid$(basCvt$,n mod b +1,1) +toBase$
n =int( n /b)
if n <1 then exit for
next i
end function
 
function toDecimal( b, s$) ' scring number to decimal
toDecimal =0
for i =1 to len( s$)
toDecimal = toDecimal * b + instr(basCvt$,mid$(s$,i,1),1) -1
next i
end function
DecimalTo BaseNumto Dec
51 211001151
27 102727
12 18c12
90 352k90
99 175e99
99 185999
55 115055
56 282056
71 342371
61 232f61

[edit] Scratch

Hello, I'm a 12 year old boy. I have posted the Scratch solution to this problem online at scratch.mit.edu

[edit] Seed7

The type integer defines the operator radix and the function integer, which convert to string and vice versa. The type bigInteger defines radix and bigInteger for corresponding purposes.

$ include "seed7_05.s7i";
include "bigint.s7i";
 
const proc: main is func
begin
writeln(60272032366_ radix 36); # Convert bigInteger to string
writeln(591458 radix 36); # Convert integer to string
 
writeln(bigInteger("rosetta", 36)); # Convert string to bigInteger
writeln(integer("code", 36)); # Convert string to integer
end func;
Output:
rosetta
code
60272032366
591458

[edit] Slate

26 printString &radix: 16
Integer readFrom: '1A' &radix: 16.

[edit] Standard ML

Translation of: Haskell
fun toBase b v = let
fun toBase' (a, 0) = a
| toBase' (a, v) = toBase' (v mod b :: a, v div b)
in
toBase' ([], v)
end
 
fun fromBase b ds =
foldl (fn (k, n) => n * b + k) 0 ds
 
val toAlphaDigits = let
fun convert n = if n < 10 then chr (n + ord #"0")
else chr (n + ord #"a" - 10)
in
implode o map convert
end
 
val fromAlphaDigits = let
fun convert c = if Char.isDigit c then ord c - ord #"0"
else if Char.isUpper c then ord c - ord #"A" + 10
else if Char.isLower c then ord c - ord #"a" + 10
else raise Match
in
map convert o explode
end

Example:

val toAlphaDigits = fn : int list -> string
- toAlphaDigits (toBase 16 42);
val it = "2a" : string
- fromBase 16 (fromAlphaDigits "2a");
val it = 42 : int

[edit] Swift

Converting integer to string:

println(String(26, radix: 16)) // prints "1a"

Converting string to integer:

import Darwin
func string2int(s: String, radix: Int) -> Int {
return strtol(s, nil, Int32(radix))
// there is also strtoul() for UInt, and strtoll() and strtoull() for Int64 and UInt64, respectively
}
println(string2int("1a", 16)) // prints "26"

[edit] Tcl

Tcl scan and format commands can convert between decimal, octal and hexadecimal, but this solution can convert between any arbitrary bases.

namespace eval baseconvert {
variable chars "0123456789abcdefghijklmnopqrstuvwxyz"
namespace export baseconvert
}
proc baseconvert::dec2base {n b} {
variable chars
expr {$n == 0 ? 0
 : "[string trimleft [dec2base [expr {$n/$b}] $b] 0][string index $chars [expr {$n%$b}]]"
}
}
proc baseconvert::base2dec {n b} {
variable chars
set sum 0
foreach char [split $n ""] {
set d [string first $char [string range $chars 0 [expr {$b - 1}]]]
if {$d == -1} {error "invalid base-$b digit '$char' in $n"}
set sum [expr {$sum * $b + $d}]
}
return $sum
}
proc baseconvert::baseconvert {n basefrom baseto} {
dec2base [base2dec $n $basefrom] $baseto
}
 
namespace import baseconvert::baseconvert
baseconvert 12345 10 23 ;# ==> 107h
baseconvert 107h 23 7 ;# ==> 50664
baseconvert 50664 7 10 ;# ==> 12345

[edit] Ursala

A function parameterized by the base b performs the conversion in each direction. Folding (=>), iteration (->), and reification (-:) operators among others are helpful.

#import std
#import nat
 
num_to_string "b" = ||'0'! (-: num digits--letters)*+ @NiX ~&r->l ^|rrPlCrlPX/~& division\"b"
 
string_to_num "b" = @x =>0 sum^|/(-:@rlXS num digits--letters) product/"b"

This test program performs the conversions in both directions for a selection of numbers in base 8 and base 32.

test_data = <1,2,15,32,100,65536,323498993>
 
#cast %sLnLUL
 
tests =
 
<
num_to_string32* test_data,
string_to_num32* num_to_string32* test_data,
num_to_string8* test_data,
string_to_num8* num_to_string8* test_data>

output:

<
   <'1','2','f','10','34','2000','9kgcvh'>,
   <1,2,15,32,100,65536,323498993>,
   <'1','2','17','40','144','200000','2322031761'>,
   <1,2,15,32,100,65536,323498993>>

[edit] Wolframalpha

input box: 1801 decimal to base 16
input box: (99 base 12)+(77 base 8)
This is Mathematica but is worth showing distinctly. Result provides endian choice and other bases typically.

[edit] XPL0

include c:\cxpl\codes;  \intrinsic 'code' declarations
string 0; \use zero-terminated string convention
 
func Num2Str(N, B); \Convert integer N to a numeric string in base B
int N, B;
char S(32); int I;
[I:= 31;
S(31):= 0; \terminate string
repeat I:= I-1;
N:= N/B;
S(I):= rem(0) + (if rem(0)<=9 then ^0 else ^a-10);
until N=0;
return @S(I); \BEWARE! very temporary string space
];
 
func Str2Num(S, B); \Convert numeric string S in base B to an integer
char S; int B;
int I, N;
[I:= 0; N:= 0;
while S(I) do
[N:= N*B + S(I) - (if S(I)<=^9 then ^0 else ^a-10); I:= I+1];
return N;
];
 
[Text(0, Num2Str(0, 10)); CrLf(0);
Text(0, Num2Str(26, 16)); CrLf(0);
Text(0, Num2Str($7FFF_FFFF, 2)); CrLf(0);
IntOut(0, Str2Num("0100", 2)); CrLf(0);
IntOut(0, Str2Num("1a", 16)); CrLf(0);
IntOut(0, Str2Num("deadbeef", 16)); CrLf(0);
]

Output:

0
1a
1111111111111111111111111111111
4
26
-559038737

[edit] zkl

The toInt(base) and toString(base) methods do this. base is 2..36

(26).toString(16)  //--> "1a"
"1a".toInt(16) //-->26

In addition, string format is able to convert to a base:

"%x %,.2B".fmt(26,26) //-->"1a 1|1010"
Personal tools
Namespaces

Variants
Actions
Community
Explore
Misc
Toolbox