COMPUTACION GRAFICA

PROBLEMAS Y ALGORITMOS
Los algoritmos son procedimientos especficos que sealan paso a paso la solucin de un
problema y que garantizan el logro de una solucin.
Generalmente estamos realizando, en forma cotidiana, una serie de pasos, procedimientos o
acciones para alcanzar algn resultado o resolver un problema. Por ejemplo, al levantarnos,
baarnos, desayunar.
Es decir todo el tiempo estamos aplicando algoritmos para resolver problemas.
Algoritmo: conjunto de pasos, procedimientos o acciones que nos permiten alcanzar un
resultado o resolver un problema.

Etapas para solucionar algn problema:

PROBLEMA

Anlisis del
problema

Construccin del
algoritmo

Verificacin del
algoritmo

Caractersticas de los Algoritmos:

Precisin: Los pasos a seguir en el algoritmo se deben precisar claramente
Determinismo: El algoritmo, dado un conjunto de datos de entrada idntico, siempre debe arrojar
los mismos resultados.
Finitud: El algoritmo, independiente de la complejidad del mismo, siempre debe tener longitud
finita.
El algoritmo consta de tres secciones o mdulos principales:

Datos de
entrada

Procesami
ento datos

Impres.
De result

Estructura de un algoritmo:

Debe tener un punto nico de inicio

Debe ser definido, no debe permitir dobles interpretaciones
Debe ser general, es decir soportar la mayora de las variantes que se puedan representar
en la definicin del problema
Debe ser finito en tamao y tiempo de ejecucin. Es decir debe tener un fin.

EJEMPLOS DE ALGORITMOS:
1. Algoritmo Promedio
Descripcin: Calcular la media de 3 nmeros
Variables: Entero: n1, n2, n3, Real: prom
Inicio
1
2
3
Fin

Leer n1, n2, n3

prom = (n1 + n2 +n3)/3
Escribir prom

2. ALGORTMO: Promedio final

DESCRIPCCION: Elaborar un algoritmo para calcular el promedio final de una asignatura. Dicha
calificacin se compone de los siguientes porcentajes.
55% ----- del promedio final de sus calificaciones parciales (3)
30% ----- del Examen
15% ----- de la calificacin de un trabajo final
CONSTANTE: ---------------------------------VARIABLE: Real: P1, P2, P3, Prom., Examen, TrabajoF, Prom. Final
INICIO
1
2
3
4
5
6
FIN

Leer P1, P2, P3

Prom=(( P1+ P2+ P3 )/3)*0.55
Leer Examen
Leer TrabajoF
Prom. Final= (Prom + (Examen*0.30) + (TrabajoF *0.15) )
Escribir Prom. Final

3. ALGORITMO: Sueldo
DESCRIPCCION: Calcular el sueldo de un empleado dados como datos de entrada: el nombre, hrs.
De trabajo y el pago en hr.
CONSTANTE: Real: Pagohr=50.30
VARIABLE: Cadena: nombre
Entero: hrs.
Real: Sueldo
INICIO
1
Leer nombre
2
Leer hrs.
3
Sueldo= Pagohr*hrs

4
FIN

Escribir Sueldo, nombre

4. ALGORITMO: Evaluacin
DESCRIPCCION: Elaborar un algoritmo que obtenga e imprima el valor de Y a partir de la ecuacin.
Y= 3*X2 + 7X - 15
CONATANTE: -----------------VARIABLE: Real: X, Y
INICIO
1
Leer X
2
Y= (3*X*X)+(7*x) -15
3
Escribir Y
FIN
5. ALGORITMO: Sistema de ecuaciones
DECRIPCCION: El sistema de ecuaciones lineales:
ax + by= c
dx + ey= f
Se puede resolver con las formulas:
X= ce bf
ae bd
y= af cd
ae bd
Si ae bd 0
Elabore un algoritmo que lea los coeficientes a, b, c, d, e, f; y calcule los valores de x, y.
CONSTANTE: -----------------------VARIABLE: Real: a, b, c, d, e, f, x, y
INICIO
1
2
3
4
FIN

Leer a, b, c, d, e, f
x=(c*e) (b*f) /(a*e) (b*d)
y=(a*f) (c*d) / (a*e) (b*d)
Escribir x, y

