martes, 2 de octubre de 2012

Ejercicio 13. Puente

PROBLEMA: Suponga que deseamos construir un puente igual al de la siguiente figura

¿Cuál es la distancia flotante del puente?

ALGORITMO
Entradas:  Numérico angulo
                   Numérico altura
Salidas:     Numérico  distancia

INICIO
Leer angulo
Leer altura
Resta 90 menos angulo y guardar en angulo
Calcular tangente de angul  y guardar en angulo
Multiplicar angulo por altura y guardar en distancia
Multiplicar distancia por 3
Imprimir distancia
FIN

PSEUDOCÓDIGO
class   Distancia_puente
          // Declaraciones (entradas)
              real:  angulo
              real:  altura
          // Declaraciones (salidas)
              real:  distancia
          // Procedimiento
main
            print  "Ingresar el ángulo"
            scan  angulo
            print  "Ingresa la altura"
            scan  altura
                     angulo = 90 - angulo
                     angulo = tangente (angulo)
                     distancia = angulo * altura
                     distancia = distancia * 3
             print  "La distancia del puente es:"
             print  distancia
end_main
     

Ejercicio 12. Terreno cercado

PROBLEMA: Si tengo un terreno que tiene 2 hectáreas de superficie y quiero cercarlo con alambre de puas, ¿Cuántos metros de alambre necesito comprar?

ALGORITMO
Entradas:  Numérico  numero_hectareas
Salidas:     Numérico  perimetro

INICIO
Leer numero_hectareas
Multiplicar numero_hectareas por 10 000 y guardar en area
Sacar raiz de area y guardar en valor_unLado
Multiplicar cuatro por valor_unLado y guardar en perimetro
Imprimir perimetro
FIN

PSEUDOCÓDIGO
class   Terreno_cercado
          // Declaraciones  (entradas)
             real: numero_hectareas
          // Declaraciones  (salidas)
             real: perimetro
          // Procedimiento
main
           print  "Ingresar el número de hectáreas que tiene el terreno de superficie"
           scan  numero_hectareas
                    area = numero_hectareas * 10 000
                    valor_unLado = raiz (area)
                    perimetro = 4 * valor_unLado
           print  "La cantidad de metros de alambre necesario es:"
           print  perimetro
end_main

                

Ejercicio 11. Lago circular

PROBLEMA: Carlos tarda una hora y media en cruzar nadando un lago circular a una velocidad constante de 5 Km/h, ¿Cuánto tiempo tardaría en darle la vuelta completa al lago a la misma velocidad?

ALGORITMO
Entradas:  Numérico  velocidad
                   Numérico  tiempo
                   Numérico  PI
Salidas:     Numérico  tiempo_final

INICIO
Leer velocidad
Leer tiempo
Establecer PI
Multiplicar velocidad por tiempo y guardar en distancia
Multiplicar PI por distancia y guardar en perimetro
Dividir perimetro entre velocidad y guardar en tiempo_final
Imprimir tiempo_final
FIN

PSEUDOCÓDIGO
class   Lago_circular
          // Declaraciones (entradas)
              real:  velocidad
              real:  tiempo
              real:  PI = 3.1416
          // Declaraciones (salidas)
              real:  tiempo_final
          // Procedimiento
main
          print  "Ingresar la velocidad del nadador"
          scan  velocidad
          print  "Ingresar el tiempo que tarda en cruzar el lago"
          scan  tiempo
                   distancia = velocidad * tiempo
                   perimetro = PI * distancia
                   tiempo_final = perimetro / velocidad
          print  "El tiempo que tarda el nadador en recorres el perímetro del lago es:"
          print  tiempo_final
end_main
 

Ejercicio 10. Vector

PROBLEMA: Resuelve lo suguiente.

vector = [((x * mov)+(2 / torque)) * (y / mov)] + [3 * (momento * angulo)]

ALGORITMO
Entradas:   Numérico mov
                    Numércio torque
                    Numérico momento
                    Numérico angulo
                    Numérico x
                    Numérico y
Salidas:      Numérico vector

INICIO
Leer mov
Leer torque
Leer momento
Leer angulo
Leer x
Leer y
Multiplicar x por mov y guardar en r1
Dividir 2 entre torque y guardar en r2
Sumar r1 mas r2 y guardar en r1
Dividir y entre mov y guardar en r2
Multiplicar r1 por r2 y guardar en r1
Multiplicar momento por angulo y guardar en r2
Multiplicar r2 por 3 y guardar en r2
Sumar r1 mas r2 y guardar en vector
Imprimir vector
FIN

