22 - Funciones: parámetros y retorno de datos tipo arreglo

Hemos visto el objetivo de plantear funciones en un programa y que las mismas pueden recibir datos por medio de parámetros y retornar un dato.

Los parámetros de una función pueden ser de tipo Int, Char, Float etc. como hemos visto en conceptos anteriores pero también pueden ser de tipo arreglo como veremos en este concepto.

Problema 1

Definir en la función main un arreglo de enteros de 5 elementos. Declarar dos funciones, en una efectuar la carga de sus elementos y en la otra su impresión.

Proyecto105 - Principal.kt

fun cargar(arreglo: IntArray) {
    for(i in arreglo.indices) {
        print("Ingrese elemento:")
        arreglo[i] = readln().toInt()
    }
}

fun imprimir(arreglo: IntArray) {
    for(elemento in arreglo)
        println(elemento)
}

fun main(parametro: Array<String>) {
    val arre = IntArray(5)
    cargar(arre)
    imprimir(arre)
}

En la función main creamos un arreglo de 5 elementos de tipo entero mediante la clase IntArray:

fun main(parametro: Array<String>) {
    val arre = IntArray(5)

Llamamos seguidamente a la función cargar y le pasamos la referencia a nuestro arreglo:

    cargar(arre)

En la función cargar podemos acceder a los 5 elementos del arreglo para cargarlos:

fun cargar(arreglo: IntArray) {
    for(i in arreglo.indices) {
        print("Ingrese elemento:")
        arreglo[i] = readln().toInt()
    }
}

Como podemos observar el parámetro se llama arreglo y la variable que le pasamos de la main se llama arre. No hay problema que tengan nombres distintos pero si es obligatorio que los dos sean de tipo IntArray.

La función imprimir recibe el arreglo y muestra su contenido:

fun imprimir(arreglo: IntArray) {
    for(elemento in arreglo)
        println(elemento)
}

Problema 2

Se desea almacenar los sueldos de operarios. Cuando se ejecuta el programa se debe pedir la cantidad de sueldos a ingresar. Luego crear un arreglo con dicho tamaño.
Definir una función de carga y otra de impresión.

Proyecto106 - Principal.kt

fun cargar(): IntArray {
    print("Cuantos sueldos quiere cargar:")
    val cantidad = readln().toInt()
    val sueldos = IntArray(cantidad)
    for(i in sueldos.indices) {
        print("Ingrese elemento:")
        sueldos[i] = readln().toInt()
    }
    return sueldos
}

fun imprimir(sueldos: IntArray) {
    println("Listado de todos los sueldos")
    for(sueldo in sueldos)
        println(sueldo)
}

fun main(parametro: Array<String>) {
    val sueldos = cargar()
    imprimir(sueldos)
}

Este problema muestra como podemos crear un arreglo en una función y retornarla. La función cargar retorna la referencia de un objeto de tipo IntArray:

fun cargar(): IntArray {

Dentro de la función creamos un arreglo, cargamos su contenido y finalmente lo retornamos:

    print("Cuantos sueldos quiere cargar:")
    val cantidad = readln().toInt()
    val sueldos = IntArray(cantidad)
    for(i in sueldos.indices) {
        print("Ingrese elemento:")
        sueldos[i] = readln().toInt()
    }
    return sueldos

En la función main llamamos a la función cargar y le asignamos a una variable que por inferencia se detecta que es de tipo IntArray:

fun main(parametro: Array<String>) {
    val sueldos = cargar()
    imprimir(sueldos)
}

Problemas propuestos

• Desarrollar un programa que permita ingresar un arreglo de n elementos, ingresar n por teclado.
  Elaborar dos funciones una donde se lo cree y cargue al arreglo y otra que sume todos sus elementos y retorne dicho valor a la main donde se lo imprima.
• Cargar un arreglo de n elementos. Imprimir el menor elemento y un mensaje si se repite dentro del arreglo.

Solución

Proyecto107

fun cargar(): IntArray {
    print("Cuantos elementos tendrá el arreglo:")
    val cantidad = readln().toInt()
    val arreglo = IntArray(cantidad)
    for(i in arreglo.indices) {
        print("Ingrese elemento:")
        arreglo[i] = readln().toInt()
    }
    return arreglo
}

fun imprimir(arreglo: IntArray) {
    println("Listado completo del arreglo")
    for(elemento in arreglo)
        println(elemento)
}

fun sumar(arreglo: IntArray): Int {
    var suma = 0
    for(elemento in arreglo)
        suma += elemento
    return suma;
}

fun main(parametro: Array<String>) {
    var arreglo = cargar()
    imprimir(arreglo)
    println("La suma de todos sus elementos es ${sumar(arreglo)}")
}




Proyecto108

fun cargar(): IntArray {
    print("Cuantos elementos tendrá el arreglo:")
    val cantidad = readln().toInt()
    val arreglo = IntArray(cantidad)
    for(i in arreglo.indices) {
        print("Ingrese elemento:")
        arreglo[i] = readln().toInt()
    }
    return arreglo
}

fun imprimir(arreglo: IntArray) {
    println("Listado completo del arreglo")
    for(elemento in arreglo)
        println(elemento)
}

fun mayor(arreglo: IntArray): Int {
    var may = arreglo[0]
    for(elemento in arreglo)
        if (elemento > may)
            may = elemento
    return may
}

fun repite(arreglo: IntArray, buscar: Int): Boolean {
    var cant = 0
    for(elemento in arreglo)
        if (elemento == buscar)
            cant++
    if (cant > 1)
        return true
    else
        return false
}

fun main(parametro: Array<String>) {
    var arreglo = cargar()
    imprimir(arreglo)
    println("El elemento mayor es ${mayor(arreglo)}")
    if (repite(arreglo,mayor(arreglo)))
        println("Se repite el mayor en el arreglo")
    else
        println("No se repite el mayor en el arreglo")
}