6. ALGORITMO: Valor absoluto

DESCRIPCCION: Calcular el valor absoluto de un numero

x Si x > 0
-x Si x < o

CONSTANTES: ---------------------VARIABLES: Entero: x

INICIO
1.
Leer x
2.
Si (x < 0) entonces
x = x * (-1)
Fin_si
3.
Escribir x
FIN
7. ALGORITMO: Par o impar
DESCRIPPCION: Elabora un algoritmo para leer un nmero y determinar si es par o impar.
CONSTANTE: --------------------------VARIABLE: Entero: N
INICIO
1.
Leer N
2.
Si (N % 2 == 0) entonces
Escribir "N en par"
Si no Escribir "N en impar"
Fin _ s
FIN

8. ALGORITMO: Nmeros
DESCRIPCCION: Elaborar un algoritmo para leer 3 nmeros y determinar si uno de ellos es la suma
de los otros dos.
CONSTANTES: ----------------------------VARIABLES: entero: N1, N2, N3
INICIO
1.
Leer N1, N2, N3
2.
S (N1 = N2 + N3) entonces
Escribir N1 es la suma de N2 + N3
S no s (N2 = N1 + N3) entonces
Escribir N2 es la suma de N1 + N3
S ni s (N3 = N1 + N2) entonces
Escribir N3 es la suma de N1 + N2)
S no Escribir Ningn es la suma de los otros dos
Fin _ s
Fin _ s
Fin _ s
FIN

1.
2.

Leer N1, N2, N3

S (N1 = N2 + N3) entonces
Escribir N1 es la suma de N2 + N3
S no s (N2 = N1 + N3) entonces

Escribir N2 es la suma de N1 + N3
S ni s (N3 = N1 + N2) entonces
Escribir N3 es la suma de N1 + N2)
S no Escribir Ningn es la suma de los otros dos
Fin _ s
Fin _ s
Fin _ s
FIN

DIAGRAMAS DE FLUJO:
Representan la esquematizacin grfica de un algoritmo.
Muestra grficamente los pasos o procesos a seguir para alcanzar la solucin de un problema.
Representa la solucin del problema, el programa representa la implementacin en un lenguaje de
programacin.
SIMBOLOS:
Marca el inicio o fin del diagrama de flujo

Para representar datos de entrada. Expresa LECTURA

Representa PROCESO. Se colocan asignaciones, operaciones aritmticas.

Decisin. Se colocan condiciones, que dependiendo del resultado, se sigue por una de las ramas o caminos
alternativos.

Representa impresin de un resultado. Expresa ESCRITURA

Expresa la direccin del flujo del programa

INICIO

Lectura
de datos

ETAPAS EN LA CONSTRUCCION DE
UN DIAGRAMA DE FLUJO
Procesami
datos

Impre.
resultado

FIN

TIPOS DE DATOS:
Se representan de forma diferente en la memoria de la computadora.
TIPO DE DATO
Int
Float
Long
double

Char

DESCRIPCION
Son cantidades ENTERAS
Son nmeros REALES. Nmero
de coma flotante.
ENTEROS LARGOS
Nmero de coma flotante de
doble precisin (ms cifras
significativas y mayor valor
posible del exponente)
Carcter. Abecedario, nmeros
o smbolos especiales

REQUERIMIENTO TIPICO
DE MEMORIA
2 bytes o una palabra (vara
de un compilador a otro)
4 palabras (32 bits)
4 palabras (32 bytes)

RANGO
-32.768 a
+32.767
3.4 x 10-38 a 3.4 x
1038
-2147.483.648 a
2147.483.648

8 palabras (64 bits)

1.7 x 10-308 a 1.7 x

10308

1 byte (8 bits)

Abecedario,
nmeros o
smbolos
especiales

Otra clasificacin:
ENTEROS: char, short, int, long, enum.
REALES: float, double, long double.
OTROS: void.
ENTEROS: signed (con signo), unsigned (sin signo)
signed char, unsigned char
signed short, unsigned short
signed int, unsigned int
signed long, unsigned long
Un ENTERO SIGNED es un entero con signo. Es decir un nmero entero positivo o negativo.
Un ENTERO UNSIGNED es un entero sin signo. Es decir un nmero entero positivo.
Si signed o unsigned no se usan con un tipo, se asume como un int. Por lo tanto son similares:
signed x;

