Data commit

Task/Non-decimal-radices-Convert/00-META.yaml

@@ -0,0 +1,3 @@
+---
+from: http://rosettacode.org/wiki/Non-decimal_radices/Convert
+note: Arithmetic operations

Task/Non-decimal-radices-Convert/00-TASK.txt

@@ -0,0 +1,17 @@
+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.  
+
+
+;Task:
+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. 
+
+For example:   the decimal number   '''26'''   expressed in base   '''16'''   would be   '''1a'''.
+
+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.
+<br><br>
+

Task/Non-decimal-radices-Convert/11l/non-decimal-radices-convert-1.11l

@@ -0,0 +1 @@
+print(Int(‘1A’, radix' 16)) // prints the integer 26

Task/Non-decimal-radices-Convert/11l/non-decimal-radices-convert-2.11l

@@ -0,0 +1 @@
+print(String(26, radix' 16)) // prints ‘1A’

Task/Non-decimal-radices-Convert/8086-Assembly/non-decimal-radices-convert-1.8086

@@ -0,0 +1,3 @@
+mov ah,02h
+mov al,00h     ;this is the unpacked encoding of octal "20" aka 10 in hexadecimal, 16 in decimal. Ignore the leading zeroes.
+byte 0D5h,08h  ;most assemblers don't allow you to encode a base so we have to inline the bytecode.

Task/Non-decimal-radices-Convert/8086-Assembly/non-decimal-radices-convert-2.8086

@@ -0,0 +1,3 @@
+mov ax,10h
+aam
+byte 0D5h,10h  ;inlined bytecode for AAD using base 16

Task/Non-decimal-radices-Convert/ACL2/non-decimal-radices-convert.acl2

@@ -0,0 +1,35 @@
+(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))

Task/Non-decimal-radices-Convert/ALGOL-68/non-decimal-radices-convert-1.alg

@@ -0,0 +1,14 @@
+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))

Task/Non-decimal-radices-Convert/ALGOL-68/non-decimal-radices-convert-2.alg

@@ -0,0 +1,36 @@
+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

Task/Non-decimal-radices-Convert/ALGOL-W/non-decimal-radices-convert.alg

@@ -0,0 +1,66 @@
+begin
+    % returns with numberInBase set to the number n converted to a string in %
+    % the specified base. Number must be non-negative and base must be in    %
+    % range 2 to 36                                                          %
+    procedure convertToBase( integer    value  n
+                           ; integer    value  base
+                           ; string(32) result numberInBase
+                           ) ;
+    begin
+        string(36) baseDigits;
+        integer    val, strPos;
+
+        assert( n >= 0 and base >= 2 and base <= 36 );
+
+        baseDigits    := "0123456789abcdefghijklmnopqrstuvwxyz";
+        numberInBase  := " ";
+        val           := n;
+        strPos        := 31;
+        while
+            begin
+                % a(b//c) is the substring of a starting at b with length c. %
+                % The first character is at position 0. The length must be   %
+                % an integer literal so it is known at compile time.         %
+                numberInBase( strPos // 1 ) := baseDigits( val rem base // 1 );
+                val    := val div base;
+                strPos := strPos - 1;
+                val > 0
+            end
+        do begin end
+    end convertToBase ;
+
+    % returns the string numberInBase converted to an integer assuming       %
+    % numberInBase ia a string in the specified base                         %
+    % base must be in range 2 to 36, invalid digits will cause the program   %
+    % to crash, spaces are ignored                                           %
+    integer procedure convertFromBase( string(32) value numberInBase
+                                     ; integer    value base
+                                     ) ;
+    begin
+        string(36) baseDigits;
+        integer    val, cPos;
+
+        assert( base >= 2 and base <= 36 );
+
+        baseDigits    := "0123456789abcdefghijklmnopqrstuvwxyz";
+        val           := 0;
+        for strPos := 0 until 31 do begin
+            string(1) c;
+            c := numberInBase( strPos // 1 );
+            if c not = " " then begin
+                cPos := 0;
+                while baseDigits( cPos // 1 ) not = c do cPos := cPos + 1;
+                val  := ( val * base ) + cPos;
+            end
+        end;
+        val
+    end convertFromBase ;
+
+    % test the procedures                                                    %
+    string(32) baseNumber;
+    i_w := 3; % set integer output width                                     %
+    for i := 2 until 36 do begin
+        convertToBase( 35, i, baseNumber );
+        write( 35, i, baseNumber, " ", convertFromBase( baseNumber, i ) );
+    end
+end.

Task/Non-decimal-radices-Convert/AWK/non-decimal-radices-convert.awk

@@ -0,0 +1,28 @@
+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)
+}

Task/Non-decimal-radices-Convert/Action-/non-decimal-radices-convert.action

@@ -0,0 +1,69 @@
+CHAR ARRAY digits="0123456789abcdefghijklmnopqrstuvwxyz"
+
+PROC CheckBase(BYTE b)
+  IF b<2 OR b>digits(0) THEN
+    PrintE("Base is out of range!")
+    Break()
+  FI
+RETURN
+
+PROC Encode(CARD v BYTE b CHAR ARRAY s)
+  CARD d
+  BYTE i,len
+  CHAR tmp
+
+  CheckBase(b)
+  len=0
+  DO
+    d=v MOD b
+    len==+1
+    s(len)=digits(d+1)
+    v==/b
+  UNTIL v=0
+  OD
+  s(0)=len
+
+  FOR i=1 to len/2
+  DO
+    tmp=s(i)
+    s(i)=s(len-i+1)
+    s(len-i+1)=tmp
+  OD
+RETURN
+
+CARD FUNC Decode(CHAR ARRAY s BYTE b)
+  CARD res
+  BYTE i,j,found
+
+  CheckBase(b)
+  res=0
+  FOR i=1 TO s(0)
+  DO
+    found=0
+    FOR j=1 TO digits(0)
+    DO
+      IF digits(j)=s(i) THEN
+        found=1 EXIT
+      FI
+    OD
+    IF found=0 THEN
+      PrintE("Unrecognized character!")
+      Break()
+    FI
+    res==*b
+    res==+j-1
+  OD
+RETURN (res)
+
+PROC Main()
+  CARD v=[6502],v2
+  BYTE b
+  CHAR ARRAY s(256)
+
+  FOR b=2 TO 23
+  DO
+    Encode(v,b,s)
+    v2=Decode(s,b)
+    PrintF("%U -> base %B %S -> %U%E",v,b,s,v2)
+  OD
+RETURN

Task/Non-decimal-radices-Convert/Ada/non-decimal-radices-convert.ada

@@ -0,0 +1,54 @@
+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;

Task/Non-decimal-radices-Convert/Aime/non-decimal-radices-convert.aime

@@ -0,0 +1,13 @@
+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');

Task/Non-decimal-radices-Convert/AppleScript/non-decimal-radices-convert-1.applescript

@@ -0,0 +1,96 @@
+-- toBase :: Int -> Int -> String
+on toBase(intBase, n)
+    if (intBase < 36) and (intBase > 0) then
+        inBaseDigits(items 1 thru intBase of "0123456789abcdefghijklmnopqrstuvwxyz", n)
+    else
+        "not defined for base " & (n as string)
+    end if
+end toBase
+
+-- inBaseDigits :: String -> Int -> [String]
+on inBaseDigits(strDigits, n)
+    set intBase to length of strDigits
+
+    script nextDigit
+        on |λ|(residue)
+            set {divided, remainder} to quotRem(residue, intBase)
+            if divided > 0 then
+                {just:(item (remainder + 1) of strDigits), new:divided, nothing:false}
+            else
+                {nothing:true}
+            end if
+
+        end |λ|
+    end script
+
+    reverse of unfoldr(nextDigit, n) as string
+end inBaseDigits
+
+-- OTHER FUNCTIONS DERIVABLE FROM inBaseDigits -------------------------------
+
+-- inUpperHex :: Int -> String
+on inUpperHex(n)
+    inBaseDigits("0123456789ABCDEF", n)
+end inUpperHex
+
+-- inDevanagariDecimal :: Int -> String
+on inDevanagariDecimal(n)
+    inBaseDigits("०१२३४५६७८९", n)
+end inDevanagariDecimal
+
+-- TEST ----------------------------------------------------------------------
+on run
+    script
+        on |λ|(x)
+            {{binary:toBase(2, x), octal:toBase(8, x), hex:toBase(16, x)}, ¬
+                {upperHex:inUpperHex(x), dgDecimal:inDevanagariDecimal(x)}}
+        end |λ|
+    end script
+
+    map(result, [255, 240])
+end run
+
+
+-- GENERIC FUNCTIONS ---------------------------------------------------------
+
+-- unfoldr :: (b -> Maybe (a, b)) -> b -> [a]
+on unfoldr(f, v)
+    set lst to {}
+    set recM to {nothing:false, new:v}
+    tell mReturn(f)
+        repeat while (not (nothing of recM))
+            set recM to |λ|(new of recM)
+            if not nothing of recM then set end of lst to just of recM
+        end repeat
+    end tell
+    lst
+end unfoldr
+
+--  quotRem :: Integral a => a -> a -> (a, a)
+on quotRem(m, n)
+    {m div n, m mod n}
+end quotRem
+
+-- map :: (a -> b) -> [a] -> [b]
+on map(f, xs)
+    tell mReturn(f)
+        set lng to length of xs
+        set lst to {}
+        repeat with i from 1 to lng
+            set end of lst to |λ|(item i of xs, i, xs)
+        end repeat
+        return lst
+    end tell
+end map
+
+-- Lift 2nd class handler function into 1st class script wrapper
+-- mReturn :: Handler -> Script
+on mReturn(f)
+    if class of f is script then
+        f
+    else
+        script
+            property |λ| : f
+        end script
+    end if
+end mReturn

Task/Non-decimal-radices-Convert/AppleScript/non-decimal-radices-convert-2.applescript

@@ -0,0 +1,2 @@
+{{{binary:"11111111", octal:"377", hex:"ff"}, {upperHex:"FF", dgDecimal:"२५५"}},
+{{binary:"11110000", octal:"360", hex:"f0"}, {upperHex:"F0", dgDecimal:"२४०"}}}

Task/Non-decimal-radices-Convert/Arturo/non-decimal-radices-convert.arturo

@@ -0,0 +1,26 @@
+fromBase: function [x,base][
+    if base=2 [ return from.binary x ]
+    if base=8 [ return from.octal x ]
+    if base=16 [ return from.hex x ]
+
+    return to :integer x
+]
+
+toBase: function [x,base][
+    if base=2 [ return as.binary x ]
+    if base=8 [ return as.octal x ]
+    if base=16 [ return as.hex x ]
+
+    return to :string x
+]
+
+loop 1..20 'i ->
+    print [
+        i "base2:" toBase i 2 "base8:" toBase i 8 "base16:" toBase i 16
+    ]
+
+print ""
+
+print ["101 => from base2:" fromBase "101" 2 "from base8:" fromBase "101" 8 "from base16:" fromBase "101" 16]
+print ["123 => from base8:" fromBase "123" 8 "from base16:" fromBase "123" 16]
+print ["456 => from base8:" fromBase "456" 8 "from base16:" fromBase "456" 16]

Task/Non-decimal-radices-Convert/AutoHotkey/non-decimal-radices-convert-1.ahk

@@ -0,0 +1,25 @@
+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
+}

Task/Non-decimal-radices-Convert/AutoHotkey/non-decimal-radices-convert-2.ahk

@@ -0,0 +1,13 @@
+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)
+}

