Ejercicio 5

Polígonos regulares

Área:    A=P*A/2

Perímetro: L*nl

Si suponemos que un exadrilatero de lucha libre tiene una longitud de 3m por lado y la distancia del centro a uno de los lados es de 2.8m. ¿Cuántos luchadores caben en el si cada luchador ocupa un área de 1m¨2?

A= P*a/2

P= L*nl

P=3m*6 =18m

A= 18m*2.8m

A= 50.4/2

A=25.2m

Algoritmo

Entradas: Numérico longitud_lado (3m)

            Numérico apotema (2.8)

            Numérico lados (6)

            Numérico area_luchador (1m)

Salidas: Numero_luchadores

Inicio

•      Leer longitud_lado

•      Establecer LADOS

•      Leer apotema

•      Leer area_luchador

•      Multiplicar longitud_lado por LADOS y guardar en Perímetro

•      Multiplicar Perímetro por apotema y guardar en Área

•      Dividir Área entre dos

•      Dividir Área entre area_luchador

•      Imprimir numero_luchadores

Fin

Diagrama de flujo

Pseudocodigo

Class  Polígonos Regulares
//Declaraciones (entradas)

Real: longitud_lado

Real: apotema

Entero: estampas

Entero: lados

Real: area_luchador
//Declaraciones (salidas)
Entero numero_luchadores
//Procedimiento

Main

Print “Ingresa longitud de lados”

Scan longitud_lado

Print “Ingresar apotema”

Scan apotema

Print “Ingresa area de luchador”

Scan area_luchador

Print “Ingresa numero de lados”

Scan lados

perímetro=  longitud_lado*lados

area= perímetro*apotema

area= area/2

numero_luchadores= area/area_luchador

Print “Los numero de luchadores son”

Scan numero_luchadores

End_main

Ejercicio 4

Polígonos Regulares

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*a/2

P= 30cm* 6 =180cm

A= 180cm * 25cm/2

A= 2250cm

A= 2250cm/30= 75.

Algoritmo

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 numero de estampas

•      Leer apotema

•      Multiplicar longitud_lado por LADOS y guardar en Perímetro

•      Multiplicar Perímetro por apotema y guardar en área

•      Dividir área entre dos

•      Dividir área entre estampas

•      Imprimir area_estampas

Fin

Diagrama de flujo

Pseudocodigo

Class  Polígonos Regulares
//Declaraciones (entradas)

Real: longitud_lado

Real: apotema

Entero: estampas

Entero: lados
//Declaraciones (salidas)

Real: area_estampas
//Procedimiento

Main

Print “Ingresa longitud de lados”

Scan longitud_lado

Print “Ingresar apotema”

Scan apotema

Print “Ingresa numero de estampas”

Scan estampas

Print “Ingresa numero de lados”

Scan lados

perímetro=  longitud_lado*lados

area= perímetro*apotema

área= area/2

area_estampas= area/estampas

Print “El area que deben tener las estampas son”

Scan area_estampas

End_main

Ejercicio 3

Movimiento  V= D/T

Un corredor, tarda 10 segundos En recorrer 100m, si suponemos que su velocidad es constante. ¿Cuál es la velocidad en KM/H ?

V=D/T

T= 10 Seg.

D= 100m.

10 seg/ 3600 seg = 0.00277 Horas

100m/1000m =0.1KM

V= 0.1Km/0.00277H

= 0.33 KM/H.

Algoritmo

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

Diagrama de flujo

                                              Pseudocodigo

Class  Movimiento  V= D/T
//Declaraciones (entradas)

Real: distancia

Real: tiempo
//Declaraciones (salidas)

Real: velocidad
//Procedimiento

Main

Print “Ingresa el tiempo en segundos”

Scan tiempo

Print “Ingresa distancia en metros”

Scan distancia

tiempo= tiempo/3600

distancia= distancia/1000

Print “La velocidad del corredor en KM/H es”

Scan velocidad

End_main

Ejercicio 2

Teorema de Pitágoras C¨2= a¨2+b¨2

Si estás parado de frente a un edifico de 5 pisos, donde cada piso tiene una altura de 3m y tu te encuentras a 25m del edificio. ¿Qué distancia hay entre tus ojos y la cima del edificio?

C´2= ¿?                    

A¨2= 3*5 = 15m

B¨2= 25m

C¨2= 15^2* 25^2

C¨2= 255 * 625

C¨2= ̸̸̸̸̸̸¨255+625

C¨2= 29.66 m

29.96 - .10 cm

28.3 m

Algoritmo

Entradas: numérico, distancia_persona

              numérico, altura_persona

              numérico, numero_pisos

              numérico, altura_piso

Salidas: numérico, distancia

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

Diagrama de flujo

Pseudocodigo

Class  Teorema de Pitágoras C¨2= a¨2+b¨2
//Declaraciones (entradas)
Real: AE

Real: altura_persona

Entero: numero_pisos

Real: altura_piso

Real: distancia_persona
//Declaraciones (salidas)

Real: distancia
//Procedimiento

Main

Print “Ingresa altura de la persona”

Scan altura_persona

Print “Ingresa numero de pisos”

Scan numero_pisos

Print “Ingresa altura de cada piso”

Scan altura_piso

Print “Ingresa distancia entre persona y edificio”

Scan distancia_persona

altura_persona= altura_persona - .10

AE= numero_pisos*altura_piso

AE= AE*AE

distancia_persona= distancia_persona*distancia_persona

distancia= distancia_persona + AE

distancia= raíz (distancia)

Print “La distancia entre los ojos de la persona y la cima del edificio es”

Scan distancia

End_main

Ejercicio 1

2ª Ley de Newton  F=m*a

Si tenemos una pelota que tiene una masa equivalente a 200gr. ¿Cuál es la fuerza que tendríamos que aplicar para mover la pelota, y esta se acelere a 3m/s ´2.?

M= 200gr.                       MULTIPLICAR

A= 3m/s¨2                       0.2 Kg * 3 m/s¨2

F= ¿?                              RESULTADO  0.6 m/s¨2

1 gr = 0.1Kg

200gr = 0.2Kg

Algoritmo

Entradas: Numérico, masa_pelota (200gr)

               Numérico, aceleracion (3m/s´2)

Salidas: numérico, fuerza (m/s´2)

Inicio

-leer masa_pelota (200)

-leer aceleracion (3)

-dividir masa_pelota entre (1000)

-multiplicar  por aceleracion

-guardar en fuerza

-imprimir fuerza

Fin

Diagrama de flujo

Pseudocodigo

Class  2ª Ley de Newton  F=m*a
//Declaraciones (entradas)

Real: masa_pelota

Real: aceleración
//Declaraciones (salidas)

Real: fuerza
//Procedimiento

Main

Print “Ingresa masa de la pelota”

Scan masa_pelota

Print “Ingresa valor de la aceleración”

Scan aceleracion

masa_pelota= masa_pelota/1000

fuerza= masa_pelota*aceleracion

Print “La fuerza que tendremos que aplicar  a la pelota es”

Scan fuerza

End_main