Programación con TDD: Ejercicios FizzBuzz y Números Romanos

Clase 15 de 24 • Curso Básico de Testing en Java

Contenido del curso

Bienvenida e Introducción

1
Testing en Java: JUnit, Mockito y TDD
01:47 min

Introducción a tests en software

2
Beneficios y tipos de tests automáticos y manuales en software
04:19 min

Preparación del IDE, proyecto y librerías

TDD

Tests en una aplicación

Requerimientos y tests

Conclusiones

24
Recomendaciones para Escribir Tests Efectivos en Programación
01:19 min

Tomar examen

FizzBuzz

Para practicar TDD, realizaremos este ejercicio clásico.

Usando TDD (empieza por los tests), implementa una función que dado un número: Si el número es divisible por 3, retorna “Fizz” Si el número es divisible por 5, retorna “Buzz” Si el número es divisible por 3 y por 5, retorna “FizzBuzz” En otro caso, retorna el mismo número

public class FizzBuzz {

    public static String fizzBuzz(int n) {
    ...
    }
}

Por ejemplo, ve escribiendo estos tests. Tras cada test, escribe el código mínimo necesario para que los tests pasen, y sigue con el siguiente test.

fizzBuzz(3) ⇒ "Fizz"
fizzBuzz(6) ⇒ "Fizz"
fizzBuzz(5) ⇒ "Buzz"
fizzBuzz(10) ⇒ "Buzz"
fizzBuzz(15) ⇒ "FizzBuzz"
fizzBuzz(30) ⇒ "FizzBuzz"
fizzBuzz(2) ⇒ "2"
fizzBuzz(16) ⇒ "16"

Reto extra: Números Romanos

Como extra, prueba este otro ejercicio. Anímate a intentarlo. ¡Te va a hacer pensar!

Usando TDD, implementa una función que convierta un número en el equivalente romano.

public class RomanNumerals {

    public static String arabicToRoman(int n) {
    ...
    }
}

Por ejemplo, ve escribiendo estos tests. Tras cada test, escribe el código mínimo necesario para que los tests pasen, y sigue con el siguiente test.

arabicToRoman(1) ⇒ "I"
arabicToRoman(2) ⇒ "II"
arabicToRoman(3) ⇒ "III"
arabicToRoman(5) ⇒ "V"
arabicToRoman(6) ⇒ "VI"
arabicToRoman(7) ⇒ "VII"
arabicToRoman(10) ⇒ "X"
arabicToRoman(11) ⇒ "XI"
arabicToRoman(15) ⇒ "XV"
arabicToRoman(16) ⇒ "XVI"
arabicToRoman(50) ⇒ "L"
arabicToRoman(51) ⇒ "LI"
arabicToRoman(55) ⇒ "LV"
arabicToRoman(56) ⇒ "LVI"
arabicToRoman(60) ⇒ "LX"
arabicToRoman(70) ⇒ "LXX"
arabicToRoman(80) ⇒ "LXXX"
arabicToRoman(81) ⇒ "LXXXI"
arabicToRoman(85) ⇒ "LXXXV"
arabicToRoman(86) ⇒ "LXXXVI"
arabicToRoman(126) ⇒ "CXXVI"
arabicToRoman(2507) ⇒ "MMDVII"

Puedes añadir más tests.

En los siguientes tests, probamos los casos en los que hay símbolos que restan, porque van a la izquierda de un símbolo mayor:

arabicToRoman(4) ⇒ "IV"
arabicToRoman(9) ⇒ "IX"
arabicToRoman(14) ⇒ "XIV"
arabicToRoman(19) ⇒ "XIX"
arabicToRoman(24) ⇒ "XXIV"
arabicToRoman(40) ⇒ "XL"
arabicToRoman(49) ⇒ "XLIX"
arabicToRoman(90) ⇒ "XC"
arabicToRoman(99) ⇒ "XCIX"
arabicToRoman(400) ⇒ "CD"
arabicToRoman(900) ⇒ "CM"

Puedes añadir más tests.

Ten en cuenta que el símbolo I puede restar a V y X. El símbolo X puede restar a L y C. El símbolo C puede restar a D y M.

Dicho de manera más simple, las combinaciones en las que hay una resta son las siguientes: IV IX XL XC CD CM.

Anddes Asociados

student•

package com.platzi.javatest.fizzbuzz;

public class FizzBuzz {

    public String fizzBuzz(int n) {
        String result = "";

        if(n%3 == 0) result += "Fizz";
        if(n%5 == 0) result += "Buzz";

        return result.isEmpty() ? String.valueOf(n) : result;
    }
}

José Gregorio López Arias

Acá te falto comprobar cuando un numero es divisible por tres y tambien por cinco. Su salida (FizzBuzz)

Ramiro Carbonell

@lopezajoseg realmente no y está bien la función, porque se concatenan. Primero evalúa el 3 y después el 5, de igual forma lo puedes validar con los tests.

Gracias por el aporte

Hipólito Morales

public class RomanNumerals {

    enum RomanNumeral {

        M(1000),CM(900),D(500),CD(400),
        C(100),XC(90),L(50),XL(40),
        X(10),IX(9),V(5),IV(4),
        I(1);

        private int value;

        RomanNumeral(int value) {
            this.value = value;
        }

        public int getValue() {
            return value;
        }

        public static List<RomanNumeral> getRomanNumerals() {
            return Arrays.asList(RomanNumeral.values());
        }

    }

    public static String arabicToRoman(int n) {

        StringBuilder collator = new StringBuilder();
        List<RomanNumeral> romanNumerals= RomanNumeral.getRomanNumerals();

        //Valida que el número sea menor a 4000 debido a que el formato cambia
        if (n > 0 && n < 4000) {

            int i = 0;
            while(n>0 && i<romanNumerals.size()){
                RomanNumeral currentRoman = romanNumerals.get(i);
                if(n>=currentRoman.getValue()){
                    collator.append(currentRoman);
                    n -= currentRoman.getValue();
                } else {
                    i++;
                }

            }

            String roman = collator.toString();
            return roman;

        } else {
            throw new IllegalArgumentException( n + "no está en el rango (0,4000)");
        }
    }

}

CIRO VLADIMIR ARREOLA CAMACHO

excelente solución! muy ingeniosa al no complicarse con los números que restan (prefijos, ej IV o IX). Pasó todas las pruebas jejeje

Tania Moreira Loor

Muy buen aporte amigo, no sabia que podría ser más fácil con el uso del enum.

Jose Gabriel Cortazar Ocampo

Reto # 2

Método refactorizado

public static String arabicToRoman(int n) {
String result = "";
	HashMap<String, Integer> romanNumerals = new LinkedHashMap();

	romanNumerals.put("M", 1000);
	romanNumerals.put("CM", 900);
	romanNumerals.put("D", 500);
	romanNumerals.put("CD", 400);
	romanNumerals.put("C", 100);
	romanNumerals.put("XC", 90);
	romanNumerals.put("L", 50);
	romanNumerals.put("XL", 40);
	romanNumerals.put("X", 10);
	romanNumerals.put("IX", 9);
	romanNumerals.put("V", 5);
	romanNumerals.put("IV", 4);
	romanNumerals.put("I", 1);

	

	for (Map.Entry<String, Integer> entry : romanNumerals.entrySet()) {
		String roman = entry.getKey();
		Integer arabic = entry.getValue();

		if (arabic == 1000 || arabic == 100 || arabic == 10 || arabic == 1) {
			while (n >= arabic) {
				result += roman;
				n = n - arabic;
			}
		} else {
			if (n >= arabic) {
				result += roman;
				n = n - arabic;
			}
		}
	}

	return result;
}

Método sin refactorizar

public static String arabicToRoman(int n) {

	String result = "";

	while (n >= 1000) {
		result += "M";
		n = n - 1000;
	}

	if (n >= 900) {
		result += "CM";
		n = n - 900;
	}

	if (n >= 500) {
		result += "D";
		n = n - 500;
	}

	if (n >= 400) {
		result += "CD";
		n = n - 400;
	}

	while (n >= 100) {
		result += "C";
		n = n - 100;
	}

	if (n >= 90) {
		result += "XC";
		n = n - 90;
	}

	if (n >= 50) {
		result += "L";
		n = n - 50;
	}

	if (n >= 40) {
		result += "XL";
		n = n - 40;
	}

	while (n >= 10) {
		result += "X";
		n = n - 10;
	}

	if (n >= 9) {
		result += "IX";
		n = n - 9;
	}

	if (n >= 5) {
		result += "V";
		n = n - 5;
	}

	if (n >= 4) {
		result += "IV";
		n = n - 4;
	}

	while (n > 0) {
		result += "I";
		n--;
	}

	return result;
}

Tests


/**
 * arabicToRoman(1) => "I" 
 * arabicToRoman(2) => "II" 
 * arabicToRoman(3) => "III"
 * 
 * arabicToRoman(5) => "V" 
 * arabicToRoman(6) => "VI" 
 * arabicToRoman(7) => "VII"
 * 
 * arabicToRoman(10) => "X" 
 * arabicToRoman(11) => "XI" 
 * arabicToRoman(15) => "XV"
 * arabicToRoman(16) => "XVI"
 * 
 * arabicToRoman(50) => "L" 
 * arabicToRoman(51) => "LI" 
 * arabicToRoman(55) => "LV"
 * arabicToRoman(56) => "LVI" 
 * arabicToRoman(60) => "LX" 
 * arabicToRoman(70) => "LXX"
 * 
 * arabicToRoman(80) => "LXXX" 
 * arabicToRoman(81) => "LXXXI" 
 * arabicToRoman(85) => "LXXXV" 
 * arabicToRoman(86) => "LXXXVI"
 * 
 * arabicToRoman(126) => "CXXVI"
 * 
 * arabicToRoman(2507) => "MMDVII"
 */


