Robot Destructor

Competencia: Gestion en TI

Curso:Programacion de robot

Actividad: Robot Destructor

Descripcion

La presente actrividad es unproyecto en el cualse puede extraer una idea clara para el futuro, ya que existe un mezcla perfecta en sofware(la progrmacion del robot) y el hadware(el mismo robot) , para ejercer una funcioon peligrosa como lo seria el derrumbe de estructuras, donde no se pueda derrumbar con dinamitas

En caso paracticos, como no se encuentra la superfuicie y dicha estructura, sera llevado a tamaño escala en un mezon, con paredes de madera que simularan la estructura.

Se pide programar un robot destructor, para que deambule por un área delimitada por paredes de granito reforzadas con titanio, en la cual se han colocado al azar una serie de pilares. Este robot debe avanzar a ciegas usando un sensor de tacto, de manera que cada vez que detecte algún obstáculo (sea un pilar o la pared) detone un explosivo y se aleje del lugar usando un patrón al azar.

Objetivos

Resolver un problema simple de utilización de sensor de tacto, incluyendo el uso

de ciclos, operaciones matemáticas y condicionales, y ocupando el lenguaje de programación NXC.

 Obtener una solución efectiva del problema utilizando el conocimiento aportado por las clases atendidas y la creatividad del grupo. 

  

Modelo de solucion/pseudocodigo   

El pseudocódigo realizado es el siguiente:

Avanzar indeterminadamente hasta que se active el sensor;

Una vez activado el sensor retroceder 0,5s;

Detenerse por 2 segundos;

Emitir un sonido;

Realizar un giro;

Avanzar nuevamente hasta que se active el sensor;

Una vez de que el sensor se halla activado 5 veces;

Apagar los motores;

Emitir un sonido;

Finalización del programa.

 Codigo Fuente

//autor:Grupo Terabytes

int Giro;

int contador=0;

task main()

{    SetSensorTouch(IN_1);

     OnFwd (OUT_BC, 80)             //avanzar indeterminadamene

     while(true)

        {

        if(SENSOR_1==1)             //condicion si se activa el sensor

           {                        //se realiza lo siguiente:

           Giro=Random (1832)+268;

           OnRev(OUT_BC, 80);       //marcha atras por

           Wait(500);

           PlayTone(4000, 500);     //emite un sonido.

           Off(OUT_BC);             //se detiene por 2.0s.

           Wait(2000);

           OnFwd(OUT_C, 80);        //realiza un giro.

           OnRev(OUT_B, 80);

           Wait(Giro);

           OnFwd(OUT_BC, 80);  //avanza hasta que se active el sensor.

           contador++;

           }

        if(contador==5)  //condición si el sensor se ha activado 5 veces.

           {Off(OUT_BC);            //apagar motores

           PlayTone(5000, 500);     //emitir un sonido

           Wait(500);

           StopAllTasks();

           }

        }

}

Conclusión.

Los objetivos planteados en esta actividad  fueron superados en justa medida, luego que el trabajo en grupo bien realizado nos llevo a desarrollar de mejor manera el ejercicio para que con ello el resultado final de nuestra actividad se viera reflejado en el video.

El desarrollo del robot esun modelo a escala de lo que seria en realidad,.

La actividad desarrollada en el primer semestre puso en practica lo aprendido en clases y combina la programacion con el diseño del robot, lo q se podria ver com el hadware.

Numeros Impares

Competencia: Aplica las ciencias de la ingenieria

Curso:Programacion II

Actividad: Numeros impares

Descripcion

Mostrara los numeros impares de  un numero de 4 digitos de forma inversa.

Para esta actividad  tambien debe crear el programa con una interfaz grafica.

Ejemplos

Entrada                           Salida

1234            <proceso>     31

3343           <proceso>      333

22               <proceso>     ingrese un numero de 4 dogitos

2464           <proceso>      no tiene numeros impares

Analisis.

Lo primero es como descomponer el numero de cuatro digitos para verificar si es o no par, para esto utilizaremos la tecnica de divicion y modulo, la division por 100 nos dara el primer numero de la serie el cual lo guardamos en una variable, luego el nuemro ingresado por el usuario determinas el % por 100 y se guarda en la misma variable, para disminuir el numero menos el 1er digito , luego se ace el mismo proceso para determinar los digitos del numero.

como se muestra en el siguiente extracto de codigo.

 n1=numero/1000;
    numero=numero%1000;
    n2=numero/100;
    numero=numero%100;
    n3=numero/10;
    numero=numero%10;