Task/Non-decimal-radices-Convert/BBC-BASIC/non-decimal-radices-convert.basic

@@ -0,0 +1,28 @@
+      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%

Task/Non-decimal-radices-Convert/BCPL/non-decimal-radices-convert.bcpl

@@ -0,0 +1,54 @@
+get "libhdr";
+
+// Reverse a string
+let reverse(str) = valof
+$(  let i = 1
+    let j = str%0
+    while i<j
+    $(  let c = str%i
+        str%i := str%j
+        str%j := c
+        i := i+1
+        j := j-1
+    $)
+    resultis str
+$)
+
+// Convert number to string given base
+let itoa(n, base, buf) = valof
+$(  let digitchar(n) =
+        n < 10 -> n + '0',
+        (n - 10) + 'A'
+    buf%0 := 0
+    $( buf%0 := buf%0 + 1
+       buf%(buf%0) := digitchar(n rem base)
+       n := n / base
+    $) repeatuntil n<=0
+    resultis reverse(buf)
+$)
+
+// Convert string to number given base
+let atoi(str, base) = valof
+$(  let digitval(d, base) =
+        '0' <= d <= '9' -> d - '0',
+        'A' <= d <= 'Z' -> (d - 'A') + 10,
+        'a' <= d <= 'z' -> (d - 'a') + 10,
+        0
+    let result = 0
+    for i=1 to str%0 do
+        result := result * base + digitval(str%i, base)
+    resultis result
+$)
+
+// Examples
+let start() be
+$(  let buffer = vec 64
+
+    writes("1234 in bases 2-36:*N")
+    for base=2 to 36 do
+        writef("Base %I2: %S*N", base, itoa(1234, base, buffer))
+
+    writes("*N*"25*" in bases 10-36:*N")
+    for base=10 to 36 do
+        writef("Base %I2: %N*N", base, atoi("25", base))
+$)

Task/Non-decimal-radices-Convert/Bracmat/non-decimal-radices-convert.bracmat

@@ -0,0 +1,23 @@
+  ( 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)))
+    );

Task/Non-decimal-radices-Convert/C++/non-decimal-radices-convert.cpp

@@ -0,0 +1,29 @@
+#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;
+}

Task/Non-decimal-radices-Convert/C-sharp/non-decimal-radices-convert.cs

