Professional Documents
Culture Documents
FUNDAMENTOS
DE PROGRAMACIÓN
CUADERNO DIGITAL
Página 2
Operador Unario.......................................................................................................... 124
IMPLEMENTACION Y APLICACIONES ...................................................................... 127
.............................................................................................. 127
DEBER .......................................................................................................................... 130
Primer Algoritmo ............................................................................................................ 130
Segundo Algoritmo ......................................................................................................... 136
2.Aritmetica de punteros .................................................................................................. 140
Inicialización de punteros ................................................................................................ 146
Indireccion de punteros.................................................................................................... 149
2. ARREGLOS ARRAYS ............................................................................................... 152
........................................................................................ 152
Representación grafica........................................................ Error! Bookmark not defined.
Estructura del arreglo ...................................................................................................... 153
Página 3
SYLLABUS
Unidad 1
LENGUAJE ALGORÍTMICO Y ESTRUCTURAS DE CONTROL
Algoritmo
Definición
Características de un algoritmo
Representación de un algoritmo
Constantes
Variables
Tipos de Datos
Operadores y expresiones
Operadores
Evaluación de expresiones
Prueba de escritorio
Prueba de escritorio
Código Fuente
Programación
Depurar
Compilar
Programa
Software
Sistema informático
Lenguaje de programación
Página 4
Historia de los lenguajes de programación
Entornos de programación
Unidad 2
PROGRAMACIÓN ESTRUCTURADA EN LENGUAJE C
Identificadores y tipos de datos
Variables y constantes
Tipos de Datos
Directivas
Main
Librerías
Constantes
Comentarios
Operadores y expresiones
Operadores unarios
Operadores binarios
Operadores de asignación
Operadores de condición
Expresiones
Sentencias de control
Instrucción if
Bucle for
Bucle while
Bucle do-while
Bucles anidados
Página 5
Unidad 3
ARREGLOS Y MODULARIZACIÓN.
Introducción a punteros
Definición y tipos
Características
Arreglos
Unidimensionales
Bidimensionales
Funciones
Características
Declaración e implementación
Paso de parámetros
Valor
Búsqueda y ordenamiento
Búsqueda lineal
Búsqueda binaria
Cadenas de caracteres
Librerías String.h
Página 6
UNIDAD 1
1. Algoritmo
1.1 Definición
Inicio
Fin
Inicio
Página 7
Escribir “El primer sumando, num1”
Leer num1;
Leer num2;
Leer sumaTotal
Fin
Inicio
Leer num1;
Leer num2;
Leer num3;
Leer sumaTotal
Fin
Inicio
Leer radio;
Longitud = 2*PI*radio
Leer longitud
Fin
Página 8
METODOLOGIA PARA LA SOLUCION DEL PROBLEMA POR MEDIO DE
LA COMPUTADORA
1. Programa.- Es una secuencia de instrucciones detalladas y codificadas a fin de que un
ordenador realice las operaciones para resolver un determinado problema.
Problema.- Es una cuestión que se propone con la finalidad de aclararla o resolverla utilizando
una metodología determinada.
a) Entrada.- Son todos los datos que hay que ingresar para la resolución del problema.
b) Proceso.- Son los diferentes procedimientos en los cuales se usan los datos
proporcionados por el usuario en el paso anterior “Entrada” para resolver el
problema.
c) Salida.- Es la solución del problema.
1. Requerimientos funcionales.
Identificar a una persona y además calcular el sueldo con horas extras en el país y el sueldo
por “comisión de servicios profesionales”
3. Herramientas de diseño.
a. Pseudocódigo
b. Diagrama de flujo
c. Implementación en lenguaje “C”
Página 9
RAPTOR
Permite crear un ambiente de diseño de visualización basado en diagrama de flujo y
pseudocódigo.
Diagrama de flujo.- Son diversas áreas de trabajo, área de símbolos, área donde muestra p lo
que esta ejecutado el programa por medio del diagrama de flujo.
Símbolos.- Son los objetos que nos ayudara a construir nuestro diagrama de
flujo.
Página 10
File
Este menú nos permite crear un nuevo archivo, abrir, guardar, copilar, mandar a imprimir el
diagrama e inclusive guardar el diagrama en el portapapeles para guardarlos en un documento
de texto o guardarlos como imagen en Paint.
Edit
Este menú nos permite copiar o pegar fragmentos de programa, además permite deshacer
cambios hechos en el diagrama.
Página 11
Menú Scale (Escala)
Página 12
Menú Run
Menú Mode
Página 13
Menú ink
Nos permite escoger un color de tinta para poder escribir hacer anotaciones, subrayan o hacer
cualquier anotación en en cualquier área del espacio del trabajo.
Menú Windows
Permite especificar la orientación que deseamos que tenga la ventana de la aplicación ya sea
vertical, horizontal o completa.
Página 14
Menú Generate
En la ayuda del programa se encuentra un manual completo en inglés de todas las funciones,
operadores matemáticos, sintaxis entre otros.
Página 15
Algoritmo
Inicio
leer ancho;
leer largo;
area= ancho*largo,
num_ladrillo=65*area,
kg_cemento=7*area,
leer num_ladrillo;
leer kg_cemento;
Fin
Página 16
Algoritmo
Inicio
leer num1;
leer num2;
producto = num1*num2
leer producto;
Fin
Inicio
real PI
Página 17
leer radio;
area = PI*radio*radio;
perimetro = 2*PI*radio
leer area,
leer perimetro,
Fin
/*Diseñe un algoritmo que le presenta calcular la suma de los numeros enteros entre 1 y 10 es
decir 1+2+3+…….+10*/
Inicio
leer numero;
leer suma;
numero = numero+1
suma=numero+suma
Página 18
leer suma_total;
Fin
1 método
2 método
Página 19
/*Diseñe e implemente un algoritmo que permita sumar los números pares de 2 al 100*/
Inicio
leer suma;
leer numero;
suma= suma+numero;
numero = numero+2;
numero=100;
leer suma_total;
Fin
Página 20
930+62=992 62+2=64 T
992+64=1056 64+2=66 T
1056+66=1122 66+2=68 T
1122+68=1190 68+2=70 T
1190+70=1260 70+2=72 T
1260+72=1332 72+2=74 T
1332+74=1406 74+2=76 T
1406+76=1482 76+2=78 T
1482+78=1560 78+2=80 T
1560+80=1640 80+2=82 T
1640+82=1722 82+2=84 T
1722+84=1806 84+2=86 T
1806+86=1892 86+2=88 T
1892+88=1980 88+2=90 T
1980+90=2070 90+2=92 T
2070+92=2162 92+2=94 T
2162+94=2256 94+2=96 T
2256+96=2352 96+2=98 T
2352+98=2450 98+2=100 T
1 método
Página 21
2 método
1. Algoritmo
Inicio
leer nombre1;
leer apellido1;
leer nombre_apellido;
Fin
Página 22
2. Diagrama de flujo en Raptor
3. Implementación “C”
Página 23
*/ Diseñe e implemente un algoritmo de datos de la carrera/*
Datos
Código: 22042
NRC: 1766
Página 24
1. Algoritmo
Inicio
char universidad, departamento, carrera, catedra, codigo, NRC, alumno, docente, periodo;
leer universidad;
leer departamento;
leer carrera;
leer catedra;
leer codigo;
leer NRC;
leer alumno;
leer docente;
leer periodo;
leer caratula;
Fin
Página 25
2. Diagrama de flujo en Raptor
3. Implementación “C”
Página 26
TIPOS DE DATOS
TIPO Tamaño en Bits Rango Mínimo
Char 8 128 a 127
unsigned char 8 0 a 255
CARÁCTER signed char 8 128 a a127
Int 16 32768 a 32767
unsigned int 16 0 a 65535
signed int 16 Igual que int
short int 16 Igual que int
ENTERO unsigned short int 16 0 a 65535
signed short int 16 Igual que short int
long int 32 214748648 a 214748647
signed long int 32 Igual a long int
unsigned long int 32 0 a 4294967295
± (3.4e - 38 a 3.4e + 38)
Float 32 6 dígitos de precisión
FLOTANTE
Ejercicios
Diseñe e implemente un algoritmo que le permita calcular la hipotenusa dado el cateto 1 con un
valor de 5 y el cateto 2 con un valor de 4; además despliegue un mensaje que indique el número
de bits con los que debe ser gestionado de acuerdo al tipo de dato proporcionado para la
resolución de la hipotenusa solicitada.
Página 27
1. Algoritmo
Inicio
leer cateto1;
leer cateto2;
leer hipotenusa;
escribir “El valor de los bits de cateto1 es igual a 16, cateto2 es igual a 16 y la hipotenusa es
igual a: 32”
Fin
Página 28
3. Implementación “C”
Página 29
ESTRUCTURA DE CONTROL
Estructura Secuencial
Ejercicio
Lab_7EstructuraSecuencial
*/ Diseñe e implemente un algoritmo que nos permita sumar 2 números enteros, en donde num1
tiene asignado un valor de 5, num2 un valor asignado con 12, especifique la suma total de estos
2 números. /*
1. Algoritmo
Inicio
leer num1;
leer num2;
leer suma_total;
Fin
& Ampersand es un puntero que permite ubicar la dirección y posición de una variable en la
memoria del computador (RAM)
Página 30
2. Diagrama de flujo en Raptor
3. Implementación “C”
Página 31
Estructura For
*/ Diseñe e implemente la estructura aplicando la estructura for en donde la condición inicial
denominado num se inicialice con un valor de 3, la condición de validación sea menor a 10 y la
condición de incremento en 1 su valor; imprima la suma bajo estas condiciones/*
Condicional de Inicialización
Condicional de Validación
Condicional de Incremento
1. Algoritmo
Inicio
leer cont;
leer cont;
cont = cont + 1;
cont = 10;
suma cont Suma=suma+cont Cont+1 Cont>10
Fin 1 3 3+1=4 3+1=4 T
4+4=8 4+1=5 T
8+5=13 5+1=6 T
13+6=19 6+1=7 T
19+7=26 7+1=8 T
26+8=34 8+1=9 T
34+9=43 9+1=10 T
Página 32
2. Diagrama de flujo en Raptor
3. Implementación “C”
Página 33
*/ Diseñe e implemente un algoritmo que permita desplegar los números dígitos en forma
ascendente /*
1. Algoritmo
Inicio
leer cont;
leer cont;
cont = cont + 1;
cont = 10;
Fin
Página 34
2. Diagrama de flujo en Raptor
3. Implementación “C”
Página 35
*/ Diseñe e implemente un algoritmo que le permita desplegar los números dígitos de forma
descendente /*
1. Algoritmo
Inicio
leer cont;
leer cont;
cont = cont - 1;
cont = 0;
Fin
Página 36
2. Diagrama de flujo en Raptor
3. Implementación “C”
Página 37
*/ Diseñe e implemente un algoritmo que le permita desplegar la siguiente serie de números 3,
5, 7, 9 /*
1. Algoritmo
Inicio
leer cont;
leer cont;
cont = cont + 2;
cont = 11;
Fin
Página 38
2. Diagrama de flujo en Raptor
3. Implementación “C”
Página 39
Estructura while
Sintaxis:
while (expresion)
Sentencia 1;
Sentencia 2;
Ejercicio
1. Algoritmo
Inicio
leer cont;
Página 40
escribir “cont”, cont;
leer cont;
cont = cont + 1;
cont = 10;
Fin
Página 41
3. Implementación “C”
Página 42
Lab_12while13
*/ Diseñe e implemente un algoritmo que le permita desplegar los números dígitos en orden
descendente /*
1. Algoritmo
Inicio
entero num= 9;
leer num;
num = num - 1;
leer num;
Fin
Página 43
3. Implementación “C”
Página 44
2 método
Página 45
Ciclo do_while
Sintaxis:
do{
sentencia1;
sentencia2;
Sentencian;
}while (condición);
Esta estructura valida la condición al finalizar, si la condición es verdadera del while se ejecutan
todas las sentencias, sentencia 1, sentencia 2,…..sentencia n, que están dentro del bloque del do;
si la condición del while es falsa se ejecutan todas las instrucciones que están fuera del do.
Lab13_do_while1
*/Diseñe e implemente un algoritmo que le permita leer números desde el teclado hasta que uno
de ellos sea menor (<) o igual (=) a 10/*
1. algoritmo
Inicio
entero num;
leer num;
num = num + 1;
num = num + 2;
num < 0;
leer num;
Fin
Página 46
2. Diagrama de flujo en raptor
3. implementación “C”
Página 47
*/ Diseñe e implemente un algoritmo que le permita imprimir la serie 3, 4, 5, 6, 7, 8, 9, 10/*
1. algoritmo
Inicio
entero num=2;
leer num;
num = num + 1
num < 10
leer num;
Fin
Página 48
2. Diagrama de flujo en raptor
3. implementación “C”
Página 49
*/ Diseñe e implemente un algoritmo que le permita imprimir la serie 3, 5, 7, 9, 11/*
1. algoritmo
Inicio
entero num=1;
leer num;
num = num + 2;
num < 10
leer num;
Fin
Página 50
2. Diagrama de flujo en raptor
3. implementación “C”
Página 51
ESTRUCTURA SELECTIVA
Sentencia if
Sintaxis:
if (expresión)
Sentecia;
*/ Diseñe e implemente un algoritmo que le permita leer 2 números enteros y a la vez le permita
comprobar cuál es el resto de la división del número entre el dividendo. Si el resto es 0, el
número es divisible para el divisor/*
1. algoritmo
Inicio
leer num;
Fin
Página 52
2. Diagrama de flujo en raptor
3. implementación “C”
Página 53
Página 54
Lab14_if2
1. algoritmo
Inicio
leer kwh;
(1000*1) = 1.2
(1000*1) = 1
(1850*1) = 0.2
leer kwh:
Fin
Página 55
3. implementación “C”
Página 56
Página 57
*/ Diseñe e implemente un algoritmo que le permita visualizar la tarifa de la luz según el
consumo de corriente eléctrica. Para un consumo menor de 184 kwh 31 dias por tarifa de 17.25$
entres 110 kwh una tarifa de 9.37$ y entre 100 kwh una tarifa de 8.43$/*
1. algoritmo
Inicio
leer kwh;
kwh = kwh*(1725/184)
leer kwh
Fin
Página 58
2. Diagrama de flujo en raptor
3. Implementación “C”
Página 59
Página 60
if_else
sintaxis:
if (expresión)
sentencia 1;
else
sentencia 2;
Lab14_if_else3
*/ Diseñe e implemente un algoritmo que le permita ingresar los números enteros, leer los
números enteros y verificar mediante una visualización si el número es divisible o no
divisible/*
Página 61
1. algoritmo
Inicio
leer divisor;
leer numero;
verdadero = 24/2
falso = 13/2
leer verdadero;
leer falso;
Fin
Página 62
3. Implementación “C”
Página 63
Lab14_if_else4
1. algoritmo
Inicio
leer numero1;
leer numero2;
Fin
Página 64
2. Diagrama de flujo en raptor
3. Implementación “C”
Página 65
Página 66
Lab14_if_else5
1. algoritmo
Inicio
leer num1;
leer num2;
leer num3;
si=(num1>num2)
si=(num1>num3)
numMayor=num1;
caso contrario=numMayor=num3;
si=(num2>num3)
caso contrario=numMayor=num2;
Fin
Página 67
3. Implementación “C”
Switch
Esta sentencia se utiliza para seleccionar una de entre múltiples alternativas, es útil cuando la
selección se basa en el valor de una variable siempre o de una expresión simple denominado
expresión de control o selector, el valor de este selector puede ser de tipo int o char, pero no
puede ser de tipo float o double.
El selector se evalúa y se compara con cada una de las etiquetas del case, cada etiqueta es un
valor único, es decir tiene un valor diferente de las otras etiquetas.
Página 68
Sintaxis:
switch (selector)
sentencia1;
break;
sentencia2;
break;
sentencian;
break;
default:
sentencia;
Lab15_switch1
1. algoritmo
Inicio
leer tipo_vehiculo;
switch (tipo_vehiculo)
case1:
break;
case2:
escribir (“autobus”);
Página 69
break;
case3:
escribir (“motocicleta”);
break;
default:
Fin
2. Implementación “C”
Página 70
Página 71
Página 72
Página 73
Lab15_switch2
*/ Diseñe e implemente un algoritmo en el cual dada una nota en un examen, le permita escribir
el literal que le corresponda a la nota/*
1. algoritmo
Inicio
entero calificacion;
leer calificacion;
switch (nota)
case1:
break;
case2:
break;
case3:
escribir (“Aprobado”);
break;
case4:
escribir (“Suspendido”);
break;
default:
Fin
Página 74
2. Diagrama de flujo en raptor
3. Implementación “C”
Página 75
Examen
*/ Diseñe e implemente un algoritmo en el cual, mediante un selector denominado carrera de
tipo entero, le permita validar etiquetas numéricas las mismas que contienen sentencias que
indican las carreras de la universidad de las Fuerzas Armadas ESPE seleccionar 6 carreras; la
instrucción de for deberá indicar esta carrera no existe/*
1. algoritmo
Inicio
entero carrera;
Página 76
escribir “Esta carrera no existe”, esta carrera no existe;
Fin
3. Implementación “C”
Página 77
Página 78
Página 79
Página 80
UNIDAD 2
*/ Diseñe e implemente un algoritmo que le prermita crear un menú la cual integre las siguientes
opciones:
1. Sumar 2 números
2. Restar 2 números
3. Multiplicar 2 números
4. Dividir dos números
Además utilice la aplicación puts; función que le permite escribir en la pantalla la cadena
apuntada a su argumento, luego de lo cual posiciona al cursor al principio de la siguiente línea.
Para la división de sebe controlar que no exista división para cero.
El selector deberá ser de tipo char, y los números que participan en las operaciones serán de tipo
float (decimales)
1. algoritmo
Inicio
char selector;
Página 81
escribir (“ 3 Multiplicar dos numeros.”);
if
si (selector > ‘0’ && selector < = ‘4’){ //&& and (y)
switch (selector)
case 1:
pausa;
case 2:
pausa;
case 3:
pausa;
case 4: Si (num2)// Si es if
pausa;
defecto: // default
Fin
Página 82
2. Implementación “C”
Página 83
Página 84
Página 85
Página 86
Lab18_integracionswitch
Página 87
Página 88
Página 89
Lab19_EntradaCaracter
*/ Diseñe e implemente un algoritmo que le permita ingresar por teclado las letras MV luego
estos caracteres deberán ser leidos/*
MV
1. algoritmo
Inicio
Fin
Página 90
2. Diagrama de flujo en Raptor
3. Implementación “C”
Página 91
Lab20_SalidaCadenaDeCaracteres
1. Algoritmo
Inicio
{
arreglo (array)
tipo de dato
char p [21] c A r r e r a
float elemento [8] 2.1 3.6 8.9 4.5 1.0 2.6 7.0
Página 92
E s p e c i a l i d a d e n P e t r o q u i m i c a
puts (CP);
puts (p);
puts (&p[12]);
Fin
Página 93
3. Implementación “C”
Página 94
Lab21_EntradaCadenaDeCaracteres
*/ Diseñe e implemente un algoritmo que le permita desplegar una entrada de caracteres/*
1. Algoritmo
Inicio
Fin
Página 95
3. Implementación “C
Página 96
Lab23_EspecificadoresFormato
*/ Diseñe e implemente un algoritmo que le permita imprimir los siguientes tipos de datos punto
flotante, entero y cadena; el punto flotante debe estar controlado por 4 números decimales/*
1. Algoritmo
Inicio
int main ( )
Fin
Página 97
3. Implementación “C”
Página 98
Putchar
Lab24_Putchar
*/ Diseñe e implemente un algoritmo que le permita usar la función Putchar, la cual le permite
escribir su argumento de tipo carácter en la pantalla en la posición del cursor. Esta función tiene
un argumento de tipo char, aunque se declara usando un parámetro enetero, en el byte de menor
orden el que se muestra en la pantalla/*
1. Algoritmo
Inicio
char ch = ‘*’;
putchar (‘A’);
putchar (‘ch’);
Fin
Página 99
3. Implementación “C”
Página 100
Página 101
Gets
Página 102
La función gets esta función lee una cadena de caracteres introducida por un teclad hasta que se
pulse control/z.
Lab25_gets
*/ Diseñe e implemente un algoritmo que le permita realizar el ingreso de una cadena que acepte
cualquier nombre, incluyendo espacios en blanco, de hasta 80 caracteres de longitud/*
1. Algoritmo
Inicio
char *ptr;
leer nombre;
Fin
3. Implementación “C”
Página 103
Página 104
Proyecto 1
Atributos:
1. Algoritmo
Inicio
leer tema;
a=1
Página 105
area_de_cultivo=(1000 m cuadrados - Verificar que el terreno sea lo mas plano posible - Un
buen drenaje - Suelo suelto);
leer area_de_cultivo;
a=2
a=3
Preparacion_del_suelo=( Aflojar el suelo con arado y rastra - Añadir material organico al suelo
recomendable 2 kilos por metro cuadrado);
leer Preparacion_del_suelo;
a=4
leer Desinfeccion_del_suelo;
a=5
Trazado_de_camas =( Una cama mide 0.70m de ancho por 30m de largo - Un pasillo o camino
entre cama y cama de 0.50m que sirve para las labores de trabajo y cosecha - En 1000 metros
cuadrados trazaremos 24 camas);
leer Trazado_de_camas;
a=6
leer Armado_de_camas ;
a=7
Página 106
Instalacion_del_agua =( Colocamos tuberia madre de 2 pulgadas de diametro a la cual
colocaremos un collarin de una pulgana para generar presión - La manguera de una pulgada se
coloca al inicio de las camas);
leer Instalacion_del_agua;
a=8
leer Instalacion_de_cintas_de_goteo_para_las_camas;
a=9
Siembra=( En cada cama entra 4 hileras e plantas de clavel con una distancia de planta a planta
de 11cm que tendríamos un promedio de 270 por hilera y un promedio de 1080 plantas por
cama - En el invernadero de 1000 m cuadrados estamos sembrando 26 mil plantas - Se hace un
orificio no tan profundo de 3 cm - Se coloca la plantula con raiz dentro del orificio -
Apretandole con la tierra);
leer Siembra;
a=10
Fertilizacion=(Desde el primer dia que se siembra necesita nutrirse por lo cual se recomienda
dar fertilizacion por medio de las cintas de goteo - En 500 litros de agua un kilo de amonio un
kilo depotasio un kilo de calcio segun vaya creciendo la planta aumentariamos la dosis);
leer Fertilizacion;
a=11
leer Primer_pinche;
a=12
Página 107
Control_de_malesas=( Evitar que la malesa crezca en la cama ya que impide alimentar de buena
manera al clavel quitando nutrientes - Se lo realiza química o manualmente);
leer Control_de_malesas;
a=13
Segundo_pinche =( Se lo realiza al mes y medio del primero con el mismo procediemiento del
primer pinche - En este caso escogiendo 2 a 3 tallos );
leer Segundo_pinche;
a=14
leer Aplicaciones_fito_sanitarios;
a=15
leer Tutoreo;
a=16
Desyeme =( Esta labor se lo realiza manualmente sacando los brotes laterales del botón -
Dejando solo el boton principal);
leer Desyeme;
a=17
Cosecha =( Esta labor se realiza a los 6 meses de haber plantado cortándole el tallo a 5 cm del
tallo principal - Cuando la flor ya indique su color);
leer Cosecha;
a=18
Página 108
Proceso_en_poscosecha =( Se lo realiza sacando las tres cuartas partes de hojas del tallo -
Selección de tallos - Selección de plagas y enfermedades - Seleccionar la Longitud);
leer Proceso_en_poscosecha;
a=19
Comercializacion=( Con la calidad requerida se procede a la venta exportando segun los clientes
- Con una gran demanda a Rusia);
leer Comercializacion;
a=20
Rentabilidad_economica =( Si todas las labores las hemos realizado bien tendremos una
rentabilidad del 50% en el primer año.);
leer Rentabilidad_economica;
Fin
Página 109
3. Implementación “C”
Página 110
Proyecto 2
1. Algoritmo
Inicio
leer tema;
a=1
Página 111
Transporte=( El transporte del petróleo comienza en la superficie del pozo, recorre un itinerario
de rutas y redes y termina en su destino final de consumo.);
leer Transporte;
a=2
leer Oleoductos;
a=3
leer Poliductos;
a=4
leer Buques_tanque_y_camiones_cisterna;
a=5
leer Tamano_de_un_tanque;
Página 112
leer num1;
leer num2;
leer num3;
si=(num1>num2)
si=(num1>num3)
MayorCapacidad = num1;
si=(num2>num3)
a=6
leer Diametro_en_pies;
leer num;
leer suma;
a=7
leer num;
num < 50
leer num;
Página 113
a=8
Carga_ventral =(La carga ventral (Bottom Loading) es una metodologia utilizada para el
despacho de camiones cisternas por bombeo de hidrocarburos livianos, a traves de un sistema de
valvulas y canerias montadas en la parte inferior de las cisternas del camion. - El factor mas
importante por el cual los paises en desarrollo desde hace tiempo fueron adoptando la carga
ventral fue la seguridad, debido al importante numero de accidentes ocurridos en los Estados
Unidos a traves de los anos en la operatoria por carga superior);
leer Carga_ventral;
a=9
leer Principales_beneficios_de_la_carga_ventral;
a=10
leer Seguridad_para_el_operador;
a=11
leer Prevencion_de_incendios;
a=12
Página 114
leer Prevencion_de_derrames;
a=13
leer La_perforacion_horizontal_a_traves_de_los_rios;
a=14
leer Como_se_hace;
a=15
leer Ventajas;
a=16
Distribucion =(El destino final del petroleo y sus derivados es el consumidor final. En el
proceso intervienen distribuidores mayoristas y minoristas, y se emplean todos los medios
posibles para el transporte y venta);
leer Distribucion;
a=17
Página 115
Condiciones =( los oleoductos de productos - los barcos de cabotaje de alta mar - los transportes
fluviales (canoas, lanchas, remolcadores) - los depositos de almacenamiento - las vagones-
cisterna - los camiones-cisterna (grandes transportes o pequenos distribuidores domesticos) - las
estaciones de servicio - el avituallamiento de las aeronaves mediante camiones especializados y
canalizaciones subterraneas);
leer Condiciones;
a=18
leer Precio_del_barril;
leer num;
num = num + 8;
leer num;
num = num + 7;
leer num;
num = num + 1;
leer num;
num = num + 2;
leer num;
num = num + 5;
leer num;
num < 63
leer num;
a=19
leer Cantidad_de_barriles_en_millones_por_dia;
leer num;
num = num + 9;
leer num;
Página 116
num = num + 8;
leer num;
num = num + 7;
leer num;
num = num + 2;
leer num;
num = num + 3;
leer num;
num < 30
leer num;
leer num;
Fin
Página 117
3. Implementación “C”
Página 118
Página 119
Unidad III
INTRODUCCION A PUNTEROS
DEFINICION
Un puntero o una variable puntero es una variable que contiene dirección de otras variables
siendo estas direcciones las posiciones internas de las variables en la memoria ram; es dear, la
variable puntera contiene valores que son direcciones de memoria donde se almacenan datos en
resumen un puntero es una variable que contiene o almacena una dirección de memoria.
Características
f (a , b)
f=Función
b=argumento 1
a=argumento 2
Lista enlazada
Arboles
Entre otras
Lista enlazada
Productos comestibles
Árbol:
Raíz padre
Página 120
TIPO
•[Lacteo,carne,verdura,fruta]
Nombre
•[Queso,pescado,col,pera]
Fecha de caducidad
•[1/2/8,2/2/18,12/3/18,20/4/18]
Precio [3.50,4.50,6.50,7.80]
Mejorar la eficiencia de ciertas rutinas mediante el uso de arreglos, cadenas estructuras entre
otras.
Arreglo
Direcciones de memoria
Su nombre
Su tipo
Su dirección de memoria
Representación de una dirección de memoria
0029FFCC
75
n
int
Página 121
En donde:
Al valor de una variable se accede por media de su nombre por ejemplo si se desea imprimir el
valor de n usamos la siguiente sentencia
Printf(“%d”,n);
Operador de dirección
El operador unario de dirección & ampersan opera o se aplica sobre el nombre de la variable
para obtener su dirección
Lab26_puntero1
#include<stdio.h>
int main()
int q=75.8965739873946739;
printf("%.11f\n",q);
RAPTOR
Página 122
DEV C++
Página 123
Operador de Indireccion
Operador Unario
Ejemplo
*punt
1)Operador
%p
Especificador de format
%d, int,
%f, float,
%c, char,
%s, string,
Página 124
Lab26_puntero2
#include<stdio.h>
int main ()
int num=75;
printf("num=%d,&num=%p,punt=%p,&punt=%p\n",num,&num,punt,&punt);
//printf("&punt=%p\n",&punt);
0000000000000000023FE40
000000000000000000023FEAC
printf
Int*
0000000000000000023FE40
num 000000000000000000023FEAC
Int*
int*
Raptor
Página 125
Dev c++
Página 126
IMPLEMENTACION Y APLICACIONES
#include<stdio.h>
int main ()
int num=75;
printf("num=%d,&num=%p,punt=%p,&punt=%p\n",num,&num,punt,&punt);
//printf("&punt=%p\n",&punt);
Página 127
}
RAPTOR
Página 128
DEV C++
Página 129
DEBER
Primer Algoritmo
#include<stdio.h>
#include<conio.h>
#include<stdlib.h>
main ()
system("color 6F");
getche();
int m;
getch();
do
char selector;
float
q=2.555,m=3.567,l=2.468,y=1.553,p=5.758,c=6.789,g=3.2546,v=2.789,co=8.3564,cu=5.789,a=
1.50234,b=2.5678,z=1.8998,r=1.5098,t=2.3567,ma=2.35678,pe=3.2567,u=2.891,n=3.6789;
puts("DEBER DE PROGRAMACION\n");
puts("Tema:Punteros\n");
puts("Nombre:Cynthia Chugchilan\n");
puts("Carrera:Ingeniera Petroquimica\n");
selector=getchar ();
Página 130
switch (selector)
case 'A':
printf("Lacteos\n");
printf("1) Queso\n");
scanf("%c",&q);
printf("2) Mantequilla\n");
scanf("%c",&m);
printf("3) Leche\n\n");
scanf("%c",&l);
printf("3) Yogur\n\n");
scanf("%c",&y);
break;
case 'B':
Página 131
printf("Carnes\n\n");
printf("Pescado\n");
scanf("%c",&p);
printf("Carne de Cerdo");
scanf("%c",&c);
printf("Gallina");
scanf("%c",&g);
printf("Carne de Vaca");
scanf("%c",&v);
printf("Carne de Cordero");
scanf("%c",&co);
printf("Cuy");
scanf("%c",&cu);
Página 132
printf("cu=%f\n",cu);// viluazilar en valor del cuy
break;
case 'C':
printf("Verduras\n");
printf("Acelgas\n");
scanf("%c",&a);
printf("Brocoli\n");
scanf("%c",&b);
printf("Zanahoria\n");
scanf("%c",&z);
printf("Rabano\n");
scanf("%c",&r);
printf("Tomate\n");
scanf("%c",&t);
Página 133
printf("El precio del tomate es :%.2f\n",t);//decimales
break;
case 'D':
printf("Frutas\n");
printf("Manzana\n");
scanf("%c",&ma);
printf("Pera");
scanf("%c",&pe);
printf("Uva");
scanf("%c",&u);
printf("Naranja");
scanf("%c",&n);
break;
default:
Página 134
printf("\n\n\tDesea repetir el proceso con algun programa 1.-SI, o ingrese cualquier otro valor
para cerrar ");
scanf("%d",&m);
}while (m==1);
RAPTOR
DEV C++
Página 135
Segundo Algoritmo
#include<stdio.h>
#include<conio.h>
#include<stdlib.h>
#include<iostream>
int main ()
Página 136
system("color 5F");
getche();
int m;
getch();
do
char selector;
puts("DEBER DE PROGRAMACION\n");
puts("Tema:Punteros\n");
puts("Nombre:Cynthia Chugchilan\n");
puts("Carrera:Ingeniera Petroquimica\n");
puts("C Caracter");
puts("D Cadena");
selector=getchar ();
switch (selector)
case 'A':
printf("Dato: %d\n",*p_n);
printf("Direccion: %p\n",p_n);
break;
case 'B':
printf("Numero flotante:\n");
Página 137
printf("Dato: %.2f\n",*p_n2);
printf("Direccion: %p\n",p_n2);
break;
case 'C':
printf("Caracter:\n");
printf("Dato: %c\n",*p_n3);
printf("Direccion: %p\n",p_n3);
break;
case 'D':
printf("Cadena de caracteres");
char Cynthia_Chucgchilan_Herrera;
char *p_n4=&Cynthia_Chucgchilan_Herrera;
printf("Dato: %s\n",nombre,*p_n4);
printf("Posicion: %p\n",p_n4);
break;
printf("\n\n\tDesea repetir el proceso con algun programa 1.-SI, o ingrese cualquier otro valor
para cerrar ");
scanf("%d",&m);
}while (m==1);
RAPTOR
Página 138
DEV C++
Página 139
2.Aritmetica de punteros
La aritmética de punteros se realiza de acuerdo al tipo ase de puntero que el puntero a un
elemento del mismo de tipo de la base. Existen solamente 2 operaciones aritméticas que se
puedan realizar con la variable puntero la suma y la resta.
Página 140
La suma, se realiza por medio de una suma de un puntero y una variable por medio del operador
incremento al puntero (punt++)
La resta tiene la misma forma de operador de la suma, considerando la resta de elementos o del
operador al puntero (punt--)
#include<stdio.h>
int main()
float num1=100,num2=200,*punt;
punt=&num2;
punt++;//punt++=punt+1
Raptor
Página 141
Página 142
Dev c++
Página 143
Diseñe e implemente un algoritmo que le permita imprimir la dirección de la
variable num1,num2 la dirección punt y el contenido del puntero punt. La
operación de decremento se realiza en el puntero punt considere las variables de
tipo float
#include<stdio.h>
int main()
float num1=100,num2=200,*punt;
punt=&num2;
punt--;//punt--=punt-1
RAPTOR
Página 144
DEV C++
Página 145
Inicialización de punteros
Luego de declarar un puntero este puntero tiene un valor desconocido por lo qué se debe
inicializar un valor conocido antes de usarlo por convenio, cuando se inicializa un puntero se
debe asignarle un valor NULL esto indica que el puntero apunta a una dirección de memoria
especifica también es frecuente inicializar los punteros con valor conocido.
#include<stdio.h>
int main()
char *aux;
Página 146
puts(punt);
for (aux=punt; *aux ; aux++);// La operacion de incremento permite ingresar cada uno de los
caracteres de la cadena desde el inicio hasta el fin de la cadena
putchar(*aux);
RAPTOR
Página 147
DEV C++
Página 148
Indireccion de punteros
Después de definir una variable puntera, la siguiente pasa es inicializar el puntero
y utilizarlo para direccionar algún dato especifico en memoria. EL uso de un
puntero para obtener el valor al que apunta es decir si dato apunta se denomina
direccionan el puntero para ellos se utiliza el operador de unidireccional.
#include<stdio.h>
int main()
char *puntcaracter;
puntcaracter=&caracter;
for(caracter='A';caracter<='Z';caracter++)
printf("%c\n",*puntcaracter);
Raptor
Página 149
Página 150
Dev c++
Página 151
2. ARREGLOS ARRAYS
Un array es un conjunto ordenado de datos del mismo tipo de los datos se denominan elementos
del array y se enumeran consecutivamente (0, 1, 2, 3, ……., (n-1) estos números se denominan
valores o subíndices del array determinándose como:
0, 1, 2, 3,……., (n-1)
e0 e1 e2 e3 e(n-1)
Estos números declarados como subíndice localizan la posición del elemento dentro del array
por lo general el array se utiliza tipos de datos tales como: char, int, float, string.
Representación grafica
Primera posición:
e0 (2,3) [2,3]
Segunda posición:
e1 (40,5) [40,5]
Tercera posición:
e2 (7,83) [7,83]
Cuarta posición:
e3 (80,5) [80,50]
Quinta posición:
e5 (1,9) [1,9]
Página 152
Estructura del arreglo
1. Declaración del arreglo
a) float e[5];
equipo_futbol[11] string
l0 l1 l2
b) Costo
costo
1 2 3 4
c0 c1 c2 c3
c) precio de vidrio
d) curso de natación
Página 153
Lucas Kevin Steven Dennis Alejandro Stalin Anderson Brayan Karla Mishell
c_n0 c_n1 c_n2 c_n3 c_n4 c_n5 c_n6 c_n7 c_n8 c_n9
stringcurso_natacion[10]=
{Lucas,kevin,Steven,Dennis,Alejandro,Stalin,Anderson,Brayan,Karla,Mishell}
a) char lacteos
b) int costo [4 ]
Página 154
c0 = 1; Acceso a la primera posición;
c) float precio_vidrios[5]
d) curso de natacion
curso_natacion [10]
Página 155
c_n4 = Alejandro; Acceso a la quinta posición;
Página 156
lab27_arrayunidimensional1
Diseñe un algoritmo que le permita crear un arreglo denominado tabla que integre
un tamaño de los 100 primeros enteros y muéstrenos por pantalla en orden
ascendente
1. Algoritmo
Inicio
#include<stdio.h>
int main ()
int num,tabla[100];
for(num=1;num<=100;num++)
tabla
for (num=1;num<=100;num++)
Página 157
T 9 8
T 10 9
T 11 10
T 12 11
T 113 12
T 14 13
T 15 14
T 16 15
T 17 16
T 18 17
T 19 18
T 20 19
T 21 20
T 22 21
T 23 22
T 24 23
T 25 24
T 26 25
T 27 26
T 28 27
T 29 28
T 30 29
T 31 30
T 32 31
T 33 32
T 34 33
T 35 34
T 36 35
T 37 36
T 38 37
T 39 38
T 40 39
T 41 40
T 42 41
T 43 42
T 44 43
T 45 44
T 46 45
T 47 46
T 48 47
T 49 48
T 50 49
T 51 50
T 52 51
T 53 52
T 54 53
T 55 54
T 56 55
T 57 56
T 58 57
T 59 58
T 60 59
T 61 60
Página 158
T 62 61
T 63 62
T 64 63
T 65 64
T 66 65
T 67 66
T 68 67
T 69 68
T 70 69
T 71 70
T 72 71
T 73 72
T 74 73
T 75 74
T 76 75
T 77 76
T 78 77
T 79 78
T 80 79
T 81 80
T 82 81
T 83 82
T 84 83
T 85 84
T 86 85
T 87 86
T 88 87
T 89 88
T 90 89
T 91 90
T 92 91
T 93 92
T 94 93
T 95 94
T 96 95
T 97 96
T 98 97
T 99 98
T 100 99
T 100
Página 159
3. Implementación “C”
Página 160
Diseñe un algoritmo que le permita ingresar un arreglo unidimensional llamado
tabla con tamaño de los 100 primeros números enteros y muéstralos por pantalla
en orden descendente
1. Algoritmo
Inicio
#include<stdio.h>
int main ()
int num,tabla[100];
for(num=0;num<=100;num++)
Página 161
tabla [num]=num;//Los elementos estan dentro del arreglo
for (num=100;num>=1;num--)
Página 162
3. Implementación “C”
Página 163
Diseñe un algoritmo que le permita ingresar un arreglo unidimensional llamado
tabla que le permita ingresar los números primos entre 1 y 100 y muéstrelos por
pantalla en forma ascendente
1. Algoritmo
Inicio
i=0;
cont=0;
if(x%z==0)
cont++;
Página 164
tabla[i]=x;
i++;
}
System (“pause”);
Página 165
Página 166
3. Implementación “C”
Página 167
Diseñe un algoritmo que le permita ingresar inicializar un arreglo con el número
de dia de cada mes, luego imprima cada mes con su respectivo número de día
1. Algoritmo
Inicio
int dias [12]={31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
int i;
Fin
Página 168
3. Implementación “C”
Página 169
lab27_arrayunidimensional5
Inicio
gets (frase);
if (frase [contador]==’/0’)
indice= contador;
break;
Fin
Página 170
Página 171
3. Implementación “C”
Página 172
lab27_arrayunidimensional6
Inicio
gets (frase);
switch (frase[contador])
case ‘a’:
sum++;
break;
case ‘e’:
sum++;
break;
case ‘i’:
sum++;
break;
case ‘o’:
sum++;
break;
case ‘u’:
sum++;
break;
default:
Página 173
break;
printf (“/n En la frase hay %d vocales que incluyen espacios en blanco como vocales /n”, sum);
Fin
Página 174
3. Implementación “C”
Página 175
Página 176