Convert a number, represented as a sequence of digits in one base, to any other base.
Implement general base conversion. Given a number in base a, represented as a sequence of digits, convert it to base b.
In positional notation, a number in base b can be understood as a linear combination of powers of b.
The number 42, in base 10, means:
(4 * 10^1) + (2 * 10^0)
The number 101010, in base 2, means:
(1 * 2^5) + (0 * 2^4) + (1 * 2^3) + (0 * 2^2) + (1 * 2^1) + (0 * 2^0)
The number 1120, in base 3, means:
(1 * 3^3) + (1 * 3^2) + (2 * 3^1) + (0 * 3^0)
I think you got the idea!
Yes. Those three numbers above are exactly the same. Congratulations!
Execute the tests with:
$ elixir all_your_base_test.exs
In the test suites, all but the first test have been skipped.
Once you get a test passing, you can unskip the next one by
commenting out the relevant @tag :pending
with a #
symbol.
For example:
# @tag :pending
test "shouting" do
assert Bob.hey("WATCH OUT!") == "Whoa, chill out!"
end
Or, you can enable all the tests by commenting out the
ExUnit.configure
line in the test suite.
# ExUnit.configure exclude: :pending, trace: true
For more detailed information about the Elixir track, please see the help page.
It's possible to submit an incomplete solution so you can see how others have completed the exercise.
if !System.get_env("EXERCISM_TEST_EXAMPLES") do
Code.load_file("all-your-base.exs", __DIR__)
end
ExUnit.start()
ExUnit.configure(exclude: :pending, trace: true)
defmodule AllYourBaseTest do
use ExUnit.Case
test "convert single bit one to decimal" do
assert AllYourBase.convert([1], 2, 10) == [1]
end
@tag :pending
test "convert binary to single decimal" do
assert AllYourBase.convert([1, 0, 1], 2, 10) == [5]
end
@tag :pending
test "convert single decimal to binary" do
assert AllYourBase.convert([5], 10, 2) == [1, 0, 1]
end
@tag :pending
test "convert binary to multiple decimal" do
assert AllYourBase.convert([1, 0, 1, 0, 1, 0], 2, 10) == [4, 2]
end
@tag :pending
test "convert decimal to binary" do
assert AllYourBase.convert([4, 2], 10, 2) == [1, 0, 1, 0, 1, 0]
end
@tag :pending
test "convert trinary to hexadecimal" do
assert AllYourBase.convert([1, 1, 2, 0], 3, 16) == [2, 10]
end
@tag :pending
test "convert hexadecimal to trinary" do
assert AllYourBase.convert([2, 10], 16, 3) == [1, 1, 2, 0]
end
@tag :pending
test "convert 15-bit integer" do
assert AllYourBase.convert([3, 46, 60], 97, 73) == [6, 10, 45]
end
@tag :pending
test "convert empty list" do
assert AllYourBase.convert([], 2, 10) == nil
end
@tag :pending
test "convert single zero" do
assert AllYourBase.convert([0], 10, 2) == [0]
end
@tag :pending
test "convert multiple zeros" do
assert AllYourBase.convert([0, 0, 0], 10, 2) == [0]
end
@tag :pending
test "convert leading zeros" do
assert AllYourBase.convert([0, 6, 0], 7, 10) == [4, 2]
end
@tag :pending
test "convert negative digit" do
assert AllYourBase.convert([1, -1, 1, 0, 1, 0], 2, 10) == nil
end
@tag :pending
test "convert invalid positive digit" do
assert AllYourBase.convert([1, 2, 1, 0, 1, 0], 2, 10) == nil
end
@tag :pending
test "convert first base is one" do
assert AllYourBase.convert([0], 1, 10) == nil
end
@tag :pending
test "convert second base is one" do
assert AllYourBase.convert([1, 0, 1, 0, 1, 0], 2, 1) == nil
end
@tag :pending
test "convert first base is zero" do
assert AllYourBase.convert([], 0, 10) == nil
end
@tag :pending
test "convert second base is zero" do
assert AllYourBase.convert([7], 10, 0) == nil
end
@tag :pending
test "convert first base is negative" do
assert AllYourBase.convert([1], -2, 10) == nil
end
@tag :pending
test "convert second base is negative" do
assert AllYourBase.convert([1], 2, -7) == nil
end
@tag :pending
test "convert both bases are negative" do
assert AllYourBase.convert([1], -2, -7) == nil
end
end
defmodule AllYourBase do
@min_base 2
@doc """
Given a number in base a, represented as a sequence of digits, converts it to base b,
or returns nil if either of the bases are less than 2
"""
@spec convert(list, integer, integer) :: list
def convert(digits, base_a, base_b) do
digits
|> to_decimal(base_a)
|> from_decimal(base_b)
end
defp to_decimal([], _), do: nil
defp to_decimal(digits, base) do
max_power = Enum.count(digits) - 1
to_decimal(digits, base, max_power, 0)
end
defp to_decimal([], _, _, acc), do: acc
defp to_decimal([digit | _], _, _, _) when digit < 0, do: nil
defp to_decimal([digit | _], base, _, _) when digit >= base, do: nil
defp to_decimal(_, base, _, _) when base < @min_base, do: nil
defp to_decimal([digit | rest], base, power, acc) do
to_decimal(rest, base, power - 1, acc + digit * trunc(:math.pow(base, power)))
end
defp from_decimal(nil, _), do: nil
defp from_decimal(_, base) when base < @min_base, do: nil
defp from_decimal(number, base, digits \\ [])
defp from_decimal(0, _, []), do: [0]
defp from_decimal(0, _, digits), do: digits
defp from_decimal(number, base, digits) do
digit = rem(number, base)
rest = div(number, base)
from_decimal(rest, base, [digit | digits])
end
end
A huge amount can be learned from reading other people’s code. This is why we wanted to give exercism users the option of making their solutions public.
Here are some questions to help you reflect on this solution and learn the most from it.
Level up your programming skills with 3,450 exercises across 52 languages, and insightful discussion with our volunteer team of welcoming mentors. Exercism is 100% free forever.
Sign up Learn More
Community comments