Autor:Felipe Andres Lagos Morapasten Competencia: Desarrollo de Software (Nivel 1) Palabras Clave:Programación II,Java, replace,Enteros.
Descripción de la Actividad
Quiero compartir con ustedes un laboratorio realizado en lenguaje Java con un problema asignado por la profesora, corresponde al curso Programación II.
El programa cuenta con una entrada de datos por parte del usuario, en este caso un número entero y un dígito también entero en este caso si el dígito se encuentra en el número se debe eliminar, al terminar esto se debe mostrar el valor del número que se ingresó, con o sin cambios de eliminación.
Solución
Lo inicial para la programación de este problema es hacer el pseudocódigo que nos dará la idea principal de la actividad, que luego se lleva, traspasa al código fuente en Java.
Pseudocódigo.
Declarar las variables para los enteros.
Declarar el escáner.
Si ( El usuario ingresó dos valores enteros (dígito y número) ).
{ Hacer el reemplazo si es que se repiten (replace), Si (el digito se encuentra en el numero) { eliminar digito} Sino { Conservar} Mostrar en Pantalla el valor de numero, que puede tener modificaciones. }
Sino
Mostrar en Pantalla que no ingresó numeros positivos.
Ejemplo paso a paso
Entrada y Salida: Numeros Enteros.
Proceso:
- Ingresar un número positivo:
- Numero= 1233
- Ingresar un digito:
- Digito= 3
- Si ( el digito (3) se encuentra en el numero (1233) )
- Eliminar
- Obtener nuevo número ( 12)
- Mostrar en pantalla el nuevo numero ( 12)
- Como se puede apreciar el digito se encontrada en el número por eso se eliminó.
Codigo del laboratorio en Java:
import java.util.scanner.*; // Librería para usar el escáner.
public class Ejercicio
{
public static void main(String[] args)
{
int r,r2,salida; // Enteros para el ingreso de los datos.
String R,R2; // Para poder trabajar con la funcion Replace
Scanner dato=new Scanner(System.in);
System.out.println("Ingrese su número: "); // Ingreso de Datos
r=dato.nextInt();
System.out.println("Ingrese el número a eliminar: "); // Ingreso de Datos
r2=dato.nextInt();
if(r>0) // Si el numero es mayor que 0
{
R=String.valueOf(r); // Pasar el numero a String
R2=String.valueOf(r2); // Pasar el digito a String
String RFINAL=R.replace(R2, ""); // Hacer el proceso de verificar
salida=Integer.parseInt(RFINAL); // Pasar a entero el número ya verificado que antes era String.
System.out.println(salida); // Mostrar el número
}
else
System.out.println("No ingreso un numero positivo"); // Mostrar en Pantalla
}
}
Se puede destacar de este código fuente el ingreso de datos enteros por parte del usuario mediante el escáner, además de usar la función, método de String replace y el paso de entero a String (valueOf) y viceversa de String a entero (Interger.parseInt ).
Captura en Pantalla sobre la Aplicación:
Reflexión
Para este problema, lo dificil fue encontrar la solución adecuada estuvo en el saber el método de la clase String que realizará todo el trabajo,el método replace, después con el conocimiento aprendido en los cursos el pasar de entero a string y al revés no significó una mayor problemática, como también la validación del numero y el uso del escáner.
Te invito a que si tienes dudas o quieres complentar 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.
Autor: Felipe Andres Lagos Morapasten Competencia: Desarrollo de Software (Nivel 1) Palabras Clave:Programación I,Java, Variables,Entero.
Descripción de la Actividad
Quiero compartir con ustedes el primer programa en Java que he realizado corresponde al curso Programación I, este programa cuenta con el ingreso de datos por parte del usuario, dos variables enteras que luego deberán ser mostradas por pantalla quedando claro las variables ingresadas en el inicio, para pasar a mostrar sus valores de forma intercambiada sus valores, de manera que quede claro el intercambio.
Solución
Lo inicial para la programación de este problema es hacer el pseudocódigo que nos dará la idea principal de la actividad, que luego se lleva, traspasa al código fuente Java.
Pseudocódigo.
Declarar las variables para los enteros.
Declarar el escáner.
Pedir que el usuario ingrese dos valores enteros.
Mostrar los valores que ingreso el usuario.
Mostrar los nuevos valores ya intercambiados.
Ejemplo paso a paso
Entrada y Salida: Numeros Enteros.
Proceso:
Ingresar un número a las variables a elección:
Variable a= 3
Variable b= 9
a=a+b;
a=3+9
a=12 // Ahora la variable A queda con un valor 12 que reemplaza al anterior valor.
b=a-b;
b=12-9
b=3 // La variable b queda con un valor 3, que es el resultado final, del valor original de a, entonces podemos ver que se ha intercambiado una variable.
a=a-b;
a= 12-3
a=9 // Esta última variable queda con el valor de la variable b y ese es su valor final
Como se aprecia el valor de las variables se ha intercambiado
Codigo de mi Primer Programa en Java:
import java.util.Scanner; // Librería para usar escaner
public class Problema
{
public static void main (String [] args){
int a; // Variables enteras para los datos que ingresa el usuario
int b;
Scanner leer = new Scanner(System.in); // Inialización del escáner
System.out.println("Ingrese valor para A"); // Mensaje en Pantalla
a=leer.nextInt();
System.out.println("Ingrese valor A"); // Mensaje en Pantalla
b=leer.nextInt();
System.out.println("Usted ingreso que A: "+a+"y B: "+b); // Mensaje en Pantalla.
a=a+b; // Procesos donde a traves de operaciones como sumas y restas se logra el intercambio.
b=a-b;
a=a-b;
System.out.println("El nuevo valor de A es : "+a); // Mensaje en Pantalla ya con los nuevos valores
System.out.println("La variable B es: "+b);
}
}
Se puede destacar de este código fuente el ingreso de datos enteros por parte del usuario mediante el escáner, además el proceso para lograr el intercambio con su respectivo mensaje en pantalla sobre los valores.
Captura en Pantalla sobre la Aplicación:
Reflexión
Para ser mi primer programa en Java, encuentro que no se me complicó mucho ya que con lo aprendido en clases pude programar esta situación sin mayores dificultades, solo destacar el uso del escáner, el proceso de intercambio con sus mensajes como corresponden.
Te invito a que si tienes dudas o quieres complentar 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.
Autor:Felipe Andres Lagos Morapasten Competencia:Desarrollo de Software (Nivel 1) Palabras Clave:Proyecto de Robot,NXC, Arreglos,Tareas.
Descripciónde la Actividad
Quiero compartirles con ustedes la realización de un video juego llamado Dribbler, correspondiente al proyecto número 1 del Curso de Robótica, que se tuvo que programar en lenguaje NXC.
El juego que debe ejecutar el robot consiste en encontrar zonas de puntaje que están en la pista sin chocar con los obstáculo que presenta al momento de impacta el juego se termina, cuenta con una especie de ayuda que consiste en una señal auditiva que hace cambiar el rumbo, sentido que lleva el robot.
Solución
Lo inicial de cada actividad es el pseudocódigo que nos dará la idea principal de la actividad, que luego se lleva, traspasa al código fuente NXC.
Umbral Sonido=80
Umbral=40
suma=0
contadorp=0 potencia=20 i=0 puntos[100] tiempo = 0
mutex bandera mutex música Tarea música() {Mientras (Siempre) {Adquirir recurso (música) Tocar música Liberar recurso (música) } // Cierre del Mientras } // Cierre de la tarea música Tarea avance () { Registrar tiempo anterior Mientras (Siempre) {Adquirir recurso (bandera); Avanzar con el valor de Potencia Liberar recurso (bandera); Si (Sensor de luz detecta negro) {Registrar tiempo de demora al encontrar el punto negro Tocar un Sonido indicando la detección de punto Si(el tiempo de demora es mayor o igual a 10) {tiempo=10 } Calcular el puntaje obtenido y guardarlo en el arreglo, puntos[] contadorp++ suma=suma+puntos[i] Si (la potencia >=100) {Potencia=100} sino {Potencia=potencia+10 } Adquirir recurso (bandera); Girar sobre su eje en un ángulo aleatorio Liberar recurso (bandera); } // Cierre del Si } // Cierre Mientras }// Cierre Tarea Avance Tarea peligro () {Mientras (Siempre) {Si (Detecta un sonido sobre el Umbral de sonido) {Adquirir recurso (bandera); Girar en un ángulo leve Liberar recurso (bandera);} //Cierre Si } // Cierre Mientras }// Cierre Tarea Peligro Tarea final () {Mientras (Siempre) {Si (Detecta pared) {Mientras (contadorp<=15) {Mostrar en pantalla los puntajes obtenidos y la suma total contadorp++ } // Cierre del Mientras Adquirir recurso (bandera); apagar motores Liberar recurso (bandera); detener todas las tareas }// Cierre del Si } // Cierre Mientras }// Cierre Tarea final. Tarea Principal () {Hacer correr todas las tareas Encender Sensores de Luz, Tacto y Sonido }
El Código fuente del proyecto es el que sigue:
#define Umbral_Sonido 80 // Usado para que el sensor de Sonido detecte el aplauso
#define Umbral 40 // Declarado para ser usada como un punto negro por el Sensor de Luz
int suma=0; // Variable que representa el total del puntaje
int contadorp=0;// Variable usada que cuenta la cantidad de veces que detecta los puntos negros.
int potencia=20; // Potencia inicial que arranca el robot en la actividad.
long actual = 0; // Usado para registrar el tiempo hasta encontrar un punto negro
long anterior = 0; // Usado para registrar el tiempo desde el comienzo.
int i=0; // Marca la posición número 1 para el arreglo
int puntos[100]; // Arreglo que guarda el valor de los puntajes obtenidos al detectar un punto negro.
int giro=0; // Variable usada para realizar un giro en 180° al momento de detectar una señal auditiva
int tiempo = 0;// Variable usada para marcar lo que demoro en buscar un punto negro, lo que determina el puntaje obtenido(( actual - anterior)/1000)
int pos=0; // Usado para que al momento de Mostrar en pantalla avance lo guardado en el arreglo.
int altura=30; // Usado como coordenada Y en la muestra de la pantalla del ladrillo.
mutex bandera; // Con esto nos aseguramos que al mover de los motores no ocurra que resultados inesperados al tratar de funcionar
mutex musiquita; // Usado para la musica de fondo y el sonido de obtener puntaje.
task musica() // Tarea de la música de Fondo.
{ while(true) // Mientras sea verdadero
{ Acquire(musiquita); // Indica que el control en este caso de la musica la tiene esta tarea. PlayTone (700,100); // Los 4 Playtone confeccionar la música de fondo gracias a sus diferentes frecuencias y tiempos. Wait (200); PlayTone (1000,100); Wait (200); PlayTone (1500,100); Wait (200); PlayTone (1200,100); Wait (200); Release(musiquita); // Esto quiere decir que libera el uso del sonido para que otra tarea la use.
} // Cierre del While
} // Cierre de la tarea musica
task avance()
{ anterior=CurrentTick(); // En esta variable guarda el tiempo desde el inicio del programa while(true) // Mientras sea verdadero
{ Acquire(bandera); // Usado para que los motores tenga el control para avanzar OnFwd(OUT_AC,potencia); // Avanzar con una potencia determinada en este caso 20. Release(bandera); //Indica que los recursos del avance esten libres, lo puedan usar otra tarea.
if(Sensor(IN_3) <= Umbral) // Si el Sensor de Luz detecta un punto negro.
{ actual=CurrentTick(); // Guarda el tiempo que demoro en detectar un punto. PlayTone (1000,100); // Los 2 Playtone marcan el hallazgo de un punto negro Wait (250); PlayTone (2000,200); Wait (250); tiempo=(actual-anterior)/1000; // La variable tiempo se guarda el tiempo exacto en segundo que demoro desde el inicio al encontrar un punto. if(tiempo>=10) // Si el tiempo es mayor o igual a 10
{tiempo=10;} // El tiempo será 10 lo que en la ecuación de los puntos lo igual a 0 el puntaje.
puntos[i]= 50 - 5*tiempo; // Arreglo que determina el puntaje obtenido en relación al tiempo obtenido. contadorp++; // Para contar el numero de veces que detecta un punto. suma=suma+puntos[i]; // Marca el resultado total del puntaje que se obtienen i++; // Usado para que se guarden valores una posición más allá de la inicial en el arreglo
if(potencia>=100) // Si la potencia es igual o mayor que 100
{potencia=100;} // La potencia es igual a 100.
else // Sino
{ potencia=potencia+10;}// La Potencia aumenta en 10
// Cierre Potencia
Acquire(bandera); // Lo mismo que en el inicio de la tarea en el uso de motores, ahora tienen el control. OnFwd(OUT_A,75); // Las dos instrucciones usadas para que realice un giro aleatorio OnRev(OUT_C,75); // para cambiar el rumbo que se lleva giro=Random(400)+200; Wait(giro); Release(bandera); // Marca el final del uso del recurso del motor,
} // Cierre del if Punto Negro
} // Cierre While
} // Cierre Tarea Avance
task peligro() // Tarea de Peligro al momento de una advertencia ante un posible choque con una pared o obtáculo.
{ while(true) // Mientras sea verdadero
{ if(Sensor(IN_2) >= Umbral_Sonido) // Si el sensor de sonido detecte un sonido ( aplauso)
{ Acquire(bandera); // Usada para que tenga el control del robot mientras sucede lo anterior OnFwd(OUT_A,75); // Instrucciones para que se realice un giro de 180° grados OnRev(OUT_C,75); Wait(200); Release(bandera); // Marca el final del control de la tarea, de los recursos.} //Cierre IF
} // Cierre While
} // Cierre Tarea Peligro
task final() // Tarea final es la que arranca al momento de detectar un golpe
{while (true) // Mientras sea verdadero
{if ((Sensor(IN_1)==1)) // Si el sensor de tacto es igual a 1, detecta un golpe
{ while(contadorp<=15) // Mientras el contador de los puntos sea menor o igual a 15
{NumOut(0, altura, puntos[pos]); // Muestra en pantalla el valor de los puntajes obtenidos TextOut(30,30,"Pje.Total"); // Muestra en pantalla el texto "Pje.Total" NumOut(30,20, suma); // Muestra en pantalla el resultado de la suma de los puntajes obtenidos contadorp++; // Le suma uno al contador de los puntos pos++; // Suma uno a la variable de la posición usada para el arreglo altura=altura+5; // Usado para que cada que muestre un valor se valla corriendo lugares en la pantalla.
} // Cierre del while
Acquire(bandera); // Con esto se asegura que al momento de ocurrir lo de arriba el control lo tenga esta tarea. Off(OUT_AC); // Apaga los motores por 5 segundos Wait(5000); Release(bandera);// Se detiene los recursos, se liberan de la tarea, el uso de los motores. StopAllTasks(); // Detiene todas las tareas
}// Cierre del If
} // Cierre While
} // Cierre Tarea final.
task main () // Tarea Principal.
{Precedes(musica,avance,final,peligro);// Usado para que todas las tareas trabajen paralelamente SetSensorTouch(IN_1); // Encender Sensor de Tacto, Puerto numero 1 SetSensorSound(IN_2); // Encender Sensor de Sonido, Puerto numero 2 SetSensorLight(IN_3); // Encender Sensor de Luz, Puerto numero 3}
Se puede destacar del codigo fuente que existen muchas instrucciones para la realización optima del proyecto, se aprecia el uso de tareas, y el guardado de valores en un arreglo, lo anterior nombrado es lo fundamental para realizar el proyecto,además se encuentran órdenes para asignar recursos, liberar recursos, mostrar en pantalla, avanzar, girar entre otras.
El video que muestra el proyecto Dribbler es este:
Reflexión
El uso de tareas y arreglos marcó totalmente el desarrollo de la actividad ya que fue necesario saber manejar las condiciones para que arranque cada tarea, ademas de asignar, liberar recursos para que no ocurra un conflicto en la ejecución del código, esto fue realizado de manera más fácil programarlo por el aprendizaje propio obtenidos en este y otros cursos. Lo que mayor complejidad fue el manejo de arreglo, al tener que modificar la posición que se guardará, así como en el mostrado en pantalla.
Te invito a que si tienes dudas o quieres complentar 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.
Autor: Felipe Andres Lagos Morapasten Competencia: Desarrollo de Software (Nivel 1) Palabras Clave: Programación de Robot,NXC, Robótica,Kit Lego.
Descripciónde la Actividad
Quiero compartirles con ustedes mi grata experiencia, como estudiante de informática, correspondiente a la actividad número 4 del Curso de Robótica, donde se tuvo que realizar un codigo fuente en NXC.
El problema consistió en hacer que el robot sea capaz de convertirse en patrullero, velando por la seguridad de una casa, recorriendo alrededor de ella, donde cada sonido es señal de que el peligro se aumenta y debe ser superior la preocupación de vigilancia hacia la casa, al momento de tener una alta vigilancia por los sonidos, el robot embiste al objetivo.
Solución
Lo primero que se debe realizar, analizar para que esta actividad se simplifique y facilite llegar a un buen resultado es la realización del pseudocódigo, para luego hacer el código fuente en el lenguaje NXC.
Nivel de alerta =0
Energía restante = 500
Intentos de robo =0
Modo patrulla
Mientras (el nivel de alerta sea menor que 100)
{
mostrar texto
{ Mostrar en la pantalla nivel de alerta
mostrar en la pantalla energía restante
mostrar en la pantalla intentos de robo }
Si el (sensor de luz detecta blanco)
{Girar levemente hacia el circulo negro}
Sino
{Avanzar}
Si (el sensor de sonido detecta un ruido)
{ Detener el robot
Tocar la sirena
{reproducir un sonido }
Sumar uno a los intentos de robo
Restar a energía restante un valor al azar entre 50 y 60
Sumar a nivel de alerta un valor al azar entre 20 y 50
}
}
Modo Guardián
Cuando (el nivel de alerta supere 100 y la energía restante sea positiva entrar modo guardián)
{
Mostrar texto
{ Mostrar en la pantalla nivel de alerta
Mostrar en la pantalla energía restante
Mostrar en la pantalla intentos de robo}
Si (el nivel de alerta es mayor que 100)
{ Entrar en el círculo
Girar sobre su eje a potencia media }
Si (el sensor de sonido detecta un ruido)
{ Sumar uno a los intentos de robo
Restar a energía restante un valor al azar entre 50 y 60
Sumar a nivel de alerta un valor al azar entre 20 y 50}
}
Modo Ataque
Cuando (la energía restante es menor o igual que 0)
{
Si (El robot detecta algo enfrente suyo a menos de 10 cm)
{Embestirlo durante un segundo a máxima potencia
Retroceder a máxima potencia durante un segundo}
}
El código fuente del programa en NXC es el siguiente:
int nivel_alerta=0; // El nivel de alerta es importante para cambiar entre los 3 modos int energia_res=500; // Energía que le queda al robot por cada intento de robo disminuye int intentos_robos=0;// Cada sonido representa un intento. #define UMBRAL 40// Rango de luz para considerar que es blanco #define UMBRAL_SONIDO 60 // Se usa para considerar el sonido con el Sensor. #define MIC // Activación del microfono para el Sensor. #define DISTANCIA 10 // Medida en cm, usado para que el Sensor detecte. sub texto() // Muestra en pantalla los intentos de robo, nivel de alerta y energia restante con sus respectivos valores. {TextOut(0,40,"Int. de robos"); NumOut (85,40,intentos_robos); TextOut(0,60,"Nv de alerta " ); NumOut (80,60,nivel_alerta); TextOut(0,50,"Energia res"); NumOut (80,50,energia_res); }
sub modo_guardian() {OnRev(OUT_C, 75);// Las 2 instrucciones permite que se de una vuelta para OnFwd(OUT_A, 75);// posicionar su entrada al ovalo Wait(250); OnFwd(OUT_AC, 50); // Avanzar Wait(1800); Off(OUT_AC);// Apaga los motores Wait(500);
while (nivel_alerta > 100 && energia_res > 0) // Mientras las 2 condiciones se cumplan. {if(Sensor(IN_2) > UMBRAL_SONIDO) // Si el sensor de sonido detecta un ruido mayor // que el umbral de sonido {++intentos_robos; // Sumar uno a intentos de robos energia_res-=(Random (11)+50); // Resta a energia res un valor entre 50 y 60 nivel_alerta+=(Random(31)+20); // Suma a nivel de alerta un valor entre 20 y 50}
texto(); // Muestra el sub modo texto OnRev(OUT_C, 50); // Estas 2 instrucciones hace que gire sobre su eje OnFwd(OUT_A, 50);} Off(OUT_AC); // Apagar motores} sub modo_ataque() { while(true) {texto(); // Muestra el texto Off(OUT_AC); // Apagar motores if (SensorUS(IN_1) < DISTANCIA) // El sensor funciona si se detecta algo entre la distancia // especificada antes {++intentos_robos; // Sigue la suma en los intentos de robos. nivel_alerta+=(Random(31)+20); // el nivel de alerta suma valores entre 20 y 50 OnFwd(OUT_AC, 100); // Ir hacia adelante embistiendo Wait(1000); OnRev(OUT_AC, 100); // Retroceder Wait(1000); Off(OUT_AC); // Apagar motores} // Cierre del if } // Cierre del while } // Cierre modo ataque
sub sirena() {PlayTone (1000,100); // Tonos de la sirena Wait (250); PlayTone (2000,200); Wait (250);}
sub modo_patrulla() {while (nivel_alerta<100) // Mientras el nivel de alerta es menor que 100 {texto(); // Muestra el sub modo texto if (Sensor(IN_3) > UMBRAL) / Si el sensor de luz detecta un rango mayor que el umbral {OnRev(OUT_C, 75);// Al detectar el color blanco se dobla hacia el circulo negro Wait(25);} else {OnFwd(OUT_C, 75); // Si no va hacia adelante OnFwd(OUT_A, 80); }
if(Sensor(IN_2) > UMBRAL_SONIDO) // Si el sensor de sonido es mayor que el //umbral_sonido {Off (OUT_AC); // Se apaga los motores por 2 segundos Wait (2000); sirena(); // Hace lo que está dentro del sub modo sirena donde reproduce un tono ++intentos_robos;// Esto hace que cada vez que detecte un sonido se le sume uno // al intento de robo energia_res-=(Random (11)+ 50);// Se resta un valor entre 50 y 60 a energia restante nivel_alerta+=(Random(31)+20); // Se suma un valor entre 20 y 50 a nivel de alerta } // Cierra if } // Cierra while } // Cierra el modo patrulla task main()
{SetSensorLight(IN_3); // Encender Sensor de Luz
SetSensorSound(IN_2);// Encender Sensor de Sonido SetSensorLowspeed (IN_1);// Encender Sensor de Ultrasonido
modo_patrulla(); // Llamado del modo patrulla
modo_guardian(); // Al terminar el modo anterior, se activa este modo
modo_ataque(); // Luego de terminar el modo guardian pasa a este ultimo
}
En resumidas cuentas en el código existen muchas instrucciones donde se destaca el uso de subrutinas, que marca que la actividad se realice de forma óptima, además de órdenes para avanzar, girar, mostrar en pantalla, emitir sonidos y el uso de variado de los sensores como el de luz, sonido y proximidad.
El video de esta actividad es el siguiente:
Reflexión
El uso de subrutinas al iniciar me resultó un poco dificultoso ya que mi pensamiento era algo diferente al que se debe tener. Al desarrollar la actividad cambió mi parecer por que debí pensar en todos los casos posibles que relata la actividad, analizando condiciones y cuando deben ocurrir ciertas cosas para hacer el buen uso de las rutinas.
Te invito a que si tienes dudas o quieres complementar esta actividad 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.
