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
package com.platzi.javatest.fizzbuzz;publicclassFizzBuzz{publicStringfizzBuzz(int n){String result ="";if(n%3==0) result +="Fizz";if(n%5==0) result +="Buzz";return result.isEmpty()?String.valueOf(n): result;}}
Acá te falto comprobar cuando un numero es divisible por tres y tambien por cinco. Su salida (FizzBuzz)
@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
publicclassRomanNumerals{enumRomanNumeral{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;}publicstaticList<RomanNumeral>getRomanNumerals(){returnArrays.asList(RomanNumeral.values());}}publicstaticStringarabicToRoman(int n){StringBuilder collator =newStringBuilder();List<RomanNumeral> romanNumerals=RomanNumeral.getRomanNumerals();//Valida que el número sea menor a 4000 debido a que el formato cambiaif(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{thrownewIllegalArgumentException( n +"no está en el rango (0,4000)");}}}
excelente solución! muy ingeniosa al no complicarse con los números que restan (prefijos, ej IV o IX). Pasó todas las pruebas jejeje
Muy buen aporte amigo, no sabia que podría ser más fácil con el uso del enum.
Reto # 2
Método refactorizado
publicstaticStringarabicToRoman(int n){String result ="";HashMap<String,Integer> romanNumerals =newLinkedHashMap(); 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
publicstaticStringarabicToRoman(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;}
publicstaticStringfizzBuzz(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 ;}
Reto #2
publicstaticStringarabicToRoman(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;}
publicclassRomanNumerals{publicstaticStringarabicToRoman(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;}}```
Estuve intentando hacerlo de forma más comprimida, pero hasta aquí llegué:
publicstaticStringarabicToRoman(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.
Practica 💻
Reto 1
package com.practicas.tdd;publicclassRomanNumerals{publicstaticStringarabicToRoman(int n){if(n ==1000){return"M";}elseif(n >1000){return"M"+arabicToRoman(n -1000);}if(n ==500){return"D";}elseif(n >500&& n <900){return"D"+arabicToRoman(n -500);}if(n ==100){return"C";}elseif(n >=400|| n >=900){return"C"+arabicToRoman(n +100);}elseif(n >100){return"C"+arabicToRoman(n -100);}if(n ==50){return"L";}elseif(n >50&& n <90){return"L"+arabicToRoman(n -50);}if(n ==10){return"X";}elseif(n >=40|| n >=90){return"X"+arabicToRoman(n +10);}elseif(n >10){return"X"+arabicToRoman(n -10);}if(n ==5){return"V";}elseif(n >5&& n !=9){return"V"+arabicToRoman(n -5);}if(n ==4|| n ==9){return"I"+arabicToRoman(n +1);}elseif(n >1){return"I"+arabicToRoman(n -1);}return"I";}}
Creo que hay un error en la parte de los números romanos:
esta esta mas fácil de entender para que no vueles mucho si recien empiezas
packagecom.platzi.javatest.util.reto3;publicclassRomanNumerals{publicstaticStringarabicToRoman(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 =newStringBuilder();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
packagecom.platzi.javatest.util.reto3;importorg.junit.jupiter.api.Test;importstaticcom.platzi.javatest.util.reto3.RomanNumerals.*;importstaticorg.hamcrest.CoreMatchers.*;importstaticorg.hamcrest.MatcherAssert.assertThat;classRomanNumeralsTest{@Testvoidnumbers_to_arabic_to_roman(){assertThat(arabicToRoman(1),is("I"));}@Testvoidnumbers_to_arabic_to_roman2(){assertThat(arabicToRoman(2),is("II"));}@Testvoidnumbers_to_arabic_to_roman126(){assertThat(arabicToRoman(126),is("CXXVI"));}@Testvoidnumbers_to_arabic_to_roman56(){assertThat(arabicToRoman(56),is("LVI"));}@Testvoidnumbers_to_arabic_to_roman2507(){assertThat(arabicToRoman(2507),is("MMDVII"));}}
Reto extra: Números Romanos
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:
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.
Una forma más limpia para que hagas tu código es la siguiente:
FizzBuzz.java
package com.platzi.javatests.fizzbuzz;publicclassFizzBuzz{publicstaticStringfizzBuzz(int num){if(num %3==0&& num %5==0)return"FizzBuzz";if(num %3==0)return"Fizz";if(num %5==0)return"Buzz";returnString.valueOf(num);}}
FizzBuzzShould.java
package com.platzi.javatests.fizzbuzz;import org.junit.Test;importstatic org.hamcrest.CoreMatchers.is;importstatic org.junit.Assert.*;publicclassFizzBuzzShould{/**
* 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".
*/ @TestpublicvoidreturnFizz_whenTheNumberIsDivisibleBy3(){assertThat(FizzBuzz.fizzBuzz(3),is("Fizz"));assertThat(FizzBuzz.fizzBuzz(3627),is("Fizz"));assertThat(FizzBuzz.fizzBuzz(2553),is("Fizz"));} @TestpublicvoidreturnBuzz_whenTheNumberIsDivisibleBy5(){assertThat(FizzBuzz.fizzBuzz(5),is("Buzz"));assertThat(FizzBuzz.fizzBuzz(32870),is("Buzz"));assertThat(FizzBuzz.fizzBuzz(7160),is("Buzz"));} @TestpublicvoidreturnFizzBuzz_whenTheNumberIsDivisibleBy3AndBy5(){assertThat(FizzBuzz.fizzBuzz(15),is("FizzBuzz"));assertThat(FizzBuzz.fizzBuzz(2550),is("FizzBuzz"));assertThat(FizzBuzz.fizzBuzz(495),is("FizzBuzz"));} @TestpublicvoidreturnNumberInString_whenTheNumberIsNotDivisibleBy3OrBy5(){assertThat(FizzBuzz.fizzBuzz(7),is("7"));assertThat(FizzBuzz.fizzBuzz(2),is("2"));assertThat(FizzBuzz.fizzBuzz(16),is("16"));}}
Reto #1
package com.platzi.javatests.challenges;publicclassFizzBuzz{publicstaticStringfizzBuzz(int n){String result ="";if( n %3==0&& n %5==0){ result ="FizzBuzz";}elseif( n %3==0){ result ="Fizz";}elseif(n %5==0){ result ="Buzz";}else{ result =String.valueOf(n);}return result;}}
Reto #2
package com.platzi.javatests.challenges;publicclassRomanNumerals{publicstaticStringarabicToRoman(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;//millarfor(i =1; i <= miles; i++){ romano = romano +"M";}//centenasif(centenas ==9){ romano = romano +"CM";}elseif(centenas >=5){ romano = romano +"D";for(i =6; i <= centenas; i++){ romano = romano +"C";}}elseif(centenas ==4){ romano = romano +"CD";}else{for(i =1; i <= centenas; i++){ romano = romano +"C";}}//decenasif(decenas ==9){ romano = romano +"XC";}elseif(decenas >=5){ romano = romano +"L";for(i =6; i <= decenas; i++){ romano = romano +"X";}}elseif(decenas ==4){ romano = romano +"XL";}else{for(i =1; i <= decenas; i++){ romano = romano +"X";}}//unidadesif(unidades ==9){ romano = romano +"IX";}elseif(unidades >=5){ romano = romano +"V";for(i =6; i <= unidades; i++){ romano = romano +"I";}}elseif(unidades ==4){ romano = romano +"IV";}else{for(i =1; i <= unidades; i++){ romano = romano +"I";}}return romano;}}
Muy bueno, requería buena lógica, felicitaciones, a mi no se me ocurrió sino ir a buscar una solución...
Buena solución
publicclassRomanNumerals{privatestaticString romanOne ="I";privatestaticString romanFive ="V";privatestaticString romanTen ="X";privatestaticString romanFifty ="L";privatestaticString romanHundred ="C";privatestaticString romanFiveHundred ="D";privatestaticString romanThounsand ="M";privatestaticString romanNumeralResult ="";publicstaticStringarabicToRoman(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;}privatestaticvoidappendRomanNumeral(String romanNumeral){ romanNumeralResult += romanNumeral;}publicstaticvoidcleanRomanNumeral(){ romanNumeralResult ="";}}
publicclassFizzBuzz{publicstaticStringfizzBuzz(int num){return(num %3)+(num %5)==0?"FizzBuzz": num %3==0?"Fizz": num %5==0?"Buzz": num+"";}}
Reto extra:
RomanNumerals
publicclassRomanNumerals{publicstaticStringarabicToRoman(int number){StringBuilder romanNumber =newStringBuilder(); 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 StringROMAN_NUMBER_I="I"; final StringROMAN_NUMBER_V="V"; final StringROMAN_NUMBER_X="X"; final StringROMAN_NUMBER_L="L"; final StringROMAN_NUMBER_C="C"; final StringROMAN_NUMBER_D="D"; final StringROMAN_NUMBER_M="M";while(number >0){if(number >=ARABIC_NUMBER_1000){//miles OK number -=ARABIC_NUMBER_1000; romanNumber.append(ROMAN_NUMBER_M);}elseif(number >=900){ number -=900; romanNumber.append(ROMAN_NUMBER_C); romanNumber.append(ROMAN_NUMBER_M);}elseif(number >=ARABIC_NUMBER_500){//quinientos OK number -=ARABIC_NUMBER_500; romanNumber.append(ROMAN_NUMBER_D);}elseif(number >=400){ number -=400; romanNumber.append(ROMAN_NUMBER_C); romanNumber.append(ROMAN_NUMBER_D);}elseif(number >=ARABIC_NUMBER_100){//cientos OK number -=ARABIC_NUMBER_100; romanNumber.append(ROMAN_NUMBER_C);}elseif(number >=90){ number -=90; romanNumber.append(ROMAN_NUMBER_X); romanNumber.append(ROMAN_NUMBER_C);}elseif(number >=ARABIC_NUMBER_50){//cincuentas OK number -=ARABIC_NUMBER_50; romanNumber.append(ROMAN_NUMBER_L);}elseif(number >=40){ number -=40; romanNumber.append(ROMAN_NUMBER_X); romanNumber.append(ROMAN_NUMBER_L);}elseif(number >=ARABIC_NUMBER_10){//decenas OK number -=ARABIC_NUMBER_10; romanNumber.append(ROMAN_NUMBER_X);}elseif(number >=9){ number -=9; romanNumber.append(ROMAN_NUMBER_I); romanNumber.append(ROMAN_NUMBER_X);}elseif(number >=ARABIC_NUMBER_5){//cincos OK number -=ARABIC_NUMBER_5; romanNumber.append(ROMAN_NUMBER_V);}elseif(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();}}
publicclassRomanNumberimplementsComparable<RomanNumber>{privateString romanNumber;private int arabicValue;private int cantRepetitions;publicRomanNumber(String romanNumber, int arabicValue,int cantRepetitions){this.romanNumber= romanNumber;this.arabicValue= arabicValue;this.cantRepetitions= cantRepetitions;}publicStringgetRomanNumber(){return romanNumber;}public int getArabicValue(){return arabicValue;} @Overridepublic int compareTo(RomanNumber comparator){return comparator.getArabicValue();}public int getCantRepetitions(){return cantRepetitions;}publicStringtoString(){return romanNumber;}public int getMaxCantValue(){return cantRepetitions * arabicValue;}}
publicclassRomanNumerals{private final staticList<RomanNumber> romanNumbers =newArrayList<>();private final staticMap<String,RomanNumber> substractionRules =newHashMap<>();static{RomanNumber romanNumberI =newRomanNumber("I",1,3);RomanNumber romanNumberV =newRomanNumber("V",5,1);RomanNumber romanNumberX =newRomanNumber("X",10,3);RomanNumber romanNumberL =newRomanNumber("L",50,1);RomanNumber romanNumberC =newRomanNumber("C",100,3);RomanNumber romanNumberD =newRomanNumber("D",500,1);RomanNumber romanNumberM =newRomanNumber("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);}publicstaticStringarabicToRoman(int number){returnarabicToRoman(number,newStringBuilder());}publicstaticStringarabicToRoman(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();}privatestatic 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;}privatestatic int countCharacter(String str,char character){ char[] chars = str.toCharArray(); int count =0;for(char aChar : chars){if(aChar == character) count++;}return count;}privatestaticRomanNumbergetInmediateInferior(RomanNumber superior){RomanNumber result = superior;for(RomanNumber romanNumber : romanNumbers){if(romanNumber.getArabicValue()< superior.getArabicValue()) result = romanNumber;}return result;}privatestaticRomanNumbergetMaxRomanNumberRepresentation(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())returngetMaxRomanNumberRepresentation(number,first.get());elsereturn maxRomanNumberRepresentation;}elsereturn maxRomanNumberRepresentation;}privatestaticRomanNumbergetMaxRomanNumberRepresentation(int number){RomanNumber romanNumberResult =null;for(RomanNumber romanNumber : romanNumbers){if(romanNumber.getArabicValue()<= number) romanNumberResult = romanNumber;}returngetMaxRomanNumberRepresentation(number,romanNumberResult);}}
privatestaticList<String> startRomanNumbers =newArrayList<String>();privatestaticList<String> middleRomanNumbers =newArrayList<String>();publicRomanNumerals(){// 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}publicstaticStringrepeatCharacterNTimes(String character, int times){String newCharacter ="";for(int i =0; i < times; i++){ newCharacter+=character;}return newCharacter;}publicstaticStringgetNumber(int number, int position){if(number <=3&& number >0){returnrepeatCharacterNTimes(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"";}publicstaticStringarabicToRoman(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
privateRomanNumerals roman;/* función que convierta un número en el equivalente romano. */ @BeforepublicvoidsetUp(){ roman =newRomanNumerals();} @Testpublicvoidcheck_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"));} @Testpublicvoidcheck_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"));} @TestpublicvoiderrorConvertNumber(){Assert.assertThat(roman.arabicToRoman(11000),is("Error cantidad"));}
