Ejercicio en Java de Programacion Avanzada UNLAM

PonyExpress.java

import org.junit.Assert;
import org.junit.jupiter.api.Test;

public class Pruebas 
{
	//Links de ayuda sobre el porque del redondeo de esa manera.
	//https://stackoverflow.com/questions/7139382/java-rounding-up-to-an-int-using-math-ceil
	//https://stackoverflow.com/questions/10444350/c-sharp-loss-of-precision-when-dividing-doubles
	/* Se parte del supuesto que el montaje y desmontaje de un caballo se puede realizar en el medio
	de la nada, no necesariamente se monta y desmonta en las estaciones unicamente, esto quiere decir
	que si tengo dos estaciones 75millas, 75millas, con el primer caballo avanzo las primeras 75 millas
	hasta la primera estacion, avanzo hasta las ultimas 25millas que es la capacidad maxima del caballo
	y en la milla 100(medio de la nada) cambio de caballo y recorro las ultimas 50 millas hasta la
	segunda estacion.
	*/
	/* Ademas tampoco se determinan con exactitud la maxima distancia entre estaciones, es decir
	obviamente va a ser un numero natural, pero podria ser 1000millas, 50000millas
	 
	*/
	/**
	 * @param estaciones es la distancia en millas de una estación hasta la otra
	 * @returns la cantidad de jinetes necesarios para enviar el correo desde un
	 * extremo hasta el otro del recorrido
	 */
	public static int jinetes2(int[] estaciones) 
	{
		int m = 0;
		for(int i:estaciones)
			m+=i;
		return (m+100-1)/100; 
	}
	
	/* Hago este metodo para que no me caguen jaja y digan que supuse mal en decir que
	 * el montaje puede ser en el medio de la nada. Este metodo tiene en cuenta que los
	 * montajes y desmontajes solo se pueden realizar en las estaciones.
	 * Esto tiene como limite (obvio) que las estaciones pueden estar separadas como mucho
	 * 100 millas que es la distancia maxima que puede recorrer un caballo.
	 */
	/**
	 * @param estaciones es la distancia en millas de una estación hasta la otra
	 * @returns la cantidad de jinetes necesarios para enviar el correo desde un
	 * extremo hasta el otro del recorrido
	 */
	public static int jinetes4(int[] estaciones) 
	{
		int m = 0;
		int c = 1;
		for(int i:estaciones)
			if((m+i)>100) {m = i; c++;} else m+=i;
		return c;
	}
	
	public static int jinetes(int [] e){
		double c=0;

		for(int i:e)
		c+=i;

		return (int)Math.ceil(c/100);
		}
	
	@Test
	public void Test1()
	{
		Assert.assertEquals(1, jinetes(new int[] {18, 15}));
	}

	@Test
	public void Test2()
	{
		Assert.assertEquals(2, jinetes(new int[] {43, 23, 40, 13}));
	}
	
	@Test
	public void Test3()
	{
		Assert.assertEquals(3, jinetes(new int[] {33, 8, 16, 47, 30, 30, 46}));
	}
	
	@Test
	public void Test4()
	{
		Assert.assertEquals(4, jinetes(new int[] {6, 24, 6, 8, 28, 8, 23, 47, 17, 29, 37, 18, 40, 49}));
	}
	
	@Test
	public void Test5()
	{
		Assert.assertEquals(1, jinetes(new int[] {100}));
	}
	
	@Test
	public void Test6()
	{
		Assert.assertEquals(2, jinetes(new int[] {75, 75, 25, 1}));
	}
	
	//Una sola estacion muy lejana desde el punto de partida.
	@Test
	public void Test7()
	{
		Assert.assertEquals(10, jinetes(new int[] {1000}));
	}
	
	//Estaciones muy lejanas entre si y con distancias no divisibles de 100.
	@Test
	public void Test8()
	{
		Assert.assertEquals(19, jinetes(new int[] {877, 999}));
	}
	
	//Una sola estacion a una milla. Test minimo.
	@Test
	public void Test9()
	{
		Assert.assertEquals(1, jinetes(new int[] {1}));
	}
	
	//Dos estaciones con distancia total de 101 milla.
	@Test
	public void Test10()
	{
		Assert.assertEquals(2, jinetes(new int[] {99, 2}));
	}
	
	public static int redondeo(int dividendo, int divisor)
	{
		return (dividendo%divisor != 0) ? (dividendo/divisor)+1 : (dividendo/divisor);
	}
	
	/**
	 * @param estaciones es la distancia en millas de una estación hasta la otra
	 * @returns la cantidad de jinetes necesarios para enviar el correo desde un
	 * extremo hasta el otro del recorrido
	 */
	public static int jinetes3(int[] estaciones) 
	{
		int millas = 0;
		int caballos = 0;
		for(int i : estaciones)
		{
			millas+=i;
			if(millas>100)
			{
				caballos+=redondeo(millas, 100);
				millas-=100*(millas/100);
			}
		}
		return (caballos<0)?1:caballos; 
	}
}