@@ -0,0 +1,128 @@
+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();
+        }
+
+    }
+
+}

Task/Non-decimal-radices-Convert/C/non-decimal-radices-convert.c

@@ -0,0 +1,48 @@
+#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;
+}

Task/Non-decimal-radices-Convert/Common-Lisp/non-decimal-radices-convert-1.lisp

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

Task/Non-decimal-radices-Convert/Common-Lisp/non-decimal-radices-convert-2.lisp

@@ -0,0 +1,5 @@
+(defun decimal-to-base-n (number &key (base 16))
+  (format nil (format nil "~~~dr" base) number))
+
+(defun base-n-to-decimal (number &key (base 16))
+  (read-from-string (format nil "#~dr~d" base number)))

Task/Non-decimal-radices-Convert/Common-Lisp/non-decimal-radices-convert-3.lisp

@@ -0,0 +1,2 @@
+(defun change-base (number input-base output-base)
+  (format nil "~vr" output-base (parse-integer number :radix input-base)))

Task/Non-decimal-radices-Convert/D/non-decimal-radices-convert-1.d

@@ -0,0 +1,8 @@
+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));
+}

Task/Non-decimal-radices-Convert/D/non-decimal-radices-convert-2.d

@@ -0,0 +1,62 @@
+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));
+}

Task/Non-decimal-radices-Convert/D/non-decimal-radices-convert-3.d

@@ -0,0 +1,30 @@
+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;
+}

Task/Non-decimal-radices-Convert/Delphi/non-decimal-radices-convert.delphi

@@ -0,0 +1,42 @@
+function GetRadixString(L: Integer; Radix: Byte): string;
+{Converts integer a string of any radix}
+const RadixChars: array[0..35] Of char =
+    ('0', '1', '2', '3', '4', '5', '6', '7',
+     '8', '9', 'A', 'B', 'C', 'D', 'E', 'F',
+     'G','H', 'I', 'J', 'K', 'L', 'M', 'N',
+     'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V',
+     'W', 'X', 'Y', 'Z');
+var I: integer;
+var S: string;
+var Sign: string[1];
+begin
+Result:='';
+If (L < 0) then
+	begin
+	Sign:='-';
+	L:=Abs(L);
+	end
+else Sign:='';
+S:='';
+repeat
+	begin
+	I:=L mod Radix;
+	S:=RadixChars[I] + S;
+	L:=L div Radix;
+	end
+until L = 0;
+Result:=Sign + S;
+end;
+
+procedure ShowRadixConvertion(Memo: TMemo);
+var B,N: integer;
+var S,RS: string;
+begin
+N:=6502;
+for B:=2 to 23 do
+	begin
+	RS:=GetRadixString(N,B);
+	RS:=LowerCase(RS);
+	Memo.Lines.Add(Format('%5d -> base: %3D = %15S',[N,B,RS]));
+	end;
+end;

Task/Non-decimal-radices-Convert/E/non-decimal-radices-convert-1.e

@@ -0,0 +1,4 @@
+def stringToInteger := __makeInt
+def integerToString(i :int, base :int) {
+  return i.toString(base)
+}

Task/Non-decimal-radices-Convert/E/non-decimal-radices-convert-2.e

@@ -0,0 +1,5 @@
+? stringToInteger("200", 16)
+# value: 512
+
+? integerToString(200, 16)
+# value: "c8"

Task/Non-decimal-radices-Convert/Elixir/non-decimal-radices-convert.elixir

@@ -0,0 +1,6 @@
+iex(1)> String.to_integer("ffff", 16)
+65535
+iex(2)> Integer.to_string(255, 2)
+"11111111"
+iex(3)> String.to_integer("NonDecimalRadices", 36)
+188498506820338115928429652

Task/Non-decimal-radices-Convert/Euphoria/non-decimal-radices-convert.euphoria

@@ -0,0 +1,35 @@
+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

Task/Non-decimal-radices-Convert/Factor/non-decimal-radices-convert.factor

@@ -0,0 +1,4 @@
+USE: math.parser
+
+12345 16 >base .
+"3039" 16 base> .

Task/Non-decimal-radices-Convert/Forth/non-decimal-radices-convert-1.fth

@@ -0,0 +1,6 @@
+42 dup
+2 base !
+.   \ 101010
+hex
+.   \ 2A
+decimal

Task/Non-decimal-radices-Convert/Forth/non-decimal-radices-convert-2.fth

@@ -0,0 +1 @@
+$ff .   \ 255

Task/Non-decimal-radices-Convert/Fortran/non-decimal-radices-convert.f

@@ -0,0 +1,46 @@
+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

Task/Non-decimal-radices-Convert/FreeBASIC/non-decimal-radices-convert.basic

@@ -0,0 +1,56 @@
+' FB 1.05.0 Win64
+
+Function min(x As Integer, y As Integer) As Integer
+  Return IIf(x < y, x, y)
+End Function
+
+Function convertToBase (n As UInteger, b As UInteger) As String
+  If n < 2 OrElse b < 2 OrElse b = 10 OrElse b > 36 Then Return Str(n)
+  Dim result As String = ""
+  Dim digit As Integer
+  While n > 0
+    digit = n Mod b
+    If digit < 10 Then
+      result = digit & result
+    Else
+      result = Chr(digit + 87) + result
+    End If
+     n \= b
+  Wend
+  Return result
+End Function
+
+Function convertToDecimal (s As Const String, b As UInteger) As UInteger
+  If b < 2 OrElse b > 36 Then Return 0
+  Dim t As String = LCase(s)
+  Dim result As UInteger = 0
+  Dim digit As Integer
+  Dim multiplier As Integer = 1
+  For i As Integer = Len(t) - 1 To 0 Step - 1
+     digit = -1
+     If t[i] >= 48 AndAlso t[i] <= min(57, 47 + b) Then
+       digit = t[i] - 48
+     ElseIf b > 10 AndAlso t[i] >= 97 AndAlso t[i] <= min(122, 87 + b) Then
+       digit = t[i] - 87
+     End If
+     If digit = -1 Then Return 0 '' invalid digit present
+     If digit > 0 Then result += multiplier * digit
+     multiplier *= b
+  Next
+  Return result
+End Function
+
+Dim s As String
+
+For b As UInteger = 2 To 36
+  Print "36 base ";
+  Print Using "##"; b;
+  s = ConvertToBase(36, b)
+  Print " = "; s; Tab(21); " -> base ";
+  Print Using "##"; b;
+  Print " = "; convertToDecimal(s, b)
+Next
+
+Print
+Print "Press any key to quit"
+Sleep

Task/Non-decimal-radices-Convert/FunL/non-decimal-radices-convert-1.funl

@@ -0,0 +1 @@
+$stdout = int( '1a', 16 )

Task/Non-decimal-radices-Convert/FunL/non-decimal-radices-convert-2.funl

@@ -0,0 +1 @@
+$stdout = str( 26, 16 )