@Test
public void roman_numbers_when_1_2_3() {

	assertThat(RomanNumerals.arabicToRoman(1), CoreMatchers.is("I"));
	assertThat(RomanNumerals.arabicToRoman(2), CoreMatchers.is("II"));
	assertThat(RomanNumerals.arabicToRoman(3), CoreMatchers.is("III"));

}

@Test
public void roman_numbers_when_5_6_7() {

	assertThat(RomanNumerals.arabicToRoman(5), CoreMatchers.is("V"));
	assertThat(RomanNumerals.arabicToRoman(6), CoreMatchers.is("VI"));
	assertThat(RomanNumerals.arabicToRoman(7), CoreMatchers.is("VII"));

}

@Test
public void roman_numbers_when_10_11_15_16() {

	assertThat(RomanNumerals.arabicToRoman(10), CoreMatchers.is("X"));
	assertThat(RomanNumerals.arabicToRoman(11), CoreMatchers.is("XI"));
	assertThat(RomanNumerals.arabicToRoman(15), CoreMatchers.is("XV"));
	assertThat(RomanNumerals.arabicToRoman(16), CoreMatchers.is("XVI"));

}

@Test
public void roman_numbers_when_50_51_55_56() {

	assertThat(RomanNumerals.arabicToRoman(50), CoreMatchers.is("L"));
	assertThat(RomanNumerals.arabicToRoman(51), CoreMatchers.is("LI"));
	assertThat(RomanNumerals.arabicToRoman(55), CoreMatchers.is("LV"));
	assertThat(RomanNumerals.arabicToRoman(56), CoreMatchers.is("LVI"));

}

@Test
public void roman_numbers_when_60_70() {

	assertThat(RomanNumerals.arabicToRoman(60), CoreMatchers.is("LX"));
	assertThat(RomanNumerals.arabicToRoman(70), CoreMatchers.is("LXX"));

}

@Test
public void roman_numbers_when_80_81_85_86() {

	assertThat(RomanNumerals.arabicToRoman(80), CoreMatchers.is("LXXX"));
	assertThat(RomanNumerals.arabicToRoman(81), CoreMatchers.is("LXXXI"));
	assertThat(RomanNumerals.arabicToRoman(85), CoreMatchers.is("LXXXV"));
	assertThat(RomanNumerals.arabicToRoman(86), CoreMatchers.is("LXXXVI"));

}

@Test
public void roman_numbers_when_126() {

	assertThat(RomanNumerals.arabicToRoman(126), CoreMatchers.is("CXXVI"));
}

@Test
public void roman_numbers_when_2507() {

	assertThat(RomanNumerals.arabicToRoman(2507), CoreMatchers.is("MMDVII"));
}

/**
 * arabicToRoman(4) => "IV" 
 * arabicToRoman(14) => "XIV"
 * arabicToRoman(24) => "XXIV" 
 * 
 * arabicToRoman(40) => "XL"
 * arabicToRoman(44) => "XLIV"
 * 
 * arabicToRoman(400) => "CD" 
 * 
 * arabicToRoman(9) => "IX" 
 * arabicToRoman(19) => "XIX" 
 * arabicToRoman(49) => "XLIX" 
 * 
 * arabicToRoman(90) => "XC" 
 * arabicToRoman(99) => "XCIX" 
 * 
 * arabicToRoman(900) => "CM"
 */

@Test
public void roman_numbers_when_4_14_24() {

	assertThat(RomanNumerals.arabicToRoman(4), CoreMatchers.is("IV"));
	assertThat(RomanNumerals.arabicToRoman(14), CoreMatchers.is("XIV"));
	assertThat(RomanNumerals.arabicToRoman(24), CoreMatchers.is("XXIV"));

}

@Test
public void roman_numbers_when_40() {
	
	assertThat(RomanNumerals.arabicToRoman(40), CoreMatchers.is("XL"));
	assertThat(RomanNumerals.arabicToRoman(44), CoreMatchers.is("XLIV"));

}

@Test
public void roman_numbers_when_400() {
	
	assertThat(RomanNumerals.arabicToRoman(400), CoreMatchers.is("CD"));

}

@Test
public void roman_numbers_when_9_19_49() {

	assertThat(RomanNumerals.arabicToRoman(9), CoreMatchers.is("IX"));
	assertThat(RomanNumerals.arabicToRoman(19), CoreMatchers.is("XIX"));
	assertThat(RomanNumerals.arabicToRoman(49), CoreMatchers.is("XLIX"));

}

@Test
public void roman_numbers_when_90_99() {
	
	assertThat(RomanNumerals.arabicToRoman(90), CoreMatchers.is("XC"));
	assertThat(RomanNumerals.arabicToRoman(99), CoreMatchers.is("XCIX"));

}

@Test
public void roman_numbers_when_900() {
	
	assertThat(RomanNumerals.arabicToRoman(900), CoreMatchers.is("CM"));

}

Gerald Zamora

Reto #1

public static String fizzBuzz(int i) {
        String result = "";
        boolean divisible = false;
        if(i % 3 == 0){
            result += "Fizz";
            divisible = true;
        }
        if(i % 5 == 0){
            result += "Buzz";
            divisible = true;
        }
        return divisible ? result: ""+i ;
    }

public static String arabicToRoman(int n) {
        String result = "";

        for (int i = 0; i < n; i++) {
            result += "I";

            result = result.replaceAll("IIII", "IV");
            result = result.replaceAll("IVI", "V");

            result = result.replaceAll("VIV", "IX");
            result = result.replaceAll("IXI", "X");

            result = result.replaceAll("XXXX", "XL");
            result = result.replaceAll("XLX", "L");

            result = result.replaceAll("LXL", "XC");
            result = result.replaceAll("XCX", "C");

            result = result.replaceAll("CCCC", "CD");
            result = result.replaceAll("CDC", "D");

            result = result.replaceAll("DCD", "CM");
            result = result.replaceAll("CMC", "M");
        }
        return result;    
}

Marcos Sebastián Imfeld

public class RomanNumerals {

    public static String arabicToRoman(int n){

        String number = "";

        while(n >= 1000) { number += "M"; n -= 1000; }
        if(n >= 900) { number +="CM"; n -= 900; }
        if(n>=900) {number += "CM"; n -= 900;}
        if(n>=500) {number += "D"; n -= 500;}
        if(n>=400) {number += "CD"; n -= 400;}
        while(n>=100){number += "C"; n -= 100;}
        if(n>=90){number += "XC"; n -= 90;}
        if(n>=50){number += "L"; n -= 50;}
        if(n>=40){number += "XL"; n -=40;}
        while(n>=10){number += "X"; n -= 10;}
        if(n>=9){number += "IX"; n -=9;}
        if(n>=5){number += "V"; n -=5;}
        if(n>=4){number += "IV"; n -=4;}
        while(n>=1){number += "I"; n -= 1;}

        return number;
    }
}```

public class RomanNumeralsTest {

    @Test
    public void roman_number() {
        assertThat(arabicToRoman(24),is("XXIV"));
    }
}```

Antonio Madrid

Estuve intentando hacerlo de forma más comprimida, pero hasta aquí llegué:

public static String arabicToRoman(int n) {

        String result = "";

        while((n <= 3000) && (n >= 1000)) { result += "M"; n -= 1000; }
        while((n <= 300) && (n >= 100)) { result += "C"; n -= 100; }
        while((n <= 150) && (n >= 50)) { result += "L"; n -= 50; }
        while((n <= 36) && (n >= 10)) { result += "X"; n -= 10; }
        while((n <= 15) && (n >= 5)) { result += "V"; n -= 5; }
        while (n <= 3 && n != 0) { result += "I"; n -= 1; }


        return result;
    }
}

Petaba en el último test donde se esperaba MMDVII y devolvía MM.

Brenda Yasmin Barrios Becerra

Practica 💻 Reto 1

William Lopera

package com.practicas.tdd;

public class RomanNumerals {

	public static String arabicToRoman(int n) {

		if (n == 1000) {
			return "M";
		} else if (n > 1000) {
			return "M" + arabicToRoman(n - 1000);
		}

		if (n == 500) {
			return "D";
		} else if (n > 500 && n < 900) {
			return "D" + arabicToRoman(n - 500);
		}

		if (n == 100) {
			return "C";
		} else if (n >= 400 || n >= 900) {
			return "C" + arabicToRoman(n + 100);
		} else if (n > 100) {
			return "C" + arabicToRoman(n - 100);
		}

		if (n == 50) {
			return "L";
		} else if (n > 50 && n < 90) {
			return "L" + arabicToRoman(n - 50);
		}

		if (n == 10) {
			return "X";
		} else if (n >= 40 || n >= 90) {
			return "X" + arabicToRoman(n + 10);
		} else if (n > 10) {
			return "X" + arabicToRoman(n - 10);
		}

		if (n == 5) {
			return "V";
		} else if (n > 5 && n != 9) {
			return "V" + arabicToRoman(n - 5);
		}

		if (n == 4 || n == 9) {
			return "I" + arabicToRoman(n + 1);
		} else if (n > 1) {
			return "I" + arabicToRoman(n - 1);
		}

		return "I";

	}

}

