Base converter

== Base converter ==
1) convert a number  2) in bases 2, 8, 10, 16  3) to Roman  4) from Roman  5) quit
choice> 9
Pick a number from 1 to 5.

== Base converter ==
1) convert a number  2) in bases 2, 8, 10, 16  3) to Roman  4) from Roman  5) quit
choice> 1
from base (2-36)> 1
A base is a whole number from 2 to 36, or nothing to cancel.
from base (2-36)> 37
A base is a whole number from 2 to 36, or nothing to cancel.
from base (2-36)> x
A base is a whole number from 2 to 36, or nothing to cancel.
from base (2-36)> 8
number> 129
9 is not a digit in base 8.
number> 8.5
8 is not a digit in base 8.
number> --5
- is not a digit; digits are 0-9, then A-Z for 10-35.
number> -
Type some digits.
number> 
Cancelled.

== Base converter ==
1) convert a number  2) in bases 2, 8, 10, 16  3) to Roman  4) from Roman  5) quit
choice> 1
from base (2-36)> 2
number> -0
to base (2-36)> 10
0 (base 2) = 0 (base 10)

== Base converter ==
1) convert a number  2) in bases 2, 8, 10, 16  3) to Roman  4) from Roman  5) quit
choice> 3
number (1-3999)> 0
Type a whole number from 1 to 3999, or nothing to cancel.
number (1-3999)> 4000
Type a whole number from 1 to 3999, or nothing to cancel.
number (1-3999)> abc
Type a whole number from 1 to 3999, or nothing to cancel.
number (1-3999)> 2026
2026 = MMXXVI

== Base converter ==
1) convert a number  2) in bases 2, 8, 10, 16  3) to Roman  4) from Roman  5) quit
choice> 4
numeral> IIII
IIII is not written the standard way; 4 is IV.
numeral> IC
IC is not written the standard way; 99 is XCIX.
numeral> VV
VV is not written the standard way; 10 is X.
numeral> MMMM
MMMM is not a numeral from I to MMMCMXCIX.
numeral> ABC
Roman numerals use only I, V, X, L, C, D and M.
numeral> IV
IV = 4

== Base converter ==
1) convert a number  2) in bases 2, 8, 10, 16  3) to Roman  4) from Roman  5) quit
choice> 4
numeral> 
Cancelled.

== Base converter ==
1) convert a number  2) in bases 2, 8, 10, 16  3) to Roman  4) from Roman  5) quit
choice> 5
Bye.

9
1
1
37
x
8
129
8.5
--5
-

1
2
-0
10
3
0
4000
abc
2026
4
IIII
IC
VV
MMMM
ABC
IV
4

5

== Base converter ==
1) convert a number  2) in bases 2, 8, 10, 16  3) to Roman  4) from Roman  5) quit
choice> 1
from base (2-36)> 10
number> 255
to base (2-36)> 16
255 (base 10) = FF (base 16)

== Base converter ==
1) convert a number  2) in bases 2, 8, 10, 16  3) to Roman  4) from Roman  5) quit
choice> 1
from base (2-36)> 16
number> ff
to base (2-36)> 2
FF (base 16) = 11111111 (base 2)

== Base converter ==
1) convert a number  2) in bases 2, 8, 10, 16  3) to Roman  4) from Roman  5) quit
choice> 1
from base (2-36)> 10
number> 123456789012345678901234567890
to base (2-36)> 36
123456789012345678901234567890 (base 10) = BYW97UM9S91DLZ68TSI (base 36)

== Base converter ==
1) convert a number  2) in bases 2, 8, 10, 16  3) to Roman  4) from Roman  5) quit
choice> 1
from base (2-36)> 10
number> -42
to base (2-36)> 2
-42 (base 10) = -101010 (base 2)

== Base converter ==
1) convert a number  2) in bases 2, 8, 10, 16  3) to Roman  4) from Roman  5) quit
choice> 2
from base (2-36)> 10
number> 2026
The number 2026 (base 10) is:
  base 2   11111101010
  base 8   3752
  base 10  2026
  base 16  7EA

== Base converter ==
1) convert a number  2) in bases 2, 8, 10, 16  3) to Roman  4) from Roman  5) quit
choice> 3
number (1-3999)> 1994
1994 = MCMXCIV

== Base converter ==
1) convert a number  2) in bases 2, 8, 10, 16  3) to Roman  4) from Roman  5) quit
choice> 3
number (1-3999)> 3999
3999 = MMMCMXCIX

== Base converter ==
1) convert a number  2) in bases 2, 8, 10, 16  3) to Roman  4) from Roman  5) quit
choice> 4
numeral> mcmxciv
MCMXCIV = 1994

== Base converter ==
1) convert a number  2) in bases 2, 8, 10, 16  3) to Roman  4) from Roman  5) quit
choice> 4
numeral> XLII
XLII = 42