Task/Non-decimal-radices-Convert/Go/non-decimal-radices-convert.go

@@ -0,0 +1,21 @@
+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)
+    }
+}

Task/Non-decimal-radices-Convert/Groovy/non-decimal-radices-convert-1.groovy

@@ -0,0 +1,2 @@
+def radixParse = { s, radix -> Integer.parseInt(s, radix) }
+def radixFormat = { i, radix -> Integer.toString(i, radix) }

Task/Non-decimal-radices-Convert/Groovy/non-decimal-radices-convert-2.groovy

@@ -0,0 +1,11 @@
+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)
+}

Task/Non-decimal-radices-Convert/Haskell/non-decimal-radices-convert-1.hs

@@ -0,0 +1,4 @@
+Prelude> Numeric.showIntAtBase 16 Char.intToDigit 42 ""
+"2a"
+Prelude> fst $ head $ Numeric.readInt 16 Char.isHexDigit Char.digitToInt "2a"
+42

Task/Non-decimal-radices-Convert/Haskell/non-decimal-radices-convert-2.hs

@@ -0,0 +1,21 @@
+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

Task/Non-decimal-radices-Convert/Haskell/non-decimal-radices-convert-3.hs

@@ -0,0 +1,4 @@
+*Main> toAlphaDigits $ toBase 16 $ 42
+"2a"
+*Main> fromBase 16 $ fromAlphaDigits $ "2a"
+42

Task/Non-decimal-radices-Convert/Haskell/non-decimal-radices-convert-4.hs

@@ -0,0 +1,54 @@
+import Data.Bifunctor (first)
+import Data.List (unfoldr)
+import Data.Tuple (swap)
+import Data.Bool (bool)
+
+
+inBaseDigits :: String -> Int -> String
+inBaseDigits ds n =
+  let base = length ds
+  in reverse $
+     unfoldr
+       ((<*>)
+          (bool Nothing . Just . first (ds !!) . swap . flip quotRem base)
+          (0 <))
+       n
+
+
+inLowerHex :: Int -> String
+inLowerHex = inBaseDigits "0123456789abcdef"
+
+inUpperHex :: Int -> String
+inUpperHex = inBaseDigits "0123456789ABCDEF"
+
+inBinary :: Int -> String
+inBinary = inBaseDigits "01"
+
+inOctal :: Int -> String
+inOctal = inBaseDigits "01234567"
+
+inDevanagariDecimal :: Int -> String
+inDevanagariDecimal = inBaseDigits "०१२३४५६७८९"
+
+inHinduArabicDecimal :: Int -> String
+inHinduArabicDecimal = inBaseDigits "٠١٢٣٤٥٦٧٨٩"
+
+toBase :: Int -> Int -> String
+toBase intBase n
+  | (intBase < 36) && (intBase > 0) =
+    inBaseDigits (take intBase (['0' .. '9'] ++ ['a' .. 'z'])) n
+  | otherwise = []
+
+main :: IO ()
+main =
+  mapM_ putStrLn $
+  [ inLowerHex
+  , inUpperHex
+  , inBinary
+  , inOctal
+  , toBase 16
+  , toBase 2
+  , inDevanagariDecimal
+  , inHinduArabicDecimal
+  ] <*>
+  [254]

Task/Non-decimal-radices-Convert/HicEst/non-decimal-radices-convert-1.hicest

@@ -0,0 +1,28 @@
+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

Task/Non-decimal-radices-Convert/HicEst/non-decimal-radices-convert-2.hicest

@@ -0,0 +1 @@
+num=7836416410; txt=zzzzzzz; 7836416410;

Task/Non-decimal-radices-Convert/Icon/non-decimal-radices-convert.icon

@@ -0,0 +1,26 @@
+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

Task/Non-decimal-radices-Convert/J/non-decimal-radices-convert-1.j

@@ -0,0 +1,2 @@
+   2b100 8b100 10b_100 16b100 36b100 36bzy
+4 64 _100 256 1296 1294

Task/Non-decimal-radices-Convert/J/non-decimal-radices-convert-2.j

@@ -0,0 +1,3 @@
+numerals=: '0123456789abcdefghijklmnopqrstuvwxyz'
+baseNtoL=: numerals {~ #.inv
+baseLtoN=: [ #. numerals i. ]

Task/Non-decimal-radices-Convert/J/non-decimal-radices-convert-3.j

@@ -0,0 +1,7 @@
+   2 baseNtoL 100 101
+1100100
+1100101
+   16 baseNtoL 26
+1a
+   36 baseLtoN 'zy'
+1294

Task/Non-decimal-radices-Convert/J/non-decimal-radices-convert-4.j

@@ -0,0 +1,6 @@
+   base=: baseNtoL :: baseLtoN
+
+   16 base 'aa'
+170
+   16 base 170
+aa

Task/Non-decimal-radices-Convert/Java/non-decimal-radices-convert-1.java

@@ -0,0 +1,7 @@
+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
+}

Task/Non-decimal-radices-Convert/Java/non-decimal-radices-convert-2.java

@@ -0,0 +1,7 @@
+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
+}

Task/Non-decimal-radices-Convert/JavaScript/non-decimal-radices-convert-1.js

@@ -0,0 +1,5 @@
+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.

Task/Non-decimal-radices-Convert/JavaScript/non-decimal-radices-convert-2.js

@@ -0,0 +1,19 @@
+var baselist = "0123456789abcdefghijklmnopqrstuvwxyz", listbase = [];
+for(var i = 0; i < baselist.length; i++) listbase[baselist[i]] = i; // Generate baselist reverse
+function basechange(snumber, frombase, tobase)
+{
+ var i, t, to = new Array(Math.ceil(snumber.length * Math.log(frombase) / Math.log(tobase))), accumulator;
+ if(1 < frombase < baselist.length || 1 < tobase < baselist.length) console.error("Invalid or unsupported base!");
+ while(snumber[0] == baselist[0] && snumber.length > 1) snumber = snumber.substr(1); // Remove leading zeros character
+ console.log("Number is", snumber, "in base", frombase, "to base", tobase, "result should be",
+             parseInt(snumber, frombase).toString(tobase));
+ for(i = snumber.length - 1, inexp = 1; i > -1; i--, inexp *= frombase)
+  for(accumulator = listbase[snumber[i]] * inexp, t = to.length - 1; accumulator > 0 || t >= 0; t--)
+  {
+   accumulator += listbase[to[t] || 0];
+   to[t] = baselist[(accumulator % tobase)  || 0];
+   accumulator = Math.floor(accumulator / tobase);
+  }
+ return to.join('');
+}
+console.log("Result:", basechange("zzzzzzzzzz", 36, 10));

Task/Non-decimal-radices-Convert/JavaScript/non-decimal-radices-convert-3.js

