Laboratorio Arreglo Números Vecinos

Autor: Felipe Andres Lagos Morapasten
Competencia: Aplica las Ciencias de la ingeniería. (Nivel 1)
Palabras Clave: Programación II, Java, Arreglos, Ciclos.

Descripción de la Actividad

Reanudando, les quiero otra vez compartir con ustedes mi actividad de laboratorio que está orientado al uso de los arreglos y también ciclos, este laboratorio es correspondiente al curso de Programación II, este programa consiste en saber cuántos elementos se encuentran en el medio de sus vecinos para verificar esto se debe comprobar mediante serie de 3 elementos(números) donde el número del medio puede ser mayor que el primer número y menor que el tercer número, o también si esto ocurre en viceversa, siendo el número de al medio menor que el primero y mayor que el tercer número, si ocurre cualquiera de las dos posibilidades , el número se considera que “está” en el medio de sus vecinos, este se cuenta mediante un contador.

Solución

Bueno para la resolución de este problema de programación es realizar el pseudocódigo del laboratorio que nos simplificará las cosas para luego traspasarlo al código fuente en Java.

Pseudocódigo.

Inicial=0;

Medio=1

Ultima=2;

Contador=0;

Recorrer=0

Declarar las variables para la posiciones (inicial, medio y ultima).

Declarar el escáner.

Declarar el arreglo.

Pedir la dimensión que va a poseer el arreglo.

Pedir los números al usuario hasta llenar la dimensión del arreglo.

Mientras( Recorrer < que la longitud del arreglo)

{

   Comparar los tres primeros números del arreglo

   Si ( el número del arreglo medio es > que numero inicial del arreglo Y numero del medio es < que número último del arreglo)

 {   Sumar uno al contador}

  Si ( el número del arreglo medio es < que numero inicial del arreglo Y numero del medio es > que número último del arreglo)

{Sumar uno al contador}

Sumar uno a inicial

Sumar uno a medio

Si(ultimo < la longitud del arreglo)

 {  Sumar uno al ultimo}

Sumar uno a recorrer.

}  // Cierre del mientras

Mostrar el valor del contador, los elementos que están en medio de sus vecinos.

Ejemplo paso a paso

Entrada: Número Entero. (La dimensión del arreglo)

Dimensión: 3

Al ser una dimensión de 3, el usuario debe ingresar 3 números que son los valores del arreglo.

N1= 2

N2=4

N3=6

Proceso:

Comparar los números, el número del medio con sus vecinos en otras palabras

esto se busca comparando los números en una serie de 3

para que un elemento (numero) este en medio de sus vecinos ,

Debe ser:

N2 > N1 y N2< N3, (o) como también puede ser N2>N3 y N2<N1.

En este ejemplo: N1=2  N2=4 N3=6

¿N2 es mayor que N1 y N2 es menor que N3?
Si, contarlo (sumarle uno al contador)

¿N2 es mayor que N3 y N2 es menor que N1?

No.

¿Revisar si es que existen más números en el arreglo?

No existen

Salida: Un mensaje en pantalla, con un número entero

Mostrar el contenido de contador:

Contador=1;

En este caso el numero n2= 4 es mayor que n1=2 y es menor que el último número n3=6.

Los elementos que están en medio de los vecinos son 1

Código del laboratorio de arreglos en Java.

import java.util.Scanner; // Librería para utilizar el escáner.

public class FelipeLagos {

    public static void main(String[] args) {

        int recorrer = 0, primero = 0, medio = 1, ultimo = 2;

        int contador = 0;

        Scanner leer = new Scanner(System.in);

        System.out.print("Ingrese la cantidad de datos del arreglo: "); // Se le pide la dimensión del arreglo al usuario

        int dim = leer.nextInt();

        int arreglo[] = new int[dim];

        for (int i = 0; i < arreglo.length; i++) {

            System.out.print("Ingrese sus valores al arreglo :");

            arreglo[i] = leer.nextInt(); // Se ingresan valores al arreglo hasta llenar la dimensión.

        }

        while (recorrer < arreglo.length - 1) { // Para revisar todo el arreglo

            if (arreglo[medio] > arreglo[primero] && arreglo[medio] < arreglo[ultimo]) {

                contador++;

            }

            if (arreglo[medio] < arreglo[primero] && arreglo[medio] > arreglo[ultimo]) {

                contador++;

            }

           

            primero++;// Para revisar los otros números del arreglo

            medio++;

            if (ultimo < arreglo.length - 1) { // Con esto se evita que cuando llegue

                ultimo++;                      // a la última posición no exista elemento y no de error.

            }

            recorrer++; // Para que se termine el ciclo de revisión

        }

        System.out.println("Los elementos en medio de los vecinos es " + contador);

    }

}

 Se puede destacar de este código fuente el uso de un arreglo con su respectivo ciclo while lo que nos permite recorrer y comparar los valores que contiene el mismo arreglo, a todo esto sumado variables especiales de posicion para revisar los vecinos 1 y 2, terminando con el método length que nos permite sacar la longitud del arreglo.

Captura en Pantalla sobre la Aplicación:

Reflexión

Siendo este mi primer laboratorio referente al tema de los arreglos donde se tuvo que aplicar el uso de ciclos , un contador y la longitud del arreglo, la lógica para sacar los elementos del medio de los vecinos no me resulto complicada, lo que si me dificultó fue sobre las posiciones del arreglo porque llega un momento donde al incrementar todas las posiciones inicial, medio y ultima, la reciente nombraba accede a una posición inexistente lo que lleva al error, lo que me hizo que tuviera que validar en ese caso, que le incremente a ultima mientras sea menor a la longitud del arreglo.

  Te invito a que si tienes dudas o quieres complementar esta actividades mediante opiniones, otras informaciones no tengas miedo de emitir tus comentarios, a participar donde cada comentario hará que se haga más interactivo este espacio.