Luis Cristóbal Oliden Albrecht

David Gallego

Creo que hay un error en la parte de los números romanos:

arabicToRoman(55) ⇒ "DV"
arabicToRoman(56) ⇒ "DVI"
arabicToRoman(60) ⇒ "DX"
arabicToRoman(70) ⇒ "DXX"
arabicToRoman(80) ⇒ "DXXX"
arabicToRoman(81) ⇒ "DXXXI"
arabicToRoman(85) ⇒ "DXXXV"
arabicToRoman(86) ⇒ "DXXXVI"

Aquí en lugar de ser la D creo que debería ser la L.

Ferran Maylinch

teacher•

Cierto!

L es 50, y D es 500.

Felipe de Jesús Galindo Aguilar

Este pequeño reto me hizo pensar bastante.

public class RomanNumerals {
    public static HashMap<Integer,String> numberToOneToTen = new HashMap<Integer,String>();
    public static void loadToOneToTen(){
        numberToOneToTen.put(0,"");
        numberToOneToTen.put(1,"I");
        numberToOneToTen.put(2,"II");
        numberToOneToTen.put(3,"III");
        numberToOneToTen.put(4,"IV");
        numberToOneToTen.put(5,"V");
        numberToOneToTen.put(6,"VI");
        numberToOneToTen.put(7,"VII");
        numberToOneToTen.put(8,"VII");
        numberToOneToTen.put(9,"IX");
    }
    public static String arabicToRoman(String number) {
        StringBuilder result = new StringBuilder();
        for (int i = number.length() - 1,aux = 0; i >= 0 ; i--,aux++) {
            int n = Integer.parseInt(String.valueOf(number.charAt(i)));
            if(aux == 0){
                result.append(String.format("%s",numberToOneToTen.get(n).toString()));
            }else if(aux == 1){
                String value = result.toString();
                result.setLength(0);
                result.append(String.format("%s%s",getDecimals(n),value));
            }else if(aux == 2){
                String value = result.toString();
                result.setLength(0);
                result.append(String.format("%s%s",getHundreds(n),value));
            }else if(aux == 3){
                String value = result.toString();
                result.setLength(0);
                result.append(String.format("%s%s",getThousand(n),value));
            }
        }
        return result.toString();
    }
    public static String getThousand(int number){
        StringBuilder result = new StringBuilder();
        switch (number){
            case 0:
                result.append("");
                break;
            case 1:
                result.append("M");
                break;
            case 2:
                result.append("MM");

        }
        return result.toString();
    }
    public static String getHundreds(int number){
        StringBuilder result = new StringBuilder();
        switch (number){
            case 0:
                result.append("");
                break;
            case 1:
                result.append("C");
                break;
            case 4:
                result.append("CD");
                break;
            case 5:
                result.append("D");
                break;
            case 9:
                result.append("CM");
                break;
        }
        return result.toString();
    }
    public static String getDecimals(int number){
        StringBuilder result = new StringBuilder();
        switch (number){
            case 0:
                result.append("");
                break;
            case 1:
                result.append("X");
                break;
            case 2:
                result.append("XX");
                break;
            case 3:
                result.append("XXX");
                break;
            case 4:
                result.append("XL");
                break;
            case 5:
                result.append("L");
                break;
            case 6:
                result.append("LX");
                break;
            case 7:
                result.append("LXX");
                break;
            case 8:
                result.append("LXXX");
                break;
            case 9:
                result.append("XC");
                break;
        }
        return result.toString();
    }
}

public class RomanNumeralsTest {

    @Before
    public void set(){
        RomanNumerals.loadToOneToTen();
    }
    @Test
    public void valid_number_1_to_roman(){
        assertEquals("I",RomanNumerals.arabicToRoman("1"));
    }
    @Test
    public void valid_number_2_to_roman(){
        assertEquals("II",RomanNumerals.arabicToRoman("2"));
    }
    @Test
    public void valid_number_3_to_roman(){
        assertEquals("III",RomanNumerals.arabicToRoman("3"));
    }
    @Test
    public void valid_number_5_to_roman(){
        assertEquals("V",RomanNumerals.arabicToRoman("5"));
    }

    @Test
    public void valid_number_6_to_roman(){
        assertEquals("VI",RomanNumerals.arabicToRoman("6"));
    }
    @Test
    public void valid_number_7_to_roman(){
        assertEquals("VII",RomanNumerals.arabicToRoman("7"));
    }
    @Test
    public void valid_number_10_to_roman(){
        assertEquals("X",RomanNumerals.arabicToRoman("10"));
    }
    @Test
    public void valid_number_11_to_roman(){
        assertEquals("XI",RomanNumerals.arabicToRoman("11"));
    }
    @Test
    public void valid_number_15_to_roman(){
        assertEquals("XV",RomanNumerals.arabicToRoman("15"));
    }
    @Test
    public void valid_number_16_to_roman(){
        assertEquals("XVI",RomanNumerals.arabicToRoman("16"));
    }
    @Test
    public void valid_number_50_to_roman(){
        assertEquals("L",RomanNumerals.arabicToRoman("50"));
    }
    @Test
    public void valid_number_51_to_roman(){
        assertEquals("LI",RomanNumerals.arabicToRoman("51"));
    }
    @Test
    public void valid_number_55_to_roman(){
        assertEquals("LV",RomanNumerals.arabicToRoman("55"));
    }
    @Test
    public void valid_number_56_to_roman(){
        assertEquals("LVI",RomanNumerals.arabicToRoman("56"));
    }
    @Test
    public void valid_number_60_to_roman(){
        assertEquals("LX",RomanNumerals.arabicToRoman("60"));
    }
    @Test
    public void valid_number_70_to_roman(){
        assertEquals("LXX",RomanNumerals.arabicToRoman("70"));
    }
    @Test
    public void valid_number_80_to_roman(){
        assertEquals("LXXX",RomanNumerals.arabicToRoman("80"));
    }
    @Test
    public void valid_number_81_to_roman(){
        assertEquals("LXXXI",RomanNumerals.arabicToRoman("81"));
    }
    @Test
    public void valid_number_85_to_roman(){
        assertEquals("LXXXV",RomanNumerals.arabicToRoman("85"));
    }
    @Test
    public void valid_number_86_to_roman(){
        assertEquals("LXXXVI",RomanNumerals.arabicToRoman("86"));
    }
    @Test
    public void valid_number_126_to_roman(){
        assertEquals("CXXVI",RomanNumerals.arabicToRoman("126"));
    }
    @Test
    public void valid_number_2507_to_roman(){
        assertEquals("MMDVII",RomanNumerals.arabicToRoman("2507"));
    }
    @Test
    public void valid_number_4_to_roman(){
        assertEquals("IV",RomanNumerals.arabicToRoman("4"));
    }
    @Test
    public void valid_number_9_to_roman(){
        assertEquals("IX",RomanNumerals.arabicToRoman("9"));
    }
    @Test
    public void valid_number_14_to_roman(){
        assertEquals("XIV",RomanNumerals.arabicToRoman("14"));
    }
    @Test
    public void valid_number_19_to_roman(){
        assertEquals("XIX",RomanNumerals.arabicToRoman("19"));
    }
    @Test
    public void valid_number_24_to_roman(){
        assertEquals("XXIV",RomanNumerals.arabicToRoman("24"));
    }
    @Test
    public void valid_number_40_to_roman(){
        assertEquals("XL",RomanNumerals.arabicToRoman("40"));
    }
    @Test
    public void valid_number_49_to_roman(){
        assertEquals("XLIX",RomanNumerals.arabicToRoman("49"));
    }
    @Test
    public void valid_number_90_to_roman(){
        assertEquals("XC",RomanNumerals.arabicToRoman("90"));
    }
    @Test
    public void valid_number_99_to_roman(){
        assertEquals("XCIX",RomanNumerals.arabicToRoman("99"));
    }
    @Test
    public void valid_number_400_to_roman(){
        assertEquals("CD",RomanNumerals.arabicToRoman("400"));
    }
    @Test
    public void valid_number_900_to_roman(){
        assertEquals("CM",RomanNumerals.arabicToRoman("900"));
    }
}

Roy Alvaro Donaires Rojas

esta esta mas fácil de entender para que no vueles mucho si recien empiezas

package com.platzi.javatest.util.reto3;


public class RomanNumerals {
    public static String arabicToRoman(int n) {
        if(n <1 || n > 3999){
            return "numero erroneo";
        }
        String[] romanNumber ={"M", "CM", "D", "CD", "C", "XC", "L", "XL", "X", "IX", "V", "IV", "I"};
        int [] arabicNumber = {1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1};
        StringBuilder numberRoma1 =new StringBuilder();
        int i =0;
        while (n >0){
            while (n >= arabicNumber[i]){
                numberRoma1.append(romanNumber[i]);
                n -= arabicNumber[i];
            }
            i++;
        }
        return numberRoma1.toString();
    }
}
```y esta es la parte de los tests

```java
package com.platzi.javatest.util.reto3;
import org.junit.jupiter.api.Test;
import static com.platzi.javatest.util.reto3.RomanNumerals.*;
import static org.hamcrest.CoreMatchers.*;
import static org.hamcrest.MatcherAssert.assertThat;