signed int x;

unsigned y;

unsigned int y;

Si omitimos signed o unsigned el compilador asume que es un tipo signed. Por ejemplo: si
colocamos:

int

el compilador asume signed int

TIPO
signed char
unsigned char
signed short
unsigned short
signed int
unsigned int
signed long
unsigned long
float
double
long double

BYTES
1
1
2
2
2
2
4
4
4
8
10

DESDE
-128
0
-32768
0
-32768
0
-2.147.483.648
0
3,4x10-38
1,7x10-308
3,4x10-4932

HASTA
127
255
32767
65535
32767
65535
2.147.483.647
4294967295
3,4x1038
1,7x10308
3,4x104932

IDENTIFICADORES O CONJUNTO DE CARACTERES DE C

Los datos que procesar una computadora, ya sean simples o estructurados, se deben almacenar
en casillas de memoria para utilizarlas posteriormente. A estas casillas se las asigna un nombre
para reconocerlas: IDENTIFICADOR.
Para hacer un identificador se puede usas maysculas de la A a la Z, y todas las minsculas. Los
dgitos: 0 al 9, el carcter subrayado _
Se distingue las maysculas de las minsculas. AUX es diferente de Aux.
CONSTANTES:
Las constantes son datos que no cambian durante la ejecucin del programa.
Constante son valores que luego de haber sido compilado el programa, no pueden ser cambiados.
Las constantes se pueden definir utilizando lo siguiente:
1. Con la directiva const
2. Usando #define
3. Con la clusula enum
1. Definicin de constantes usando const:
const int nu1 = 20;
const int nu2 = 15;
const float re1 = 2.18;
const char ca1 = f;

/* nu1 es constante de tipo entero */

/* nu2 es constante de tipo entero */
/* re1 es constante de tipo real */
/* ca1 es constante de tipo carcter */

2. Definicin de constantes usando #define:

Es otra alternativa para definir constantes.
#define nu1 20
#define nu2 15
#define re1 2.18
#define ca1 = f
#define INTERES 0.23
#define PI=3.141593
#define CIERTO 1
#define FALSO 0

/* nu1 es constante de tipo entero */

/* nu2 es constante de tipo entero */
/* re1 es constante de tipo real */
/* ca1 es constante de tipo carcter */

3. Constantes usando Enum

Otra alternativa de nombrar constantes es usando ENUM:
Los valores se asignan de manera predeterminada en incrementos unitarios, comenzando desde
cero. Se usa cuando se quiere definir constantes con valores predeterminados:
enum { va0, va1, va2, va3 };

/* Define 4 variables enteras */

Es similar a:
const int va0 = 0;
const int va1 = 1;
const int va2 = 2;
const int va3 = 3

VARIABLES
El valor de una variable puede cambiar a lo largo de la ejecucin de un programa.
Es un identificador que se utiliza para representar cierto tipo de informacin dentro de una parte
de un programa.
El valor asignado a una variable, el programa puede recuperarlo simplemente haciendo referencia
al nombre de la variable.
El valor de la variable puede cambiar a lo largo del programa, pero no puede cambiar su tipo de
dato.
La asignacin es una operacin destructiva, ya que si la variable tena un valor, este se destruye al
asignar el nuevo.

Ejemplos: declaraciones:
int va1, va2;
float re1, re2;
char ca1, ca2;
va1 = 10;
va2 = va1 + 15;
va1 = 15;
re1 = 3.235;
ca1 = t;
ca2 = ?;

/* Asignacin de 25 a va2 */
/* La variable va1 modifica su valor */
/* Asignacin del valor 3.235 a la variable re1 que es real */
/* Asignacin del caracter t a la variable ca1 */
/* Asignacin del caracter ? a la variable ca2 */

OPERADORES
Los operadores sirven para realizar operaciones. Pueden ser:
1. Operadores aritmticos
1.1 Operadores aritmticos simplificados
1.2 Operadores de incremento y decremento
2. Operadores relacionales
3. Operadores lgicos
4. Operador coma
1. Operadores Aritmticos:
Existen 5 operadores en C:
Operador
+
*
/
%

