Suma de subconjuntos con Kotlin

¿De qué trata el programa -suma de subconjuntos- en Kotlin?

El programa recibe N cantidad de números enteros, los almacena en un slice o array, divide esa lista en dos subconjuntos, suma los valores de cada uno y al final del proceso el programa le dirá al usuario si la suma del subconjunto 1 es igual a la suma del subconjunto 2.




Código fuente:
/*
*    Autor:  Fixed Torres
*    Descp:  Se parte un conjunto de numeros en 2 y se suman los valores de cada
*            subconjunto, por ultimo se comparan para saber si son el mismo valor.
*/

fun sumSubConjunto1(conjunto: List<Int>, cantidad: Int): Int {
    var (sumsub, rebanada) = Pair(0, 0)
    rebanada = cantidad / 2
    (0..rebanada).forEach { it ->
        sumsub += conjunto.get(it)
    }
    return sumsub
}

fun sumSubConjunto2(conjunto: List<Int>, cantidad: Int): Int {
    var (sumsub, rebanada) = Pair(0, 0)
    rebanada = cantidad / 2 + 1
    (rebanada until cantidad).forEach { it ->
        sumsub += conjunto.get(it)
    }
    return sumsub
}

fun main(Args: Array<String>) {
    var conjunto = arrayListOf<Int>()
    var (item, cantidad) = Pair(0, 0)
    var (subsum1, subsum2) = Pair(0, 0)

    print("Ingrese la cantidad de elementos del conjunto: ")
    cantidad = readLine()?.toInt() as Int

    (1..cantidad).forEach {
        print("Ingrese el elemento #${it}: ")
        item = readLine()?.toInt() as Int
        conjunto.add(item)
    }

    subsum1 = sumSubConjunto1(conjunto, cantidad)
    subsum2 = sumSubConjunto2(conjunto, cantidad)

    if(subsum1 == subsum2) {
        println("La suma de los subconjuntos da el mismo resultado")
    } else {
        println("La suma de los subconjuntos da diferente resultado")
    }
}

Este programa es un poco extenso pero contiene conceptos nuevos como las listas (arrayList), las funciones, los argumentos a funciones y los retornos. Entre otros. Vamos paso a paso con breves explicaciones.

Función sumSubConjunto1, sumando el primer subconjunto:
fun sumSubconjunto1(conjunto: List<Int>, cantidad: Int): Int {
    var (sumsub, rebanada) = Pair(0, 0)
    rebanada = cantidad / 2
    (0..rebanada).forEach { it ->
        sumsub += conjunto.get(it)
    }
    return sumsub
}

La función sumSubConjunto1 básicamente lo que hace es procesar la mitad de los valores del conjunto que están ubicados entre el índice 0 y el índice cantidad / 2. Recibe recibe 2 argumentos, el primero es la lista de valores, el segundo es la cantidad de valores y retorna un número entero que corresponde a la suma de los valores. Las funciones en Kotlin tienen la siguiente estructura:

fun 'nombre' (argumento 1, argumento 2 ... argumento n): tipo de retorno {
    // Cuerpo de la funcion
    return valor
}
Declarando variables:
var (sumsub, rebanada) = Pair(0, 0)

Declaramos 2 variables inicializadas a cero, dichas variables se declaran usando la clase Pair()1 debido a que no se pueden realizar en una sola línea o asignación múltiple como en C++, Go, Groovy, Python y otros.

Partiendo el conjunto en 2:
rebanada = cantidad / 2

La variable rebanada va a almacenar el valor resultante de dividir por 2 la variable cantidad, este valor representa la mitad del conjunto de valores ingresados por el usuario.

Función .forReach {…}, procesando la información:
(0..rebanada).forEach { it ->
    sumsub += conjunto.get(it)
}

La función .forEach {} es parte de los que se conoce como Funciones de Orden Superior, itera sobre secuencia de elementos y rangos, en este caso va desde 0 hasta rebanada e incluye el último valor. La variable it que se encuentra antes del símbolo «->» es opcional siempre que sea el único parámetro existente. La línea sumsub += conjunto.get(it) es equivalente a sumsub = sumsub + conjunto.get(it), con el método .get() obtenemos el valor almacenado en el índice it el cual es sumado con el valor de sumsub.

Función sumSubConjunto2, sumando el segundo subconjunto:
fun sumSubconjunto2(conjunto: List<Int>, cantidad: Int): Int {
    var (sumsub, rebanada) = Pair(0, 0)
    rebanada = cantidad / 2 + 1
    (rebanada until cantidad).forEach { it ->
        print("${conjunto.get(it)} ")
        sumsub += conjunto.get(it)
    }
    return sumsub
}
Declarando variables:
var (sumsub, rebanada) = Pair(0, 0)

Declaramos 2 variables inicializadas a cero, dichas variables se declaran usando la clase Pair()1 debido a que no se pueden realizar en una sola línea o asignación múltiple como en C++, Go, Groovy, Python y otros.

Partiendo el conjunto en 2:
rebanada = cantidad / 2 + 1