== Base converter ==
1) convert a number  2) in bases 2, 8, 10, 16  3) to Roman  4) from Roman  5) quit
choice> 5
Bye.

1
10
255
16
1
16
ff
2
1
10
123456789012345678901234567890
36
1
10
-42
2
2
10
2026
3
1994
3
3999
4
mcmxciv
4
XLII
5

# P021 base converter: whole numbers between bases 2 to 36, a number in the
# common bases at once, and Roman numerals both ways.
import bases
import roman
import text

60 => longest

def ask_base(prompt):
    # A base from 2 to 36, asked again until one is typed; -1 cancels.
    while True:
        text.trim(input(prompt)) => answer
        if answer == "":
            return 0 - 1
        text.number(answer) => b
        if b >= 2 and b <= 36:
            return b
        "A base is a whole number from 2 to 36, or nothing to cancel." ^0

def parse_number(s, base):
    # [negative, digits, ""] for a whole number written in base (a minus sign
    # in front allowed), or [False, [], what is wrong].
    text.upper(s) => s
    False => negative
    if len(s) > 0 and s[0] == "-":
        True => negative
        s[1:len(s)] => s
    if s == "":
        return [False, [], "Type some digits."]
    if len(s) > longest:
        return [False, [], "At most " + str(longest) + " digits."]
    [] => digits
    for c in s:
        bases.digit_value(c) => v
        if v == 0 - 1:
            return [False, [], c + " is not a digit; digits are 0-9, then A-Z for 10-35."]
        if v >= base:
            return [False, [], c + " is not a digit in base " + str(base) + "."]
        digits + [v] => digits
    bases.strip(digits) => digits
    if digits == [0]:
        False => negative
    return [negative, digits, ""]

def ask_number(base):
    # A number in base, asked again until one is typed; None cancels.
    while True:
        text.trim(input("number> ")) => answer
        if answer == "":
            return None
        parse_number(answer, base) => r
        if r[2] == "":
            return r
        r[2] ^0

def shown(n, digits):
    # A number with its sign, from its sign and digit values.
    if n[0]:
        return "-" + bases.written(digits)
    return bases.written(digits)

True => running
while running:
    "" ^0
    "== Base converter ==" ^0
    "1) convert a number  2) in bases 2, 8, 10, 16  3) to Roman  4) from Roman  5) quit" ^0
    text.trim(input("choice> ")) => choice
    if choice == "1" or choice == "2":
        ask_base("from base (2-36)> ") => base
        None => n
        if base != 0 - 1:
            ask_number(base) => n
        0 - 1 => target
        if n != None and choice == "1":
            ask_base("to base (2-36)> ") => target
        if n == None or (choice == "1" and target == 0 - 1):
            "Cancelled." ^0
        elif choice == "1":
            (shown(n, n[1]) + " (base " + str(base) + ") = " + shown(n, bases.convert(n[1], base, target)) + " (base " + str(target) + ")") ^0
        else:
            ("The number " + shown(n, n[1]) + " (base " + str(base) + ") is:") ^0
            for b in [2, 8, 10, 16]:
                ("  " + ("%-9s" % ("base " + str(b))) + shown(n, bases.convert(n[1], base, b))) ^0
    elif choice == "3":
        while True:
            text.trim(input("number (1-3999)> ")) => answer
            text.number(answer) => v
            if answer == "" or (v >= 1 and v <= 3999):
                break
            "Type a whole number from 1 to 3999, or nothing to cancel." ^0
        if answer == "":
            "Cancelled." ^0
        else:
            (str(v) + " = " + roman.to_roman(v)) ^0
    elif choice == "4":
        while True:
            text.upper(text.trim(input("numeral> "))) => answer
            if answer == "":
                break
            roman.from_roman(answer) => r
            if r[1] == "":
                break
            r[1] ^0
        if answer == "":
            "Cancelled." ^0
        else:
            (answer + " = " + str(r[0])) ^0
    elif choice == "5":
        False => running
    else:
        "Pick a number from 1 to 5." ^0
"Bye." ^0

import bases
import roman
import text
longest = 60

def ask_base(prompt):
    while True:
        answer = text.trim(input(prompt))
        if answer == "":
            return 0 - 1
        b = text.number(answer)
        if b >= 2 and b <= 36:
            return b
        print("A base is a whole number from 2 to 36, or nothing to cancel.")

def parse_number(s, base):
    s = text.upper(s)
    negative = False
    if len(s) > 0 and s[0] == "-":
        negative = True
        s = s[1:len(s)]
    if s == "":
        return [False, [], "Type some digits."]
    if len(s) > longest:
        return [False, [], "At most " + str(longest) + " digits."]
    digits = []
    for c in s:
        v = bases.digit_value(c)
        if v == 0 - 1:
            return [False, [], c + " is not a digit; digits are 0-9, then A-Z for 10-35."]
        if v >= base:
            return [False, [], c + " is not a digit in base " + str(base) + "."]
        digits = digits + [v]
    digits = bases.strip(digits)
    if digits == [0]:
        negative = False
    return [negative, digits, ""]