Propsito
Adicin
Sustraccin
Multiplicacin
Divisin
Mdulo o residuo

No hay operador de exponenciacin en C. Para esto hay una funcin de biblioteca (pow) que
realiza la exponenciacin.

int x
(x es una variable entera)
float v (v es una variable flotante)
Operador aritmtico
+

Operacin
Suma
Resta

Multiplicacin

Divisin

Modulo - Residuo

c1 = P;
c2 = T;

En ASCII P = 80
En ASCII T = 84
En ASCII 5 = 53

Expresin
c1
c1 + c2
c1 + c2 + 5
c1 + c2 + 5

Valor
80
164
169
217

Si a y b son enteros:
a = 11; b = -3;
Expresin
a+b
ab
a*b
a/b
a%b

Valor
8
14
-33
-3
2

Ejemplos
x = 4.5 + 3;
v = 4.5 + 3;
x = 4.5 - 3;
v = 4.5 - 3;
x = 4.5 * 3;
v = 4.5 * 3;
v = 4 * 3;
x = 4 / 3;
x = 4.0 / 3.0;
v = 4 / 3;
v = 4.0 / 3;
v = ((float) 4 / 3);
v = ((float) 5 + 3) / 6;
x = 15 % 2;
v = (15 % 2) / 2;
v = ((float) 15 % 2)) / 2;

Resultados
x = 7;
v = 7.5;
x = 1;
v = 1.5;
x = 12;
v = 13.5;
v = 12.0
x = 1;
x = 1;
v = 1.0
v = 1.33;
v = 1.33;
v = 1.33;
x = 1;
v = 0.0;
v = 0.5;

Si a y b son enteros:
a = -11; b = 3;
Expresin
a+b
ab
a*b
a/b
a%b

Valor
-8
-14
-33
-3
-2

Si a y b son enteros:
a = -11; b = -3;
Expresin
a+b
ab
a*b
a/b
a%b

Valor
-14
-8
33
3
-2

Coma flotante:
r1 = -0.66;
r2 = 4.50;
Expresin
r1 + r2
r1 r2
r1 * r2
r1 / r2
i = 7;
f = 5.5;
c = w;

Valor
3.84
-5.16
-2.97
-0.146667
/* Entero */
/* Coma flotante */
/* Caracter */

Expresin
i+f
i+c
i + c 0
(i + c) (2 * f / 5)

Valor
12.5
126
78
123.8

Tipo
Doble precisin
Entero
Entero
Doble precisin

Conversin de Tipo (Cast)

i = 7;
/* Entero */
f = 8.5;
/* Coma flotante */
(i + f) % 4
/* Es una expresin invlida. Ya que (i + f) es de coma flotante en vez de
entero. */
( int ( i + f ) ) % 4
/* Es una expresin valida. Ya que (i + f) es transformada a entero. */
/* La especificacin de tipo solo afecta al primer operando. */

f es una variable de coma flotante.

f = 5.5;
( int f ) % 2

/* Es una expresin valida. Contiene dos operandos enteros, el resultado es 1 */

/* Sin embargo que f sigue siendo una variable de coma flotante, y se transforma
en 5 solo para la operacin del resto */

Los operandos *, /, % tienen mayor precedencia que la +, -.

Ejemplo:
a = 1, b = 2, c = 3, d = 4;
ab/c*d

a[(b/c)]*d]

1.666666

48

36

Ejemplo:
Int i = 8, j = 15, k = 4;
x = 2 * (( i % 5 ) * ( 4 * ( j 3) / ( k + 2 )));
int x, i = 8, j = 15, k = 5;
x = 2 * (( i % 5 ) * ( 4 * ( j - 3) / ( k + 2 )));

1.1 Operadores Aritmticos simplificados

En lenguaje C se puede simplificar el uso de los operadores aritmticos:
int x, y (x e y son variables enteras)
Operador
aritmtico
+

Forma
simplificada
+=

-=

*=

/=

%=

