Algoritmo 3

Entradas: numérico distancia (D), numérico tiempo(T)
Salidas: numérico velocidad (V)
Inicio
Leer distancia (D)
Leer tiempo (T)
Dividir (T) entre 3600s
Guardar en (H)
Dividir (D) entre 1000m
Guardar en (D)
Dividir (D) por (H)
Guardar en (V)
Imprimir resultado (V)
Fin

Pseudo Codigo

Class Movimiento
// Declaraciones (Entradas)
real: tiempo
real: distancia
// Declaraciones (Salidas)
real: velocidad
// Procedimiento
main
print "ingresa el tiempo en segundos"
scan tiempo
print "ingresa la distancia en metros"
scan distancia
tiempo=tiempo/3600
distancia=distancia/1000
velocidad=distancia/tiempo
print "la velocidad del corredor en KM/H es"
print velocidad
end_main 

El puente colgante

Si tengo un puente de una distancia colgante x y quiero saber cuanto mide teniendo los ángulos... ¿Cuál es la distancia de ese puente colgante?

 

Algoritmo 13

Entradas: numérico angulo_uno (60º), numérico altura (25m)

Salidas: numérico distancia (?)
Inicio
Leer angulo_uno
Leer altura
Restar 90 menos angulo_uno
Multiplicar altura entre coseno de angulo_uno
Guardar en distancia
Multiplicar distancia por 3
Guardar en distancia
Imprimir distancia
Fin

Diagrama de Flujo

Pseudo Codigo

Class El puente colgante
// Declaraciones (Entradas)
entero: angulo_uno

entero: altura
// Declaraciones (Salidas)
real: distancia
// Procedimiento
main
print "Introduce el ángulo uno"
scan angulo_uno

print "Introduce la altura"
scan altura
angulo_uno=90-angulo_uno

distancia=altura x coseno(angulo_uno)

distancia=distancia x 3
print "La distancia del puente es de"
print distancia
end_main

Hectáreas

Si tengo un terreno que tiene 2 hectáreas de superficie y quiero cercarlo con alambre de púas... ¿Cuántos metros de alambre necesito comprar?

Área

A= L x L
A = L^2
A= 141 x 141
A = 141^2
A= 141
Perímetro
P= 4 x L
P= 4 + (141)
P= 564

Algoritmo 12

Entradas: numérico numero_hectareas

Salidas: numérico metros_alambre
Inicio
Leer numero_hectareas
Multiplicar numero_hectareas por 10000
Guardar en numero_hectareas
Calcular la raiz de numero_hectareas
Guardar en metros_alambre
Multiplicar metros_alambre por 4
Guardar en metros alambre
Imprimir metros_alambre
Fin

Digrama de Flujo

Pseudo Codigo

Class Terreno con hectareas
// Declaraciones (Entradas)
real: numero_hectareas
// Declaraciones (Salidas)
real: metros_alambre
// Procedimiento
main
print "Introduce el numero de hectareas"
scan numero_hectareas
numero_hectareas = numero_hectareas/10000

metros_alambre = metros_alambre * 4
print "Los metros de alambre son"
print metros_alambre
end_main

Ejercicio 11

Carlos tarda 1 hora y media en cruzar nadando un lago circular a una velocidad constante de 5Km/h.¿Cuánto tiempo tardaría si quisiera darle una vuelta completa a lo largo a la misma velocidad?

V= D/T
V= 5Km / h
T= 1.5 h

D= V x T

D= 7.5 KM

3.1416 x D = Perímetro

3.1416 x 7.25 = 23.562 Km

Algoritmo 11

 

Entradas: numérico velocidad, numérico tiempo_inicial, numérico PI

Salidas: numérico tiempo_circular
Inicio
Leer valor velocidad
Leer valor tiempo_inicial
Establecer PI
Multiplicar velocidad por tiempo_inicial
Guardar en diametro
Multiplicar PI por diametro
Guardar en perimetro
Dividir perimetro entre velocidad
Guardar en tiempo_circular
Imprimir tiempo_circular
Fin

Diagrama de Flujo

 

Pseudo Codigo

Class Carlos nadando
// Declaraciones (Entradas)
real: velocidad

real: tiempo_inicial
entero: PI
// Declaraciones (Salidas)
real: tiempo_circular
// Procedimiento
main
print "Introduce el valor de la velocidad"
scan velocidad
print "Introduce el tiempo inicial"
scan tiempo_inicial
diámetro=velocidad x tiempo_inicial
perimetro=PI x diametro
tiempo_circular=perimetro/velocidad
print "El tiempo en recorrer el lago es de"
print tiempo_circular
end_main

Formula 3

Vector = { (( x*mov) + (2 / torque)) * (y/mov)} + {3*Momento * ángulo )}

 

Algoritmo 10

Entradas: numérico x, numérico mov, numérico torque, numérico y, numérico momento, numérico vector

Salidas: Numérico vector
Inicio
Leer x
Leer mov
Leer torque
Leer y
Leer momento
Leer vector
Multiplicar x por mov
Guardar en R1
Dividir 2 entre torque
Guardar en R2
Multiplicar R1 por R2
Guardar en R1
Multiplicar momento por angulo
Guardar en R2
Multiplicar R2 por3
Guardar en R2
Sumar R1 mas R2
Guardar en vector
Imprimir vector
Fin

Diagrama de Flujo

 

 

Pseudo Codigo

Class Vector torque
// Declaraciones (Entradas)
real: x

real: mov

real: torque

real: y

real: momento

real: vector
// Declaraciones (Salidas)
real: vector_final
// Procedimiento
main
print "Introduce el valor de x"
scan x
print "Introduce el valor de mov"
can mov

print "Introduce el valor de torque"
scan torque

print "Introduce el valor de y"
scan y

print "Introduce el valor del momento"
scan momento

print "Introduce el valor del vector"
scan vector

r1=x*mov

r2=r1/torque

r1=altura+r1

r1=r1 * r2

vector=vector_final

vector_final=r1+r2
print "El resultado del vector es"
print vector_final
end_main

 

Fórmula 2

altura + masa^2 / área / \Velocidad + peso

Resultado = {((masa x masa) / área) + altura) / (\Velocidad x peso)}

Algoritmo 9

Entradas: numérico altura, numérico masa, numérico área, numérico velocidad, numérico peso

Salidas: numérico resultado
Inicio
Leer valor altura
Leer valor masa
Leer valor área
Leer valor velocidad
Leer valor peso
Multiplicar masa por masa
Guardar en R1
Dividir R1 entre área
Sumar altura mas R1
Guardar en R1
Sumar velocidad mas peso y guardar en R2
Sacar la raíz de R2
Guardar en R2
Dividir R1 entre R2
Guardar en resultado
Imprimir resultado
Fin

Formula

R= 2x+ 3y * 5z / x^2 + y^2

El primer paso es:
Pasarlo a formula lineal

Separándolo en operaciones básicas.

R= {(2*x) + ((3*y) * (5*z))} / {(x*x) + (y*y)}

ALGORITMO 8

Entradas: numérico x, numérico y, numérico z
Salidas: numérico r
Inicio
Leer valor x
Leer valor y
Leer valor z
Multiplicar 3 por y Y Guardar en R1
Multiplicar 5 por z Y Guardar en R2
Multiplicar R1 por R2 y guardar en R
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

 

Diagrama de Flujo

 

 

Pseudo Codigo

Class Resolver la formula
// Declaraciones (Entradas)
real: x

real: y

real: z
// Declaraciones (Salidas)
real: r
// Procedimiento
main
print «Introduce el valor de x»
scan x
print «Introduce el valor de y»
scan y

print «Introduce el valor de z»
scan z

r1=e*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 es»
print r
end_main

 

Tiempo de melisa

Melisa llega al salón alas 7:15, suponiendo que se baja del autobús alas 7:00 y de la entrada de la universidad a la puerta del laboratorio CB-09 hay 328 metros, ¿Cuál es la velocidad constante a la que debe caminar melisa?

Algoritmo 7

Entradas: numérico distancia_metros (328 m), numérico hora_inicial (7:00), numérico hora_final (7:15)

Salidas: numérico velocidad_constante
Inicio
Leer distancia_metros
Leer hora_inicial
Leer hora_final
Restar hora_inicial menos hora_final
Guardar en tiempo
Dividir distancia_metros entre tiempo
Guardar en velocidad
Imprimir velocidad
Fin

 

Diagrama de Flujo

Pseudo Codigo

 

Class Tiempo de melisa
// Declaraciones (Entradas)
real: distancia

real: tiempo_inicial

real: tiempo_final
// Declaraciones (Salidas)
real: velocidad
// Procedimiento
main
print "Introduce el valor de la distancia en metros"
scan distancia
print "Introduce el valor de la hora inicial"
scan tiempo_inicial

print "Introduce el tiempo final"
scan tiempo_final

velocidad=tiempo_final-tiempo_inicial
print "La velocidad constante a la que debe caminar melisa es"
print velocidad
end_main

 

 

Fecha de nacimiento

Conociendo la fecha de nacimiento de una persona y el año actual, determinar ¿Cuál es la edad de la persona en ese año?

Algoritmo 6

Entradas: alfanumérico fecha_nacimiento numérico anio_actual
Salidas: numérico edad_persona
Inicio
Leer fecha_nacimiento
Leer anio_actual
Seleccionar anio_actual
Seleccionar anio_nacimiento
Restar anio_nacimiento menos anio_actual
Guardar en edad_persona
Imprimir edad_persona
Fin

Diagrama de Flujo

Pseudo Codigo

Class Fecha de nacimiento
// Declaraciones (Entradas)
real: fecha_nacimiento

real: anio_actual
real: ANIO_NACIMIENTO
// Declaraciones (Salidas)
real: edad_actual
// Procedimiento
main
print "Introduce el valor de la fecha de nacimiento"
scan fecha_nacimiento
print "Introduce el año actual"
scan anio_actual
select anio_nacimiento

edad_actual=anio_actual-anio_nacimiento
print "La edad actual es"
print edad_actual
end_main

Polígonos regulares Estampitas

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

A= P x a/2

P= 30cm x 6 =180cm

A= 180cm x 25cm/2

A= 2250cm

A= 2250cm /30= 75.

Algoritmo 5

Entradas: numérico longitud_lado (30cm), numérico apotema (25cm), numérico LADOS (6), numérico estampas (30)
Salidas: numérico area_estampas
Inicio                                             
Leer longitud_lado
Establecer LADOS
Leer apotema
Multiplicar longitud_lado por LADOS y guardar en perimetro
Multiplicar perimetro por apotema y guardar en área
Dividir area entre dos
Dividir area entre estampas
Imprimir area_estampas
Fin

 

Diagrama de Flujo

 

 

 

Pseudo Codigo

Class Polígonos regulares
// Declaraciones (Entradas)
real: longitud_de_lados

real: apotema
entero: LADOS=6
real: area_luchador
// Declaraciones (Salidas)
real: numero_luchadores
// Procedimiento
main
print "Ingresa el valor de longitud de lados"
scan longitud_de_lados
print "ingresa el valor del apotema"
scan apotema
print "ingresa área de luchador"
scan area_luchador
perimetro=longitud_de_lados x LADOS
area=perimetro x apotema
area=area/2
numero_luchadores=area/area_luchador
print "El numero de luchadores que caben en el hexarilatero es de"
print numero_luchadores
end_main

Algoritmo 4

 

Entradas: numérico longitud_lado(3m), numérico apotema(2.8), numérico lados(6), numérico area_luchador (1m)
Salidas: numérico numero_luchadores
Inicio
Leer longitud_lado
Establecer LADOS
Leer apotema
Leer area_luchador
Multiplicar longitud_lado por LADOS y guardar en Perimetro
Multiplicar Perimetro por apotema y guardar en area
Dividir area entre dos
Dividir area entre area_luchador
Imprimir numero_luchadores
Fin

Digrama de Flujo

 

Pseudo Codigo

 

 

 

Class Polígonos regulares

// Declaraciones (Entradas)
real: longitud_de_lados

real: apotema
entero: LADOS=6

real: area_luchador
// Declaraciones (Salidas)
real: numero_luchadores
// Procedimiento
main

print "Ingresa el valor de longitud de lados"
scan longitud_de_lados

print "Ingresa el valor del apotema"
scan apotema
print "Ingresa área de luchador"
scan area_luchador
perimetro=longitud_de_lados x LADOS

area=perimetro x apotema

area=area/2

numero_luchadores=area/area_luchador
print "El numero de luchadores que caben en el hexadrilatero es de: "
print numero_luchadores
end_main

 

Algoritmo 3

Entradas: numérico distancia (D), numérico tiempo(T)
Salidas: numérico velocidad (V)
Inicio
Leer distancia (D)
Leer tiempo (T)
Dividir (T) entre 3600s
Guardar en (H)
Dividir (D) entre 1000m
Guardar en (D)
Dividir (D) por (H)
Guardar en (V)
Imprimir resultado (V)
Fin

Pseudo Codigo

 

Class Movimiento
// Declaraciones (Entradas)
real: tiempo
real: distancia
// Declaraciones (Salidas)
real: velocidad
// Procedimiento
main
print "Ingresa el tiempo en segundos"
scan tiempo
print "Ingresa la distancia en metros"
scan distancia
tiempo=tiempo/3600
distancia=distancia/1000
velocidad=distancia/tiempo
print "La velocidad del corredor en KM/H es"
print velocidad
end_main

 

 

Algoritmo 2

 

Entradas: numérico altura_de_la persona (AP), numérico numero_de_pisos(NP), numérico altura_de_cada_piso(APE), numérico distancia_entrepersona_y_edificio(D)

Salida: numérico distancia_hipotenusa(H)

Inicio
Leer altura de la persona (AP)
Leer numero de pisos (NP)
Leer altura de cada piso (APE)
Leer distancia entre persona y edificio (D)
Restar (AP) menos .10m
Multiplicar NP por APE y guardar en AE
Restar AE menos AP
Elevar AE al cuadrado
Elevar D al cuadrado
Sumar AE y D
Guardar en H
Calcular la raíz cuadrada de H
Imprimir distancia (H)
Fin


 

 

 

 Pseudo Codigo

 

Class Teorema de Pitágoras // Declaraciones (Entradas)
real: ap
real: np
real: ape
real: dist
// Declaraciones (Salidas)
real: h
// Procedimiento
main
print "Ingresa altura persona"
scan ap
print "ingresa numero de pisos"
scan np
print "ingresa altura piso"
scan ap
print "ingresa distancia a edificio"
scan dist
ap=ap-0.10
ae=np x ape
ae=ae - ap
ae=ae^2
dist=dist^2
h=ae + dist
h=raiz(h)
print "la distancia de ojos al techo es"
print h
end_main