def ask_number(base):
    while True:
        answer = text.trim(input("number> "))
        if answer == "":
            return None
        r = parse_number(answer, base)
        if r[2] == "":
            return r
        print(r[2])

def shown(n, digits):
    if n[0]:
        return "-" + bases.written(digits)
    return bases.written(digits)

running = True
while running:
    print("")
    print("== Base converter ==")
    print("1) convert a number  2) in bases 2, 8, 10, 16  3) to Roman  4) from Roman  5) quit")
    choice = text.trim(input("choice> "))
    if choice == "1" or choice == "2":
        base = ask_base("from base (2-36)> ")
        n = None
        if base != 0 - 1:
            n = ask_number(base)
        target = 0 - 1
        if n != None and choice == "1":
            target = ask_base("to base (2-36)> ")
        if n == None or choice == "1" and target == 0 - 1:
            print("Cancelled.")
        elif choice == "1":
            print(shown(n, n[1]) + " (base " + str(base) + ") = " + shown(n, bases.convert(n[1], base, target)) + " (base " + str(target) + ")")
        else:
            print("The number " + shown(n, n[1]) + " (base " + str(base) + ") is:")
            for b in [2, 8, 10, 16]:
                print("  " + "%-9s" % ("base " + str(b)) + shown(n, bases.convert(n[1], base, b)))
    elif choice == "3":
        while True:
            answer = text.trim(input("number (1-3999)> "))
            v = text.number(answer)
            if answer == "" or v >= 1 and v <= 3999:
                break
            print("Type a whole number from 1 to 3999, or nothing to cancel.")
        if answer == "":
            print("Cancelled.")
        else:
            print(str(v) + " = " + roman.to_roman(v))
    elif choice == "4":
        while True:
            answer = text.upper(text.trim(input("numeral> ")))
            if answer == "":
                break
            r = roman.from_roman(answer)
            if r[1] == "":
                break
            print(r[1])
        if answer == "":
            print("Cancelled.")
        else:
            print(answer + " = " + str(r[0]))
    elif choice == "5":
        running = False
    else:
        print("Pick a number from 1 to 5.")
print("Bye.")

# P021 base converter - whole numbers between bases 2 to 36. A number is kept
# as its list of digit values, most significant first, and converted by long
# division done by hand: divide the whole list by the new base, keep the
# remainder as the next digit, and repeat until nothing is left. Every step
# uses small numbers only, so numbers of any length come out exact.

"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ" => digit_chars

def digit_value(c):
    # The value of digit c (0-9, A-Z), or -1.
    for i in [0:35]:
        if digit_chars[i] == c:
            return i
    return 0 - 1

def divide(digits, base, by):
    # [quotient digits, remainder] of the number digits (in base) divided by
    # the small number by; the quotient has no leading zeros.
    [] => q
    0 => carry
    for d in digits:
        carry * base + d => current
        int((current - current % by) / by) => part
        current % by => carry
        if len(q) > 0 or part > 0:
            q + [part] => q
    return [q, carry]

def convert(digits, base, new_base):
    # The digits of the same number in new_base.
    if len(digits) == 0:
        return [0]
    digits => rest
    [] => out
    while len(rest) > 0:
        divide(rest, base, new_base) => r
        [r[1]] + out => out
        r[0] => rest
    return out

def strip(digits):
    # digits without leading zeros (but at least one digit).
    0 => i
    while i < len(digits) - 1 and digits[i] == 0:
        i + 1 => i
    return digits[i:len(digits)]

def written(digits):
    "" => out
    for d in digits:
        out + digit_chars[d] => out
    return out

digit_chars = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"

def digit_value(c):
    for i in range(0, 36):
        if digit_chars[i] == c:
            return i
    return 0 - 1

def divide(digits, base, by):
    q = []
    carry = 0
    for d in digits:
        current = carry * base + d
        part = int((current - current % by) / by)
        carry = current % by
        if len(q) > 0 or part > 0:
            q = q + [part]
    return [q, carry]

def convert(digits, base, new_base):
    if len(digits) == 0:
        return [0]
    rest = digits
    out = []
    while len(rest) > 0:
        r = divide(rest, base, new_base)
        out = [r[1]] + out
        rest = r[0]
    return out

def strip(digits):
    i = 0
    while i < len(digits) - 1 and digits[i] == 0:
        i = i + 1
    return digits[i:len(digits)]

