Mostrando entradas con la etiqueta Programación I-Estructuras Repetitivas. Mostrar todas las entradas
Mostrando entradas con la etiqueta Programación I-Estructuras Repetitivas. Mostrar todas las entradas

martes, 5 de abril de 2011

Calculo de una serie nivel intermedio. #01

 Desarrollar un algoritmo para calcular la siguiente serie.

Sí el valor de x = 2 y se repite 3 veces entonces:

Ahora sabemos que tipo de estructura podemos usar:
Sabiendo el número de veces que se va a repetir; se usaría una automática.

Ésta serie se puede repetir la cantidad de veces que el usuario indique, además se solicitará como dato de entrada el valor de “x” para realizar dicho calculo.


Existen varias formas de realizar dicho ejercicio. 
Para ello primero dividimos el problema en varias partes. 
------------------------------------------------------------------------------------
Entrada


vecesRepetirSerie
   x


--------------------------------------------------------------------------
Proceso


numerador = 12
exponencial = 0
coeficiente = 1
serie = 0
haga desde i=1 hasta vecesRepetirSerie
   denominador = x^exponencial
   exponencial = exponencial + 3.5
   termino = numerador/denominador
   numerador = numerador + 3
   si i MOD 2 = 0 entonces
      termino = (-1)*termino
   fin_si
   serie = serie + termino
   imprimir(“El termino ”; i “es ”; termino)
fin_desde
             imprimir(“El resultado de la serie es: ”; serie)


--------------------------------------------------------------------------
Salida

termino
   serie

--------------------------------------------------------------------------
DESARROLLO DEL ALGORITMO

inicio_calculoSerie
   var numerador:real
   var exponencial:real
   var serie:real
   var denominador:real
   var termino:real
   var i:entero
   numerador = 12
   exponencial = 0
   serie = 0
   vecesRepetirSerie = leer(“Ingrese el número de veces a repetir la serie”)
   x = leer(“Ingrese el valor de x”)
   haga desde i=1 hasta vecesRepetirSerie
      denominador = x^exponencial
      exponencial = exponencial + 3.5
      termino = numerador/denominador
      numerador = numerador + 3
      si i MOD 2 = 0 entonces
             termino = (-1)*termino              
      fin_si
      serie = serie + termino
      imprimir(“El termino ”; i “es ”; termino)
   fin_desde
   imprimir(“El resultado de la serie es: ”; serie)
fin_calculoSerie


UAL



haga desde i=1 hasta vecesRepetirSerie
(¿1<=3?)
True
(¿2<=3?)
True
(¿3<=3?)
True
(¿4<=3?)
False
denominador = x^exponencial
2^0=1
2^3.5=11.31
2^7=128
exponencial = exponencial + 3.5
0+3.5=3.5
3.5+3.5=7
7+3.5=10.5

termino = numerador/denominador
12/1=12
15/11.31=1.3262
18/128=0.14

numerador = numerador + 3
12+3=15
15+3=18
18+3=21

si i MOD 2 = 0 entonces
1MOD2=1; ¿1=0?
False
2MOD2=0;
¿0=0?
True

3MOD2=1;
¿1=0?
False

termino = (-1)*termino

(-1)*1.3262=-1.3262


serie = serie + termino
0+12=12
12+(-1.3262)=10.67
10.67+0.14=10.81

i=i+1
1+1=2
2+1=3
3+1=4









Memoria

numerador
12
15
18
21

exponencial
0
3.5
7
10.5

serie
0
12
10.67
10.81

denominador
1
11.31
128


termino
12
1.3262
-1.3262
0.14

i
1
2
3
4

vecesRepetirSerie
3




x
2






Pantalla
Ingrese el número de veces a repetir la serie
  3
Ingrese el valor de x
   2
El termino 1 es 12
El termino 2 es -1.32
El termino 3 es 0.14
El resultado de la serie es 10.81

lunes, 4 de abril de 2011

Realizar el algoritmo para el cálculo del factorial de un número

Algoritmo en pseudocódigo para el cálculo del factorial de un número

Desarrollar un algoritmo para calcular e imprimir el factorial de un número.


Eg. Se desea programar el siguiente algoritmo:


                5! = 1x2x3x4x5 = 120
                4! = 1x2x3x4 = 24
                3! = 1x2x3 = 6
                2! = 1x2 = 1
                1! = 1
                0! = 1


1) Se debe solicitar al usuario el numero del factorial a calcular. 

En este caso sería "n" que es el número de entrada que es 5.

Luego; la estructura repetitiva está en el cálculo mismo del número. 

2) Para el cálculo de 5! el ciclo se repetirá desde 1 hasta 5 inclusivos.

3) Usaremos una estructura repetitiva automática ya que sabemos el número de veces que se repetirá dicha estructura.



Entrada

numero = 5

-------------------------------------------

Proceso

  1. factorial = 1
  2. si numero >= 1 entonces
  3.    haga desde i=1 hasta numero
  4.       factorial = factorial*i
  5.    fin_desde
  6. sino
  7.    si numero = 0
  8.       factorial = 1
  9.    sino
  10.       imprimir("No se puede calcular factorial; número negativo")
  11.    fin_si  
  12. fin_si
     
------------------------------------------------------------------------------------------------------------------------


Salida

factorial



DESARROLLO DEL ALGORITMO


inicio calculoFactorial
   1:var factorial:real
   2:var numero:real
      3:numero = Leer("Ingrese un número natural")
   4:factorial = 1
   5:si numero >= 1 entonces
      6:haga desde i=1 hasta numero
         7:factorial = factorial*i
      8:fin_desde
   9:sino
      10:si numero = 0
         11:factorial = 1
      12:sino
         13:imprimir("No se puede calcular factorial; número invalido")
      14:fin_si  
   15:fin_si
   16:imprimir"El factorial de: ";  numero  "es: ";  factorial
17:fin calculoFactorial

-------------------------------------------------
Corrida:




(¿1<=3?)
(¿2<=3?)
(¿3<=3?)
(¿4<=3?)
si numero >= 1 entonces
TRUE
True
True
FALSE
haga desde i=1 hasta numero
TRUE



factorial = factorial*i
1*1=1
1*2=2
2*3=6

i = i+1
1+1=2
2+1=3
3+1=4