The requirements

We just use the characters from I to M.

We first write a simple conversion function which ignores the abbreviation syntax, so instead of IX for 9 we write VIIII. To do so we use integer division and modulo operation.  We start with the highest number and work our way down. Have a look:

def convert_number_simple(number):
    roman_literal = ""
    thousands = number / 1000
    roman_literal += "M" * thousands
    five_hundreds = number % 1000 / 500
    roman_literal += "D" * five_hundreds
    hundreds = number % 1000 % 500 / 100
    roman_literal += "C" * hundreds
    fifties = number % 1000 % 500 % 100 / 50
    roman_literal += "L" * fifties
    tens = number % 1000 % 500 % 100 % 50 / 10
    roman_literal += "X" * tens
    fives = number % 1000 % 500 % 100 % 50 % 10 / 5
    roman_literal += "V" * fives
    ones = number % 1000 % 500 % 100 % 50 % 10 % 5
    roman_literal += "I" * ones
return roman_literal

This is by far not the most efficient way to convert a number. You could introduce a variable which holds the last calculation for the modulo operation, but I chose this representation for the sake of readability.

After we have written the simple conversion we can introduce the complex format by replacing string sequences which represent
900, 90, 9 and 4. It is important that we do it again in an descendant order because if we got “VIIII” and would replace”IIII” we would end up with VIV which is a non-valid numeral.

def convert_number(number):
    easy = convert_number_simple(number)
    easy = easy.replace("DCCCC", "CM") # 900
    easy = easy.replace("LXXXX", "XC") # 90
    easy = easy.replace("VIIII", "IX") # 9
    easy = easy.replace("IIII", "IV")  # 4
return easy

To test drive our code, Python has an assert function build in so we can write our main function as follows:

def main():
    assert("M" == convert_number_simple(1000))
    assert("MM" == convert_number_simple(2000))
    assert("D" == convert_number_simple(500))
    assert("MD" == convert_number_simple(1500))
    assert("C" == convert_number_simple(100))
    assert("L" == convert_number_simple(50))
    assert("X" == convert_number_simple(10))
    assert("V" == convert_number_simple(5))
    assert("I" == convert_number_simple(1))

    assert("MDCCCCLXXXIIII" == convert_number_simple(1984))
    assert("MCMLXXXIV" == convert_number(1984))
    assert("IV" == convert_number(4))
    assert("IX" == convert_number(9))


if __name__ == '__main__':
    main()

So far the solution in Python – stay tuned for Part 2 in which we do it in Rust 🙂

The post Code Kata: Roman Numeral – Part 1 appeared first on Creatronix.

To kill two birds with one stone I first solve a programming puzzle with my lingua franca Python. That helped me to concentrate on solving the algorithmic part of the puzzle because I don’t have to constantly worry about syntax and semantics.

Then I did the whole thing again this time in the language I want to learn: Rust

To give You an example how that works I will elaborate on the Christmas tree kata. Ok, what is the Christmas tree? It’s a neat little programming exercise where You have to print a Christmas tree on the console.

e.g. a tree with height 2 looks like this:

 X
XXX
 |

and a tree with height 3 looks like this:

  X
 XXX
XXXXX
  |

How do You solve this? First of all You have to understand how many whitespaces and “X”s You will find in each line depending on the level.
So for a tree with height 2 there is one whitespace and one X in the first and no whitespace and 3 “X” in the second row and two whitespaces and one “|” in the third line.

Let’s make a little table to see where this is going:

row  WS   X   |
0    1    1   0
1    0    3   0
2    1    0   1

Same thing again for height 3

row  WS   X   |
0    2    1   0
1    1    3   0
2    0    5   0
3    2    0   1

I hope it becomes quite easy to see how the characters have to be printed out:
for whitespaces it is “height – current_row – 1”,
for “X” it is “2 * current_row + 1”
and the last line is always “height – 1” whitespaces plus the “|” character.

In Python it looks like this:

height = 3
for line in range(height):
    print (" " * (height-line-1)) + "X" * (2*line+1)
print (" " * (height-1)) + "|"

And now for something completely different: Rust
Rust is a strongly and statically typed language, so there is a bit more effort in writing this Kata down. It looks like this:

fn draw_christmas_tree(height: i32){
    let mut val: String = String::new();
    for i in 0..height {
        for j in 0..height-i{
            val.push_str(" ");
        }
         for k in 0..(2*i+1){
            val.push_str("X");
        }
        val.push_str("\n");
    }
    for j in 0..height{
        val.push_str(" ");
    }
    val.push_str("|");
    println!("{}", val);

}
fn main() {
    draw_christmas_tree(3);
}

Because in Rust You don’t have the smooth “repeat a string n times” syntax You have to iterate more often. I also tried to append the characters to a string buffer before printing them out so it looks a bit more different then the solution in python.

The post Code Kata: Christmas Tree appeared first on Creatronix.