def written(digits):
    out = ""
    for d in digits:
        out = out + digit_chars[d]
    return out

# P021 base converter - Roman numerals from 1 to 3999. Writing one walks a
# table from the largest value down, the subtractive pairs (CM, CD, XC, XL,
# IX, IV) being entries of the table. Reading one adds each symbol's value,
# except that a symbol smaller than the one after it is subtracted. Reading
# alone would accept IIII or IC, so a numeral counts only if writing its value
# again gives exactly the same letters.

[[1000, "M"], [900, "CM"], [500, "D"], [400, "CD"], [100, "C"], [90, "XC"],
 [50, "L"], [40, "XL"], [10, "X"], [9, "IX"], [5, "V"], [4, "IV"], [1, "I"]] => table

def to_roman(n):
    # The Roman numeral for 1 <= n <= 3999.
    "" => out
    for row in table:
        while n >= row[0]:
            out + row[1] => out
            n - row[0] => n
    return out

def symbol_value(c):
    for row in table:
        if row[1] == c:
            return row[0]
    return 0

def read_value(s):
    # The value of s by the add-or-subtract rule, or -1 if a letter is not a
    # Roman symbol.
    0 => total
    for i in [0:len(s) - 1]:
        symbol_value(s[i]) => v
        if v == 0:
            return 0 - 1
        if i + 1 < len(s) and v < symbol_value(s[i + 1]):
            total - v => total
        else:
            total + v => total
    return total

def from_roman(s):
    # [value, ""] for a numeral written the standard way, otherwise
    # [0, what is wrong].
    read_value(s) => v
    if v == 0 - 1:
        return [0, "Roman numerals use only I, V, X, L, C, D and M."]
    if v < 1 or v > 3999:
        return [0, s + " is not a numeral from I to MMMCMXCIX."]
    if to_roman(v) != s:
        return [0, s + " is not written the standard way; " + str(v) + " is " + to_roman(v) + "."]
    return [v, ""]

table = [[1000, "M"], [900, "CM"], [500, "D"], [400, "CD"], [100, "C"], [90, "XC"], [50, "L"], [40, "XL"], [10, "X"], [9, "IX"], [5, "V"], [4, "IV"], [1, "I"]]

def to_roman(n):
    out = ""
    for row in table:
        while n >= row[0]:
            out = out + row[1]
            n = n - row[0]
    return out

def symbol_value(c):
    for row in table:
        if row[1] == c:
            return row[0]
    return 0

def read_value(s):
    total = 0
    for i in range(0, len(s)):
        v = symbol_value(s[i])
        if v == 0:
            return 0 - 1
        if i + 1 < len(s) and v < symbol_value(s[i + 1]):
            total = total - v
        else:
            total = total + v
    return total

def from_roman(s):
    v = read_value(s)
    if v == 0 - 1:
        return [0, "Roman numerals use only I, V, X, L, C, D and M."]
    if v < 1 or v > 3999:
        return [0, s + " is not a numeral from I to MMMCMXCIX."]
    if to_roman(v) != s:
        return [0, s + " is not written the standard way; " + str(v) + " is " + to_roman(v) + "."]
    return [v, ""]

# P021 base converter - reading what is typed. The interpreter that checks
# every session does not run string methods yet, so the text handling is
# written out here.

def trim(s):
    # s without the spaces at either end.
    0 => i
    len(s) => j
    while i < j and s[i] == " ":
        i + 1 => i
    while j > i and s[j - 1] == " ":
        j - 1 => j
    return s[i:j]

def upper(s):
    # s with a-z turned into A-Z; everything else as it was.
    "abcdefghijklmnopqrstuvwxyz" => lower_letters
    "ABCDEFGHIJKLMNOPQRSTUVWXYZ" => upper_letters
    "" => out
    for c in s:
        c => d
        for i in [0:25]:
            if lower_letters[i] == c:
                upper_letters[i] => d
        out + d => out
    return out

def number(s):
    # The value of s if it is digits only (at least one), otherwise -1.
    if s == "":
        return 0 - 1
    0 => n
    for c in s:
        if not (c in "0123456789"):
            return 0 - 1
        n * 10 + int(c) => n
    return n

def trim(s):
    i = 0
    j = len(s)
    while i < j and s[i] == " ":
        i = i + 1
    while j > i and s[j - 1] == " ":
        j = j - 1
    return s[i:j]

def upper(s):
    lower_letters = "abcdefghijklmnopqrstuvwxyz"
    upper_letters = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
    out = ""
    for c in s:
        d = c
        for i in range(0, 26):
            if lower_letters[i] == c:
                d = upper_letters[i]
        out = out + d
    return out

def number(s):
    if s == "":
        return 0 - 1
    n = 0
    for c in s:
        if not c in "0123456789":
            return 0 - 1
        n = n * 10 + int(c)
    return n