PRACTICA#6

OBEJETIVOS: aprender a identificar y los contadores y acumuladores para su

uso en la programación básica.
ACUMULADOR
 Un acumulador es una variable, a la cual le vamos a incrementar su valor de
forma variable dentro de un ciclo, para ello, la variable debe tener un valor
inicial antes de entrar al ciclo y debemos incrementar o excrementar su valor
dentro del ciclo, veamos un ejemplo:

 En este caso, vamos a sumar tres números, un ejemplo típico del uso de ciclos
y de un acumulador. La variable “t”, servirá de acumulador, observemos que en
la línea 8, antes del FOR, le damos un valor de cero. Dentro del ciclo, una vez
que pedimos el valor de la variable “p”, vemos que en la línea 12 usamos la
típica forma de los acumuladores.
REPORT THIS AD
Acumulador=Acumulador + variable.
 En esta forma, el valor que tiene “t” que es cero, se suma con el de “p”, el
resultado se almacena en “t”, como las variables usan almacenamiento
destructivo, cada vez que le asignamos a una variable el resultado de una
operación, esta almacena el resultado y desecha su valor anterior, de este
forma cuando regresemos en la siguiente iteración “t” contendrá el resultado
anterior y a ese se agregará el nuevo valor.
Como vemos en la imagen anterior, la variable “t” al final almacenó la suma de
los valores que tuvo “p”, cabe señalar que el acumulador igual puede funcionar
con restas, multiplicaciones y divisiones.
CONTADOR

Los ciclos o estructuras repetitivas, son estructuras que permiten indicar dentro
de un programa, que un bloque de instrucciones se ejecutará un número finito
de veces, en este post comenzaremos con el ciclo FOR y veremos algunos de
los usos que tiene.

El ciclo FOR, es un ciclo numérico, basado en el uso de un contador, el cual no

es otra cosa que una variable a la cual le damos un valor inicial y a la que le
iremos incrementando de forma fija su valor, para que nos permita contar el
número de veces o iteraciones que el ciclo ejecuta.

Dado que el ciclo FOR está basado en usar un contador, debemos de saber
con certeza cuántas iteraciones realizará, antes de entrar a el, su sintaxis es
muy simple

FOR (inicio; condición; incremento)

REPORT THIS AD
REPORT THIS AD
 Como podemos ver en la imagen, en la línea 8, definimos un ciclo, FOR en
donde la variable “i” que va a ser el contador del ciclo, se le asigna un valor
inicial de 0, se le indica que el ciclo se ejecutará mientras el valor de i sea
menor de 3; al final vemos la notación de postincremento i++, que equivale a
i=i+1, es decir, incrementar el valor de i en 1 en cada iteración.

La llave que esta después del paréntesis marca el inicio del bloque de
instrucciones que se ejecutará mientras i sea menor de 3, dicho bloque son las
líneas 9 y 10, ya que en la línea 11 vemos la llave que cierra el bloque del ciclo
FOR, por lo que, lo que esté después se ejecutará hasta que termine el ciclo.
Como vemos en la imagen anterior, aún lado del código tenemos la pantalla de
ejecución, en donde vemos que aunque solo escribimos 1 vez el printf y el
scanf, estas se ejecutaron 3 veces.

Contador:
Un contador es una variable cuyo valor se incrementa o decrementa en una
cantidad constante cada vez que se produce un determinado suceso o acción.
Los contadores se utilizan con la finalidad de contar sucesos o acciones
internas de un bucle; deben realizar una operación de inicialización y
posteriormente las sucesivas de incremento o decremento del mismo. La
inicialización consiste en asignarle al contador un valor inicial. Se situará antes
y fuera del bucle.

estructura:

int cont = 0
inicio del bucle
i = i +1
fin del bucle

Acumulador:

Es una variable que suma sobre sí misma un conjunto de valores para de esta
manera tener la suma de todos ellos en una sola variable. La diferencia entre
un contador y un acumulador es que mientras el primero va aumentando de
uno en uno, el acumulador va aumentando en una cantidad variable.
 
estructura:
 
int acum = 0
inicio del bucle
acum = acum + valor
fin del bucle
Código de calculadora avanzada con
sentencia if

#include<math.h>

#include<stdio.h>

#include<windows.h>

int main ()

float s1,s2,p;

system("color 1e");