PSEUDOCÓGIDO
class   Vector
          // Declaraciones (entradas)
             real:  mov
             real:  torque
             real:  momento
             real:  angulo
             real:  x
             real:  y
          // Declaraciones (salidas)
             real:  vector
          // Procedimiento
main   
           print  "Ingresar el valor de mov"
           scan  mov
           print  "Ingresar el valor de torque"
           scan  torque
           print  "Ingresar el valor de momento"
           scan  momento
           print  "Ingresar el valor del ángulo"
           scan  angulo
           print  "Ingresar el valor de X"
           scan  x
           print  "Ingresar el valor de Y"
           scan  y
                    r1 = x * mov
                    r2 = 2 / torque
                    r1 = r1 + r2
                    r2 = y / mov
                    r1 = r1 * r2
                    r2 = momento * angulo
                    r2 = r2 * 3
                    vector = r1 + r2
          print  "El valor de vector es:"
          print vector
end_main

Ejercicio 9. Resultado

PROBLEMA: Resolver la siguiente ecuación

resultado = altura + masa^2 / area    = [(altura) + ((masa * masa)/area)] / [raiz(velocidad+peso)]
                  raiz (velocidad + peso)

ALGORITMO
Entradas:  Numérico   altura
                Numérico   masa
                Numérico   area
                Numérico   velocidad
                Numérico   peso
Salidas:    Numérico   resultado

INICIO
Leer altura
Leer masa
Leer area
Leer velocidad
Leer peso
Multiplicar masa por masa y guardar en r1
Dividir r1 entre area y guardar en r1
Sumar altura mas r1 y guardar en r1
Sumar velocidad mas peso y guardar en r2
Sacara la raiz de r2 y guardar en r2
Dividir r1 entre r2 y guardar en resultado 
Imprimir resultado
FIN


PSEUDOCÓDIGO
class  Resultado_de_ecuacion
          // Declaraciones (entradas)
              real:  altura
              real:  masa
              real:  area
              real:  velocidad
              real:  peso
          // Declaraciones (salidas)
              real:  resultado
          // Procedimiento
main
            print  "Ingresar el valor de la altura"
            scan  altura
            print  "Ingresar el valor de la mas"
            scan  masa
            print  "Ingresar el valor del área"
            scan  area
            print  "Ingresar el valor de la velocidad"
            scan  velocidad
            print  "Ingresar el valor del peso"
            scan  peso
                      r1 = masa * masa
                      r1 = r1 / area
                      r1 = altura + r1
                      r2 = velocidad + peso
                      r2 = raiz (r2)
                      resultado = r1 / r2
           print  "El resultado de la ecuación es:"
           print  resultado
end_main



Ejercicio 8. Ecuación

PROBLEMA: Resolver la siguiente ecuación...

r = 2x+3y*5z      =       r = [(2*x)+((3*y)*(5*z))] / [(x*x)+(y*y)]



        x2+y


ALGOTIRMO
Entradas:  Numérico  x
                Numérico  y     
                Numérico  z
Salidas:    Numérico   r        

INICIO
Leer x
Leer y
Leer z
Multiplicar 3 por y  y guardar en r1
Multiplicar 5 por z y guardar en r2
Multiplicar r1 por r2 y guardar en r1
Multiplicar 2 por x y guardar en r2
Sumar r1 mas r2 y guardar en r1
Multiplicar x por x y guardar en r2
Multiplicar y por y y guardar en r3
Sumar r2 mas r3 y guardar en r2
Dividir r1 entre r2 y guardar en r
Imprimir r
FIN


PSEUDOCÓDIGO
class   Ecuacion
           // Declaraciones (entradas)
               real:  x
               real:  y
               real:  z
            // Declaraciones (salidas) 
               real:  r
            // Procedimiento
main
              print  "Ingresar el valor de X"
              scan  x
              print  "Ingrsar el valor de Y"
              scan  y
              print  "Ingresar el valor de Z"
              scan  z
                        r1 = 3 * y
                        r2 = 5 * z
                        r1 = r1 * r2
                        r2 = 2 * x
                        r1 = r1 + r2
                        r2 = x * x
                        r3 = y * y
                        r2 = r2 + r3
                          r = r1 / r2
             print  "El resultado de la ecuación es:"
             print  r
end_main

