**Problem :**

Write a method that when passed an integer between 1 and 3000

returns a string in Roman numeral.

4 should return 'IIII'.

Hint: Use the integer division and modulus methods.

Roman Numerals : I = 1, V = 5, X = 10, L = 50, C = 100, D = 500, M = 1000

**Objective :**Convert a decimal number to a roman number.

Source( #1millionwomentotech)

This is a python solution for the problem

import math

d=0

while ((d > 3000) or (d==0)):

d=int(input("Enter number 1-3000 :"))

rn=""

#our rules = [M => 1000 , D = 500, C => 100, L => 50, X = 10, V => 5, I => 1]

decimal=[1000,500,100,50,10,5,1]

roman=["M","D","C","L","X","V","I"]

i=0

for n in decimal:

if (d==9) :

rn=rn+"IX"

break

if (d==4):

rn=rn+"IV"

break

q = math.floor(d/n)

r= d % n

rn=rn+ (q * roman[i])

d=r

i=i+1

print(rn)

The important question is how did we get it ?

I think it's worth learning.

**Method:**

We need to develop an algorithm to solve this problem.

An Algorithm is a sequence of steps to solve a problem. In each step we get closer to the solution.

Now We have to break the problem to small tasks to solve it.

Each task handles a part of the problem. It take inputs, process and output something.

The next task takes that output as an input, process and output something for the next task.

The input > process > output > input > process > output > input ...... goes on until all tasks are done.

We build the solution completing each task.

Each task may need few steps .

These steps are our lines of code.

Finally we may have the found the solution.

Remember in programming we find solution not at once. It is step wise.

What is important is identify problem and tasks to solve the problem.

Think it as a workflow.

Imagine flying from Fiji Island to small city in Cape Town. It is not one stop.

Multiple stop, flight cancellations, delays and all problems can come.

There always can be better ways.

This is my way!

**1. Design Manual Algorithm**

Think about how we would like to do it on paper. Describe It first!

I picked 2669 because it satisfies all Roman numerals.

**2, Look at 2669 like an ancient Roman.**

For a fellow Roman this number is made of 1000+1000+500+100+50+ 5+1+1+1+1

So what we have to do is break 2669 to 1000s, 500s, 100s, 50s, 10s, 5s and 1s.

**3.0 Our Tasks**

**Step 1:**Find how many 1000s in the number given.

Initial number = 2669

Since 2669 >= 1000 ; The initail largest base value is 1000

Divide 2669/1000. Quotient = 2, Remainder =669.

So the symbol M will be repeated twice. M * Quotient

MM

**Step 2:**Find how many 500s in the remaining number

Now we convert remainder 669

1000 > 669 >= 500 ; The base value now 500.

Divide 669/500. Quotient = 1, Remainder =169. The symbol D repeated once. D * M * Quotient

MMD

**Step 3:**Find how many 100s in remaining number

Now we convert remainder 139

500 > 169 >= 100 ; largest base value is 100.

Divide 169/100. Quotient = 1, Remainder = 69. The symbol C repeated once.

MMDC

**Step 4:**Find how many 50s in remaining number

Now we convert remainder 69

100 > 69 >= 50 ; largest base value is 50.

Divide 69/50. Quotient = 1, Remainder = 19. The symbol L repeated once.

MMDCL

**Step 5:**Find how many 10s in remaining number

Now we convert remainder 19

50 > 19 >= 10 ; largest base value is 10.

Divide 19/10. Quotient = 1, Remainder = 9. The symbol X repeated once.

MMDCLX

**Step 5:**Find how many 5s in remaining number

Now we convert remainder 9

10 > 9 >= 5 ; largest base value is 5.

Divide 9/5. Quotient = 1, Remainder = 4 The symbol V repeated once.

MMDCLXV

**Step 6:**Find how many 1s in remaining number

Now we convert remainder 4

Divide 4/1. Quotient = 4, Remainder = 0 The symbol I repeated four times. IIII

MMDCLXVIIII

**4. Fix Unexpected Problems:**

Oh! our flight is not direct to the small city. Tts an island, we have to take the boat and a car too.

Decimal 4 and 9 are represented in Roman numerals as IV and IX

Our algorithm gives IIII or VIIII . Roman's will not buy our program.

So we need a fix step 5 and 6 with some conditions

if remainder is 9 use IX

if remainder == 4 use IV

Use the algorithm and convert 0, 1, 5, 7, 10, 11, 25, 51, 105, 551, 1056, 2005 to Roman on paper.

You can convert any number to Roman in paper now.

Now lets write the algorithm in pseudo code as we did it manually.

Pseudo code is the steps we take to solve the problem, its not a programming language.

Pseudo code is not a standard, its English and math based description of how we intend to program the solution. This is my style. You can write it in your own way.

What we actually do is document the steps we did manually that way computer would do it.

rn=""

if not d <=3000 or d = 0 ask again

let d= 2669

#floor gives quotient of a division floor(7/2) is 3

q = floor(d/1000) => 2 * 1000 => 2 * M

#% is modular division 5 % 2 is 1

r= d % 1000 => 669

rn="MM"

if r >=500 :

d=r= 669

q = floor (d/500) => 1 * 500 => 1 * D

r= d % 500 => 169

rn="MM"+"D"

if r >= 100

d=r= 169

d = floor(d/100) => 1 * 100 => 1 * C

r= d % 100 => 69

rn="MMD"+"C"

if r >= 50

d=r= 69

d = floor(d/50) => 1 * 50 => 1 * L

r= d % 50 => 19

rn="MMDC"+"L"

if r >= 10

d=r=19

d = floor(d/10) => 1 * 10 => 1 * X

r= d % 10 => 9

rn="MMDCL"+"X"

if r >= 5

if r ==9 rn = "MMDCLX"+"IX"

else

d=r

d = floor(d/5) => n (1 or 0)

r= d % 5 => r1

rn="MMDCL"+"V"

if r >=1

if r ==4 rn = "MMDCLX"+"IV"

rn="MMDCL"+"I" * r

Now test out few numbers again.

Do 0, 1, 111, 245, 1500, 2999, 3000, 3001 manually on your pseudo code to make sure.

If they works out, this seems to be our algorthm to solve the problem in steps.

This does not have to be perfect.

Because we never run pseudo code on a computer.

**Now lets develop an algorithm for the computer.**

First study the repeated patterns in manual algorithm.

To write python code we need to know about

They are our ingredients to code the solution.

Lists, List Elements, Iterating lists with for loops and breaks, Strings, integer division and modules operator, input and output function.

**How do we represent base data and rules ?**

our rules are [M => 1000 , D = 500, C => 100, L => 50, X = 10, V => 5, I => 1]

our rules can be represented in two lists

decimal=[1000,500,100,50,10,5,1]

roman[M,D,C,L,X,V,I]

d=input a number

rn="" initial roman number is empty

rn="" initial roman number is empty

i=0

for n in decimal[...] here we process the list

if d==9 rn=rn+"IX" break

if d==4 rn=rn+"IV" break

#floor gives quotient of a division we know how many 100s when we do 350/100

q = floor(divide d/n)

# % is modular operator gives a remainder of a division

r= d % decimal[i] => 669

rn=rn+ q * roman[q] # build the roman number string

d=r

i=i+1

print(rn)

Now code your idea in python or in any other language.

This is how I teach kids to code algorithms. May suit aspiring beginners.

If you like this, I would write more lesson plans for your home work.

## No comments:

Post a Comment