La variable rebanada va a almacenar el valor resultante de dividir por 2 la variable cantidad y sumándole 1, este valor representa la otra mitad del conjunto de valores ingresados, iniciando en el siguiente índice.

Función .forReach {…}, procesando la información:
(rebanada until cantidad).forEach { it ->
    sumsub += conjunto.get(it)
}

La función .forEach {} en este caso va a itera sobre el rango de valores que va desde rebanada hasta cantidad sin incluir el último valor usando la palabra clave until. La variable it que se encuentra antes del símbolo «->», es opcional siempre que sea el único parámetro que existe. La línea sumsub += conjunto.get(it) es una suma equivalente a sumsub = sumsub + conjunto.get(it), con el método .get() obtenemos el valor almacenado en el índice it el cual es sumado con el valor de sumsub.


Función main():
fun main(Args: Array<String>) {
    var conjunto = arrayListOf<Int>()
    var (item, cantidad) = Pair(0, 0)
    var (subsum1, subsum2) = Pair(0, 0)

    print("Ingrese la cantidad de elementos del conjunto: ")
    cantidad = readLine()?.toInt() as Int

    (1..cantidad).forEach {
        print("Ingrese el elemento #${it}: ")
        item = readLine()?.toInt() as Int
        conjunto.add(item)
    }

    subsum1 = sumSubconjunto1(conjunto, cantidad)
    subsum2 = sumSubconjunto2(conjunto, cantidad)

    if(subsum1 == subsum2) {
        println("La suma de los subconjuntos da el mismo resultado")
    } else {
        println("La suma de los subconjuntos da diferente resultado")
    }
}

La función main() como en la mayoría de los lenguajes de programación, es la función principal. Es la única función que se ejecuta cuando el programa esta en ejecución y en su interior debe ir el bloque de código que procesa la información.

Declarando variables:
var conjunto = arrayListOf<Int>()
var (item, cantidad) = Pair(0, 0)
var (subsum1, subsum2) = Pair(0, 0)

Aquí ya se ve un concepto nuevo y corresponde a la creación de variables de tipo Array Dinámicos. Este tipo de Arrays son mutables, esto quiere decir que puede modificarse y se crean usando la clase arrayListOf  y entre un par de <…> va el tipo de dato que almacenará dicho array, ya sea Int, Long, String, Byte, etc. En la segunda y tercer línea se crean 4 variables usando la clase Pai()1 ya visto anteriormente y que fue marcada con un superíndice.

Clase Pair()1: desestructura dos valores recibidos como argumentos y los asigna a dos variables a su izquierda encerradas entre paréntesis (…). Existe una clase para el manejo de 3 valores, llamada Triple().

Solicitando e ingresando datos por teclado, función readLine():
print("Ingrese la cantidad de elementos del conjunto: ")
cantidad = readLine()?.toInt() as Int

La primera línea imprime un mensaje indicando al usuario que ingrese la cantidad de elementos que desea almacenar en el conjunto. La segunda línea se usa la función readLine() para ingresar datos por teclado, esto hace que el programa espere en pantalla hasta que el usuario escriba un valor y presione Enter; por último, dicho valor es convertido a tipo Int con la función .toInt() y es asignado a la variable cantidad, que será pasada como argumento a las dos funciones anteriormente mencionadas.

Función .forEach {…}, iterando para añadir los elementos al conjunto:
(1..cantidad).forEach {
    print("Ingrese el elemento #${it}: ")
    item = readLine()?.toInt() as Int
    conjunto.add(item)
}

La función .forEach {…} va a iterar desde 1 hasta el valor cantidad, si vale 5, entonces va a iterar 5 veces. En la segunda línea se imprime un mensaje indicando al usuario que ingrese el elemento #N, la expresión ${it} es reemplazada por un número del rango. En la tercera línea la función readLine() nos permite ingresar datos por teclado, luego se convierten a tipo Int usando la función .toInt() y se asigna a la variable item. Por último, vamos a ir agregando cada elemento ingresado por el usuario al array conjunto creado al principio con la clase arrayListOf usando el método .add(), el cual toma un valor y lo agrega al final del array.




Llamando a las funciones sumSubconjunto1 y sumSubconjunto2:
subsum1 = sumSubconjunto1(conjunto, cantidad)
subsum2 = sumSubconjunto2(conjunto, cantidad)

Recordemos que ambas funciones retornan un valor de tipo Int, dichos valores deben ser almacenados en variables del mismo tipo; las dos funciones reciben 2 argumento cada, el primero debe ser de tipo array y el segundo de tipo Int, asi que le pasamos el array conjunto y la variable cantidad. El resultado de cada función será almacenado en las variables subsum1 y subsum2.

Sentencia if(), comprobando la igualdad de ambos subconjuntos:
if(subsum1 == subsum2) {
    println("La suma de los subconjuntos da el mismo resultado")
} else {
    println("La suma de los subconjuntos da diferente resultado")
}

Este fragmento de código lo único que hace es comparar el valor de ambos subconjuntos y verificar si son iguales, de acuerdo al resultado de dicha comparación asimismo mismo se imprime un mensaje indicando si la suma de ambos subconjuntos son o no son iguales.

Deja un comentario

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *