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
martes, 2 de octubre de 2012
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
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
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
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
PSEUDOCÓDIGO
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)]
r = 2x+3y*5z = r = [(2*x)+((3*y)*(5*z))] / [(x*x)+(y*y)]
x2+y2
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
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
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
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
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
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
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
Suscribirse a:
Entradas (Atom)