class RomanNumeralsTest {
    @Test
    void numbers_to_arabic_to_roman() {
        assertThat(arabicToRoman(1), is("I"));
    }
    @Test
    void numbers_to_arabic_to_roman2() {
        assertThat(arabicToRoman(2), is("II"));
    }

    @Test
    void numbers_to_arabic_to_roman126() {
        assertThat(arabicToRoman(126), is("CXXVI"));
    }

    @Test
    void numbers_to_arabic_to_roman56() {
        assertThat(arabicToRoman(56), is("LVI"));
    }

    @Test
    void  numbers_to_arabic_to_roman2507() {
        assertThat(arabicToRoman(2507),is("MMDVII"));
    }
}

Harrison Martinez

Luego de mucho analisis lo logre! buen ejercicio para entrenar la logica, la clave para mi estaba en entender como va el patron de conversión de numeros enteros a numeros romanos, antes de escribir culquier linea de codigo, luego de encontrar el patron si comence con el algoritmo, modularice la funcionalidad para no cargar toda la logica en la función principal arabicToRoman el codigo por ahora solo transforma numeros del 1 (I) al 3999 (MMMCMXCIX), se puede seguir desarrollando para agregar mas pero por ahora lo deje asi, tambien controla que los numeros sean mayores a 0, ahora la clase RomanNumerals:

package com.platzi.javatest.reto2;

public class RomanNumerals {

    public static String arabicToRoman(int n){
        String numeroRomanoFinal = "";

        if (n <= 0){
            numeroRomanoFinal = "Error";
        }else if (Integer.toString(n).length() == 1){
            numeroRomanoFinal = evaluaDecimal(n);
        }else {
            while (n > 0) {
                int fraccionDecimal = numeroDecimalRestar(n);
                String fraccionRomana = evaluaDecimal(fraccionDecimal);
                numeroRomanoFinal = numeroRomanoFinal + fraccionRomana;
                n = n - fraccionDecimal;
            }
        }

        return numeroRomanoFinal;
    }

    public static Integer numeroDecimalRestar(int n){
        char[] arrayNumeroSeparado = Integer.toString(n).toCharArray();
        char primerNumero = arrayNumeroSeparado[0];
        int cantidadCeros = arrayNumeroSeparado.length - 1;
        int auxcantidadCeros = cantidadCeros;
        String ceros = "";
        while (auxcantidadCeros > 0){
            ceros = ceros + "0";
            auxcantidadCeros--;
        }
        String numeroDecimal = primerNumero + ceros;

        return Integer.parseInt(numeroDecimal);
    }

    public static String evaluaDecimal(int n){
        String numeroRomano = "";
        switch (n){
            case 1:
                numeroRomano = "I";
                break;
            case 2:
                numeroRomano = "II";
                break;
            case 3:
                numeroRomano = "III";
                break;
            case 4:
                numeroRomano = "IV";
                break;
            case 5:
                numeroRomano = "V";
                break;
            case 6:
                numeroRomano = "VI";
                break;
            case 7:
                numeroRomano = "VII";
                break;
            case 8:
                numeroRomano = "VIII";
                break;
            case 9:
                numeroRomano = "IX";
                break;
            case 10:
                numeroRomano = "X";
                break;
            case 20:
                numeroRomano = "XX";
                break;
            case 30:
                numeroRomano = "XXX";
                break;
            case 40:
                numeroRomano = "XL";
                break;
            case 50:
                numeroRomano = "L";
                break;
            case 60:
                numeroRomano = "LX";
                break;
            case 70:
                numeroRomano = "LXX";
                break;
            case 80:
                numeroRomano = "LXXX";
                break;
            case 90:
                numeroRomano = "XC";
                break;
            case 100:
                numeroRomano = "C";
                break;
            case 200:
                numeroRomano = "CC";
                break;
            case 300:
                numeroRomano = "CCC";
                break;
            case 400:
                numeroRomano = "CD";
                break;
            case 500:
                numeroRomano = "D";
                break;
            case 600:
                numeroRomano = "DC";
                break;
            case 700:
                numeroRomano = "DCC";
                break;
            case 800:
                numeroRomano = "DCC";
                break;
            case 900:
                numeroRomano = "CM";
                break;
            case 1000:
                numeroRomano = "M";
                break;
            case 2000:
                numeroRomano = "MM";
                break;
            case 3000:
                numeroRomano = "MMM";
                break;
        }
        return numeroRomano;
    }
}

Ahora la clase de test:

package com.platzi.javatest.reto2;

import org.junit.Test;

import static org.junit.Assert.*;

public class RomanNumeralsTest {

    @Test
    public void return_I_when_number_is_1(){
        assertEquals("I", RomanNumerals.arabicToRoman(1));
    }

    @Test
    public void return_II_when_number_is_2(){
        assertEquals("II", RomanNumerals.arabicToRoman(2));
    }

    @Test
    public void return_III_when_number_is_3(){
        assertEquals("III", RomanNumerals.arabicToRoman(3));
    }

    @Test
    public void return_V_when_number_is_5(){
        assertEquals("V", RomanNumerals.arabicToRoman(5));
    }

    @Test
    public void return_VI_when_number_is_6(){
        assertEquals("VI", RomanNumerals.arabicToRoman(6));
    }

    @Test
    public void return_VII_when_number_is_7(){
        assertEquals("VII", RomanNumerals.arabicToRoman(7));
    }

    @Test
    public void return_X_when_number_is_10(){
        assertEquals("X", RomanNumerals.arabicToRoman(10));
    }

    @Test
    public void return_XCIX_when_number_is_99(){
        assertEquals("XCIX", RomanNumerals.arabicToRoman(99));
    }

    @Test
    public void return_MMMCMXCIX_when_number_is_3999(){
        assertEquals("MMMCMXCIX", RomanNumerals.arabicToRoman(3999));
    }

    @Test
    public void return_MDCCXXXVIII_when_number_is_1738(){
        assertEquals("MDCCXXXVIII", RomanNumerals.arabicToRoman(1738));
    }

    @Test
    public void return_CMXLIII_when_number_is_943(){
        assertEquals("CMXLIII", RomanNumerals.arabicToRoman(943));
    }

    @Test
    public void return_Error_when_number_is_0(){
        assertEquals("Error", RomanNumerals.arabicToRoman(0));
    }

    @Test
    public void return_Error_when_number_is_negative(){
        assertEquals("Error", RomanNumerals.arabicToRoman(-56));
    }
}

Eduardo Pérez

Hola, quiero aportar dos observaciones:

Tu programa contempla muchos factores lo cual considero excelente, compruebas si se ingresa un cero o un número negativo o un número mayor al 3999, has pensando en un control de errores y pruebas unitarias muy completas, te felicito por ello.

Por otro lado considero que el algoritmo se volvio un poco extenso y puedes simplificarlo a un más sin perder la escencia de todo lo que has hecho. Hay otras formas de lograrlo que puedan disminuir el código escrito para hacerlo más simplificado.

Nahuel Matias Regueira

public class FizzBuzz {

    public static String comprueba (Integer num){
        if ((num%5==0)&&(num%3==0)){return "FIZZBUZZ";}
        if ((num%3==0)){return "FIZZ";}
        if ((num%5==0)){return "BUZZ";}

        return (num.toString());
    }

}

public class FizzBuzzTest {

    @Test
    public void fizzbuzz_3(){assertEquals("FIZZ", FizzBuzz.comprueba(3)); }
    @Test
    public void fizzbuzz_6(){
        assertEquals("FIZZ", FizzBuzz.comprueba(6));
    }
    @Test
    public void fizzbuzz_5(){
        assertEquals("BUZZ", FizzBuzz.comprueba(5));
    }
    @Test
    public void fizzbuzz_10(){
        assertEquals("BUZZ", FizzBuzz.comprueba(10));
    }
    @Test
    public void fizzbuzz_15(){
        assertEquals("FIZZBUZZ", FizzBuzz.comprueba(15));
    }
    @Test
    public void fizzbuzz_30(){
        assertEquals("FIZZBUZZ", FizzBuzz.comprueba(30));
    }
    @Test
    public void fizzbuzz_2(){
        assertEquals("2", FizzBuzz.comprueba(2));
    }
    @Test
    public void fizzbuzz_16(){
        assertEquals("16", FizzBuzz.comprueba(16));
    }

}

Cesar David Ramírez Dimaté

Una forma más limpia para que hagas tu código es la siguiente:

FizzBuzz.java

package com.platzi.javatests.fizzbuzz;

public class FizzBuzz {

  public static String fizzBuzz(int num) {
  if (num % 3 == 0 && num % 5 == 0) return "FizzBuzz";
  if (num % 3 == 0) return "Fizz";
  if (num % 5 == 0) return "Buzz";
  return String.valueOf(num);
  }
}

FizzBuzzShould.java

package com.platzi.javatests.fizzbuzz;

import org.junit.Test;

import static org.hamcrest.CoreMatchers.is;
import static org.junit.Assert.*;

public class FizzBuzzShould {
  /**
   * If the number is divisible by 3, it's "Fizz".
   * If the number is divisible by 5, it's "Buzz".
   * If the number is divisible by 3 and by 5, it's "FizzBuzz".
   */