Ej:
expresion 1 += expresin 2
Equivale a:
expresion 1 = expresion 1 + expresion 2
expresion 1 -= expresion 2
Equivale a:
expresion 1 = expresion 1 - expresion 2

Ejemplo

Equivalencia

Resultado

x = 6;
y = 4;
x += 5;
x += y;
x = 10;
y = 5;
x -= 3;
x -= y;
x = 5;
y = 3;
x *= 4;
x *= y;
x = 25;
y = 3;
x /= 3;
x /= y;
x = 20;
y = 3;
x %= 12;
x %= y;

x = 6;
y = 4;
x = x + 5;
x = x + y;
x = 10;
y = 5;
x = x - 3;
x = x - y;
x = 5;
y = 3;
x = x * 4;
x = x * y;
x = 25;
y = 3;
x = x / 3;
x = x / y;
x = 20;
y = 3;
x = x % 12;
x = x % y;

x = 6;
y = 4;
x = 11;
x = 15;
x = 10;
y = 5;
x = 7;
x = 2;
x = 5;
y = 3;
x = 20;
x = 60;
x = 25;
y = 3;
x = 8;
x = 2;
x = 20;
y = 3;
x = 8;
x = 2;

1.2 Operadores de incremento y decremento

Los operadores de incremento (++) o decremento (--) se los puede utilizar antes o despus de la
variable.
int x, y (x e y son enteros)
Operador

Operacin

++

Incremento

Ejemplos
x = 7;
y = x++;
x = 7;
y = ++x;

--

Decremento

x = 6;
y = x--;
x = 6;
y = --x;

Resultados
x = 7;
y = 7;
x = 8;
x = 7;
y = 8;
x = 8;
x = 6;
y = 6;
x = 5;
x = 6;
y = 5;
x = 5;

Los operadores de incremento o decremento se los conoce como OPERADORES MONARIOS, ya

que actan sobre un solo operando para producir un nuevo valor.
El operador MENOS MONARIO es diferente al menos aritmtico (-) ya que ste ltimo requiere dos
operandos.
EN C TODAS LAS CONSTANTES NUMERICAS SON POSITIVAS. Por lo tanto un nmero negativo es
en realidad una expresin.
Ejemplo: Operador MENOS MONARIO:
-743

-0x7FFF

-0.2

-5E-8

Operador incremento (++) y operador decremento (--):

Ejemplos:
i = 5;
++i;
--i;

=
=

/* Variable entera */
i = i + 1;
=
i = i 1;
=

++i;

i++;

--i;

i--;

6
4;

-raiz1

-(x+y) -3 * (x+y)

Ejemplos:
printf (i = %d\n, i);
printf (i = %d\n, ++i);
printf (i = %d\n, i);

i = 1;
i = 2;
i = 2;

/* Visualiza el valor de i */
/* Incrementa i y presenta despus su valor */
/* Visualiza el valor final de i */

printf (i = %d\n, i);

printf (i = %d\n, i++);

i = 1;
i = 1;

printf (i = %d\n, i);

i = 2;

/* Visualiza el valor de i */
/* Se visualiza el valor actual de i y despus lo
incrementa a 2*/
/* Visualiza el valor final de i */

Ejemplos:

OPERADOR MONARIO sizeof (Tamao de )

Devuelve el tamao de su operando en bytes.
Ejemplo:
i = variable entera
x = variable de coma flotante
d= variable de doble precisin
c= variable de carcter
printf (int: %d\n, sizeof i);
printf (float: %d\n, sizeof x);
printf (double: %d\n, sizeof d);
printf (char: %d\n, sizeof c);

int = 2
float = 4
double = 8
char = 1

Otra forma de obtener sta informacin es utilizar un cast, en lugar de una variable dentro de
cada sentencia printf. Cada cast est encerrado en parntesis.
printf (int: %d\n, sizeof (int));
printf (float: %d\n, sizeof (float));
printf (double: %d\n, sizeof (double));
printf (char: %d\n, sizeof (char));

int = 2
float = 4
double = 8
char = 1

Ejemplo: con caracteres

char texto [] = California;
printf (Nmero de caracteres =%d, sizeof texto);
El array texto tiene 11 caracteres.

Nmero de caracteres = 11

