println("Hola, practiquemos con unos ejercicios")

// 1 ////////////////////////////////////////////////////////////////////////////////////////
//Necesitamos una función que imprima en una línea una secuencia separada por espacios como la siguiente:
//La secuencia debe imprimir hasta el elemento definido por el parámetro de entrada "length".
//El primer elemento es un parámetro de entrada opcional, debe ser 0 por defecto.
//El segundo elemento es un parámetro de entrada opcional, debe ser 1 por defecto.
//A partir del tercer elemento, el elemento se calcula como la suma de los 2 elementos anteriores.
def printLucasSequence(def inSeqLen, def inFirstParam, def inSecondParam) {
  
}
// Input: 8
// 0 1 1 2 3 5 8 13

// Input: 4, 2, 3
// 2 3 5 8


// 2 ////////////////////////////////////////////////////////////////////////////////////////
// Un parámetro de solicitud del servicio web del cliente debe tener 10 caracteres.
// Debe contener un ID de cliente, pero este ID no siempre tiene 10 caracteres.
// Por lo tanto, si es necesario, el ID debe ser completado con 0s a la izquierda.
// O si el ID es demasiado largo, se deben tomar los últimos 10 caracteres.

// Crear una función que tome el ID del cliente y devuelva la cadena de 10 caracteres formateada.
// IN:  ID del cliente como cadena.
// OUT: Cadena con caracteres de longitud.
def formatIdForRequest(def inId) {
    
}
// Input: 1234
// 0000001234


// 3 ////////////////////////////////////////////////////////////////////////////////////////
// La respuesta de un cliente de webservice contiene una lista de IDs de sus clientes.
// Los IDs válidos tienen el formato *****-NNNN con * una letra mayúscula y N un número

// Crear una función que valide el formato de los IDs y devuelva un mapa con 2 elementos
// IN:  Lista con los IDs como cadenas.
// OUT: Mapa con 2 elementos:
// El 1er elemento clave es "válido" y su valor es una lista de IDs válidos.
// El 2do elemento clave es "inválido" y su valor es una lista de IDs inválidos.
def getValidInvalidMap(def inList) {
    
}
// println(getValidInvalidMap(testList))
// Input: def idList = ["ABC-1234", "D4F4", "ZXY-0000", "123-ABCD", "65ad", "testing", "RTE-9876"]
// [valid:[ABC-1234, ZXY-0000, RTE-9876], invalid:[D4F4, 123-ABCD, 65ad, testing]]


// 4 ////////////////////////////////////////////////////////////////////////////////////////
// Crear un método que:
// imprima los IDs válidos y sus deudas sólo si la deuda es mayor o igual a 0 como:
// el id y "es nuestro propietario por" la cantidad de "millones de dólares".
// si la deuda es menor que 0, imprime el id y " parece que es nuestro prestamista :/ ."
// si no se encuentra un ID válido imprime el id y " ¡podría ser un cliente fantasma!"
// Los IDs de las deudas vienen como un mapa de entrada
// IN:  Mapa de ids válidos e inválidos devueltos por el método anterior.
// Mapa con los IDs como claves y las deudas como valores.
def getDebtOfIds(def inIdMap, def inDebtMap) {

}
//getDebtOfIds(getValidInvalidMap(testList), debtMap)
/*
Input: def inDebtMap = ["ABC-1234": -45, "ZXY-0000": 45.3]
ABC-1234 		parece que es nuestro prestamista :/ .
ZXY-0000 		es nuestro propietario por 45,3 millones de dólares.
¡RTE-9876 	¡podría ser un cliente fantasma!
*/