  @Test
  public void returnFizz_whenTheNumberIsDivisibleBy3() {
    assertThat(FizzBuzz.fizzBuzz(3), is("Fizz"));
    assertThat(FizzBuzz.fizzBuzz(3627), is("Fizz"));
    assertThat(FizzBuzz.fizzBuzz(2553), is("Fizz"));
  }

  @Test
  public void returnBuzz_whenTheNumberIsDivisibleBy5() {
    assertThat(FizzBuzz.fizzBuzz(5), is("Buzz"));
    assertThat(FizzBuzz.fizzBuzz(32870), is("Buzz"));
    assertThat(FizzBuzz.fizzBuzz(7160), is("Buzz"));
  }

  @Test
  public void returnFizzBuzz_whenTheNumberIsDivisibleBy3AndBy5() {
    assertThat(FizzBuzz.fizzBuzz(15), is("FizzBuzz"));
    assertThat(FizzBuzz.fizzBuzz(2550), is("FizzBuzz"));
    assertThat(FizzBuzz.fizzBuzz(495), is("FizzBuzz"));
  }

  @Test
  public void returnNumberInString_whenTheNumberIsNotDivisibleBy3OrBy5() {
    assertThat(FizzBuzz.fizzBuzz(7), is("7"));
    assertThat(FizzBuzz.fizzBuzz(2), is("2"));
    assertThat(FizzBuzz.fizzBuzz(16), is("16"));
  }
}

Gabriel Antonio Macavilca Almanza

package com.platzi.javatests.challenges;

public class FizzBuzz {

    public static String fizzBuzz(int n){

        String result = "";

        if ( n % 3 == 0 && n % 5 == 0){
            result = "FizzBuzz";
        } else if ( n % 3 == 0 ) {
            result = "Fizz";
        } else if (n % 5 == 0){
            result = "Buzz";
        } else {
            result = String.valueOf(n);
        }

        return result;
    }
}

package com.platzi.javatests.challenges;

public class RomanNumerals {

    public static String arabicToRoman(int n) {

        int i, miles, centenas, decenas, unidades;
        String romano = "";
        //obtenemos cada cifra del número
        miles = n / 1000;
        centenas = n / 100 % 10;
        decenas = n / 10 % 10;
        unidades = n % 10;

        //millar
        for (i = 1; i <= miles; i++) {
            romano = romano + "M";
        }

        //centenas
        if (centenas == 9) {
            romano = romano + "CM";
        } else if (centenas >= 5) {
            romano = romano + "D";
            for (i = 6; i <= centenas; i++) {
                romano = romano + "C";
            }
        } else if (centenas == 4) {
            romano = romano + "CD";
        } else {
            for (i = 1; i <= centenas; i++) {
                romano = romano + "C";
            }
        }

        //decenas
        if (decenas == 9) {
            romano = romano + "XC";
        } else if (decenas >= 5) {
            romano = romano + "L";
            for (i = 6; i <= decenas; i++) {
                romano = romano + "X";
            }
        } else if (decenas == 4) {
            romano = romano + "XL";
        } else {
            for (i = 1; i <= decenas; i++) {
                romano = romano + "X";
            }
        }

        //unidades
        if (unidades == 9) {
            romano = romano + "IX";
        } else if (unidades >= 5) {
            romano = romano + "V";
            for (i = 6; i <= unidades; i++) {
                romano = romano + "I";
            }
        } else if (unidades == 4) {
            romano = romano + "IV";
        } else {
            for (i = 1; i <= unidades; i++) {
                romano = romano + "I";
            }
        }
        return romano;

    }

}

WILMAR ARLEY ZAPATA VILLA

Muy bueno, requería buena lógica, felicitaciones, a mi no se me ocurrió sino ir a buscar una solución...

Wilmer Arnulfo Rivera Dueñas

Buena solución

public class RomanNumerals {

	private static String romanOne = "I";
	private static String romanFive = "V";
	private static String romanTen = "X";
	private static String romanFifty = "L";
	private static String romanHundred = "C";
	private static String romanFiveHundred = "D";
	private static String romanThounsand = "M";
	private static String romanNumeralResult = "";

	public static String arabicToRoman(int n) {

		if(n >= 1000 && n < 4000) {
			appendRomanNumeral(romanThounsand);
			arabicToRoman(n - 1000);
		}
		if(n >= 900 && n < 1000) {
			appendRomanNumeral(romanHundred + romanThounsand);
			arabicToRoman(n - 900);
		}
		if(n >= 500 && n < 900){
			appendRomanNumeral(romanFiveHundred);
			arabicToRoman(n - 500);
		}
		if(n >= 400 && n < 500) {
			appendRomanNumeral(romanHundred + romanFiveHundred);
			arabicToRoman(n - 400);
		}
		if(n >= 100 && n < 400) {
			appendRomanNumeral(romanHundred);
			arabicToRoman(n - 100);
		}
		if(n >= 90 && n < 100) {
			appendRomanNumeral(romanTen + romanHundred);
			arabicToRoman(n - 90);
		}
		if(n >= 50 && n < 90) {
			appendRomanNumeral(romanFifty);
			arabicToRoman(n - 50);
		}
		if(n >= 40 && n < 50) {
			appendRomanNumeral(romanTen + romanFifty);
			arabicToRoman(n - 40);
		}
		if(n >= 10 && n < 40) {
			appendRomanNumeral(romanTen);
			arabicToRoman(n - 10);
		}
		if(n == 9) {
			appendRomanNumeral(romanOne + romanTen);
			arabicToRoman(n - 9);
		}
		if(n >= 5 && n < 9) {
			appendRomanNumeral(romanFive);
			arabicToRoman(n - 5);
		}
		if(n == 4) {
			appendRomanNumeral(romanOne + romanFive);
			arabicToRoman(n - 4);
		}
		if(n >= 1 && n < 4) {
			appendRomanNumeral(romanOne);
			arabicToRoman(n - 1);
		}
		return romanNumeralResult;
	}

	private static void appendRomanNumeral(String romanNumeral) {
		romanNumeralResult += romanNumeral;
	}

	public static void cleanRomanNumeral() {
		romanNumeralResult = "";
	}
}

package com.platzi.javatests.reto2;

public class RomanNumerals {
    public static String arabicToRoman(int n) {

        int aux, contador = 0, factor, descomponer;
        String individual = "", total="";

        aux = n;

        while(aux!=0){

            aux = aux/ 10;
            contador++;

        }

        factor = (int) Math.pow(10, (contador-1));

        while(factor!=0){

            n = (int) (n%(Math.pow(10, contador)));

            descomponer = (n/factor)*factor;

            System.out.println("numero: " + descomponer);

            contador--;

            factor = factor/10;

            switch (descomponer){
                case 0: individual = "";
                    break;
                case 1: individual = "I";
                    break;
                case 2: individual = "II";
                    break;
                case 3: individual = "III";
                    break;
                case 4: individual = "IV";
                    break;
                case 5: individual = "V";
                    break;
                case 6: individual = "VI";
                    break;
                case 7: individual = "VII";
                    break;
                case 8: individual = "VIII";
                    break;
                case 9: individual = "IX";
                    break;
                case 10: individual = "X";
                    break;
                case 20: individual = "XX";
                    break;
                case 30: individual = "XXX";
                    break;
                case 40: individual = "XL";
                    break;
                case 50: individual = "L";
                    break;
                case 60: individual = "LX";
                    break;
                case 70: individual = "LXX";
                    break;
                case 80: individual = "LXXX";
                    break;
                case 90: individual = "XC";
                    break;
                case 100: individual = "C";
                    break;
                case 200: individual = "CC";
                    break;
                case 300: individual = "CCC";
                    break;
                case 400: individual = "CD";
                    break;
                case 500: individual = "D";
                    break;
                case 600: individual = "DC";
                    break;
                case 700: individual = "DCC";
                    break;
                case 800: individual = "DCCC";
                    break;
                case 900: individual = "CM";
                    break;
                case 1000: individual = "M";
                    break;
                case 2000: individual = "MM";
                    break;
                case 3000: individual = "MMM";
                    break;
            }

            total = total+individual;

        }

        return total;

    }
}

package com.platzi.javatests.reto2;

import org.junit.Test;

import static org.hamcrest.CoreMatchers.is;
import static org.junit.Assert.*;

public class RomanNumeralsShould {

    @Test
    public void when_number_is_1() {
        assertThat(RomanNumerals.arabicToRoman(1), is("I"));
    }

    @Test
    public void when_number_is_2() {
        assertThat(RomanNumerals.arabicToRoman(2), is("II"));
    }

    @Test
    public void when_number_is_3() {
        assertThat(RomanNumerals.arabicToRoman(3), is("III"));
    }

    @Test
    public void when_number_is_4() {
        assertThat(RomanNumerals.arabicToRoman(4), is("IV"));
    }

    @Test
    public void when_number_is_5() {
        assertThat(RomanNumerals.arabicToRoman(5), is("V"));
    }

    @Test
    public void when_number_is_6() {
        assertThat(RomanNumerals.arabicToRoman(6), is("VI"));
    }

    @Test
    public void when_number_is_7() {
        assertThat(RomanNumerals.arabicToRoman(7), is("VII"));
    }

    @Test
    public void when_number_is_8() {
        assertThat(RomanNumerals.arabicToRoman(8), is("VIII"));
    }

    @Test
    public void when_number_is_9() {
        assertThat(RomanNumerals.arabicToRoman(9), is("IX"));
    }