REVISAR EJERCICIO USANDO SIZEOF PARA DETERMINAR TAMANO DE VARIABLES.

EJERCICIOS:
que_imprime1.c
#include <stdio.h>
main ()
{
int i = 5, j = 7, k = 3, m1;
float x = 2.5, z = 1.8, t;
m1 = ((j % k) / 2) + 1;
m1 += i;
m1 %= --i;
printf("El valor de m1 es: %d\n", m1);
t = ((float) (j % k) / 2);
printf("Primer t es: %f\n", t);
t++;
printf("Segundo t es: %f\n", t);
x *= ++z;
t -= (x += ++i);
printf("\nEl valor de t es: %.2f",t);
}
que_imprime2.c
#include <stdio.h>
main ()
{
int i = 15, j, k, l;
j = (15 > i--) > (14 < ++i);
printf("\nEl valor de j es: %d", j);
//printf("\nEl valor de i es: %d", i);
k = !('b' != 'd') > (!i - 1);
printf("\nEl valor de k es: %d", k);
//printf("\nEl valor de i es: %d", i);
l = (!(34 > (70 % 2)) || 0);
printf("\nEl valor de l es: %d", l);
}

Construya un diagrama de flujo que, al recibir como datos la longitud y el peso de un objeto
expresados en pies y libras, imprima los datos de ese objeto pero expresados en metros y kilos,
respectivamente.

EXPRESIONES LOGICAS
Llamadas tambin Booleanas en honor al matemtico George Boole estn construidas por
nmeros, contantes o variables, y operadores lgicos o ralacionales.
En lenguaje C, todo valor distinto de cero es verdad. Es decir 0 (cero) es falso.

2. Operadores relacionales
Operador relacional
==
!=
<
>
<=
>=

Operacin
Igual a
Diferente de
Menor que
Mayor que
Menor o igual que
Mayor o igual que

Ejemplos
res = h == p;
res = a != b;
res = 7 < 15;
res = 22 > 11;
res = 15 <= 2;
res = 35 >= 20;

Resultados
res = 0;
res = 1;
res = 1;
res = 1;
res = 0;
res = 1;

Cuando se usan operadores relacionales con operandos lgicos, falso siempre es menor que
verdadero.
res = (7 > 8) > (9 > 6);

/* 0 > 1 (falso) -> 0 */

La expresin resultante ser de tipo entero, ya que verdad = 1, y falso = 0.

i=1
j=2
k=3
Expresin
i<j
( i < j ) >= k
( i < j ) > (i + 5 )
( k != 3 )
j == 2

Interpretacin
Verdad
Falso
Falso
Falso
Verdad

Valor
1
0
0
0
1

3. Operadores Lgicos
int x, y; (x e y son variables enteras)

Operador
lgico
!

Operacin
Negacin

&&

Conjuncin

||

Disyuncin

Ejemplos

Resultados

x = (!(7 > 15));

/* (!0) */
y = (!0);
x = (35 > 20) && (20 <= 23); /* 1 && 1 */
y = 0 && 1;
x = (35 > 20) || (20 <= 18); /* 1 || 0 */
y = 0 || 1;

x = 1;
y = 1;
x = 1;
y = 0;
x = 1;
y = 1;

Tabla de verdad de los operadores lgicos

P
V
1
V
1
F
0
F
0

Q
V
1
F
0
V
1
F
0

(!P)
F
0
F
0
V
1
V
1

(!Q)
F
0
V
1
F
0
V
1

(P || Q)
V
1
V
1
V
1
F
0