@@ -0,0 +1,28 @@
+// Tom Wu jsbn.js http://www-cs-students.stanford.edu/~tjw/jsbn/
+var baselist = "0123456789abcdefghijklmnopqrstuvwxyz", listbase = [];
+for(var i = 0; i < baselist.length; i++) listbase[baselist[i]] = i; // Generate baselist reverse
+function baseconvert(snumber, frombase, tobase) // String number in base X to string number in base Y, arbitrary length, base
+{
+ var i, t, to, accum = new BigInteger(), inexp = new BigInteger('1', 10), tb = new BigInteger(),
+     fb = new BigInteger(), tmp = new BigInteger();
+ console.log("Number is", snumber, "in base", frombase, "to base", tobase, "result should be",
+             frombase < 37 && tobase < 37 ? parseInt(snumber, frombase).toString(tobase) : 'too large');
+ while(snumber[0] == baselist[0] && snumber.length > 1) snumber = snumber.substr(1); // Remove leading zeros
+ tb.fromInt(tobase);
+ fb.fromInt(frombase);
+ for(i = snumber.length - 1, to = new Array(Math.ceil(snumber.length * Math.log(frombase) / Math.log(tobase))); i > -1; i--)
+ {
+  accum = inexp.clone();
+  accum.dMultiply(listbase[snumber[i]]);
+  for(t = to.length - 1; accum.compareTo(BigInteger.ZERO) > 0 || t >= 0; t--)
+  {
+   tmp.fromInt(listbase[to[t]] || 0);
+   accum = accum.add(tmp);
+   to[t] = baselist[accum.mod(tb).intValue()];
+   accum = accum.divide(tb);
+  }
+  inexp = inexp.multiply(fb);
+ }
+ while(to[0] == baselist[0] && to.length > 1) to = to.slice(1); // Remove leading zeros
+ return to.join('');
+}

Task/Non-decimal-radices-Convert/JavaScript/non-decimal-radices-convert-4.js

@@ -0,0 +1,93 @@
+(() => {
+    'use strict';
+
+    // toBase :: Int -> Int -> String
+    const toBase = (intBase, n) =>
+        intBase < 36 && intBase > 0 ?
+        inBaseDigits('0123456789abcdef'.substr(0, intBase), n) : [];
+
+
+    // inBaseDigits :: String -> Int -> [String]
+    const inBaseDigits = (digits, n) => {
+        const intBase = digits.length;
+
+        return unfoldr(maybeResidue => {
+                const [divided, remainder] = quotRem(maybeResidue.new, intBase);
+
+                return {
+                    valid: divided > 0,
+                    value: digits[remainder],
+                    new: divided
+                };
+            }, n)
+            .reverse()
+            .join('');
+    };
+
+
+    // GENERIC FUNCTIONS
+
+    // unfoldr :: (b -> Maybe (a, b)) -> b -> [a]
+    const unfoldr = (mf, v) => {
+        var xs = [];
+        return (until(
+            m => !m.valid,
+            m => {
+                const m2 = mf(m);
+                return (
+                    xs = xs.concat(m2.value),
+                    m2
+                );
+            }, {
+                valid: true,
+                value: v,
+                new: v,
+            }
+        ), xs);
+    };
+
+    // curry :: ((a, b) -> c) -> a -> b -> c
+    const curry = f => a => b => f(a, b);
+
+    // until :: (a -> Bool) -> (a -> a) -> a -> a
+    const until = (p, f, x) => {
+        let v = x;
+        while (!p(v)) v = f(v);
+        return v;
+    }
+
+    // quotRem :: Integral a => a -> a -> (a, a)
+    const quotRem = (m, n) => [Math.floor(m / n), m % n];
+
+    // show :: a -> String
+    const show = x => JSON.stringify(x, null, 2);
+
+
+    // OTHER FUNCTIONS DERIVABLE FROM inBaseDigits
+
+    // inLowerHex :: Int -> String
+    const inLowerHex = curry(inBaseDigits)('0123456789abcdef');
+
+    /// inUpperHex :: Int -> String
+    const inUpperHex = curry(inBaseDigits)('0123456789ABCDEF');
+
+    // inOctal :: Int -> String
+    const inOctal = curry(inBaseDigits)('01234567');
+
+    // inDevanagariDecimal :: Int -> String
+    const inDevanagariDecimal = curry(inBaseDigits)('०१२३४५६७८९');
+
+
+    // TESTS
+    // testNumber :: [Int]
+    const testNumbers = [255, 240];
+
+    return testNumbers.map(n => show({
+        binary: toBase(2, n),
+        base5: toBase(5, n),
+        hex: toBase(16, n),
+        upperHex: inUpperHex(n),
+        octal: inOctal(n),
+        devanagariDecimal: inDevanagariDecimal(n)
+    }));
+})();

Task/Non-decimal-radices-Convert/Joy/non-decimal-radices-convert.joy

@@ -0,0 +1,9 @@
+DEFINE
+  digit == "0123456789abcdefghijklmnopqrstuvwxyz" of;
+  itostr ==
+    "" rollup
+    [>=] [dup rollup div digit rotated swons rollup] while
+    pop digit swons.
+
+26 16 itostr.
+"1a" 16 strtol.

Task/Non-decimal-radices-Convert/Jq/non-decimal-radices-convert-1.jq

@@ -0,0 +1,20 @@
+# Convert the input integer to a string in the specified base (2 to 36 inclusive)
+def convert(base):
+  def stream:
+    recurse(if . >= base then ./base|floor else empty end) | . % base ;
+  [stream] | reverse
+  | 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;
+
+# input string is converted from "base" to an integer, within 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];

Task/Non-decimal-radices-Convert/Jq/non-decimal-radices-convert-2.jq

@@ -0,0 +1,3 @@
+(255 | convert(16)),
+ ("ff" | to_i(16)),
+ ("10" | to_i(10))

Task/Non-decimal-radices-Convert/Julia/non-decimal-radices-convert.julia

@@ -0,0 +1,15 @@
+@show string(185, base=2)
+@show string(185, base=3)
+@show string(185, base=4)
+@show string(185, base=5)
+@show string(185, base=6)
+@show string(185, base=7)
+@show string(185, base=8)
+@show string(185, base=9)
+@show string(185, base=10)
+@show string(185, base=11)
+@show string(185, base=12)
+@show string(185, base=13)
+@show string(185, base=14)
+@show string(185, base=15)
+@show string(185, base=16)

Task/Non-decimal-radices-Convert/Kotlin/non-decimal-radices-convert.kotlin