    @Test
    public void when_number_is_10() {
        assertThat(RomanNumerals.arabicToRoman(10), is("X"));
    }

    @Test
    public void when_number_is_11() {
        assertThat(RomanNumerals.arabicToRoman(11), is("XI"));
    }

    @Test
    public void when_number_is_14() {
        assertThat(RomanNumerals.arabicToRoman(14), is("XIV"));
    }

    @Test
    public void when_number_is_15() {
        assertThat(RomanNumerals.arabicToRoman(15), is("XV"));
    }

    @Test
    public void when_number_is_16() {
        assertThat(RomanNumerals.arabicToRoman(16), is("XVI"));
    }

    @Test
    public void when_number_is_19() {
        assertThat(RomanNumerals.arabicToRoman(19), is("XIX"));
    }

    @Test
    public void when_number_is_24() {
        assertThat(RomanNumerals.arabicToRoman(24), is("XXIV"));
    }

    @Test
    public void when_number_is_40() {
        assertThat(RomanNumerals.arabicToRoman(40), is("XL"));
    }

    @Test
    public void when_number_is_49() {
        assertThat(RomanNumerals.arabicToRoman(49), is("XLIX"));
    }

    @Test
    public void when_number_is_50() {
        assertThat(RomanNumerals.arabicToRoman(50), is("L"));
    }

    @Test
    public void when_number_is_51() {
        assertThat(RomanNumerals.arabicToRoman(51), is("LI"));
    }

    @Test
    public void when_number_is_55() {
        assertThat(RomanNumerals.arabicToRoman(55), is("LV"));
    }

    @Test
    public void when_number_is_56() {
        assertThat(RomanNumerals.arabicToRoman(56), is("LVI"));
    }

    @Test
    public void when_number_is_60() {
        assertThat(RomanNumerals.arabicToRoman(60), is("LX"));
    }

    @Test
    public void when_number_is_70() {
        assertThat(RomanNumerals.arabicToRoman(70), is("LXX"));
    }

    @Test
    public void when_number_is_80() {
        assertThat(RomanNumerals.arabicToRoman(80), is("LXXX"));
    }

    @Test
    public void when_number_is_81() {
        assertThat(RomanNumerals.arabicToRoman(81), is("LXXXI"));
    }

    @Test
    public void when_number_is_85() {
        assertThat(RomanNumerals.arabicToRoman(85), is("LXXXV"));
    }

    @Test
    public void when_number_is_86() {
        assertThat(RomanNumerals.arabicToRoman(86), is("LXXXVI"));
    }

    @Test
    public void when_number_is_90() {
        assertThat(RomanNumerals.arabicToRoman(90), is("XC"));
    }

    @Test
    public void when_number_is_99() {
        assertThat(RomanNumerals.arabicToRoman(99), is("XCIX"));
    }

    @Test
    public void when_number_is_126() {
        assertThat(RomanNumerals.arabicToRoman(126), is("CXXVI"));
    }

    @Test
    public void when_number_is_400() {
        assertThat(RomanNumerals.arabicToRoman(400), is("CD"));
    }

    @Test
    public void when_number_is_900() {
        assertThat(RomanNumerals.arabicToRoman(900), is("CM"));
    }