Ejercicio 7. Llegada de Melissa

PROBLEMA: Melissa llega al salón a las 7:15 am, suponiendo que se baja del autobús a las 7:00 am y que de la entrada de la universidad a la puerta del laboratorio CB-09 hay 3028 m ¿Cuál es la velocidad constante a la que debe caminar Melissa?

ALGORITMO
Entradas:  Numérico   baja_autobus
                   Numérico   entrada_salon
                   Numérico   distancia
Salidas:     Numérico   velocidad

INICIO
Leer baja_autobus
Leer entrada_salon

Leer distancia
Restar entrada_salon menos baja_autobus y guardar en tiempo
Dividir distancia entre tiempo y guardar en velocidad
Imprimir velocidad
FIN

PSEUDOCÓDIGO
class   Llegada_de_Melissa
          // Declaraciones (entradas)
             real:   baja_autobus
             real:   entrada_salon
             real:   distancia
           // Declaraciones (salidas)
             real:   velocidad
           // Procedimiento
main
           print  "Ingresar la hora en que baja del autobús"
           scan  baja_autobus
           print  "Ingresar la hora en que entra al salón"
           scan  entrada_salon
           print  "Ingresar la distancia entre la entrada de la universidad y el salón"
           scan  distancia
                    tiempo = entrada_salon - baja_autobus
                    velocidad = distancia / tiempo
           print  "La velocidad constante de Melissa es:"
           print  velocidad
end_main

Ejercicio 6. Edad de una persona

PROBLEMA: Conociendo la fecha de nacimeinto de una persona  y el año actual, determinar  cuál es la edad de la persona en el año actual.

ALGORITMO
Entradas:  Alfanumérico  fecha_nacimiento
                Numérico  anio_actual
Salidas:     Numérico  edad_persona
INICIO
Leer fecha nacimiento
Leer anio_actual
Seleccionar  anio_nacimiento
Restar anio_actal menos anio_nacimiento y guardar en edad_persona
Imprimir edad_persona
FIN

PSEUDOCÓDIGO
class  Edad_persona
         // Declaraciones (entradas)
            cadena:  fecha_nacimiento
            real:  anio_actual
         // Declaraciones (salidas)
            entero:  edad_persona
         // Procedimiento
main
             print  "Ingresar la fecha de nacimiento de la persona"
             scan  fecha_nacimiento
             print  "Ingresar el año actual"
             scan  anio_actual
                      edad_persona = anio_actual - anio_nacimiento
             print  "La edad de la persona es:"
             print  edad_persona
end_main
          
         

Ejercicio 5. Papalote Hexagonal

PROBLEMA: Suponga que quiere crear un papalote hexagonal que mida 30 cm de lado con una distancia de 25 cm hasta el centro del papalote y lo quiere adornar con estampitas de hadas, ¿Qué tamaño deben tener las estampitas para poder pegarle 30 estampitas?

ALGORITMO
Entradas:  Numérico  longitud_lado
                 Numérico  apotema
                 Numérico  numero_estampitas
                 Numérico  LADOS
Salidas:    Numérico  area_estampitas
INICIO
Leer longitud_lado
Leer apotema
Leer numero_estampitas
Establecer LADOS
Multiplicar longitud_lado por LADOS y guardar en perimetro
Multiplicar perimetro por apotema y guardar en area
Dividir area entre 2 y guardar en area
Dividir area entre numero_estampitas y guardar en area_estampitas
Imprimir area_estampitas
FIN

PSEUDOCÓDIGO
class   Papalote_hexagonal
          //  Declaraciones (entradas)
              real:  longitud_lado
              real:  apotema
              real:  numero_estampitas
              entero:  LADOS = 6
          //  Declaraciones (salidas)
              real:  area_estampitas
          //  Procedimiento
main
              print  "Ingresar la longitud de cada lado"
              scan  longitud_lado
              print  "Ingresar el valor del apotema"
              scan  apotema
              print  "Ingresar el número de estampitas"
              scan  numero_estampitas
                       perimetro = longitud_lado * LADOS
                       area = perimetro * apotema
                       area = area / 2
                       area_estampitas = area / numero_estampitas
              print  "El áre de cada estampita en el papalote es:"
              print  area_estampitas
end_main
 

Ejercicio 4. Hexadrilatero

PROBLEMA: Si suponemos que un hexadrilatero de lucha libre tiene una longitud de 3 metros por lado y la distancia del centro a uno de los lados es de 2.8 metros, ¿Cuántos luchadores caben en él si cada luchador ocupa un area de 1m^2?