@@ -0,0 +1,45 @@
+// version 1.0.6
+
+fun min(x: Int, y: Int) = if (x < y) x else y
+
+fun convertToBase(n: Int, b: Int): String {
+    if (n < 2 || b < 2 || b == 10 || b > 36) return n.toString() // leave as decimal
+    val sb = StringBuilder()
+    var digit: Int
+    var nn = n
+    while (nn > 0) {
+        digit = nn % b
+        if (digit < 10) sb.append(digit)
+        else            sb.append((digit + 87).toChar())
+        nn /= b
+    }
+    return sb.reverse().toString()
+}
+
+fun convertToDecimal(s: String, b: Int): Int {
+    if (b !in 2..36) throw IllegalArgumentException("Base must be between 2 and 36")
+    if (b == 10) return s.toInt()
+    val t = s.toLowerCase()
+    var result = 0
+    var digit: Int
+    var multiplier = 1
+    for (i in t.length - 1 downTo 0) {
+        digit = -1
+        if (t[i] >= '0' && t[i] <= min(57, 47 + b).toChar())
+            digit = t[i].toInt() - 48
+        else if (b > 10 && t[i] >= 'a' && t[i] <= min(122, 87 + b).toChar())
+            digit = t[i].toInt() - 87
+        if (digit == -1) throw IllegalArgumentException("Invalid digit present")
+        if (digit > 0) result += multiplier * digit
+        multiplier *= b
+    }
+    return result
+}
+
+fun main(args: Array<String>) {
+    for (b in 2..36) {
+        val s = convertToBase(36, b)
+        val f = "%2d".format(b)
+        println("36 base $f = ${s.padEnd(6)} -> base $f = ${convertToDecimal(s, b)}")
+    }
+}

Task/Non-decimal-radices-Convert/LFE/non-decimal-radices-convert.lfe

@@ -0,0 +1,12 @@
+> (: 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"

Task/Non-decimal-radices-Convert/Liberty-BASIC/non-decimal-radices-convert.basic

@@ -0,0 +1,32 @@
+   '   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

Task/Non-decimal-radices-Convert/Lua/non-decimal-radices-convert.lua

@@ -0,0 +1,16 @@
+function dec2base (base, n)
+    local result = ""
+    repeat
+        local digit = n % base
+        if digit > 9 then
+            digit = string.char(digit + 87)
+        end
+        result = digit .. result
+        n = n // base
+    until n == 0
+    return result
+end
+
+local x = dec2base(16, 26)
+print(x)                    --> 1a
+print(tonumber(x, 16))      --> 26

Task/Non-decimal-radices-Convert/M2000-Interpreter/non-decimal-radices-convert.m2000

@@ -0,0 +1,26 @@
+Module Checkit {
+  k$=lambda$ (m, b as integer=16) -> {
+    if b<2 or b>16 then error "base out of range"
+    if m=0 then ="0" : exit
+    z$="0123456789ABCDEF"
+    =lambda$ z$, b (m) ->{
+      =if$(m=0->"", lambda$(m div b)+mid$(z$, m mod b + 1, 1))
+    }(m)
+  }
+  k=lambda (m$, b as integer=16) -> {
+    if b<2 or b>16 then error "base out of range"
+    m$=trim$(m$)
+    if m$="0" then =0 : exit
+    z$="0123456789ABCDEF"
+    =lambda z$, b (m$) ->{
+      =if(Len(m$)=0->0, lambda(mid$(m$,2))+(instr(z$, left$(m$,1))-1)*b**(len(m$)-1))
+    }(m$)
+  }
+  Print k$(0)="0", k("0")=0
+  Print k$(65535)="FFFF", k("FFFF", 16)=65535
+  Print k$(0xF00F)="F00F", k("F00F", 16)=0xF00F
+  Print k$(0xFFFFFFFF)="FFFFFFFF", k("FFFFFFFF", 16)=0xFFFFFFFF
+  Print k$(100, 8)="144", k("144", 8)=100
+  Print k$(100, 2)="1100100", k("1100100", 2)=100
+}
+Checkit

Task/Non-decimal-radices-Convert/M4/non-decimal-radices-convert.m4

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

Task/Non-decimal-radices-Convert/MATLAB/non-decimal-radices-convert.m

@@ -0,0 +1,2 @@
+dec2base(26,16)
+base2dec('1a', 16)

Task/Non-decimal-radices-Convert/Maple/non-decimal-radices-convert.maple

@@ -0,0 +1,31 @@
+#converts a number to a given based represented by a string
+to_base := proc(num, based)
+  local i;
+  local chart := "0123456789abcdefghijklmnopqrstuvwxyz";
+  local conversion := ListTools:-Reverse((convert(num,base,based)));
+  local str := StringTools:-StringBuffer();
+  for i in conversion do
+    str:-append(chart[i+1]);
+  end do;
+  return str;
+end proc:
+
+#find the location of char in chart
+find_digit := proc(char)
+  if (StringTools:-HasAlpha(char)) then
+    return (StringTools:-Ord(char) - 87);
+  else
+    return (StringTools:-Ord(char) - 48);
+  end if;
+end proc:
+
+#converts a string  with given base to a number
+from_base := proc(str, base)
+  local char;
+  local result := 0;
+  for char in str do
+    result *= base;
+    result += find_digit(char);
+  end do;
+  return result;
+end proc:

Task/Non-decimal-radices-Convert/Mathematica/non-decimal-radices-convert.math

@@ -0,0 +1,2 @@
+IntegerString[26,16]
+FromDigits["1a", 16])

Task/Non-decimal-radices-Convert/NetRexx/non-decimal-radices-convert.netrexx