    @Test
    public void when_number_is_2507() {
        assertThat(RomanNumerals.arabicToRoman(2507), is("MMDVII"));
    }
}```

Ricardo Barrera Quijano

Reto #1:

public class FizzBuzz {
    public static String fizzBuzz(int num){
        return (num % 3) + (num % 5) == 0 ?  "FizzBuzz" : num % 3 == 0 ? "Fizz" : num % 5 ==0 ? "Buzz": num+"";
    }
}

Jose Alexis Vazquez Morales

Reto extra: RomanNumerals

public class RomanNumerals {

    public static String arabicToRoman(int number) {

        StringBuilder romanNumber = new StringBuilder();

        final int ARABIC_NUMBER_1    = 1;
        final int ARABIC_NUMBER_5    = 5;
        final int ARABIC_NUMBER_10   = 10;
        final int ARABIC_NUMBER_50   = 50;
        final int ARABIC_NUMBER_100  = 100;
        final int ARABIC_NUMBER_500  = 500;
        final int ARABIC_NUMBER_1000 = 1000;

        final String ROMAN_NUMBER_I = "I";
        final String ROMAN_NUMBER_V = "V";
        final String ROMAN_NUMBER_X = "X";
        final String ROMAN_NUMBER_L = "L";
        final String ROMAN_NUMBER_C = "C";
        final String ROMAN_NUMBER_D = "D";
        final String ROMAN_NUMBER_M = "M";

        while (number > 0) {

            if (number >= ARABIC_NUMBER_1000) { //miles OK
                number -= ARABIC_NUMBER_1000;
                romanNumber.append(ROMAN_NUMBER_M);
            } else if (number >= 900) {
                number -= 900;
                romanNumber.append(ROMAN_NUMBER_C);
                romanNumber.append(ROMAN_NUMBER_M);
            } else if (number >= ARABIC_NUMBER_500) { //quinientos OK
                number -= ARABIC_NUMBER_500;
                romanNumber.append(ROMAN_NUMBER_D);
            } else if (number >=400) {
                number -= 400;
                romanNumber.append(ROMAN_NUMBER_C);
                romanNumber.append(ROMAN_NUMBER_D);
            } else if (number >= ARABIC_NUMBER_100) { //cientos OK
                number -= ARABIC_NUMBER_100;
                romanNumber.append(ROMAN_NUMBER_C);
            } else if (number >= 90) {
                number -= 90;
                romanNumber.append(ROMAN_NUMBER_X);
                romanNumber.append(ROMAN_NUMBER_C);
            } else if (number >= ARABIC_NUMBER_50) { //cincuentas OK
                number -= ARABIC_NUMBER_50;
                romanNumber.append(ROMAN_NUMBER_L);
            } else if (number >= 40) {
                number -= 40;
                romanNumber.append(ROMAN_NUMBER_X);
                romanNumber.append(ROMAN_NUMBER_L);
            } else if (number >= ARABIC_NUMBER_10) { //decenas OK
                number -= ARABIC_NUMBER_10;
                romanNumber.append(ROMAN_NUMBER_X);
            } else if (number >= 9) {
                number -= 9;
                romanNumber.append(ROMAN_NUMBER_I);
                romanNumber.append(ROMAN_NUMBER_X);
            } else if (number >= ARABIC_NUMBER_5) { //cincos OK
                number -= ARABIC_NUMBER_5;
                romanNumber.append(ROMAN_NUMBER_V);
            } else if (number >= 4) {
                number -= 4;
                romanNumber.append(ROMAN_NUMBER_I);
                romanNumber.append(ROMAN_NUMBER_V);
            } else {
                number -= ARABIC_NUMBER_1;
                romanNumber.append(ROMAN_NUMBER_I);
            }
        }

        return romanNumber.toString().toString();
    }
}

RomanNumeralsShould

class RomanNumeralsShould {

    @Test
    public void be_I_when_the_input_is_one() {
        assertEquals("I",RomanNumerals.arabicToRoman(1));
    }

    @Test
    public void be_II_when_the_input_is_two() {
        assertEquals("II",RomanNumerals.arabicToRoman(2));
    }

    @Test
    public void be_III_when_the_input_is_three() {
        assertEquals("III",RomanNumerals.arabicToRoman(3));
    }

    @Test
    public void be_V_when_the_input_is_five() {
        assertEquals("V",RomanNumerals.arabicToRoman(5));
    }

    @Test
    public void be_VI_when_the_input_is_six() {
        assertEquals("VI",RomanNumerals.arabicToRoman(6));
    }

    @Test
    public void be_VII_when_the_input_is_seven() {
        assertEquals("VII",RomanNumerals.arabicToRoman(7));
    }

    @Test
    public void be_X_when_the_input_is_ten() {
        assertEquals("X",RomanNumerals.arabicToRoman(10));
    }

    @Test
    public void be_XI_when_the_input_is_eleven() {
        assertEquals("XI",RomanNumerals.arabicToRoman(11));
    }

    @Test
    public void be_XV_when_the_input_is_fiveteen() {
        assertEquals("XV",RomanNumerals.arabicToRoman(15));
    }

    @Test
    public void be_XVI_when_the_input_is_sixteen() {
        assertEquals("XVI",RomanNumerals.arabicToRoman(16));
    }

    @Test
    public void be_L_when_the_input_is_fivety() {
        assertEquals("L",RomanNumerals.arabicToRoman(50));
    }

    @Test
    public void be_LI_when_the_input_is_fivety_one() {
        assertEquals("LI",RomanNumerals.arabicToRoman(51));
    }

    @Test
    public void be_LV_when_the_input_is_fivety_five() {
        assertEquals("LV",RomanNumerals.arabicToRoman(55));
    }

    @Test
    public void be_LVI_when_the_input_is_fivety_six() {
        assertEquals("LVI",RomanNumerals.arabicToRoman(56));
    }

    @Test
    public void be_LX_when_the_input_is_sixty() {
        assertEquals("LX",RomanNumerals.arabicToRoman(60));
    }

    @Test
    public void be_LXX_when_the_input_is_seventy() {
        assertEquals("LXX",RomanNumerals.arabicToRoman(70));
    }

    @Test
    public void be_LXXX_when_the_input_is_eighty() {
        assertEquals("LXXX",RomanNumerals.arabicToRoman(80));
    }

    @Test
    public void be_LXXXI_when_the_input_is_eighty_one() {
        assertEquals("LXXXI",RomanNumerals.arabicToRoman(81));
    }

    @Test
    public void be_LXXXV_when_the_input_is_eighty_five() {
        assertEquals("LXXXV",RomanNumerals.arabicToRoman(85));
    }

    @Test
    public void be_LXXXVI_when_the_input_is_eighty_six() {
        assertEquals("LXXXVI",RomanNumerals.arabicToRoman(86));
    }

    @Test
    public void be_CXXVI_when_the_input_is_one_hundred_thenty_six() {
        assertEquals("CXXVI",RomanNumerals.arabicToRoman(126));
    }

    @Test
    public void be_MMDVII_when_the_input_is_two_thousand_five_hundred_seven() {
        assertEquals("MMDVII",RomanNumerals.arabicToRoman(2507));
    }

    @Test
    public void be_IV_when_the_input_is_four() {
        assertEquals("IV",RomanNumerals.arabicToRoman(4));
    }

    @Test
    public void be_IX_when_the_input_is_nine() {
        assertEquals("IX",RomanNumerals.arabicToRoman(9));
    }

    @Test
    public void be_XIV_when_the_input_is_fourteen() {
        assertEquals("XIV",RomanNumerals.arabicToRoman(14));
    }

    @Test
    public void be_XIX_when_the_input_is_nineteen() {
        assertEquals("XIX",RomanNumerals.arabicToRoman(19));
    }

    @Test
    public void be_XXIV_when_the_input_is_twenty_four() {
        assertEquals("XXIV",RomanNumerals.arabicToRoman(24));
    }

    @Test
    public void be_XL_when_the_input_is_fourty() {
        assertEquals("XL",RomanNumerals.arabicToRoman(40));
    }

    @Test
    public void be_XLIX_when_the_input_is_fourty_nine() {
        assertEquals("XLIX",RomanNumerals.arabicToRoman(49));
    }

    @Test
    public void be_XC_when_the_input_is_ninety() {
        assertEquals("XC",RomanNumerals.arabicToRoman(90));
    }

    @Test
    public void be_XCIX_when_the_input_is_ninety_nine() {
        assertEquals("XCIX",RomanNumerals.arabicToRoman(99));
    }

    @Test
    public void be_CD_when_the_input_is_four_hundred() {
        assertEquals("CD",RomanNumerals.arabicToRoman(400));
    }

    @Test
    public void be_CM_when_the_input_is_nine_hundred() {
        assertEquals("CM",RomanNumerals.arabicToRoman(900));
    }
}

Sergio

public class RomanNumber implements Comparable<RomanNumber>{
    private String romanNumber;
    private int arabicValue;
    private int cantRepetitions;

    public RomanNumber(String romanNumber, int arabicValue,int cantRepetitions) {
        this.romanNumber = romanNumber;
        this.arabicValue = arabicValue;
        this.cantRepetitions = cantRepetitions;
    }

    public String getRomanNumber() {
        return romanNumber;
    }

    public int getArabicValue() {
        return arabicValue;
    }

    @Override
    public int compareTo(RomanNumber comparator) {
        return comparator.getArabicValue();
    }

    public int getCantRepetitions() {
        return cantRepetitions;
    }

    public String toString(){
        return romanNumber;
    }

    public int getMaxCantValue(){
        return cantRepetitions * arabicValue;
    }
}

public class RomanNumerals {

    private final static List <RomanNumber> romanNumbers  = new ArrayList<>();
    private final static Map <String, RomanNumber> substractionRules = new HashMap<>();

    static {
        RomanNumber romanNumberI = new RomanNumber("I", 1, 3);
        RomanNumber romanNumberV = new RomanNumber("V", 5, 1);
        RomanNumber romanNumberX = new RomanNumber("X", 10, 3);
        RomanNumber romanNumberL = new RomanNumber("L", 50, 1);
        RomanNumber romanNumberC = new RomanNumber("C", 100, 3);
        RomanNumber romanNumberD = new RomanNumber("D", 500, 1);
        RomanNumber romanNumberM = new RomanNumber("M", 1000, 3);

        romanNumbers.add(romanNumberI);
        romanNumbers.add(romanNumberV);
        romanNumbers.add(romanNumberX);
        romanNumbers.add(romanNumberL);
        romanNumbers.add(romanNumberC);
        romanNumbers.add(romanNumberD);
        romanNumbers.add(romanNumberM);

        Collections.sort(romanNumbers,(x,y)-> x.getArabicValue() < y.getArabicValue() ? -1 : 1);

        substractionRules.put("V",romanNumberI);
        substractionRules.put("X",romanNumberI);
        substractionRules.put("L",romanNumberX);
        substractionRules.put("C",romanNumberX);
        substractionRules.put("D",romanNumberC);
        substractionRules.put("M",romanNumberC);
    }

    public static String arabicToRoman(int number){
        return arabicToRoman(number,new StringBuilder());
    }

    public static String arabicToRoman(int number,StringBuilder stringBuilder){
        RomanNumber maxRomanNumberRepresentation = getMaxRomanNumberRepresentation(number);
        if(maxRomanNumberRepresentation.getArabicValue() > number){
            RomanNumber substractionRomanNumber = substractionRules.get(maxRomanNumberRepresentation.getRomanNumber());
            int substraction = maxRomanNumberRepresentation.getArabicValue() - substractionRomanNumber.getArabicValue();
            if(number - substraction == 0)
                stringBuilder
                        .append(substractionRomanNumber.getRomanNumber())
                        .append(maxRomanNumberRepresentation.getRomanNumber());
            else{
                int maxCantValue = substractionRomanNumber.getMaxCantValue();
                if(maxCantValue < number && substraction < number){
                    stringBuilder
                            .append(substractionRomanNumber)
                            .append(maxRomanNumberRepresentation);
                    int result = number - maxRomanNumberRepresentation.getArabicValue() + substractionRomanNumber.getArabicValue();
                    if(result != 0)
                        arabicToRoman(result, stringBuilder);
                }else {
                    RomanNumber inmediateInferior = getInmediateInferior(maxRomanNumberRepresentation);
                    stringBuilder.append(inmediateInferior);
                    int result = number - inmediateInferior.getArabicValue();
                    if (result != 0)
                        arabicToRoman(result, stringBuilder);
                }
            }
        }else{
            int result = appendWhileMaxNumber(number, maxRomanNumberRepresentation, stringBuilder);
            if(result != 0)
                arabicToRoman(result,stringBuilder);
        }

        return stringBuilder.toString();
    }


    private static int appendWhileMaxNumber(int number,RomanNumber maxRomanNumberRepresentation,StringBuilder stringBuilder){
        int result = number;
        int maxCharacter = countCharacter(stringBuilder.toString(),maxRomanNumberRepresentation.getRomanNumber().toCharArray()[0]);
        if(number >= maxRomanNumberRepresentation.getArabicValue() && maxCharacter < maxRomanNumberRepresentation.getCantRepetitions() && number != 0){
            stringBuilder.append(maxRomanNumberRepresentation);
            result = number - maxRomanNumberRepresentation.getArabicValue();
        }
        return result;
    }

    private static int countCharacter(String str,char character){
        char[] chars = str.toCharArray();
        int count = 0;
        for (char aChar : chars) {
            if(aChar == character)
                count++;
        }
        return count;
    }

    private static RomanNumber getInmediateInferior(RomanNumber superior){
        RomanNumber result = superior;
        for (RomanNumber romanNumber : romanNumbers) {
            if(romanNumber.getArabicValue() < superior.getArabicValue())
                result = romanNumber;
        }
        return result;
    }

    private static RomanNumber getMaxRomanNumberRepresentation(int number,RomanNumber maxRomanNumberRepresentation){
        int maxCantNumber = maxRomanNumberRepresentation.getArabicValue() * maxRomanNumberRepresentation.getCantRepetitions();
        int resta = number - maxCantNumber;
        if(resta > 0){
            Optional<RomanNumber> first = romanNumbers
                    .stream()
                    .filter(rn -> rn.getArabicValue() > maxRomanNumberRepresentation.getArabicValue())
                    .findFirst();
            if(first.isPresent())
                return getMaxRomanNumberRepresentation(number,first.get());
            else return maxRomanNumberRepresentation;
        }else return maxRomanNumberRepresentation;
    }

    private static   RomanNumber getMaxRomanNumberRepresentation(int number) {
        RomanNumber romanNumberResult = null;
        for (RomanNumber romanNumber : romanNumbers) {
            if(romanNumber.getArabicValue() <= number)
                romanNumberResult = romanNumber;
        }
        return getMaxRomanNumberRepresentation(number,romanNumberResult);
    }
}

public class RomanNumeralsTest {

    @Test
    public void sum_roman_numbers_test_case(){
        String romanNumber1 = RomanNumerals.arabicToRoman(1);
        String romanNumber2 = RomanNumerals.arabicToRoman(2);
        String romanNumber3 = RomanNumerals.arabicToRoman(3);
        String romanNumber5 = RomanNumerals.arabicToRoman(5);
        String romanNumber6 = RomanNumerals.arabicToRoman(6);
        String romanNumber7= RomanNumerals.arabicToRoman(7);
        String romanNumberX= RomanNumerals.arabicToRoman(10);
        String romanNumberXI= RomanNumerals.arabicToRoman(11);
        String romanNumberXV= RomanNumerals.arabicToRoman(15);
        String romanNumberXVI= RomanNumerals.arabicToRoman(16);
        String romanNumberL = RomanNumerals.arabicToRoman(50);
        String romanNumberLVI = RomanNumerals.arabicToRoman(56);
        String romanNumberLX = RomanNumerals.arabicToRoman(60);
        String romanNumberLXX = RomanNumerals.arabicToRoman(70);
        String romanNumberLXXX = RomanNumerals.arabicToRoman(80);
        String romanNumberLXXXI = RomanNumerals.arabicToRoman(81);
        String romanNumberLXXXV = RomanNumerals.arabicToRoman(85);
        String romanNumberLXXXVI = RomanNumerals.arabicToRoman(86);
        String romanNumberCXXVI = RomanNumerals.arabicToRoman(126);
        String romanNumberMMDVII = RomanNumerals.arabicToRoman(2507);
        Assert.assertThat(romanNumber1,is("I"));
        Assert.assertThat(romanNumber2,is("II"));
        Assert.assertThat(romanNumber3,is("III"));
        Assert.assertThat(romanNumber5,is("V"));
        Assert.assertThat(romanNumber6,is("VI"));
        Assert.assertThat(romanNumber7,is("VII"));
        Assert.assertThat(romanNumberX,is("X"));
        Assert.assertThat(romanNumberXI,is("XI"));
        Assert.assertThat(romanNumberXV,is("XV"));
        Assert.assertThat(romanNumberXVI,is("XVI"));
        Assert.assertThat(romanNumberL,is("L"));
        Assert.assertThat(romanNumberLVI,is("LVI"));
        Assert.assertThat(romanNumberLX,is("LX"));
        Assert.assertThat(romanNumberLXX,is("LXX"));
        Assert.assertThat(romanNumberLXXX,is("LXXX"));
        Assert.assertThat(romanNumberLXXXI,is("LXXXI"));
        Assert.assertThat(romanNumberLXXXV,is("LXXXV"));
        Assert.assertThat(romanNumberLXXXVI,is("LXXXVI"));
        Assert.assertThat(romanNumberCXXVI,is("CXXVI"));
        Assert.assertThat(romanNumberMMDVII,is("MMDVII"));
    }

    @Test
    public void substraction_roman_numbers_test_case(){
        String romanNumberIV = RomanNumerals.arabicToRoman(4);
        String romanNumberIX = RomanNumerals.arabicToRoman(9);
        String romanNumberXIV = RomanNumerals.arabicToRoman(14);
        String romanNumberXIX = RomanNumerals.arabicToRoman(19);
        String romanNumberXXIV = RomanNumerals.arabicToRoman(24);
        String romanNumberXL= RomanNumerals.arabicToRoman(40);
        String romanNumberXLIX= RomanNumerals.arabicToRoman(49);
        String romanNumberXC= RomanNumerals.arabicToRoman(90);
        String romanNumberXXIX= RomanNumerals.arabicToRoman(99);
        String romanNumberCD= RomanNumerals.arabicToRoman(400);
        String romanNumberCM= RomanNumerals.arabicToRoman(900);
        Assert.assertThat(romanNumberIV,is("IV"));
        Assert.assertThat(romanNumberIX,is("IX"));
        Assert.assertThat(romanNumberXIV,is("XIV"));
        Assert.assertThat(romanNumberXIX,is("XIX"));
        Assert.assertThat(romanNumberXXIV,is("XXIV"));
        Assert.assertThat(romanNumberXL,is("XL"));
        Assert.assertThat(romanNumberXLIX,is("XLIX"));
        Assert.assertThat(romanNumberXC,is("XC"));
        Assert.assertThat(romanNumberXXIX,is("XCIX"));
        Assert.assertThat(romanNumberCD,is("CD"));
        Assert.assertThat(romanNumberCM,is("CM"));
    }
}

Jose Roberto Saavedra Carvajal

Mi solución de conversión a números romanos.

Clase RomanNumerals

private static List<String> startRomanNumbers = new ArrayList<String>();
    private static List<String> middleRomanNumbers = new ArrayList<String>();

    public RomanNumerals(){
        // números menores a 3 en tipificación de longitud
        startRomanNumbers.add("I"); // unidad
        startRomanNumbers.add("X"); // decena
        startRomanNumbers.add("C"); // centena
        startRomanNumbers.add("M"); // miles
        // números de 5 en longitud
        middleRomanNumbers.add("V"); // unidad
        middleRomanNumbers.add("L"); // decena
        middleRomanNumbers.add("D"); // centena
        middleRomanNumbers.add("V+"); // miles
    }

    public static String repeatCharacterNTimes(String character, int times){
        String newCharacter = "";
        for (int i = 0; i < times; i++) {
            newCharacter+=character;
        }
        return newCharacter;
    }

    public static String getNumber(int number, int position){
        if(number <= 3 && number > 0){
            return repeatCharacterNTimes(startRomanNumbers.get(position), number);
        }
        if(number == 4){
            return startRomanNumbers.get(position) + middleRomanNumbers.get(position);
        }
        if(number == 5){
            return middleRomanNumbers.get(position);
        }
        if(number <= 8 && number > 0){
            int numberLessThanFive = number - 5;
            return middleRomanNumbers.get(position) + repeatCharacterNTimes(startRomanNumbers.get(position), numberLessThanFive);
        }
        if(number == 9){
            return startRomanNumbers.get(position) + startRomanNumbers.get(position+1);
        }

        return "";
    }
    public static String arabicToRoman(int number) {
        String[] parts = String.valueOf(number).split("");
        if(number >= 10000 || number < 0){
            return "Error cantidad";
        }
        String romanNumber = "";
        int counter = (parts.length-1);
        for (int i = 0; i < parts.length; i++) {
            int num = Integer.parseInt(parts[i]);
            romanNumber += getNumber(num, counter);
            counter--;
        }
        return romanNumber;
    }

Clase de Test - RomanNumeralsTest

private RomanNumerals roman;
    /* función que convierta un número en el equivalente romano. */
    @Before
    public void setUp(){
        roman = new RomanNumerals();
    }

    @Test
    public void check_base_numbers(){
        Assert.assertThat(roman.arabicToRoman(1), is("I"));
        Assert.assertThat(roman.arabicToRoman(2), is("II"));
        Assert.assertThat(roman.arabicToRoman(3), is("III"));
        Assert.assertThat(roman.arabicToRoman(4), is("IV"));
        Assert.assertThat(roman.arabicToRoman(5), is("V"));
        Assert.assertThat(roman.arabicToRoman(6), is("VI"));
        Assert.assertThat(roman.arabicToRoman(7), is("VII"));
        Assert.assertThat(roman.arabicToRoman(8), is("VIII"));
        Assert.assertThat(roman.arabicToRoman(9), is("IX"));
        Assert.assertThat(roman.arabicToRoman(10), is("X"));
        Assert.assertThat(roman.arabicToRoman(50), is("L"));
        Assert.assertThat(roman.arabicToRoman(100), is("C"));
        Assert.assertThat(roman.arabicToRoman(1000), is("M"));
    }

    @Test
    public void check_random_numbers(){
        Assert.assertThat(roman.arabicToRoman(11), is("XI"));
        Assert.assertThat(roman.arabicToRoman(15), is("XV"));
        Assert.assertThat(roman.arabicToRoman(16), is("XVI"));
        Assert.assertThat(roman.arabicToRoman(51), is("LI"));
        Assert.assertThat(roman.arabicToRoman(55), is("LV"));
        Assert.assertThat(roman.arabicToRoman(56), is("LVI"));
        Assert.assertThat(roman.arabicToRoman(60), is("LX"));
        Assert.assertThat(roman.arabicToRoman(70), is("LXX"));
        Assert.assertThat(roman.arabicToRoman(80), is("LXXX"));
        Assert.assertThat(roman.arabicToRoman(81), is("LXXXI"));
        Assert.assertThat(roman.arabicToRoman(85), is("LXXXV"));
        Assert.assertThat(roman.arabicToRoman(86), is("LXXXVI"));
        Assert.assertThat(roman.arabicToRoman(126), is("CXXVI"));
        Assert.assertThat(roman.arabicToRoman(2507), is("MMDVII"));
    }

    @Test
    public void errorConvertNumber(){
        Assert.assertThat(roman.arabicToRoman(11000), is("Error cantidad"));
    }

Gracias.

Programación con TDD: Ejercicios FizzBuzz y Números Romanos

Bienvenida e Introducción

Testing en Java: JUnit, Mockito y TDD

Introducción a tests en software

Beneficios y tipos de tests automáticos y manuales en software

Preparación del IDE, proyecto y librerías

Uso de IntelliJ IDEA para Escribir y Probar Código Java

Creación de Tests Unitarios y Excepciones en Java

Escribir Tests en Java con JUnit: Instalación y Uso Básico

Organización de Tests en Funciones Separadas

Testing en Java con JUnit para Verificar Contraseñas

Simulación de Clases en Java con Moquito

Simulación de Pasarelas de Pago con Mockito

Organización y Mejora de Tests en jUnit

Función `isEmpty` y pruebas con JUnit en Java

TDD

Desarrollo Guiado por Pruebas (TDD): Conceptos y Ciclo Red-Green-Refactor

TDD para calcular años bisiestos en Java

Cálculo de Descuentos con Pruebas Unitarias en Java