Una vez guardados los digitos del numero ingresados por el suario en variables diferentes iniciamos la verificacion de que si es opara  o no mediante la sentencia if,

en la cual al numero se deteermina el resto de la division por dos, y de ser mayor a 0 quiere decir de que es par

if(numero%2>0)
     {output=output +String.valueOf(numero);
        /*empezamos por el ultimo digito para q de esta manera
           se imoprima el numero de forma inversa
        */}
if(n3%2>0)
    {output=output+String.valueOf(n3);}
if(n2%2>0)
    {output=output +String.valueOf(n2);}   
if(n1%2>0)
    {output=output +String.valueOf(n1);}

Codigo Fuente

/**
 * Mostrar los numeros impares de un numero de 4 digitos de forma inversa
 *
 * @author Patricio Riquelme

 */
import java. awt.event.*;
import java. awt.*;
import javax. swing.*;
import java. util.*;

public class impares implements ActionListener{
private static final int ANCHO=300;
private static final int ALTO=200;
private static final int ANCHO_TEXTO=20;
/*rangos de la ventana*/

private static final FlowLayout ESTILO_LAYOUT=new FlowLayout();
private static final String LEYENDA="determinemos que numero es impar";

private JFrame ventana= new JFrame("numeros impares");
private JTextArea leyenda=new JTextArea (LEYENDA,1,ANCHO_TEXTO);

private JLabel numEtiq = new JLabel("ingrese el numero");
private JTextField numTexto= new JTextField(ANCHO_TEXTO);

private JLabel resEtiq = new JLabel ("resultado");
private JTextField resTexto= new JTextField(ANCHO_TEXTO);

private JButton Boton = new JButton("mostrar");

public impares(){
    ventana. setSize(ANCHO,ALTO);
      Boton.addActionListener(this);
       leyenda.setEditable(false);
         ventana.setLayout(ESTILO_LAYOUT);           
           ventana.add (leyenda);
             ventana.add(numEtiq);
               ventana.add(numTexto);
                 ventana.add(Boton);
                   ventana.add(resEtiq);
                    ventana.add(resTexto);
                      ventana. setVisible(true);
}
public void  actionPerformed (ActionEvent z){
int n3,n2,n1;
String output="";
int numero=Integer.parseInt(numTexto.getText());

if (numero>999 && numero<10000)
{//descomponemos el numero de 4 digitos ingresado por el usuario
    n1=numero/1000;
    numero=numero%1000;
    n2=numero/100;
    numero=numero%100;
    n3=numero/10;
    numero=numero%10;
/*comprobamos si son su modulo es > 0 es
es decir el resto de la divicion po2 es mayor a 0 es por
que es impar*/
if(numero%2>0)
     {output=output +String.valueOf(numero);
        /*empezamos por el ultimo digito para q de esta manera
           se imoprima el numero de forma inversa
        */}
if(n3%2>0)
    {output=output+String.valueOf(n3);}
if(n2%2>0)
    {output=output +String.valueOf(n2);}   
if(n1%2>0)
    {output=output +String.valueOf(n1);}


    resTexto.setText(output);
  }

else
    { output=String.valueOf("error de numero");
        resTexto.setText(output);
}
}

public static void main (){
impares gui= new impares();
}
}

Conclusion 

Siempre es efectivo realizar laboratorios y ejercicios para que se estimule al estudiante, ademas de mejorar la ortografia de programacion y  agregar conocimiento al mismo. Este programa necesita conocimiento  aplicacion de ciencias basicas como lo son las matematica, la base de las ingenierias.

Numero Capicua.

Competencia: Aplica las ciencias de la ingenieria

Curso:Programacion I

Actividad: Serie Fibonacci Invertida

Descripcion

Se nos pide desarrollar un programa con interfaz grafica, con el objetivo de q el usuario ingrese un numero y el  programa le señale si es o no capicua. Un numero capicua es un numero que se lee de la misma manEra de derecha a izquierda como de izquierda a derecha

Ejemplo

Entrada                                Salida

12321           <proceso>       Si es capicua.

222              <proceso>       Ingrese un numero de 5 digitos.

12345           <proceso>       No es capicua.

Analisis de solucion.

Nos centraremos en solo la parte delcodig por el cual se debe descomponer  para que de esta manera compara los numeros uno por una hasta el del centro con los del final.

El ussuario debe ingresar un numero mayor a 9999  y menor a 100000 es decior un numero de 5 digitos,