ALGORITMO
Entradas:   Numérico  longitud_lado
                  Numérico  apotema
                  Numérico  area_luchador
                  Numérico  LADOS
Salidas:     Numérico  numero_luchadores
INICIO
Leer longitud_lado
Leer apotema
Leer area_luchador
Establecer LADOS
Multiplicar longitud_lado por LADOS y guardar en perimetro
Multiplicar perimetro por apotema y guardar en area
Dividir area entre dos y guardar en area
Dividir area entre area_luchador y guardar en numero_luchadores
Imprimir numero_luchadores
FIN

PSEUDOCÓDIGO
class   Hexadrilatero
          // Declaraciones (entradas)
             real: longitud_lado
             real: apotema
             real: area_luchador
             entero: LADOS = 6
          // Declaraciones (salidas)
             real: numero_luchadores
          // Procedimiento
main
           print "Ingresa la longitud de cada lado del hexadrilatero"
           scan  longitud_lado
           print  "Ingresa el valor del apotema"
           scan  apotema
           print  "Ingresa el área de cada luchador"
           scan  area_luchador
                    perimetro = longitud_lado * LADOS
                    area = perimetro * apotema
                    area = area / 2
                    numero_luchadores = area / area_luchador
           print  "El número de luchadores que caben en el hexadrilatero es:"
           print  numero_luchadores
end_main

lunes, 1 de octubre de 2012

Ejercicio 3. Movimiento

PROBLEMA: Un corredor tarda 10 segundos en recorrer 100 metros, si suponemos que su velocidad es constante ¿Cuál es su velocidad en Km/hr?

ALGORITMO
Entradas:   Numérico   tirmpo
                 Numérico  distancia
Salidas:      Numérico   velocidad
INCIIO
Leer tiempo
Leer distancia
Dividir tiempo entre  3600 y guardar en tiempo
Dividir distancia entre 1000 y guardar en distancia
Dividir distancia entre tiempo y guardar en velocidad
Imprimir velocidad
FIN

PSEUDOCÓDIGO
class   VelocidadCorredor
          // Declaraciones (entradas)
             real:   tiempo
             real:   distancia
          // Procedimiento
              real: velocidad
main
          print   "Ingresa el tiempo en segundos del corredor"
          scan   tiempo
          print   "Ingresa la distancia recorrida en metros"
          scan   distancia
          tiempo = tiempo / 3600
          distancia = distancia entre 1000
          velocidad = distancia / tiempo
          print   "La velocidad del corredor en Km/Hr es:"
          print   velocidad
end_main



Ejercicio 2. Teorema de Pitágoras

PROBLEMA: Si estas parado frente a un edificio de 5 pisos donde cada piso tiene una altura de 3 metros y  tu te encuentras a 25 metros del edificio. ¿Cuál es la distancia entre tus ojos y la cima del edificio.

ALGORITMO
Entradas:   Numérico   ap (altura de la persona)
                 Numérico   np (número de pisos)
                 Numérico   ape (altura de cada piso)
                 Numérico   dist (distancia entre la persona y el edificio)
Salidas:     Numérico   h  (hipotenusa = distancia entre los ojos y la cima del edificio)
INICIO
Leer ap
Leer np
Leer ape
Leer dist
Restar ap menos .10 y guardar en ap
Multiplicar np  por ape y guardar en ae
Restar ae menos ap y guardar en ae
Elevar ae al cuadrado y guardar en ae
Elevar dist al cuadrado y guardar en dist
Sumar ae mas dist y guardar en h
Calcular la raiz cuadrada de h y guardar en h
Imprimir h
FIN

PSEUDOCÓDIGO
class   DistanciaEdificioPersona
          // Declaraciones (entradas)
             real:   ap
             real:   np
             real:   ape
             real:   dist
          // Declaraciones (salidas)
             real:   h
main
         print  "Introduce la altura de la persona"
         scan  ap
         print  "Ingresa el número de pisos del edificio"
         scan  np
         print  "Ingresa la altura de cada piso"
         scan  ape
         print  "Ingresa la distancia entre la persona y el edificio"
         scan  dist
         ap = ap-.10
         ae = np*ape
         ae = ae-ap
         ae = ae^2
         dist = dist^2
         h = ae+dist
         h = raiz(h)
         print  "La distancia de los ojos al techo es:"
         print  h
end_main