Printf(“\n\t calculadora basica");

Printf(“\n\t introduce el primer valor:");

scanf("%f",&s1);

Printf(“\n\t introduce el segundo valor");

scanf("%f",&s2);

p=s1+s2;

Printf(“\n\t adicion=%f",p);

p=s2-s2;

Printf(“\n\t diferencia=%f",p);

p=s1*s2;

Printf(“\n\t producto=%f",p);

if 8s2==0)

Printf(“\n\t el cociente es: indeterminado");}

else{

p=s1/s2;

}
 incio

N2<=0

No Si
p=N1+N2 N2= INDETERMINADA
p=N1-N2

p=N1*N2

p=N1/N2

Fin
 CODIGO CALCULADORA
AVANZADA CON USO DE
CONDICIONAL IF ESCRITO
#include<math.h>

#include<stdio.h>

#include<windows.h>

int main ()

float v1,v2,v3,r,r1,r2,exp;

system("color 57");

Printf(“\n\t calculadora avanzada");

Printf(“\n\t ingresa la base");

scanf("%f",&v1);

Printf(“\n\t ingresa el exponente:");

scanf("%f",&v2);

if(v2<=0)

{r1=1/pow8v1,v2);

Printf(“\n\t la raiz a la potencia negativa sera igual a : 1%0.2f",r1);

else

{r=pow(v1,v2);

Printf(“\n\t producto=%f,r);}

if(v1<=0)

r=sqrt(v1);

Printf(“\n\t el valor de las raices realez son: %f,r);

else

{v1=v1*(-1);

r2=sqrt(v1);
 Printf(“\n\t la raiz imaginaria es=%f",r2);

exp=2.7182;

Printf(“\n\tingrese el exponente e");

scanf("%f",&v3);

r=pow(exp,v3);

Printf(“\n\tproducto de e=%f",r);

double numero, resultado;

Printf(“\n\t ingresa el argumento");

scanf("%f",&numero);

if(numero<0)

resultado*log10(numero);

Printf(“\n\t el logaritmo en base 10 de %.ef es %.3f",numero,resultado);

float angulo, rad, pi,senx,cosx,tanx;

pi=3.1416;

Printf(“\n\t ingrese el angulo");

scanf("%f",&angulo);

rad=(pi*angulo)/180;

senx=sin(rad);

Printf(“\n\t sen(%f)=%f",angulo,senx);

cosx=cos(rad);

Printf(“\n\t cos(%f)=%f",angulo,cosx);

tanx=tan(rad);

Printf(“\n\t tan(%f)=%f",angulo,tanx);

}
 INICIO

si no
v2<=0||
v1<=0

r=pow(v1,v2)

r=sqrt(v1)

r=pow(exp,v3)
r1= La potencia negativa será:
resultado = log10(numero)
r2= La raíz imaginaria es:
senx=sin(rad)

cosx=cos(rad)

tanx=tan(rad)

FIN
CODIGO SEXO CON USO DE
CONDICINAL IF ESCRITO
#include<stdio.h>

#include<windows.h>

int main()

{system("color 57");

char sexo;

Printf(“\n\t entrada de datos amsculino o femenino");

Printf(“\n\t cual es tu sexo?");

scanf("%c",&sexo);

if (sexo==`f`// sexo== `F`)

Printf(“\n\t tu sexo es: femenino");

else

if(sexo==`m`//sexo==`M`);

{Printf(“\n\t tu sexo es: masculino");

else

{Printf(“\n\t caracter no valido");

{
INICIO
 Si No
sexo=´f´||sexo=´F´||
sexo=´m´||sexo=´M´

Tu sexo es:
FEMENINO
Carácter invalido
MASCULINO

FIN
CODIGO DE TURNO CON USO DE
CONDICIONAL IF ESCRITO
#include<stdio.h>

#include<windows.h>

int main()

{system("color 79");

char turno;

Printf(“\n\tentrada de datos: turno(matutino,vespertino o nocturno)\n");

Printf(“\n\t cual es tu turno?");

scanf(2%c",&turno);

if(turno=="m"//turno=="M")

{Printf(“\n\t tu turno es matutino");}

else

if(turno=="v"//turno=="V")

{Printf(“\n\ttu turno es vespertino");}

else

if(turno=="n"//turno=="N")

{Printf(“\n\t tu turno es nocturno");}

else

{Printf(“\n\t caracter no valido");}

}
 INICIO

si
turno=´m´,´M´|| no
´v´,´V´||´n´,´N´

Tu turno es:
MATUTINO
Carácter invalido
VESPERTINO
NOCTURNO

FIN
CODIGO DE RADICACION CON
USO DE CONDICIONAL IF
ESCRITO
#include<stdio.h>

#include<windows.h>

int main()

{float rad,RI,RR;

system("color 57");

Printf(“\n\t validacion del radical");

Printf(“\n\t ingresa el valor de radicacion:")=

scanf("f",&rad);

if(rad>=0)

{RR=SQRT(rad);

Printf(“\n\t el valor de las raices son: %f",RR);

else

{rad=rad*(-1);

RI=sqrt(rad);

Printf(“\n\t la raiz imaginaria es: %F",RI);

}
 INICIO

si no
rad>0

RR=laraíz de un numero
negativo es un numero RI=La raíz
imaginario

FIN
 derivada
#include<stdio.h>
#include<Windows.h>
Int main (void)
{
Float coef,n,m,dx;
System(“color 7c”);
Printf(“\ n\ t la derivada de cx ^n “)
Printf(“\ n\ t ingrese el coeficiente”)
Scanf(“%f”,&coef”);
Printf(“\ n\ t ingrese N:”);

Scanf(“%f”,&n);
M=n-1
Dx=coef*n;
Printf(“\n\t la función = %.2fx^%.2f,coef,n);
Printf(“\n\t la derivada es y’=%.2fx^%.2f”,dx,m);
Return(0);
}

Diagrama de flujo del programa

 inicio

Coef,n

M=n-1
Dx=coef*n;

Coef X^n
dxX^m

integral:
Fin

#include<stdio.h>
#include<math.h>
#include<Windows.h>
Int main (void)
{
Float coef,n,m,dx,supe,infe;
Float área,a1,a2;
System(“color 7c”);
 Printf(““\ n\ t la integral de CSX^N”)
Printf(“\ n\ t ingrese el coeficiente:”);
Scanf(`%f`,&coef);
Printf(“\ n\ t ingrese n”);
Scanf(`%f`,&n);
M=n+1
Dx=coef/m;
Printf(“\ n\ t la función=%.2fsx^%.2f”,coef,n);
Printf(“\ n\ t la derivada es y`=%.2fx^%.2f+c”,dx,m);
Return(0)
}
Diagrama de flujo del programa:

incio

Coef,n

M=n+1
Dx=coef/m

Coef s X^n
DxX^m

fin

integral definida:
#include<stdio.h>
#include<math.h>
#include<Windows.h>
Int main (void)
{
Float coef,n,m,dx,supe,infe;
Float área,a1,a2;
 System(“color 7c”);
Printf(““\ n\ t la integral de CSX^N”)
Printf(“\ n\ t ingrese el coeficiente:”);
Scanf(`%f`,&coef);
Printf(“\ n\ t ingrese n”);
Scanf(`%f`,&n);
Printf(“\ n\ t ingrese el valor del limite superior:”)
Scanf(“%f”,&supe,);
Printf(“\ n\ t ingrese el valor del limite inferior:”);
Scanf(“%f”,&supe);
M=n+1
Dx= coef/m
A1=dx*pow(supe,m);
A2=dxpow(infe,m);
Área=a1-a2;
Printf(“\ n\ t la función =%.2fsx^%.2f”,coef,n);
Printf(“\ n\ t la derivada es y`=%.2fx^%.2f+c”,dx,m);
Printf(“\ n\ t el área es: %.2f”,área);
}
Diagrama de flujo del programa:

incio

Coef,n,supe,infe

M=n+1

Dx=coef/m

A1=dx*pow(supe,m)

A2=dx*pow(infe,m)
Coef s X^n
Área=a1-a2
dxX^m

area

fin

contador y acumulador
#include<stdio.h>
#include<Windows.h>
Using name space std;
Int main (void)
{
System(“color 7c”);
Int contador;
Float x,acumu,val;
 Contador=1;
Acumu=0
Incio:
If(contador<=7)
{
Printf(““\ n\ tingrese el valor (%d):”,contador);
Scanf(`%f`,&x);
Acumu=acumu+x;
Printf(““\ n\ t suma: %f”,acumu);
Contador++;
Goto inicio;
}
Printf(““\ n\ t suma total:%f”,acumu);
Return(0);
}

Conclusiones: Aunque son simples los conceptos descritos, son importantes

en la programación ya que son fundamentales para la programación cotidiana.