if (a>9999 && a<100000)

    {

        b = a/10000;

        c = a%10;

        d = a/10;

        e = d%10;

        f = d%1000;

        g = f/100;

       

        if (b==c && e==g )

En la primera linea de codigo se ve la validacion del numero para poder acer el proceso matematico para ir obteniendo cada digito del numero mediante divisiones y modulos(obtencion del resto de la division). para luego llegar a la comparacion de los dos primeros nuero con los dos ultimos, en caso de que la respuesta de la condicion sea verdadera el nuemero ingresado por el ususario es capicua. 

Codigo Funte

import javax.swing.*;

import java.awt.*;

import java.awt.event.*;

    public class RiquelmePatricio implements ActionListener

    {

    private static final int ANCHO = 300;

    private static final int ALTO = 200;

    private static final int ANCHO_TEXTO = 20;

   

    private static final FlowLayout ESTILO_LAYOUT = new FlowLayout();

    private static final String LEYENDA ="Ingrese un numero de 5 digitos y veremos si es o no capicua";

   

    private JFrame ventana= new JFrame ("Numero Capicua");

    private JTextArea leyenda = new JTextArea (LEYENDA,1,ANCHO_TEXTO);

   

    private JLabel nEtiq= new JLabel("ingese el numero");

    private JTextField nTexto = new JTextField (ANCHO_TEXTO);

   

    private JLabel resultadoEtiq = new JLabel("Resultado");

    private JTextField resultadoTexto= new JTextField(ANCHO_TEXTO);

   

    private JButton botonCalcular = new JButton ("Calcular");

   

    public RiquelmePatricio()

    {

    ventana.setSize(ANCHO, ALTO);

    ventana.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

         leyenda.setEditable(false);

         leyenda.setLineWrap(true);

         leyenda.setWrapStyleWord(true);

         leyenda.setBackground(ventana.getBackground());

         resultadoTexto.setEditable(false);

         resultadoTexto.setBackground(Color.ORANGE);

         botonCalcular.addActionListener(this);

             ventana.setLayout(ESTILO_LAYOUT);

             ventana.add(leyenda);

             ventana.add(nEtiq);

             ventana.add(nTexto);

             ventana.add(resultadoEtiq);

             ventana.add(resultadoTexto);

             ventana.add(botonCalcular); 

             ventana.setVisible(true);

    }

   

public void actionPerformed(ActionEvent z)

{

int b,c,d,e,f,g;

int a = Integer.parseInt(nTexto.getText());

if (a>9999 && a<100000)

    {

        b = a/10000;

        c = a%10;

        d = a/10;

        e = d%10;

        f = d%1000;

        g = f/100;

       

        if (b==c && e==g )

            {

            String output = String.valueOf("Si es capicua");// mensaje a mostrar en string

            resultadoTexto.setText(output);} // espacio donde mostrar el mensaje

            else {String output = String.valueOf("No lo es");// mensaje a mostrar en string

                resultadoTexto.setText(output);} // espacio donde mostrar el mensaje

            }

        else

            {

            String output = String.valueOf("error de ingreso");// mensaje a mostrar en string

            resultadoTexto.setText(output);} // espacio donde mostrar el mensaje

            }

public static void main(){ //ejecucion del programa

RiquelmePatricio gui = new RiquelmePatricio();

}

}

Conclusion

La interfaz grafica hace que el programa sea mas interactivo y llame mas la antencio, por esto es fundamental el diseño, pero no deja de lado la funcion que cumplira el programa, este es un programa basico en java, pero con interfaz grafica se complica mas por lo que se necesita mas conocimietno e ingenio.

Cuenta vecinos

Competencia: Aplica las ciencias de la ingenieria

Curso:Programacion II

Actividad:Contar vecinos

Descripcion.

Al referirse a vecinos quiere decir que el numero del centro debe tener un numero menor a la derecha y un mayor a la izquierda o biceversa. 

Ejemplos. 

Crear un arreglo numérico con datos ingresados por teclado (dados por el usuario). La dimensión la ingresa el usuario. El programa debe entregar cuántos elementos están entre medio de sus vecinos.

N = 10// tamaño del arrglo, y en fin es la cantidad de un numeros que puede ingresa el ususario. hay

7         5          11       20       6          7          8          2          5          0   =  2  

7         5          3          10       16       20       6          4          7         11   =   hay  5.

Analisis 

Lo primero es darle el tamaño al arreglo en el cual vamos a guardar los numeros ingresados por el usuario, porle decimos al usuario que ingrese el numero mediante un mensaje y luego el valor entregado lo lemos con el metodo o clase scanner.

System.out.println("Ingrese la cantidad de numeros que decea guardar");
       Cant=Leer.nextInt();
       int arreglo[]=new int[Cant];  

Y a cintinuacio la ayuda del ciclo for guardamos los numeros q va ingresando el usuario

 for(i=0; i<=Cant-1; i++){          
       System.out.println("ingrese el "+(i+1)+" numero que decea guardar");         
       arreglo[i]=Leer.nextInt();

Con un segundo ciclo  for recorremos el arrglo con los datos tya guardados y vamos aciendo la comparacion para obtener los unmeros vecinos.

 

     for(i=1; i<arreglo.length-1; i++){
             if(arreglo[i]>arreglo[i-1]&& arreglo[i]<arreglo[i+1]){
                 ContarVecinos++;}
             else if(arreglo[i]<arreglo[i-1]&& arreglo[i]>arreglo[i+1]){
                ContarVecinos++;      

                                    
                                } 

Codigo Fuente.

package patricioriquelmesoto;

import java.util.Scanner;

/**
 *
 * @author Full-Boost
 */
public class PatricioRiquelmeSoto {
    Public static void main(String[] args) {      
       
       int Cant;//variable que le dara el tamaño al arreglo
       int i=0; //contador inicializado en 0
      
       int ContarVecinos=0;
       int n;
        //declaramos el sacanner para leer los datos q ingresa el usuario
       Scanner Leer=new Scanner(System.in);
       System.out.println("Ingrese la cantidad de numeros que decea guardar");
       Cant=Leer.nextInt();
       int arreglo[]=new int[Cant];  

        //definimos el arreglo y le damos el tamño que ingresa el ususario.
                   
       for(i=0; i<=Cant-1; i++){         
          //guardamos los numeros que  ingresa el usuario
       System.out.println("ingrese el "+(i+1)+" numero que decea guardar");
         
       arreglo[i]=Leer.nextInt();
          }
         for(i=1; i<arreglo.length-1; i++){
             if(arreglo[i]>arreglo[i-1]&& arreglo[i]<arreglo[i+1]){
                 ContarVecinos++;
                                          }                
             else if(arreglo[i]<arreglo[i-1]&& arreglo[i]>arreglo[i+1]){
                ContarVecinos++;                                  
                                }  }  

//un ultimo ciclo for para mostrarle los numeros q ingreso
         for(i=0; i<=Cant-1; i++) {
             System.out.print(arreglo[i]+"-");
                               }

//mostramos la cantidad de numeros que hay.
         System.out.print(" Hay "+ContarVecinos+" numero vecinos");
        
        
    }
}

Conlusion

Este nuevo Laboratorio de Programacion sigue siendo totalmente complementario a la catedra, ya que se pone practica lo aprendido en esta, nuevamente el uso de arreglos es fundamental para reponder y resover estos ejercicios, calro que se presenta una dificultad no vistra antes, que era comparar el mismo arreglo con posciones diferente, es decir el numero que estaba en una poscicion del arreglo con otro numero del mismo arreglo.

 

Serie Fibonacci

Competencia: Aplica las ciencias de la ingenieria

Curso:Desarrollo cliente servidor

Actividad: Serie Fibonacci Invertida

Descripcion

Para esta nueva actividad es funfamental concimiento de programacion en java ademas de las matematicas, parte de las ciencias basica.

El proble en si es el siguiente:

Genere una solución para el problema de imprimir los N primeros términos de la
serie de Fibonnaci en orden inverso al considerado normal, usando un arreglo de enteros
para almacenar los valores ordenados inversamente. Cree un método al cual se le ingrese el
número de términos y devuelva un arreglo con los elementos de la serie en orden inverso.

Ejemplos

Entrada                                                        Salida

1.    <5>           →        <Proceso>    →        <3,2,1,1,0>

2.    <0>           →        <Proceso>    →        <Debe ingresar un número mayor que 0>

3.    <1>           →        <Proceso>    →        <0>

4.    <-1>          →        <Proceso>    →        <Debe ingresar un número mayor que 0>

5.    <-3>          →        <Proceso>    →        < Debe ingresar un número mayor que 0>

6.    <2,3>        →        <Proceso>    →        <error de ingreso/Ingrese un numero entero>

 Analisis de solucion.

           La serie de fibonacci  se obtiene  mediante la función sucesiva,donde  dos variables se inicializan con 0 y 1, luego  cada número que se obtiene es la suma del anterior.

La función del arreglo  es guardar un dato en este caso los números de la serie en una posición de este, determinada por el contador i,mediante el ciclo for, este arreglo tendrá el tamaño del valor ingresado por el usuario.

En un  segundo ciclo for,  asemos el procedimiento de guardar de forma invertida  en el arreglo2 la serie  que se encuentra en el arreglo. Aquí recorrimos el arreglo  de forma inversa(desde la cantidad que ingresa el usuario hasta 0)y a la vez que vamos guardando en arreglo2 la serie. 

Codigo fuente.

import java.util.Scanner;

public class SerieFibonacci {

public  static void main(String[]args){

         

  

try{/*para estar libre de posibles amenazas al programa(que se caiga

         * por un dato mal ingresado por el ususario)*/

           

        //variables del main

int array[];

int Cant;

int i=0;

     

        //para leer los datos

Scanner Leer=new Scanner (System.in);

            

System.out.println("la cantidad de nuemros que desea ver de la serie Fibonacci.");

       Cant=Integer.parseInt(Leer.next());

       /*variable en la que se guarda lo ingresado por el ususario*/

         

        /*condicion se es menor a cero enviarle un mensaje al ususario

         * que debe ingresar un número mayor a cero    */    

if(Cant<=0) {

          System.out.print("debe ser mayor que 0");

            }

     

         /*si ingresa un numero mayor a cero sigue el codigo*/

else{

     SerieFibonacci s=new SerieFibonacci();

           array=s.serie(Cant);

         /*se crea un objeto de la clase

        * se crea tambien un arreglo llamado array y se le da el valor que

            * retorna el medtodo

            *terminando ser igual al valor que retorna el metodo serie*/

 

     /*anunciamos al usuario que se mostrara la serie inversa*/

System.out.println("La serie fibonacci invertida es: ");

      System.out.println("");

       

     

      /*creamos un ciclo for para recorrer el con

       * los valores obtenidos del metodo*/

for(i=0; i<=Cant-1; i++){

         System.out.print (" "+array[i]);

                       }      

                   }

      

/*excepcion en el caso de que el ususario ingresara un caracter o un tipo de

         * dato que no se le pide, para que de esta manera no se caiga el programa*/

catch(NumberFormatException e){

            System.out.println("Error de ingreso");

            System.out.append("Ingrese un numero entero "+e.getMessage());

           

        }

        /*se ejecuta al final de la aplicacion para anunciar que

         * el programa se finalizo*/  

   finally{

        System.out.println("");

        System.out.println("Programa terminado.");

    }

}

//metodo para determinar la serie de fibonacci.

int[] serie(int Cant2)

{ 

  //inicializamos variables  

    int a=0;

    int i=0;

    int f1=0;

    int f2=1;

    //ambos arreglos tienen el tamaño del valor ingresado por el ususario

    int [] arreglo=new int[Cant2];

    int [] arreglo2=new int[Cant2];

    /*el array arreglo guardara la serie en linea

      el array arreglo2 guardar la serie invertida*/

         

  /*si el numero ingresado por el usuario es 1 el arreglo 2

    guardar este valor. Luego se retornara el arreglo2*/

       if(Cant2==1){

                 

                  arreglo2[a]=0;

                  }

        

  /* Si el valor ingresado por el usuario es mayor a dos se emieza a ejecutar

        * el for para obtener la serie fibonacci*/

       if(Cant2>=2){

     

                   for(i=0; i<=Cant2-1; i++)

                  {

                    arreglo[i]=f1;

                    f2+=f1;

                    f1 = f2 - f1;     

                  }

/* con el segundo for recorremos el primer arreglo en forma invertida para

  * ir guardando en el segundo arreglo la serie fibonacci de forma invertida*/                  

                   for(i=Cant2-1; i>=0; i--)

                   {

                    arreglo2[a]=arreglo[i];

                         

                    a++;

                   }

             

                 }

/*retornamos el arreglo con la serie invertida guarda a la clase principal*/

  return arreglo2;    

}

}

 Captura del programa





 Conclusion.

La determinacion de la serie de fibonaccio requier de conocimiento de funciones en matematicas ademas de una serie programacion, ya que seutiliza el ciclo for, contadores, y lo primordial de esta actividad los arreglos, algo muy faci de aprender y de utilizar, resultando ser muy utiles para diferentes propositos.