@@ -0,0 +1,39 @@
+/* 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)

Task/Non-decimal-radices-Convert/Nim/non-decimal-radices-convert.nim

@@ -0,0 +1,33 @@
+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].toLowerAscii
+    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

Task/Non-decimal-radices-Convert/OCaml/non-decimal-radices-convert-1.ocaml

@@ -0,0 +1,12 @@
+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"

Task/Non-decimal-radices-Convert/OCaml/non-decimal-radices-convert-2.ocaml

@@ -0,0 +1,18 @@
+let basen_of_int b n : string =
+  let tab = "0123456789abcdefghijklmnopqrstuvwxyz" in
+  let rec aux x l =
+    if x < b
+    then tab.[x] :: l
+    else aux (x / b) (tab.[x mod b] :: l)
+  in
+  String.of_seq (List.to_seq (aux n []))
+
+let basen_to_int b ds : int =
+  let of_sym c =
+    int_of_char c - match c with
+    | '0' .. '9' -> int_of_char '0'
+    | 'a' .. 'z' -> int_of_char 'a' - 10
+    | 'A' .. 'Z' -> int_of_char 'A' - 10
+    | _ -> invalid_arg "unkown digit"
+  in
+  String.fold_left (fun n d -> n * b + of_sym d) 0 ds

Task/Non-decimal-radices-Convert/PARI-GP/non-decimal-radices-convert.parigp

@@ -0,0 +1,17 @@
+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);
+  for(i=1,#s,1,
+    t=b*t+s[i]-if(s[i]<58,48,87)
+  );
+  t
+};

Task/Non-decimal-radices-Convert/PHP/non-decimal-radices-convert-1.php

@@ -0,0 +1 @@
+base_convert("26", 10, 16); // returns "1a"

Task/Non-decimal-radices-Convert/PHP/non-decimal-radices-convert-2.php

@@ -0,0 +1 @@
+intval("1a", 16); // returns 26

Task/Non-decimal-radices-Convert/PHP/non-decimal-radices-convert-3.php

@@ -0,0 +1 @@
+base_convert(26, 10, 16); // returns "1a"

Task/Non-decimal-radices-Convert/PHP/non-decimal-radices-convert-4.php

@@ -0,0 +1,12 @@
+// 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

Task/Non-decimal-radices-Convert/PL-I/non-decimal-radices-convert.pli

@@ -0,0 +1,12 @@
+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;

Task/Non-decimal-radices-Convert/PL-M/non-decimal-radices-convert.plm

@@ -0,0 +1,78 @@
+100H:
+
+/* CONVERT A NUMBER TO A GIVEN BASE */
+TO$BASE: PROCEDURE (N, BASE, BUF) ADDRESS;
+    DECLARE (N, BUF, I, J, K) ADDRESS;
+    DECLARE (D, BASE, STR BASED BUF) BYTE;
+
+    /* GENERATE DIGITS */
+    I = 0;
+DIGIT:
+    D = N MOD BASE;
+    N = N / BASE;
+    IF D < 10 THEN STR(I) = D + '0';
+    ELSE STR(I) = (D - 10) + 'A';
+    I = I + 1;
+    IF N > 0 THEN GO TO DIGIT;
+
+    /* PUT DIGITS IN HIGH-ENDIAN ORDER */
+    J = 0;
+    K = I-1;
+    DO WHILE (J < K);
+        D = STR(K);
+        STR(K) = STR(J);
+        STR(J) = D;
+        K = K-1;
+        J = J+1;
+    END;
+
+    STR(I) = '$';
+    RETURN BUF;
+END TO$BASE;
+
+
+/* READ A NUMBER IN A GIVEN BASE */
+FROM$BASE: PROCEDURE (BUF, BASE) ADDRESS;
+    DECLARE (BUF, RESULT) ADDRESS;
+    DECLARE (D, BASE, CHAR BASED BUF) BYTE;
+
+    RESULT = 0;
+    DO WHILE CHAR <> '$';
+        D = CHAR - '0';
+        IF D >= 10 THEN D = D - ('A' - '0') + 10;
+        RESULT = (RESULT * BASE) + D;
+        BUF = BUF + 1;
+    END;
+    RETURN RESULT;
+END FROM$BASE;
+
+/* CP/M BDOS ROUTINES */
+BDOS: PROCEDURE (F,A); DECLARE F BYTE, A ADDRESS; GO TO 5; END BDOS;
+EXIT: PROCEDURE; CALL BDOS(0,0); END EXIT;
+PRINT: PROCEDURE (S); DECLARE S ADDRESS; CALL BDOS(9,S); END PRINT;
+CRLF: PROCEDURE; CALL PRINT(.(13,10,'$')); END CRLF;
+
+/* EXAMPLES */
+DECLARE I BYTE, N ADDRESS;
+
+CALL PRINT(.'1234 IN BASES 2-36: $'); CALL CRLF;
+DO I=2 TO 36;
+    CALL PRINT(.'BASE $');
+    CALL PRINT(TO$BASE(I, 10, .MEMORY));
+    CALL PRINT(.(': ',9,'$'));
+    CALL PRINT(TO$BASE(1234, I, .MEMORY));
+    CALL CRLF;
+END;
+
+CALL PRINT(.'''25'' IN BASES 10-36: $'); CALL CRLF;
+DO I=10 TO 36;
+    CALL PRINT(.'BASE $');
+    CALL PRINT(TO$BASE(I, 10, .MEMORY));
+    CALL PRINT(.(':',9,'$'));
+    N = FROM$BASE(.'25$', I);
+    CALL PRINT(TO$BASE(N, 10, .MEMORY));
+    CALL CRLF;
+END;
+
+CALL EXIT;
+EOF

Task/Non-decimal-radices-Convert/Pascal/non-decimal-radices-convert.pas

@@ -0,0 +1,45 @@
+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.

Task/Non-decimal-radices-Convert/Perl/non-decimal-radices-convert-1.pl

@@ -0,0 +1,4 @@
+sub to2  { sprintf "%b", shift; }
+sub to16 { sprintf "%x", shift; }
+sub from2  { unpack("N", pack("B32", substr("0" x 32 . shift, -32))); }
+sub from16 { hex(shift); }

Task/Non-decimal-radices-Convert/Perl/non-decimal-radices-convert-2.pl

@@ -0,0 +1,16 @@
+sub base_to {
+  my($n,$b) = @_;
+  my $s = "";
+  do {
+    $s = ('0'..'9','a'..'z')[$n % $b] . $s
+  } while $n = int($n / $b);
+  $s
+}
+sub base_from {
+  my($n,$b) = @_;
+  my $t = 0;
+  for my $c (split(//, lc($n))) {
+    $t = $b * $t + index("0123456789abcdefghijklmnopqrstuvwxyz", $c);
+  }
+  $t;
+}

Task/Non-decimal-radices-Convert/Perl/non-decimal-radices-convert-3.pl

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

Task/Non-decimal-radices-Convert/Perl/non-decimal-radices-convert-4.pl

@@ -0,0 +1,5 @@
+use ntheory qw/fromdigits todigitstring/;
+my $n   = 65261;
+my $n16 = todigitstring($n, 16) || 0;
+my $n10 = fromdigits($n16, 16);
+say "$n $n16 $n10";  # prints "65261 feed 65261"

Task/Non-decimal-radices-Convert/Phix/non-decimal-radices-convert-1.phix

@@ -0,0 +1,11 @@
+(phixonline)-->
+ <span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
+ <span style="color: #0000FF;">?{</span><span style="color: #000000;">26</span><span style="color: #0000FF;">,</span><span style="color: #000000;">0b11010</span><span style="color: #0000FF;">,</span><span style="color: #000000;">0o32</span><span style="color: #0000FF;">,</span><span style="color: #000000;">0x1A</span><span style="color: #0000FF;">,</span><span style="color: #000000;">0X1a</span><span style="color: #0000FF;">,</span><span style="color: #000000;">#1A</span><span style="color: #0000FF;">,</span><span style="color: #000000;">0(16)1A</span><span style="color: #0000FF;">}</span>        <span style="color: #000080;font-style:italic;">-- displays {26,26,26,26,26,26,26}</span>
+ <span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"%d == 0b%b == 0x%x\n"</span><span style="color: #0000FF;">,</span><span style="color: #000000;">26</span><span style="color: #0000FF;">)</span>             <span style="color: #000080;font-style:italic;">-- displays 26 == 0b11010 == 0x1A</span>
+ <span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"%d == o(62)%A\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">26</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">62</span><span style="color: #0000FF;">,</span><span style="color: #000000;">26</span><span style="color: #0000FF;">}})</span>        <span style="color: #000080;font-style:italic;">-- displays 26 == 0(62)Q</span>
+ <span style="color: #0000FF;">?</span><span style="color: #7060A8;">to_number</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"1a"</span><span style="color: #0000FF;">,{},</span><span style="color: #000000;">16</span><span style="color: #0000FF;">)</span>                          <span style="color: #000080;font-style:italic;">-- displays 26</span>
+ <span style="color: #008080;">include</span> <span style="color: #004080;">mpfr</span><span style="color: #0000FF;">.</span><span style="color: #000000;">e</span>
+ <span style="color: #004080;">mpfr</span> <span style="color: #000000;">f</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">mpfr_init</span><span style="color: #0000FF;">()</span>
+ <span style="color: #7060A8;">mpfr_set_str</span><span style="color: #0000FF;">(</span><span style="color: #000000;">f</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"110.01"</span><span style="color: #0000FF;">,</span><span style="color: #000000;">2</span><span style="color: #0000FF;">)</span>
+ <span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"0b%s == %s\n"</span><span style="color: #0000FF;">,{</span><span style="color: #7060A8;">mpfr_get_fixed</span><span style="color: #0000FF;">(</span><span style="color: #000000;">f</span><span style="color: #0000FF;">,</span><span style="color: #000000;">0</span><span style="color: #0000FF;">,</span><span style="color: #000000;">2</span><span style="color: #0000FF;">),</span><span style="color: #7060A8;">mpfr_get_fixed</span><span style="color: #0000FF;">(</span><span style="color: #000000;">f</span><span style="color: #0000FF;">)})</span> <span style="color: #000080;font-style:italic;">-- 0b110.01 == 6.25</span>
+<!--

Task/Non-decimal-radices-Convert/Phix/non-decimal-radices-convert-2.phix

@@ -0,0 +1,25 @@
+(phixonline)-->
+ <span style="color: #000080;font-style:italic;">-- demo\rosetta\Convert_base.exw</span>
+ <span style="color: #008080;">function</span> <span style="color: #000000;">to_base</span><span style="color: #0000FF;">(</span><span style="color: #004080;">integer</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">base</span><span style="color: #0000FF;">)</span>
+     <span style="color: #004080;">sequence</span> <span style="color: #000000;">s</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">""</span>
+     <span style="color: #008080;">while</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">></span><span style="color: #000000;">0</span> <span style="color: #008080;">do</span>
+         <span style="color: #004080;">integer</span> <span style="color: #000000;">c</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">remainder</span><span style="color: #0000FF;">(</span><span style="color: #000000;">i</span><span style="color: #0000FF;">,</span><span style="color: #000000;">base</span><span style="color: #0000FF;">)</span>
+         <span style="color: #000000;">s</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">prepend</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">,</span><span style="color: #000000;">c</span><span style="color: #0000FF;">+</span><span style="color: #008080;">iff</span><span style="color: #0000FF;">(</span><span style="color: #000000;">c</span><span style="color: #0000FF;"><</span><span style="color: #000000;">10</span><span style="color: #0000FF;">?</span><span style="color: #008000;">'0'</span><span style="color: #0000FF;">:</span><span style="color: #008000;">'a'</span><span style="color: #0000FF;">-</span><span style="color: #000000;">10</span><span style="color: #0000FF;">))</span>
+         <span style="color: #000000;">i</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">floor</span><span style="color: #0000FF;">(</span><span style="color: #000000;">i</span><span style="color: #0000FF;">/</span><span style="color: #000000;">base</span><span style="color: #0000FF;">)</span>
+     <span style="color: #008080;">end</span> <span style="color: #008080;">while</span>
+     <span style="color: #008080;">if</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">)=</span><span style="color: #000000;">0</span> <span style="color: #008080;">then</span> <span style="color: #000000;">s</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">"0"</span> <span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
+     <span style="color: #008080;">return</span> <span style="color: #000000;">s</span>
+ <span style="color: #008080;">end</span> <span style="color: #008080;">function</span>
+
+ <span style="color: #008080;">function</span> <span style="color: #000000;">from_base</span><span style="color: #0000FF;">(</span><span style="color: #004080;">string</span> <span style="color: #000000;">s</span><span style="color: #0000FF;">,</span> <span style="color: #004080;">integer</span> <span style="color: #000000;">base</span><span style="color: #0000FF;">)</span>
+     <span style="color: #004080;">integer</span> <span style="color: #000000;">res</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">0</span>
+     <span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">do</span>
+         <span style="color: #004080;">integer</span> <span style="color: #000000;">c</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">s</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">]</span>
+         <span style="color: #000000;">res</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">res</span><span style="color: #0000FF;">*</span><span style="color: #000000;">base</span><span style="color: #0000FF;">+(</span><span style="color: #000000;">c</span><span style="color: #0000FF;">-</span><span style="color: #008080;">iff</span><span style="color: #0000FF;">(</span><span style="color: #000000;">c</span><span style="color: #0000FF;"><=</span><span style="color: #008000;">'9'</span><span style="color: #0000FF;">?</span><span style="color: #008000;">'0'</span><span style="color: #0000FF;">:</span><span style="color: #008000;">'a'</span><span style="color: #0000FF;">-</span><span style="color: #000000;">10</span><span style="color: #0000FF;">))</span>
+     <span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
+     <span style="color: #008080;">return</span> <span style="color: #000000;">res</span>
+ <span style="color: #008080;">end</span> <span style="color: #008080;">function</span>
+
+ <span style="color: #0000FF;">?</span><span style="color: #000000;">to_base</span><span style="color: #0000FF;">(</span><span style="color: #000000;">256</span><span style="color: #0000FF;">,</span><span style="color: #000000;">16</span><span style="color: #0000FF;">)</span>
+ <span style="color: #0000FF;">?</span><span style="color: #000000;">from_base</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"100"</span><span style="color: #0000FF;">,</span><span style="color: #000000;">16</span><span style="color: #0000FF;">)</span>
+<!--

Task/Non-decimal-radices-Convert/PicoLisp/non-decimal-radices-convert.l

@@ -0,0 +1,22 @@
+(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))

Task/Non-decimal-radices-Convert/Pop11/non-decimal-radices-convert-1.pop11

@@ -0,0 +1,3 @@
+define number_to_base(n, base);
+    radix_apply(n, '%p', sprintf, base);
+enddefine;

Task/Non-decimal-radices-Convert/Pop11/non-decimal-radices-convert-2.pop11

@@ -0,0 +1,3 @@
+define string_in_base_to_number(s, base);
+    incharitem(stringin(base >< ':' >< s))();
+enddefine;

Task/Non-decimal-radices-Convert/PureBasic/non-decimal-radices-convert.basic

@@ -0,0 +1,36 @@
+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

Task/Non-decimal-radices-Convert/Python/non-decimal-radices-convert-1.py

@@ -0,0 +1 @@
+i = int('1a',16)  # returns the integer 26

Task/Non-decimal-radices-Convert/Python/non-decimal-radices-convert-2.py

@@ -0,0 +1,3 @@
+digits = "0123456789abcdefghijklmnopqrstuvwxyz"
+def baseN(num, b):
+    return digits[num] if num < b else baseN(num // b, b) + digits[num % b]