i=7
f = 5.5
c = w
Expresin
( i >= 6 ) && ( c == 'w )
( i >= 6 ) || ( c == 119 )
( f < 11 ) && ( i > 100 )
( c != 'p' ) || ( (i + f) <= 10 )

Interpretacin
Verdad
Verdad
Falso
Verdad

Valor
1
1
0
1

(P && Q)
V
1
F
0
F
0
F
0

4. Operador Coma
Sirve para encadenar diferentes expresiones.
int x,y,z,v;

(x, y, z y v son variables tipo entero)

Expresin
x = (v = 3, v * 5);
x = (v += 5, v % 5);

x = (y = (15 > 10), z = (2 >= y), y && z);

x = (y = (!(7 > 15), z = (35 > 40) && y, (!(y && z)));

Equivalencia
v = 3;
x = v * 5;
v = v + 5;
x = v % 3;
y = (15 > 10);
z = (2 >= y);
x = y && z;
y = (!(7 > 15);
z = (35 > 40) && y;
x = (!(y && z));

Resultados
v=3
x = 15
v=8
x=2
y=1
z=1
x=1
y=1
z=0
x=1

PRIORIDADES DE LOS OPERADORES

Las expresiones se evalan de izquierda a derecha, pero los operadores se aplican segn su
prioridad.

Operadores
()
!, ++, -*. /, %
+, ==, !=, <, >, <=, >=
&&, ||
+=, -=, *=, /=, %=
,

Jerarqua
(mayor)

(menor)

CONSTRUCCION DE DIAGRAMAS DE FLUJO

Construir un diagrama de flujo que, al recibir como datos A, B, C y D que representan nmeros
enteros, escriba los mismos en orden inverso.
A, B, C, D variables enteras
Diagrama de flujo 1.2

Construir un diagrama de flujo que, al recibir como datos la clave del empleado y los seis primeros
sueldos del ao, calcule el ingreso total semestral y el promedio mensual, e imprima la calve del
empleado, el ingreso total y el promedio mensual.
Datos: clave, s1, s2, s3, s4, s5, s6
La clave es de tipo int, s1 hasta s6 son de tipo flotante.

ENTRADA Y SALIDA DE DATOS

getchar. Entrada de un carcter
Se logra entrada de caracteres uno a uno.
variable de carcter = getchar();
Ej:
char c;
.
.
c = getchar (); /* Se lee del dispositivo de enteada estndar un carcter y
entonces se le asigne a c */
putchar. Entrada de un carcter
Visualizar un carcter usando putchar.
putchar (variable de carcter);
Ej:
char c;
.
.
c = putchar ();
estndar */

/* Se transmite el valor actual de c al dispositivo de salida

FUNCION SCANF
Se usa para introducir datos en el computador desde el dispositivo de entrada estndar.
scanf(cadena de control, arg1, arg2,, argn)
Cadena de control: hace referencia a una cadena de caracteres que contiene cierta informacin
sobre el formato de los datos
arg1, arg2, argn son argumentos que representan los datos. (En realidad argumentos son
punteros que indican las direcciones de memoria donde se encuentran los datos)
En la cadena de control se incluyen:
Grupos individuales de caracteres
Con un grupo de caracteres por cada dato de entrada
Cada grupo de caracteres debe comenzar con %
En su forma ms sencilla, un grupo de caracteres estar formado por el % seguido de un carcter
de conversin que indica el tipo de dato correspondiente.

Ejemplo:

Ej:
#include <stdio.h>
main ()
{
char letras [20];
int entero;
float costo;
.
scanf(%s %d %f, letras, &entero, &costo);
.
}
Cada nombre de variable debe ser precedido por &, ya que son punteros que indican donde se
encuentran situados los datos en la memoria de la computadora.
Los nombres de arreglos no deben ser precedidos por ampersand (&)
La cadena de control es: %s %d %f que contiene 3 grupos de caracteres.
%s indica que el primer argumento es (letras) representa una cadena de caracteres.
%d indica que el segundo argumento (&entero) es un entero decimal.
%f indica que el tercer argumento (&costo) es de coma flotante.

Caracteres de conversin de los datos de entrada de uso comn.

Carcter de
conversin
c
d
E
f
G
h
i
o
s
u
[]

Significado
El dato es un carcter
El dato es entero decimal
El dato es de coma flotante
El dato es de coma flotante
El dato es de coma flotante
El dato es un entero corto
El dato es un entero decimal, octal o hexadecimal
El dato es entero octal
El dato es una cadena de caracteres seguida de un carcter de
espacio \0
El dato es un entero decimal sin signo
El dato es una cadena de caracteres que puede incluir caracteres
de espaciado

FUNCION PRINTF
Sirve para escribir datos en el dispositivo de salida estndar.
Printf se ocupa de transportar datos de la memoria de la computadora al dispositivo de salida
estndar. Scanf en cambio, introduce datos del dispositivo de entrada estndar y los almacena en
la memoria de la computadora.
printf(cadena de control, arg1, arg2,, argn)
Cadena de control: hacen referencia a una cadena de caracteres que contiene informacin sobre
el formato de la salida.
Arg1, agr2,.., argn, son argumentos que representan los datos de salida.
Los argumentos de printf no representan direcciones de memoria por lo tanto no son precedidos
por ampersand.
Caracteres de conversin de los datos de salida de uso comn:
Carcter de
conversin
c
d
e
f
g
i

Significado
El dato es visualizado como un carcter
El dato es visualizado como un s entero decimal con signo
El dato es visualizado como un valor de coma flotante con
exponente
El dato es visualizado como un valor de coma flotante sin
exponente
El dato es visualizado como un valor de coma flotante utilizando
la conversin de tipo e o tipo f segn sea el caso
El dato es visualizado como un valor como un entero con signo

o
s
u
x

El dato es visualizado como un valor entero octal, sin cero inicial

El dato es visualizado como una cadena de caracteres
El dato es visualizado como un valor un entero decimal sin signo
El dato es visualizado como un entero hexadecimal sin el prefijo
0x

Ejemplo:
#include <stdio.h>
#include <math.h>
main ()
{
float i = 2.0, j = 3.0;
printf(%f %f %f %f, i, j, i + j, sqrt(i = j));
}
Ejemplo:
#include <stdio.h>
main ()
{
char letras[20];
int entero;
float costo;
printf(%s %d %f, letras, entero, costo);
}
La cadena de control es: %s %d %f. Contiene %s caracteres, %d entero, %f costo de coma
flotante.
Probar con esta cadena de control: printf(%s%d%f, letras, entero, costo);
Ejemplo:
#include <stdio.h>
main ()
{
double x = 5000.0, y = 0.0025;
printf(%f %f %f\n\n, x, y, x*y, x/y);
printf(%e %e %e, x, y, x*y, x/y);
}

Salida1:
5000.00000

0.002500

12.500000

2000000.000000

5.00000e+003 2.50000e-003 1.250000e+001

2.0000000e+006

Ejemplo:
#include <stdio.h>
main ()
{
char linea[80];
scanf(%[^\n], lnea);
printf(%s, lnea);
}
Ingresar: La Liga es uno de los mejores equipos de futbol del Ecuador!
#include <stdio.h>
main ()
{
/* especificacin de longitud de campo mnima *(
Int i = 12345;
float x = 345.678;
printf("%3d %5d %8d\n\n", i, i, i);
printf("%3f %10f %13f\n\n", x, x, x);
printf("%3e %13e %16e", x, x, x);
}
FUNCIONES gets y puts
Cada una de estas funciones acepta un solo argumento. Facilitan las transferencias de cadenas de
caracteres entre computadora y dispositivos de entrada/salida.
Con gets la cadena se introduce por teclado y termina con un carcter de nueva lnea.
Ofrecen alternativas sencillas al scanf y al printf.

Ejemplo:
#include <stdio.h>
main () / * leer y escribir una lnea de texto * /
(
char linea [80];
gets (linea) ;
puts (linea);
}
Programa ejemplo:
#include <stdio.h>
main ()
/* ejemplo de programa interactivo */
{
char nombre [20];
float nota1, nota2, nota3, media;
printf("Por favor, introduce tu nombre: ");
scanf ("%[^\n]", nombre);

/* introducir nombre */

printf ("Por favor, introduce la primera nota: "); /* introducir nota 1 */

scanf("%f", &notal);
printf("Por favor, introduce la segunda nota: "); /* introducir nota 2 */
scanf ("%f", &nota2);
printf("Por favor, introduce la tercera nota: "); /* introducir nota 3 */
scanf ("%f", &nota3);

media = (notal+nota2+nota3)/3;

/* calcular la media */

printf ("\n\nNombre: %-s\n\n", nombre);

printf ("Nota 1: %-5.1f\n", notal);
printf("Nota 2: %-5.1f\n", nota2);
printf("Nota 3: %-5.1f\n\n", nota3);
printf("Media: %-5.1f\n\n", media);

/* escribir salida */