PEdro

Notas de Programación Estructurada
Lizbeth Gallardo López Pedro Lara Velázquez
Departamento de Sistemas División de Ciencias Básicas e Ingeniería Universidad Autónoma Metropolitana – Azcapotzalco

Julio de 2011

Notas de Programación Estructurada

Índice Presentación ……………………………………………………………….. 1. Arquitectura de la Computadora……………………………………….. o Modelo actual de la computadora o Software de base 2. Algoritmos ……………………………………….……………………. o Componentes principales de un algoritmo o Programación o Programación estructurada o Diagramas de Flujo 3. Lenguaje C y FreeBasic .………………………….……………........... o C: Tipos de datos y operadores o FreeBasic: Tipos de datos y operadores o Primer programa: “Hola Mundo!” o Entrada y salida de datos 4. Estructuras de selección ………………………………….……………. o Selección simple (if) o Selección binaria (if-else) o Selección encadenada (if - else if - else) o Selección múltiple (case) 5. Funciones …………………………………………………….………... o Conceptos básicos o Paso de parámetro por valor o Paso de parámetro por referencia 6. Estructuras repetitivas …………………………………………………. o Durante (for) o Mientras (while) o Haz - mientras (do-while) 7. Tipos de datos estructurados ……………………………..…………… o Arreglos unidimensionales o Arreglos bidimensionales o Cadenas 8. Archivos ………………………………………………………………. o Conceptos básicos o Funciones usuales para el manejo de archivos Referencias ………………………………………………………….......... 2 3

9

14

25

35

43

54

68

77

Lizbeth Gallardo - Pedro Lara

UAM Azcapotzalco

Página 1

Notas de Programación Estructurada
PRESENTACIÓN
Desde finales de 1953, cuando John Backus propuso el lenguaje FORTRAN como una alternativa más práctica a la programación en lenguaje Ensamblador (muy cercano al lenguaje máquina), se han desarrollado una infinidad de lenguajes de programación, así como dialectos de los mismos. Estos programas nos sirven para desarrollar algoritmos de solución para resolver problemas de programación concretos. A los algoritmos de solución para un problema específico se les llama programas. Un algoritmo se puede comparar a una receta de cocina, donde el conjunto de instrucciones ordenadas se definen una sola vez y después puede ser repetido por otras personas. Así, un algoritmo se propone una sola vez y después puede ser traducido a varios lenguajes. En la actualidad existen distintos paradigmas de programación: imperativo, funcional, orientado a objetos y lógico por mencionar solo algunos. La programación imperativa estructurada la define Edsger Dijkstra como “una filosofía para la implementación de algoritmos a través de un conjunto finito de estructuras bien organizadas”. Dicho en otras palabras, la programación estructurada parte un gran problema en pedazos más pequeños, de tal forma que el programa final es el resultado de resolver cada subproblema de una manera más sencilla. En estos apuntes se utilizan dos lenguajes de programación estructurada: C y FreeBasic. Dentro de los lenguajes imperativos estructurados, C es el lenguaje más utilizado en la actualidad por su versatilidad y por la gran cantidad de bibliotecas disponibles para los programadores. Una biblioteca contiene un conjunto funciones que pueden reutilizarse en soluciones a problemas específicos, por ejemplo: integración y derivación de funciones matemáticas, generadores de interfaces de usuario. En contraste con el lenguaje ensamblador, el cual es considerado de bajo nivel porque todo se desarrolla muy cerca del lenguaje de máquina, C es considerado un lenguaje de nivel intermedio, ya que permite realizar aplicaciones que “blindan” al programador de los detalles de la arquitectura de hardware; pero si el programador lo requiere, C le permite comunicarse con ella. FreeBasic es considerado un lenguaje imperativo estructurado de alto nivel porque aunque puede comunicarse con la arquitectura de hardware, el programador no es consciente de ello. FreeBasic es ampliamente utilizado por desarrolladores que requieren rapidez en el cálculo numérico, el cual es comparable con la rapidez proporcionada por compiladores C. A diferencia de C, FreeBasic permite hacer gráficos bidimensionales con notable facilidad. Estas notas se dividen de la siguiente forma: los capítulos 1 y 2 presentan una introducción a la arquitectura actual de una computadora y al concepto de algoritmos; el capítulo 3 hace una breve presentación de los lenguajes C y FreeBasic; en el capítulo 4 se presentan las estructuras de selección; el capítulo 5 presenta el concepto de función, el cual es indispensable en el paradigma de programación estructurada; el capítulo 6 presenta las estructuras iterativas; el capítulo 7 presenta el concepto de datos estructurados; finalmente, el capítulo 8 presenta el manejo de archivos de texto.

Lizbeth Gallardo - Pedro Lara

UAM Azcapotzalco

Página 2

Notas de Programación Estructurada
CAPÍTULO I ARQUITECTURA DE LA COMPUTADORA
Una computadora está formada por: Hardware: Parte física o tangible: CPU, monitor, DD, etc. Software: Sistema Operativo, programas, algoritmos, etc.

Modelo actual de la Computadora

a) UNIDAD CENTRAL DE PROCESAMIENTO

Registros

b) MEMORIA

ALU

Unidad de control

Contador de programa

c) DISPOSITIVOS DE ENTRADA / SALIDA

La arquitectura de hardware de una computadora que prevalece hasta nuestros días se atribuye a John von Neumann y otros investigadores. Los principales componentes de la computadora son: a) Unidad central de procesamiento (CPU) Se encarga de realizar las operaciones aritmético-lógicas con los datos, la forman: la Unidad Aritmético Lógica, la Unidad de Control y la Unidad de Memoria. Unidad aritmético-lógica (ALU)

Lizbeth Gallardo - Pedro Lara

UAM Azcapotzalco

Página 3

Notas de Programación Estructurada
Encargada de realizar operaciones: aritméticas y lógicas. Dentro de las operaciones aritméticas, distinguimos entre las unarias: incremento y decremento; y las binarias: +, , * y /. La forma de expresar las operaciones binarias es: A <operador> B = C Las operaciones lógicas son: NOT (unaria), AND, OR, XOR. A excepción de la operación de negación, el resto son binarias. Ejemplo: p= “llueve afuera”; q= “hay sol” Diagrama Operación lógica NOT (p) NOT (q) p AND q p OR q p XOR q Resultado ” No llueve afuera” “No hay sol” “llueve afuera y hay sol” “Llueve afuera o hay sol” “Llueve afuera o hay sol, pero solo uno de los dos”

Unidad de Control Es la responsable de seleccionar las operaciones aritmético-lógicas. Esto se logra a partir de varias líneas de control que pueden estar activas o inactivas. Por ejemplo para una ALU simple con 10 operaciones diferentes se necesitan cuatro líneas de control, las cuales pueden definir 16 (24) situaciones diferentes, diez de las cuales pueden usarse para las operaciones aritmético-lógicas y el resto para otros propósitos. Ejemplo: 0000 0001 0010 0011 Neutro (no hay operación por hacer) Operación suma Operación resta Operación de multiplicación. etc.

Registros 1. Registros de entrada. En el pasado las computadoras solo tenían un registro de entrada para alojar, por turnos, uno de los datos de entrada (el otro dato de entrada venía directamente de la memoria). Actualmente las computadoras utilizan docenas de registros para acelerar las operaciones, las cuales son cada vez más complejas y requieren de varios registros para mantener los resultados intermedios. 2. Registros de instrucción (I). El CPU es el responsable de buscar las instrucciones en la memoria, una a una; luego debe almacenarlas en el registro de instrucción, interpretarlas y ejecutarlas. 3. Contador de programa (PC): Hace un seguimiento de la instrucción que se ejecuta actualmente; concluida la ejecución, el contador se incrementa para apuntar a la dirección (de memoria) de la siguiente instrucción. Lizbeth Gallardo - Pedro Lara UAM Azcapotzalco Página 4

Notas de Programación Estructurada
b) Memoria Es una colección de localidades o celdas de almacenamiento. Cada localidad tiene un identificador único conocido como “dirección “. Los datos se transfieren hacia y desde la memoria en grupos de bits llamados palabras.

“0” 00000000 . . . Dirección “255” 111111111 Dirección Con 8 bits tenemos 256 direcciones posibles. 8 bits forman un “byte”. Existen varios tipos de memoria, de los cuales distinguiremos: 1) la memoria RAM y 2) la memoria ROM. Memoria RAM (Random Access Memory). Es la memoria principal de una computadora. Un usuario puede leer y escribir en la RAM mientras la máquina esté encendida. La información es automáticamente borrada si deja de alimentarse de energía eléctrica a la computadora. Por esta característica, a la RAM también se le llama memoria volátil. Memoria ROM (Read Only Memory). El contenido de esta memoria es grabada por el fabricante. De la información contenida en esta memoria podemos citar: datos del fabricante, modelo de la computadora, tipo de procesador, capacidad de almacenamiento, la fecha, etc. También contiene un programa llamado BIOS el cual “arranca o inicia” a la computadora. Almacenamiento de datos en la Memoria Principal (RAM) Un bit es la unidad mínima de almacenamiento en una computadora; éste físicamente es un condensador: si está cargado, entonces representa 1 (verdadero); si no está cargado, entonces representa 0 (falso). +++ ---1 0

A una celda de memoria también se le conoce con el nombre de “palabra”. Una palabra puede contener desde un patrón de 8 bits (ej. 10100100) hasta 64 bits (computadoras recientes).

Lizbeth Gallardo - Pedro Lara

UAM Azcapotzalco

Página 5

Notas de Programación Estructurada
Aquí representamos a una memoria con cinco celdas; donde cada celda está formada por un patrón de 8 bits.
Contenido

Otra representación para una celda puede ser una caja, cuyo contenido es un valor expresado en binario (10111010), el cual tendrá un significado particular para la computadora.

10111010

La cantidad de celdas que contienen las memorias de las máquinas es variable: de cientos (un horno de microondas) a miles de millones (computadoras actuales). El tamaño de la memoria principal suele medirse en términos de unidades de 1‟048,576 celdas (este valor corresponde a una potencia de 2, así es más natural como unidad de medida dentro de la computadora, que un millón exacto). 210 → 1,024 bytes → 1 Kilobyte (kb) 220 → 1'048,576 bytes → 1 Megabyte (Mb) 230 → 1,024 Mb → 1 Gigabyte (Gb) Para identificar cada celda de la memoria principal se le asigna un identificador único, llamado dirección, el cual es un valor numérico consecutivo (ver figuras).
Contenido

celda 0000000000000000 celda 0000000000000010 . . celda 1111111111111111 10111010 0000000000000001
Dirección

Por ejemplo una computadora de tamaño de palabra igual a 8 bits y con 4 Mb tiene 4*1'048,576= 4'192,304 celdas, cada una con un tamaño de un byte. Todas con su dirección correspondiente: 0,1,2,... 4'192,303 ( pero expresado en binario).

c) Dispositivos de entrada / salida Dispositivos de Entrada. Permiten ingresar datos a la computadora (usuario  computadora)

Lizbeth Gallardo - Pedro Lara

UAM Azcapotzalco

Página 6

Notas de Programación Estructurada
Dispositivos de Salida. Permiten recibir datos de la computadora (computadora  usuario)

Dispositivos de almacenamiento secundario. Se clasifican como dispositivos de Entrada y Salida, a la vez. Salida: Pueden almacenar grandes volúmenes de información. Entrada: Esta información puede recuperarse en un momento posterior. Ejemplo: disco duro, discos 3 ½, USB, CD, DVD, Floppy, SD, etc.

Software de base
Al encender la computadora se ejecuta un programa llamado BIOS (Basic Input-Output System), el cual está guardado en la ROM. El BIOS se encarga de checar a todos los dispositivos conectados a la computadora y se encarga de buscar al Sistema Operativo en el disco duro, para luego cargarlo a la RAM. El software de base esta formado por un conjunto de programas que nos permite comunicarnos con el hardware de la computadora. En la figura el software de base está entre el Hardware y los Programas de aplicación.

Programa de aplicación Compiladores Ensambladores Macro-procesadores enlazadores Cargadores Editores de texto Depuradores Sistema Operativo
Programas E/S Sistema de Despachador Archivos de alto nivel (scheduler) Bibliotecas Manejo de memoria Manejo de Dispositivos

Hardware de la computadora
En nuestro curso, nosotros construiremos programas de aplicación. Un programa de aplicación que será escrito en un lenguaje de alto nivel (C); luego será traducido por un compilador a lenguaje máquina (lenguaje binario 0-apagado y 1-encendido); y finalmente, la CPU los ejecutará. Lizbeth Gallardo - Pedro Lara UAM Azcapotzalco Página 7

Notas de Programación Estructurada
Compilador: Es un programa (o conjunto de programas) encargado de traducir de un programa fuente, escrito en lenguaje de alto nivel, a un programa objeto, escrito en código máquina (lenguaje binario). Un compilador realiza las siguientes operaciones: análisis léxico (lexical analysis), preprocesamiento (preprocessing), análisis sintáctico (parsing), análisis semántico (semantic analysis), generación de código (code generation) y optimización de código (code optimization). Para obtener un programa ejecutable intervienen dos programas (o software de base) más, a saber: el ligador (linker) y el cargador (loader). Un enlazador es un programa que toma los archivos: 1) del código objeto generados en el proceso de compilación y 2) el código objeto de las funciones empleadas por el programador en su programa de aplicación (las cuales forman parte de una biblioteca proporcionada por el lenguaje de alto nivel); finalmente, enlaza ambos tipos de códigos objeto produciendo un archivo ejecutable. Un cargador es el responsable de llevar el contenido del archivo ejecutable (programa ejecutable) a la memoria principal (RAM) para, a solicitud del usuario, iniciar su ejecución.

Lizbeth Gallardo - Pedro Lara

UAM Azcapotzalco

Página 8

Notas de Programación Estructurada

CAPITULO II ALGORITMOS

Un algoritmo es un conjunto de pasos precisos y ordenados, que nos permiten alcanzar un resultado, o bien resolver un problema. Características de un algoritmo: Precisión. Los pasos a seguir e el algoritmo deben evitar, en la medida de lo posible, la ambigüedad. Finitud. Independientemente de la complejidad (dificultad) del algoritmo, el conjunto de pasos debe ser finito. Determinismo. Para un mismo conjunto de datos entrada, el algoritmo siempre debe arrojar el o los mismos resultados.

Componentes principales de un algoritmo

Datos de entrada

Procesamiento de datos

Impresión de resultados

Ejemplo de un algoritmo: „darse de alta en el aula virtual‟ 1.- Acceder a la dirección de aula virtual. 2.- Acceder a CBI. 3.- Seleccionar la UEA “Introducción a la Programación”. 4.- Leer instrucciones para el registro. 5.- Realizar el registro. 5.1. Escribir matrícula. 5.2. Escribir fecha de nacimiento. 5.3. Escribir datos generales. 6.- Acceder a aula virtual. 7.- Escribir contraseña. 8.- Matricularse.

Lizbeth Gallardo - Pedro Lara

UAM Azcapotzalco

Página 9

Notas de Programación Estructurada
Las etapas para resolver un problema proponiendo un algoritmo son: 1) análisis del problema, 2) construcción de un algoritmo y 3) verificación del algoritmo. El Análisis del problema nos permite determinar su naturaleza; identificar motivos, razones o causas de un problema específico; dividir el problema en subproblemas. Luego, hacemos un proceso de síntesis donde elaboramos escenarios, diseñamos una solución para cada subproblema, para luego integrarlas y así solucionar el problema inicial; este proceso también incluye mejorar esta solución. La verificación del algoritmo consiste en ejecutar (o realizar) cada paso señalado en el algoritmo, con datos de entrada para los cuales conocemos los resultados.

Programación
Programar es concebir un algoritmo que permita a una computadora resolver un problema. Programar implica un proceso mental complejo dividido en varias etapas:

Planteamiento de un problema Comprensión del problema Solución del problema

PROCESO MENTAL

Expresar los pasos a seguir para obtener la solución (algoritmo), empleando un lenguaje claro, estricto y universal: pseudocódigo

PROGRAMAR

CODIFICACIÓN:
Traducir el algoritmo a un lenguaje de programación adecuado (lenguaje de alto nivel)

La codificación consiste en traducir el algoritmo a un lenguaje de programación, para así obtener un programa fuente. Un programa, concepto desarrollado por von Neumann en 1946, es un conjunto de instrucciones que sigue una computadora para alcanzar un resultado específico. El programa se escribe en un lenguaje de programación, a partir de un diagrama de flujo o de un algoritmo expresado en pseudocódigo. Un lenguaje de programación está constituido por un conjunto de reglas sintácticas y semánticas. Las reglas sintácticas especifican la correcta formación de palabras y oraciones en un lenguaje. Las reglas semánticas especifican el sentido o significado de un símbolo, una palabra o una oración. Lizbeth Gallardo - Pedro Lara UAM Azcapotzalco Página 10

Notas de Programación Estructurada

Programación Estructurada
La programación estructurada es una filosofía para la implementación de algoritmos a través de un conjunto finito de estructuras debidamente organizadas. Fué propuesto, en 1965, por Edgser Dijkstra, en la Universidad de Hainover. Teorema de la estructura (Bohn y Jacopini). Son necesarios 3 estructuras básicas para construir cualquier programa. 1. Una estructura de proceso. 2. Una estructura de decisión binaria.

V

F

3. Una estructura de repetición.

Diagramas de Flujo
Un diagrama de flujo es la representación gráfica de un algoritmo; la construcción correcta de éste es muy importante porque nos permite escribir un programa en cualquier lenguaje de programación estructurada. A continuación presentamos los principales símbolos para representar a un algoritmo. Símbolo Descripción Se utiliza para marcar el inicio y fin de un programa.

Lizbeth Gallardo - Pedro Lara

UAM Azcapotzalco

Página 11

Notas de Programación Estructurada
Se utiliza para introducir datos de entrada. Expresa lectura. Representa un proceso. En su interior se colocan asignaciones, operaciones aritméticas, etc.
si no

Se utiliza para representar una decisión y dependiendo del resultado, el flujo del diagrama sigue por uno de los caminos alternativos. Se utiliza para representar una decisión múltiple y dependiendo del resultado, el flujo del diagrama sigue por uno de los caminos alternativos. Se utiliza para representar la estructura repetitiva “for” Se utiliza para representar la impresión de resultados. Expresa escritura. Expresan la dirección del flujo del diagrama.

O P

Expresa conexión dentro de una misma página. Expresa conexión entre diferentes páginas.

Se utiliza para expresar un módulo de un problema. Es decir, un sub-problema que hay que resolver antes de continuar con el flujo del diagrama.

Reglas para construir un diagrama de flujo 1. Todo diagrama de flujo debe tener un inicio y un fin. 2. Las líneas de dirección deben ser rectas 3. Las líneas de dirección deben estar conectadas a un símbolo que exprese lectura, proceso, decisión, escritura, conexión o fin del programa. 4. Un diagrama de flujo debe construirse de arriba hacía abajo y de izquierda a derecha. 5. La notación utilizada en el diagrama de flujo debe ser independiente del lenguaje de programación. 6. Al realizar una tarea compleja, es conveniente poner comentarios que ayuden a entenderla. 7. Si la construcción de un diagrama de flujo requiere más de una hoja, debemos emplear los conectores adecuados y enumerar las páginas. Lizbeth Gallardo - Pedro Lara UAM Azcapotzalco Página 12

Notas de Programación Estructurada
8. No es posible que a un símbolo determinado llegue más de una línea de dirección. 2. No deben de ser inclinadas 8. Inválido 8. Válido

2. No se deben cruzar

3. Conectadas a un símbolo

Lizbeth Gallardo - Pedro Lara

UAM Azcapotzalco

Página 13

Notas de Programación Estructurada CAPÍTULO III CONCEPTOS BÁSICOS DE Lenguaje C y FreeBasic
Lenguaje C
C es un lenguaje de programación inventado por Dennis M. Ritchie entre 1969 y 1973 en los Laboratorios Bell de New Jersey. C es un lenguaje estructurado, el cual ofrece algunas ventajas: 1) control de flujo, 2) manejo de variables simples y estructuradas, 3) economía en su forma de expresar operaciones y 4) un conjunto de operadores. Originalmente C fue diseñado para el sistema operativo UNIX; sin embargo, el lenguaje C no esta ligado a ningún hardware o sistema operativo particular; podemos citar el ejemplo del sistema operativo Linux, desarrollado por Linus Torvals utilizando únicamente lenguaje C. El lenguaje C es especialmente poderoso, pero es un lenguaje fuertemente orientado para Ingenieros en Computación, porque es un lenguaje del llamado nivel intermedio (se pueden hacer cosas muy apagadas a la arquitectura con la que se esté trabajando). Es un lenguaje con una curva de aprendizaje un poco más inclinada, pero como se mencionó anteriormente, esto permite hacer un uso más eficiente del hardware, siempre y cuando se esté dispuesto a pagar el precio en tiempo y esfuerzo que esto implica.

Tipos de datos
Los datos que procesa una computadora se clasifican en: básicos y estructurados a) Básicos: Constituye un solo valor que puede ser: 1) entero, 2) real, 3) entero largo, 4) real de doble precisión o 5) carácter. Tipo de Dato int long float double char Bits 16 32 16 64 8 Descripción Entero Entero largo Real Real de doble precisión Caracter Rango -32,768 a 32,767 -2‟147,483,648 a 2‟147,483,647 -3.4x10-38 a 3.4x1038 -1 -1.7x10-308 a 1.7x10308-1
0 – 255

b) Estructurados Hacen referencia a un grupo de valores. Arreglos (vectores y matrices): Todos los valores del arreglo son de un solo tipo básico. Cadenas: Es un vector que guarda valores de tipo caracter. Lizbeth Gallardo - Pedro Lara UAM Azcapotzalco Página 14

Notas de Programación Estructurada
Registros: Hacen referencia a un grupo de valores, donde cada uno de ellos puede ser de un tipo básico; inclusive puede incluir tipos de datos estructurados (arreglos, cadenas o registros). Identificadores. Es el nombre que identifica a una o varias celdas de memoria, las cuales contendrán datos simples o estructurados. Un identificador se forma por medio de letras, dígitos y el carácter subrayado (_). Un identificador siempre comienza con una letra. El lenguaje, C distingue entre minúsculas y mayúsculas, Ejemplo: Aux y aux son identificadores diferentes. La longitud máxima más común de un identificador, no excede los 7 caracteres. Existe un conjunto de palabras reservadas del lenguaje C que no deben emplearse como identificadores. auto break case char const continue default do double else enum extern float for int short signed sizeof static struct switch typedef union unsigned void volatile while goto if long register return main

Variables. Empleamos un identificador para nombrar a una variable, la cual designa un conjunto de celdas, que guardarán un valor temporalmente; es decir que el valor cambiará durante el tiempo de ejecución del programa. En el lenguaje C declaramos una variable, de los tipos mencionados en el apartado 6. Ejemplos:
int valor_1; float valor_2=5.4; //se asigna un valor inicial a la variable

NOTA: El signo de igual (=) significa, en lenguaje C, asignación. El valor de la derecha del signo se asigna a la variable o constante de la izquierda. Constantes. Empleamos un identificador para nombrar a una constante, la cual designa un conjunto de celdas, que guardarán un valor que no cambia durante el tiempo de ejecución del programa.
#define PI 3.14169 const float PI=3.14169;

Operadores
Distinguiremos tres tipos de operadores: 1) aritméticos, 2) relacionales y 3) lógicas. También analizaremos los operadores simplificados, operadores incremento/decremento y el operador coma (,). Lizbeth Gallardo - Pedro Lara UAM Azcapotzalco Página 15

Notas de Programación Estructurada
Operadores aritméticos Suponga que declaramos dos variables una de tipo real y otra de tipo entera:
float v; int x;

Símbolo + -

Descripción Suma Resta

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;

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

*

multiplicación

/

división

%

módulo (residuo de una división)

x=15%2; x=1 v=(15%2)/2; v=0.0 v=((float)(15%2))/2; v=0.5

Al evaluar expresiones aritméticas debemos respetar la jerarquía de los operadores y aplicarlos de izquierda a derecha. Mayor prioridad Menor prioridad *, /, % +, -

Operadores aritméticos simplificados. Nos permiten realizar la misma operación utilizando una notacipon más compacta. Operador += -= *= /= %= Lizbeth Gallardo - Pedro Lara Operación larga x=x+5 y=y-2 x=x*y x=x/y x=x%y Operación simplificada X+=5 y-=2 x*=y x/=y x%=y Página 16

UAM Azcapotzalco

Notas de Programación Estructurada

Operadores de incremento y decremento. Se pueden utilizar antes o después de la variable, pero los resultados son diferentes. Suponga que declaramos las variables x y y como enteras: int x,y; x=7; Operación y=x++ y=++x y=x-y=--x Resultados y=7 x=8 y=8 x=8 y=7 x=6 y=6 x=6

Expresiones lógicas o booleanas. Están formadas por números, constantes, variables y operadores lógicos y relacionales. El valor que pueden tomar estas expresiones al ser evaluadas, es 1 (verdaderas) ó 0 (falso). Las expresiones lógicas se utilizan frecuentemente en estructuras selectivas y en estructuras repetitivas.

Operadores relacionales. Se utilizan para comparar 2 operando números, caracteres, cadenas, constantes o variables.
Operador relacional
== != < > <= >=

Descripción
igual a diferente de menor que mayor que Menor o igual que Mayor o igual que

Ejemplo
“h”==”p” “h”!=”p” 7<5 22>11 15<=2 35>=20

Resultado
0 (F) 1 (V) 0 (F) 1 (V) 0 (F) 1 (V)

Operadores lógicos. Permiten formular condiciones complejas a partir de condiciones simples.
Operadores lógicos Diagrama de Venn asociado Operador NOT

! Lizbeth Gallardo - Pedro Lara UAM Azcapotzalco

Página 17

Notas de Programación Estructurada
&& ||
P 1 1 0 0 Q 1 0 1 0 !P 0 0 1 1 !Q 0 1 0 1 P||Q 1 1 1 0 P&&Q 1 0 0 0 AND OR

Operador “,” (coma) Sirve para encadenar expresiones. Ejemplo 1: int x, y, z, v; x= (v=3, v*5); Ejecutamos las operaciones de izquierda a derecha: 1) v = 3 2) x= v*3 = 3*5 3) x=15 Ejemplo 2: x=( y=(15>10), z=(2>=y), y && z ) Ejecutamos las operaciones de izquierda a derecha: 1) y=(15 > 10)  y = 1 (verdadero) 2) z=(2 >= y)  z = 1 3) x=(y && z)  x=1 Prioridades de los operadores Las expresiones se evalúan de izquierda a derecha, pero los operadores se aplican según su prioridad. Prioridad (+) ( ) ! , ++, - *, /, % +, = =, !=, <, >, <=, >= &&, || + =, - =, * =, / =, % = , UAM Azcapotzalco Página 18

(-) Lizbeth Gallardo - Pedro Lara

Notas de Programación Estructurada
FreeBasic
FreeBasic es la versión estructurada del lenguaje BASIC (Beginners All-Purpose Symbolic Instruction Code), desarrollado originalmente por John George Kemeny y Thomas Eugene Kurtz en el Dartmouth College de New Hampshire, USA en 1964. FreeBasic fue desarrollado en 2004 con la idea de tener un lenguaje de programación que se compare en velocidad al lenguaje C que permitiera: el uso de gráficos, la programación orientada a objetos y que fuera un lenguaje fácil de aprender. Una ventaja que ofrece FreeBasic es que se puede utilizar las bibliotecas de C sin ninguna modificación. Este lenguaje está recomendado para programadores que requieren un lenguaje eficiente de alto nivel, que no implique conocer detalles de la arquitectura de la computadora; por ejemplo, estudiantes de licenciaturas como: Industrial, Física, Energía, Ambiental, Diseño de la comunicación gráfica etc., excepto, las Ingenierías en Computación y Electrónica, donde es necesario conocer los detalles de la arquitectura de la computadora y emplear lenguajes de bajo nivel (ensamblador) y nivel intermedio (C), para construir software de base, tales como: sistemas operativos, ensambladores, cargadores, etc. Es importante mencionar que FreeBasic suele ser integrado a algún otro lenguaje, por ejemplo Visual Basic, el cual genera interfaces gráficas. Gran parte de las aplicaciones de la NASA se desarrollan en FreeBasic y PowerBasic (un lenguaje propietario muy similar a FreeBasic).

Tipos de datos
a) Básicos: Son muy similares a los usados en C, solo en lugar de tipo caracter, se tiene el tipo cadena de caracteres: Tipo de Dato integer uinteger single double string Bits 32 32 32 64 Descripción Entero largo Entero positivo Real Real de doble precisión Cadena de caracteres Rango -2‟147,483,648 a 2‟147,483,647 0 a 4‟294,967,295 -3.4x10-38 a 3.4x1038 -1 -1.7x10-308 a 1.7x10308-1 Cada caracter es de 8 bits

b) Estructurados: Hacen referencia a un grupo de valores. En Freebasic no se tiene estructuras de cadenas, porque es un tipo básico. o Arreglos (vectores y matrices): Todos los valores del arreglo son de un solo tipo básico. Se declara una cadena con la instrucción dim o Registros: Hacen referencia a un grupo de valores, donde cada uno de ellos puede ser de un tipo básico; inclusive puede incluir tipos de datos estructurados (arreglos, cadenas o registros). Identificadores. Es el nombre que identifica a una o varias celdas de memoria, las cuales contendrán datos simples o estructurados. Un identificador se forma por medio de letras, dígitos y el carácter subrayado (_). Lizbeth Gallardo - Pedro Lara UAM Azcapotzalco Página 19

Notas de Programación Estructurada
Un identificador siempre comienza con una letra y se forma por medio de letras, dígitos y el carácter subrayado (_). FreeBasic no distingue entre minúsculas y mayúsculas, Ejemplo: Aux y aux es el mismo identificador, y el límite para la longitud de un identificador son 255 caracteres. Existe un conjunto de palabras reservadas (keywords) que no deben emplearse como identificadores y son las siguientes: case const continue do double else enum extern for int short sizeof static struct select union unsigned while goto if long return

Se puede saber de una forma sencilla cuando se está usando una palabra reservada en editores de Freebasic como el FBI de porque todas las palabras clave se ponen en letras negritas azul obscuro Variables. Para declarar una variable en FreeBasic se usa la instrucción dim seguida del nombre y del tipo. Por ejemplo, para definir la variable num del tipo entero y la variable flotante del tipo real doble precisión se escribe: dim num as integer, flotante as double

Constantes. Las constantes que son variables que tienen el mismo valor durante todo el tiempo de ejecución del programa, se definen exactamente igual que en C: #define PI 3.14169 const float PI=3.14169; Operadores. Se tiene los mismos tipos de operadores aritméticos, relacionales y lógicos en FreeBasic con exactamente las mismas características, con las siguientes diferencias en sintaxis únicamente: Operador igualdad desigualdad modulo entero lógico AND lógico OR lógico NOT En C == != % && || ! En FreeBasic = <> mod and or not

Primer programa: “Hola Mundo!”
Función main(). El lenguaje de programación C opera a través de funciones. Una función es un “pedazo” de código que realiza una tarea específica dentro de un programa. En el Capítulo 5 se habla de las funciones a detalle. Cuando ejecutamos un Lizbeth Gallardo - Pedro Lara UAM Azcapotzalco Página 20

Notas de Programación Estructurada
programa, el sistema operativo se comunica con una función principal llama main(), la cual devuelve, al sistema operativo, un valor de 0 indicando que la ejecución del programa se realizó con éxito; y devuelve un valor de 1 indicando que el programa no terminó su ejecución correctamente.
Tipo de valor que devuelve la función. Nombre (SIN ESPACIOS) Lista de argumentos que recibe la función.

int main (void)
Cuerpo de la función

{
Declaración_de_variables instrucción_1; Instrucción_2; return 0;

}
Ejemplo: “mundo.c”
#include <stdio.h> int main(void){ //Incluye las funciones de entrada/salida //inicia la función main

}

printf (“Hola mundo!”); //Imprimir en pantalla Hola mundo! return 0; //Valor que devuelve la función al sistema operativo //Fin de la función main

Ejemplo: “mundo.bas”. Un programa equivalente en freeBasic es simplemente:
Print “Hola Mundo!”

FreeBasic da por un hecho que cualquier cosa que no sea parte de otra función o subrutina, es parte de la función principal, por esta razón no requiere definirla.

Entrada y Salida de Datos
Entrada con formato: La lectura desde el teclado se realiza por medio de la función scanf (“código de formato”, dirección) El código de formato designará el tipo de dato que se recibirá desde el teclado, el cual se asignará a la dirección de memoria de una variable determinada.
Código de formato %u %d %i Descripción Enteros sin signo de 16 bits (unsigned int) Enteros de 16 bits (int)

Lizbeth Gallardo - Pedro Lara

UAM Azcapotzalco

Página 21

Notas de Programación Estructurada
%ld %f %lf %e %g %c %s Enteros de 32 bits (long) Reales de 32 bits (float) Reales de 64 bits (double) Formato exponencial Real o exponencial según el tamaño del número Caracter de 8 bits Cadena de caracteres que termina con el carácter nulo “\0” (null)

Es importante destacar que se puede controlar la cantidad de dígitos a imprimir en la pantalla, por ejemplo
% -6d % 4.2f Escribe un entero con seis dígitos, con justificación a la izquierda Escribe un real con 4 dígitos, dos de ellos serán utilizados para los decimales, con justificación a la derecha.

En FreeBasic para la entrada de datos se utiliza la función input: Input “Dame la temperatura en grados Fahrenheit: ”, fahr Salida a monitor Salida con formato: Para imprimir en la pantalla una salida con un formato específico, empleamos la función printf (“cadena de caracteres, caracter de control y código de formato”, variable); Observe que printf puede incluir una cadena de caracteres para informar algo al usuario; luego, puede incluir un formato de impresión para los datos (tabulador, saltar una línea), empleando los caracteres de control; además puede incluir uno o varios códigos de formato para indicar el tipo de dato que se va a imprimir; finalmente, incluye la o las variables que contienen los datos.

Carácter de control \n \t \v \f \a \‟ \” \\

Descripción Saltar a una nueva línea Tabulador horizontal Tabulador vertical Avanzar una página Sonido de alerta Imprimir apostrofe Imprimir comillas Imprimir diagonal inversa

En FreeBasic, para dar salida formateada de números se escribe indicando las cifras significativas con el símbolo “#” print using "Decimales: ###.### - Enteros: ##"; 1/3,2.4 sleep

Ejercicio 1: Conversión Fahrenheit a Centígrados

Lizbeth Gallardo - Pedro Lara

UAM Azcapotzalco

Página 22

Notas de Programación Estructurada
Escribir un algoritmo que transforme las temperaturas de grados Fahrenheit a grados centígrados con 5 cifras decimales. La ecuación de conversión es: °C = (°F-32)*5/9 Versión C:
#include <stdio.h> main(){ float fahr, cent; printf("Dame la temperatura en Fahrenheit: "); scanf("%f", &fahr); cent=5*(fahr-32)/9; printf("En centigrados es: %4.5f ",cent); }

fahrenheit.c

Comentarios: scanf("%f", &fahr);

Caracteres de formato

Asigna el valor del teclado en la localidad de memoria asignada a “fahr”

Versión FreeBasic:
dim cent as double, fahr as double input "Dame la temperatura en Fahrenheit: ", fahr cent=5*(fahr-32)/9 print using "En centigrados es: ###.#####"; cent sleep fahrenheit.bas

NOTA: a partir de este momento, todos los programas propuestos tendrán una versión en C seguida una versión en FreeBassic. Programa 2: El TOEFL (Test of English as a Foreign Language, Prueba de nivel de Inglés como lengua extranjera) es una prueba que se pide a todos los estudiantes de intercambio, o aquellos que realizarán estudios de posgrado en países de habla inglesa y otros países (algunas universidades de Alemania y Rusia, por ejemplo). Este examen consiste en 3 secciones: 50 preguntas de opción múltiple sobre comprensión de palabra hablada (listening comprehension), 40 preguntas sobre la habilidad para escribir correctamente (grammar) y 50 preguntas sobre comprensión de lectura (reading comprehension). Del número total de respuestas correctas en cada sección, se utiliza la siguiente fórmula para calcular el número de puntos obtenidos.

Lizbeth Gallardo - Pedro Lara

UAM Azcapotzalco

Página 23

Notas de Programación Estructurada
Puntos TOEFL = 10*(65+LC+G+RC)/3 Hacer un programa que haga este cálculo dando como valores de entrada los tres valores de preguntas correctas y la salida sea el puntaje del examen.
#include <stdio.h> main() { float p1, p2, p3, puntaje; printf("Dame los 3 puntajes: "); scanf("%f %f %f", &p1,&p2,&p3); puntaje=10*(65+0.878*p1+1.1669*p2+0.8865*p3)/3; printf("Tu puntaje es: %.0f", puntaje); } toelf.c dim a as double, b as double, c as double, puntaje as double input "Dame los 3 puntajes: "; a,b,c puntaje=10*(65+0.878*a+1.1669*b+0.8865*c)/3 print "Tu puntaje es: ", puntaje sleep toelf.bas

Lizbeth Gallardo - Pedro Lara

UAM Azcapotzalco

Página 24

Notas de Programación Estructurada
CAPÍTULO IV ESTRUCTURAS DE SELECCIÓN
Estas estructuras se utilizan cuando en la solución de un problema, debemos tomar una decisión, la cual determinará el flujo que seguirá el programa que estamos construyendo. La toma de una decisión se basa en la evaluación de una o más condiciones. Distinguimos cuatro tipos de estructuras selectivas: Estructura selectiva simple (if) Estructura selectiva doble (if – else) Estructura selectiva encadenada (if – else if - else) Estructura selectiva múltiple (switch)

Estructura selectiva simple (if)
En tiempo de ejecución, al llegar a este punto del programa se evalúa la condición; si es verdadera entonces se ejecuta un bloque de instrucciones específico; pero si la condición es falsa entonces este bloque es ignorado y se continúa con el flujo normal del programa.
if(condicion){ bloque_V; } : donde:
V

condicion

F

bloque_V

la condicion puede estar formada por una o varias condiciones que al ser evaluadas nos proporcionan un valor lógico (v-verdadero ó f-falso). bloque_V denota un conjunto de instrucciones que se ejecuta únicamente cuando el resultado de la condición es verdadera

Ejercicio: Descuento en dulces para los niños menores de 12 años En la tienda de Don Pascual hay una promoción que consiste en otorgar el 20% de descuento solo para los niños menores de 12 años, cuya compra sea mayor o igual a 100. Realice un programa para que de manera automática, Don Pascual no tenga que utilizar su calculadora cada que atienda a un niño con esas características.
#include <stdio.h> #define DESC 0.80 int main(void){ float venta=0.0; int esMenor=0; printf("Cual es la cantidad de la venta: "); scanf("%f",&venta);

Lizbeth Gallardo - Pedro Lara

UAM Azcapotzalco

Página 25

Notas de Programación Estructurada
printf("Es menor de edad (1-si 0-no): "); scanf("%d",&esMenor); if(venta>=100 && esMenor==1){ venta=venta*DESC; } printf("A pagar: %8.2f",venta); return 0; } dulces.c #define DESC 0.80 dim venta as double, esMenor as integer input "Cual es la cantidad de la venta: ", venta input "Es menor de edad (1-si 0-no): ", esMenor if venta>=100 and esMenor=1 then venta=venta*DESC print "A pagar: ",venta sleep dulces.bas

Estructura selectiva doble (if-else)
Simple En este tipo de estructura, tenemos dos bloques alternativos de instrucciones, los cuales son independientes uno de otro; en el punto de la toma de una decisión solo se ejecutará uno de ellos, dependiendo del valor lógico que resulte al evaluar la condición.
if(condicion){ bloque_V; } else{ bloque_F; } : donde: la condicion puede estar formada por una o varias condiciones que al ser evaluadas nos proporcionan un valor lógico (v-verdadero ó ffalso). bloque_V denota un conjunto de instrucciones que se ejecuta únicamente cuando el resultado de la condición es verdadera bloque_F denota un conjunto de instrucciones que se ejecuta únicamente cuando la condición es falsa

V

condicion

F

bloque_V

bloque_F

Ejercicio: Raíces de un polinomio de segundo grado. Hacer un algoritmo que encuentre las raíces de un polinomio de segundo grado. El algoritmo debe proporcionar las raíces imaginarias, si ese fuera el caso. x=((-b±√(b2-4ac))/(2a))

Lizbeth Gallardo - Pedro Lara

UAM Azcapotzalco

Página 26

Notas de Programación Estructurada
#include <stdio.h> #include <math.h> int main(void){ float a, b, c, det, aux; printf("Dame los 3 coeficientes de la ecuación de segundo grado:"); printf("ax2+bx+c=0"); scanf("%f %f %f",&a,&b,&c); det=(b*b-4*a*c); aux=-b/(2*a); if(det < 0){ printf("x1 = %f + %f i \n",aux,pow(-det,.5)/(2*a)); printf("x2 = %f - %f i",aux,pow(-det,.5)/(2*a)); } else { printf("x1= %f \n X2= %f",aux+pow(det,.5)/(2*a),aux pow(det,.5)/(2*a)); } }

ecuacion.c dim a as double, b as double, c as double dim det as double, aux as double print "Dame los 3 coeficientes de la ecuacion de segundo grado:" input "ax2+bx+c=0 :", a,b,c det=(b^2-4*a*c) aux=-b/(2*a) if det < 0 then print "x1 = ";aux; " + "; ((-det)^.5)/(2*a); " i" print "x2 = ";aux; " - "; ((-det)^.5)/(2*a); " i" else print "x1 = "; aux+(det^.5)/(2*a) print "x2 = "; aux-(det^.5)/(2*a) end if sleep ecuacion.bas

Anidada En términos generales, una estructura selectiva puede contener a otras estructuras, por ejemplo: una estructura de proceso, una estructura de repetición e incluso una nueva estructura selectiva. En particular, cuando una condición que es verdadera nos lleva a evaluar una nueva condición, decimos que las estructuras selectivas están anidadas. Observe que en las estructuras anidadas se debe tener cuidado de no olvidar cerrar las llaves correspondientes a cada una de las estructuras; y también, se debe tener cuidado de cerrarlas en el lugar adecuado.

Lizbeth Gallardo - Pedro Lara

UAM Azcapotzalco

Página 27

Notas de Programación Estructurada

V

condicion1
F

F

V

condicion2

bloque1_F

V

condicion3

F

bloque2_F

bloque3_V

bloque3_F

if(condicion1){ if(condicion2){ if(condicion3){ bloque3_V; } else{ bloque3_F; } } }

Ejercicio: construir un programa que simule el juego de piedra-papel-tijera. Como entrada el usuario proporciona un de los siguientes números, donde cada uno tendrá un significado distinto: 1significa piedra, 2 significa papel y 3 significa tijera. Como salida el programa deberá indicar el ganador del juego. Es importante señalar que para simular la tirada de la computadora, en el programa deberá seleccionarse uno de los tres valores de manera aleatoria, empleando la función que genere un número aleatorio (random en inglés) del lenguaje de programación en que se desee codificar el algoritmo.
Entrada: 1 Salida: Tu opcion es Piedra, yo escogi Piedra – Empatamos!

Tenemos que definir una tabla que nos permita identificar los casos de gane y pierde para ambos jugadores (la computadora y el usuario).
Computadora Usuario 1-Piedra 2-Papel 3-Tijera 1-Piedra Empate Gané Ganaste 2-Papel Gané Empate Ganaste 3-Tijera Ganaste Gané Empate

“Gané”, “Ganaste” y “empate” son expresiones provenientes del “jugador” simulado por la computadora.

Lizbeth Gallardo - Pedro Lara

UAM Azcapotzalco

Página 28

Notas de Programación Estructurada
#include<stdio.h> #include<stdlib.h> #include<time.h> int main(void){ int num=0, opc=0; srand(time(NULL)); num=(rand()%3)+1; printf("1-Piedra 2-Papel 3-Tijera \n"); printf("Escoge una de las opciones anteriores: "); scanf("%d",&opc); if(opc==1){ if(num==1) printf("Tu opcion es Piedra, yo escogi Piedra - Empatamos!"); else if(num==2) printf("Tu opcion es Piedra, yo escogi Papel - Gane!"); else if(num==3) printf("Tu opcion es Piedra, yo escogi Tijera - Ganaste!"); } else if(opc==2){ if(num==1) printf("Tu opcion es Papel, yo escogi Piedra - Ganaste!"); else if(num==2) printf("Tu opcion es Papel, yo escogi Papel - Empatamos!"); else if(num==3) printf("Tu opcion es Papel, yo escogi Tijera - Gane!"); } else if(opc==3){ if(num==1) printf("Tu opcion es Tijera, yo escogi Piedra - Gane!"); else if(num==2) printf("Tu opcion es Tijera, yo escogi Papel - Ganaste!"); else if(num==3) printf("Tu opcion es Tijera, yo escogi Tijera -Empatamos!"); } return 0; }

piedra-papel-tijera.c

print "1-piedra 2-Papel 3-Tijera" randomize timer dim opc as integer, num as integer num=int(rnd*3)+1 input "Escoge una opcion: ", opc if opc = 1 then if num = 1 then print "Yo escogí if num = 2 then print "Yo escogí if num = 3 then print "Yo escogí end if if opc = 2 then if num = 1 then print "Yo escogí if num = 2 then print "Yo escogí if num = 3 then print "Yo escogí end if if opc = 3 then if num = 1 then print "Yo escogí if num = 2 then print "Yo escogí if num = 3 then print "Yo escogí

Piedra - Empatamos!" Papel - Gane!" Tijeras - Ganaste!" Piedra - Ganaste!" Papel - Empatamos!" Tijeras - Gane!" Piedra - Gané!" Papel - Ganaste!" Tijeras - Empatamos!"

Lizbeth Gallardo - Pedro Lara

UAM Azcapotzalco

Página 29

Notas de Programación Estructurada
end if sleep piedra-papel-tijera.bas

Estructura selectiva encadenada (if - else if - else)
Cuando una condición que es falsa nos lleva a evaluar una nueva condición, decimos que las estructuras selectivas están encadenadas. Cada condición se evalúa siguiendo el orden, el bloque de instrucciones del else solo se ejecutará cuando ninguna de las condiciones anteriores se ha cumplido. Observe que en las estructuras encadenadas mantienen independencia una de otra, por lo tanto es más sencillo manipularlas durante la solución de un problema.

V

condicion1

F

bloque1_V

V

condicion2

F

bloque2_V

V

condicion3

F

bloque3_V

bloque3_F

if (condicion1){ bloque1_V; } else if (condicion2){ bloque2_V; } else if (condicion3){ bloque3_V; } else{ bloque3_F; }

Ejercicio: construir un programa que simule el juego de la pirinola, también llamada perinola o peonza. En este problema no hay una entrada por parte del usuario; es el programa quien genera un valor aleatorio, correspondiente a los lados de la pirinola, para luego indicar la acción que los jugadores deben realizar. La tabla de abajo determina el valor y la acción asociada. Lizbeth Gallardo - Pedro Lara UAM Azcapotzalco Página 30

Notas de Programación Estructurada
Salida: Todos ponen

Valor 1 2 3 4 5 6 7
#include<stdio.h> #include<stdlib.h> #include<time.h>

Acción Pon uno Pon dos Toma uno Toma dos Todos toman Todos ponen Pierdes todo

int main(void){ double num=0.0; srand(time(NULL)); printf("Pirinola/perinola/peonza digital \n"); printf("el numero es: %lf ", num=(rand()/(float)1e9)); if(num < 1.0/7.0) printf("Pon uno \n"); else if(num < 2.0/7.0) printf("Pon dos \n"); else if(num < 3.0/7.0) printf("Toma uno \n"); else if(num < 4.0/7.0) printf("Toma dos \n"); else if(num < 5.0/7.0) printf("Toma todo \n"); else if(num < 6.0/7.0) printf("Todos ponen \n"); else printf("Pierdes todo"); return 0; } pirinola.c

randomize timer dim num as double num=rnd print "Pirinola/perinola/peonza digital" if num < 1/7 then print "Pon uno" elseif num < 2/7 then print "Pon dos" elseif num < 3/7 then print "Toma uno" elseif num < 4/7 then print "Toma dos" elseif num < 5/7 then print "Toma Todo" elseif num < 6/7 then print "Todos Ponen" else print "Pierdes todo" endif sleep pirinola.bas

Lizbeth Gallardo - Pedro Lara

UAM Azcapotzalco

Página 31

Notas de Programación Estructurada
Ejercicio: construya un algoritmo que calcule el resultado de la siguiente función.
3*y+36 y2 -10 y3+ y2 -1 0 si 0< y ≤ 11 si 11< y ≤ 33 si 33 < y ≤ 64 en otro caso

x=

#include<stdio.h> #include<math.h> int main(void){ float x=0.0, y=0.0; printf("Introduce el valor de y: "); scanf("%f", &y); if(y>0.0 && y<=11.0) printf("x = %.2f", 3*y+36); else if(y>11.0 && y<=33.0) printf("x = %.2f", pow(y,2)+10); else if (y>33.0 && y<=64.0) printf("x=%.2f", pow(y,3)+pow(y,2)-1); else printf ("x=%.2f", x); return 0; } xyFuncion.c

dim x,y as double input "Introduce el valor de y: ",y if y>0.0 and y<=11.0 then print "x="; 3*y+36 elseif y>11.0 and y<=33.0 then print "x="; y^2+10 elseif y>33.0 and y<=64.0 then print "x="; y^3+y^2-1 else print "x="; x endif sleep xyFuncion.bas

Estructura selectiva múltiple (switch ó select)
En algunos problemas que involucran tomar una decisión entre múltiples opciones conviene emplear la estructura switch, en lugar de emplear estructuras condicionales encadenada. Esta estructura proporciona un código más claro para quienes lo leen. Un uso común de la estructura selectiva múltiple es la construcción de un menú de opciones para el usuario del programa.

Lizbeth Gallardo - Pedro Lara

UAM Azcapotzalco

Página 32

Notas de Programación Estructurada
selector
case 1 case 2 case 3 default

bloque1

bloque2

bloque3

bloqueD

switch(selector){ case 1: bloque1; break; case 2: bloque2; break; case 3: bloque3; break; default: bloqueD; break; }

Donde: case: denota un conjunto de instrucciones que deben ejecutarse en una opción particular. selector: solo puede tomar valores de tipo enteros o de tipo carácter opcionN: denota un número entero ó un carácter, de acuerdo al selector bloqueD: denota un conjunto de instrucciones que deben ejecutarse en un caso particular break: indica el fin de las instrucciones un caso default: el conjunto de instrucciones que se ejecutará cuando el valor del selector no corresponda a ninguno de los casos anteriores.

Ejercicio: dado el sueldo, la categoría y el costo por una hora extra de trabajo, calcular el sueldo total de un empleado en base a la siguiente tabla: Categoría 1 2 3 4 Precio por hora extra 30 38 50 70

Nota: si el empleado trabaja más de 30 horas extras solo se la pagan las primeras 30.

Lizbeth Gallardo - Pedro Lara

UAM Azcapotzalco

Página 33

Notas de Programación Estructurada
#include <stdio.h> int main(void){ int categoria=0,hExtra=0; float sueldo=0.0,PHE=0.0; printf("CAT \t Precio HE \n"); printf(" 1 \t 30 \n 2 \t 38 \n 3 \t 50 \n 4 \t 70 \n"); printf("Categoria, sueldo, hrs extra: "); scanf("%d %f %d", &categoria,&sueldo,&hExtra); if(hExtra > 30) hExtra=30; switch(categoria){ case 1: PHE = 30; break; case 2: PHE = 38; break; case 3: PHE = 50; break; case 4: PHE=70; break; default: PHE = 0; break; } printf("El sueldo total es de : %.2f", sueldo+PHE*hExtra); return 0; } sueldoSwitch.c dim sueldo as double,PHE as double print "CAT","Precio HE" print "1","30" : print"2","38": print"3","50": print"4","70" input "Categoria, sueldo, hrs extra: ", categoria,sueldo,hExtra if(hExtra > 30) then hExtra=30 select case categoria case 1 PHE = 30 case 2 PHE = 38 case 3 PHE = 50 case 4 PHE = 70 case else PHE = 0 end select print "El sueldo total es de :"; sueldo+PHE*hExtra sleep sueldoSwitch.bas

Lizbeth Gallardo - Pedro Lara

UAM Azcapotzalco

Página 34

Notas de Programación Estructurada
CAPÍTULO V FUNCIONES
Para resolver un problema de gran tamaño es conveniente descomponerlo en subproblemas, de tal manera que cada uno de ellos pueda ser resuelto de una manera más sencilla. El lenguaje C emplea el término “función” para denotar el código que resuelve un subproblema. Algunas ventajas de emplear funciones son: Facilita la escritura y lectura de los programas Permite el trabajo en paralelo Facilita la asignación de responsabilidades El código de la función se escribe una sola vez y se utiliza tantas veces como sea necesario. Facilita el mantenimiento de los programas.

Conceptos básicos
Formalmente: Sea L(p) la longitud de un programa cualquiera y sean l(p1) y l(p2) las longitudes de dos segmentos mutuamente excluyentes y complementarios del mismo programa p; de tal modo que la longitud del programa será: L(p)=l(p1) + l(p2); donde p designa al programa completo y pi denota los subprogramas (códigos) que conforman a p. Sean además E(p), e(p1) y e(p2) los esfuerzos necesarios para obtener L(p), l(p1) y l(p2) respectivamente; en general se tendrá que: E(p) >e(p1) + e(p2) Principios de diseño de una función: 1) Las partes altamente relacionadas, deben pertenecer a la misma función; y 2) las partes no relacionadas deben residir en otras funciones. Existen algunas reglas básicas para definir y emplear las funciones en el lenguaje C: 1) declarar la función (también llamado prototipo de la función), 2) Definición de la función, y 3) llamado de una función. 1) Para que el compilador reconozca una función como parte de un programa, ésta debe ser declarada al inicio del programa, de la siguiente manera:
tipo_dato nombre_funcion (lista_parametros); Donde: Tipo_dato indica el tipo de dato que devolverá la función al concluir su ejecución, por elemplo: int, float, char Lista_parametros corresponde al conjunto de valores que recibirá de la función que la llamó. Los valores están contenidos en variables, por lo tanto deberán recibirse estos valores en variables locales (propias de la función receptora)

Lizbeth Gallardo - Pedro Lara

UAM Azcapotzalco

Página 35

Notas de Programación Estructurada
Nota: una función no necesariamente devuelve un valor y no necesariamente recibe parámetros, en este caso se indica con la palabra reservada void

NOTA: Si no se escribe el prototipo de una función, entonces su definición debe presentarse antes de la función principal. 2) Definir una función significa especificar el conjunto de instrucciones que realizarán una tarea determinada dentro del programa.
tipo_dato nombre_funcion (lista_parametros){ declarar_variables; bloque_de_instrucciones; return <valor_de_regreso>; } Donde: Declarar_variables corresponden a variables locales que requerirá la función para realizar su tarea. Bloque de instrucciones que determinan el comportamiento de la función return marca el fin de la función y devuelve, cuando así se requiera, un resultado cuyo tipo corresponde al definido en el prototipo de la función Nota: una función no necesariamente devuelve un valor y no necesariamente recibe parámetros, en este caso se indica con la palabra reservada void

3) El llamado a una función se realiza desde la función principal o desde cualquier otra función. Durante la ejecución del programa, el llamado a una función implica un “salto” hacia ella para ejecutar su conjunto de instrucciones; al terminar se devuelve el control de la ejecución a la función que la llamó; en este caso a la función main(). Al hacer el llamado debe especificarse: 1) el nombre de la función; y 2) los valores que va a requerir para realizar su tarea, los valores contenidos en variables se escriben dentro del paréntesis, siguiendo el orden y respetando el tipo de dato declarado.
int main(void){ : nombre_funcion(lista_de_valores) : return 0; }

Ejercicio: Dados tres números enteros a, b y c, encontrar al mayor de entre ellos.

Lizbeth Gallardo - Pedro Lara

UAM Azcapotzalco

Página 36

Notas de Programación Estructurada
#include <stdio.h> int leeValor(void); int encuentraMax (int, int, int); void imprime(int); int main(void){ int a,b,c,max; a=leeValor(); b=leeValor(); c=leeValor(); max = encuentraMax(a,b,c); imprime(max); return 0; } int leeValor(void){ int val; printf("Dame un valor entero: "); scanf("%d", &val); return (val); } int encuentraMax(int a, int b, int c){ int max; if(a>b && a>c){ max=a; } else if (b>a && b>c){ max=b; } else { max=c; } return (max); } void imprime(int max){ printf("El mayor de los números es: %d",max); return; } maxNum.c function leeValor() input "Dame un valor entero: ", valor return valor end function function encuentraMax(a as integer, b as integer, c as integer) if a>b and a>c then: max=a elseif b>a and b>c then: max=b else: max=c end if return max end function sub imprime(max as integer) print "El mayor de los numeros es:"; max end sub

Lizbeth Gallardo - Pedro Lara

UAM Azcapotzalco

Página 37

Notas de Programación Estructurada
a=leeValor(): b=leeValor(): c=leeValor() max = encuentraMax(a,b,c) imprime(max) sleep maxNum.bas

Paso de parámetros por valor
La comunicación entre las funciones se lleva a cabo mediante el paso de parámetros, el cual se puede hacer de dos formas; por valor y por referencia se describirá primero el paso de parámetros por valor. En el paso de parámetros por valor, la función receptora recibe parámetros que son copia de los valores contenidos en las variables originales (propias de la función que hace el llamado); por lo tanto, si una variable local (propia de la función receptora) sufre una alteración no afectará a la variable original, porque la variable local solo tiene una copia del valor. Ejercicio: retomando el juego de piedra-papel-tijera para reformular el código, empleando una función llamada “referi” encargada de determinar al ganador de la jugada.
#include<stdio.h> #include<stdlib.h> #include<time.h> void referi(int mine, int yours); int main(void){ int mine=0, yours=0; printf("Juguemos a piedra papel o tijera \n"); printf(" 1. Piedra \n 2. Papel \n 3. Tijera \n"); printf("Cual es tu tirada: "); scanf("%d", &yours); printf("Mi tirada es: "); srand(time(NULL)); mine=rand()%3+1; printf("%d \n",mine); referi(mine,yours); return 0; } void referi(int mine, int yours){ if(mine==yours) printf("Empate entre tu y yo \n"); else{ switch(yours){ case 1: if(mine==2) printf("Gane !!!! \n"); else printf("Ganaste!!! \n"); break; case 2: if(mine==1) printf("Ganaste!!! \n"); else printf("Gane!!! \n");

Lizbeth Gallardo - Pedro Lara

UAM Azcapotzalco

Página 38

Notas de Programación Estructurada
break; case 3: if(mine==1) printf("Gane!!! \n"); else printf("Ganaste!!! \n"); break; default: printf("ERROR en tu tiro!!! \n"); break; } } return; } pipati-2.c sub referi(mine as integer, yours as integer) if mine=yours then print "Empate entre tu y yo" else select case yours case 1 if mine=2 then print "Gane !!!" else print "Ganaste!!!" case 2 if mine=1 then print "Ganaste!!!" else print "Gane!!!" case 3 if mine=1 then print"Gane!!!" else print "Ganaste!!!" case else print "ERROR en tu tiro!!!" end select end if end sub print "Juguemos a piedra papel o tijera" print " 1. Piedra": print " 2. Papel": print " 3. Tijera" input "Cual es tu tirada? ", yours randomize timer mine=int(rnd*3)+1 print "Mi tirada es: "; mine referi(mine,yours) sleep pipati-2.bas

Paso de parámetros por referencia
Aquí los parámetros no son copias de los valores, sino las direcciones de las variables originales; por lo tanto, si un parámetro sufre una alteración en la función que lo recibe, la variable original también se ve afectada. En el lenguaje C, el paso de parámetros por referencia se realiza mediante el concepto de “apuntador”. Un apuntador es una dirección de memoria (por ejemplo 00X00X101010). Dado que debemos manipular una dirección de memoria, se vuelve necesario poder declarar variables que puedan guardar direcciones; las cuales no corresponden a ninguno de los tipos de datos básicos vistos hasta ahora (int, float, char, etc.). Por lo tanto, emplearemos una notación especial que nos permita denotar una variable de tipo apuntador, a saber los operadores de: dirección (&), declaración de variable tipo apuntador (*) e indirección (*). En efecto el operador * tiene un doble propósito.

Lizbeth Gallardo - Pedro Lara

UAM Azcapotzalco

Página 39

Notas de Programación Estructurada
int main(void){ int x=0,z=0; int *y; //declaro a y como una variable de tipo apuntador x=3; y=&x; // a y le asigno la dirección de x, por lo tanto y apunta a x z=*y; // a z le asigno el valor de la variable a la cual apunta y printf("z= %d ",z); return 0; }

En tiempo de ejecución, el manejo de la memoria sería como se muestra en la siguiente figura:

Ejemplo: Escribir un programa que realice el intercambia de valores entre tres variables empleando paso de parámetros por referencia.
#include<stdio.h> void intercambia(int *x, int *y); int main(void){ int a=10, b=5; printf("\n Los valores de A y B son: %d y %d",a,b); intercambia(&a,&b); printf("\n Los valores actuales de A y B son: %d y %d", a,b); return 0; } void intercambia(int *x, int *y){ int aux; aux=*x; *x=*y; *y=aux; return; } intercambia.c

Lizbeth Gallardo - Pedro Lara

UAM Azcapotzalco

Página 40

Notas de Programación Estructurada
sub intercambia(BYREF x as integer, BYREF y as integer) aux=x : x=y : y=aux end sub a=10: b=5 print : print print "Los valores de las variables originales A y B son: "; a; " y"; b intercambia(a,b) print "Los valores de A y B han sido intercambiados, ahora son: "; a; " y"; b sleep intercambia.bas

Ejercicio: construya un programa en C que reciba un valor entero correspondiente a una cantidad en segundos. Escriba una función denominada “convertir” que reciba como parámetro, por valor, la cantidad de segundos; y los parámetros, por referencia, hora, min. La función habrá de convertir y mostrar en pantalla la cantidad de segundos en su equivalente en horas, minutos y segundos restantes.
Entrada:3600 Salida: 1h 0m 0s

Lizbeth Gallardo - Pedro Lara

UAM Azcapotzalco

Página 41

Notas de Programación Estructurada
#include <stdio.h> void convertir (int,int*,int*,int*); int main(void){ int segundos,hora,min,seg; printf("Ingresa los segundos: "); scanf("%d",&segundos); convertir(segundos,&hora,&min,&seg); printf("%d h %d min %d seg",hora,min,seg); return 0; } void convertir (int segundos,int* hora, int* min, int*seg){ *hora = segundos /3600; *min=(segundos % 3600)/60; *seg=(segundos % 3600)%60; return; } horminsec.c sub convertir(segundos as integer,BYREF hora as integer, BYREF min as integer, BYREF seg as integer) hora = int(segundos/3600) min=int((segundos mod 3600)/60) seg=(segundos mod 3600) mod 60 end sub input "Ingresa los segundos: ", segundos convertir(segundos,hora,min,seg) print hora;"h"; min; "min";seg; "seg" sleep horminsec.bas

Lizbeth Gallardo - Pedro Lara

UAM Azcapotzalco

Página 42

Notas de Programación Estructurada
CAPÍTULO VI ESTRUCTURAS REPETITIVAS
En la solución algunos problemas es común requerir que un conjunto de operaciones (instrucciones) sea ejecutado varias veces. Al conjunto de instrucciones que se ejecuta repetidamente se le llama ciclo; si bien las instrucciones son las mismas, los datos pueden variar. En una estructura repetitiva debe existir una condición que detenga la ejecución del ciclo (suele llamarse condición de paro). En cada iteración esta condición de paro es evaluada para decidir si el ciclo continúa ó si debe detenerse.

Estructura repetitva „Durante‟ (for)
Generalmente, la estructura for se utiliza en soluciones donde se conoce el número de veces que deberá repetirse el ciclo. Por lo tanto, se establece un contador inicial; este contado se va incrementando ó decrementando en cada iteración, hasta alcanzar un valor máximo ó mínimo; una vez alcanzado este valor, el ciclo termina y se continúa con el flujo normal del programa.
for (exp1, exp2, exp3){ bloque_V; }

exp1, exp2, exp3 V bloque_V

F

donde: exp1: establece un valor inicial a un contador. exp2: correspondiente a la condición de paro donde se determina el valor máximo o mínimo que podrá alcanzar el contador. exp3: corresponde al incremento ó decremento para el contador. bloque_V: conjunto de instrucciones que se repetirá hasta que la condición sea falsa. Cuando la condición es falsa.

Ejercicio: Se dice que un número entero es perfecto si la suma de sus divisores excepto él mismo es igual al propio número. Por ejemplo seis es número perfecto porque 1*2*3=6 y 1+2+3 = 6. Escriba un programa que obtenga los números perfectos comprendidos entre 1 y 10000.
#include<stdio.h> int main(void){ int num=0, sum=0, i=0; printf("Numeros perfectos \n\n"); for(num=1; num<=1e4; num++){ sum=0; for(i=1; i<=(num/2); i++) if(num%i==0) sum = sum+i; if(sum==num) printf ("%d es numero perfecto \n", num); } return 0; } 4perfectos.c

Lizbeth Gallardo - Pedro Lara

UAM Azcapotzalco

Página 43

Notas de Programación Estructurada
print "Numeros perfectos" dim num as integer for num=1 to 1e4 sum=0 for i=1 to num/2 if num mod i = 0 then sum = sum+i next i if sum = num then print num; " es numero perfecto" next num sleep 4perfectos.bas

Ejercicio: construir un programa que simule el juego de adivinar un número comprendido entre 1 y 100. El usuario tiene 7 oportunidades para lograrlo. El programa debe generar aleatoriamente el número y luego solicitar al usuario que lo adivine. Si el número del usuario es menor que el número aleatorio, se le indica “mi número es mayor”; pero si el número del usuario es mayor que el número aleatorio, se le indica “mi número es menor”; si el número del usuario es igual que el número aleatorio, se le indica “Acertaste”; si el usuario agota sus oportunidades simplemente termina el programa.
Entrada: 50 Salida: Mi número es mayor #include<stdio.h> #include<stdlib.h> #include<time.h> int main(){ int num, tuNum, i; srand(time(NULL)); printf("Adivina un número en 7 oportunidades o menos\n"); printf("\n El numero es un entero entre 1 y 100"); num=(rand()%100)+1; for(i=1; i<=7; i++){ printf("\n Intento # %i: ",i); scanf("%d", &tuNum); if(num < tuNum) printf("El numero es menor \n"); else if(num > tuNum) printf("El numero es mayor \n"); else{ printf("Acertaste!!! \n"); exit(1); } } printf("\n LAAASTIIIMAAA!!! Se acabaron tus intentos!\n\n"); return 0; } adivina.c randomize timer num=int(rnd*100)+1 print "Estoy pensando un numero, Adivina cual es en 7 oportunidades o menos:" for i=1 to 7

Lizbeth Gallardo - Pedro Lara

UAM Azcapotzalco

Página 44

Notas de Programación Estructurada
print i; input ". Dame un numero:", adiv if num < adiv then print "el numero es menor" elseif num > adiv then print "el numero es mayor" else print "acertaste!" exit for endif if i>=7 then print "LASSSSTIMAAAA!!! Se acabaron sus intentos" next i sleep

adivina.bas

Construir un programa que determine los números primos comprendidos entre 1 y 1e4. Un número es primo, si sus únicos divisores son él mismo y la unidad. No hay entrada por parte del usuario; como salida enlistar los números primos con la siguiente leyenda: x es primo.
Salida:

1es primo 2 es primo 3 es primo : 9973 es primo
#include<stdio.h> #define LIM 1e4 int main(){ int num=0, i=0, band=0, cont=0; printf("Numeros primos comprendidios en un rango %.2e\n", LIM); for(num=2; num<=LIM; num++){ band=0; for(i=2; i<=num/2; i++){ if(num%i==0) band=1; } if(band==0){ printf("%d es primo \n", num); cont++; } } printf("\n%d numeros primos en el rango de 1 a %.2e\n", cont, LIM); return; } primo-02.c

#define LIM 1e4 dim num, cont as integer print "Numeros primos comprendidos entre 1 y "; LIM for num=2 to LIM flag=0 for i=2 to num/2 if num mod i = 0 then flag = 1 next i if flag = 0 then

Lizbeth Gallardo - Pedro Lara

UAM Azcapotzalco

Página 45

Notas de Programación Estructurada
print num; " es primo" cont+=1 endif next num print cont; " numeros primos en el rango de 1 a "; LIM sleep primo-02.bas

Ejercicio: construir un algoritmo que calcule el factorial de un número empleando funciones.
#include <stdio.h> int fact(int); int main(void){ int n,f; printf("introduce un numero natural: "); scanf("%d",&n); f=fact(n); if(f<0) printf("Error!"); else printf("fact(%d) = %d",n,f); return 0; } int fact(int n){ int aux=1,x=0; if(n<0) return -1; else { for(x=1; x<=n; x++){ aux=aux*x; } } return aux; } factorial.c function fact(n as uinteger) aux=1 for x=1 to n aux=aux*x next x return aux end function input "introduce un numero natural:", n if n<0 then print "Error!" : sleep : end print"fact("; n; " ) =";fact(n) sleep factorial.bas

Estructura repetitiva „Mientras‟ (while)
La estructura while evalúa primero una condición, si esta resulta verdadera entonces se ejecuta el bloque de instrucciones; de lo contrario, se continúa con el flujo normal del programa. Generalmente, la estructura while se emplea en soluciones donde no se conoce previamente la

Lizbeth Gallardo - Pedro Lara

UAM Azcapotzalco

Página 46

Notas de Programación Estructurada
cantidad de iteraciones que deben realizarse para obtener un resultado. Sin embargo, una estructura while puede emplearse en lugar de una estructura for en soluciones donde se conoce el número de iteraciones.
while(condicion){ bloque_v; }

condicion V bloque_V

F

Donde: condicion: mientras la condición sea verdadera, el ciclo continúa en ejecución . La condición de paro puede implicar varias condiciones unidas por los operadores lógicos && y || bloque_V: es el conjunto de instrucciones que conformarán el ciclo

Ejercicio: escriba un programa que obtenga la siguiente serie: 2,7,10,15,18,23,…,2500
#include <stdio.h> int main(void){ int serie=2, cambio=1; while(serie<=2500){ printf("%d\t",serie); if(cambio==1){ serie+=5; cambio=0; } else{ serie+=3; cambio=1; } } return 0; } serie3-5.c dim serie, cambio as integer serie=2 cambio=1 while serie <=2500 print serie, if cambio=1 then serie+=5 cambio=0 else serie+=3 cambio=1 endif wend sleep serie3-5.bas

Lizbeth Gallardo - Pedro Lara

UAM Azcapotzalco

Página 47

Notas de Programación Estructurada
Ejercicio: escriba un programa en C que solicite calificaciones a un usuario. El programa debe aceptar calificaciones hasta que se introduce un valor fuera del rango, y el rango es [0,10]. Además, el programa debe mostrar la suma y el promedio de las calificaciones.
#include <stdio.h> int main(void){ float califica=0.0, total=0.0, contador=0.0; printf("Calificacion: "); scanf("%f",&califica); while(califica>=0 && califica<=10){ total+=califica; contador++; printf("Calificacion: "); scanf("%f",&califica); } if(total!=0){ printf("La suma es: %.2f \n",total); printf("El promedio es: %.2f \n",total/contador); } return 0; } calificacion.c dim califica, total as double, contador as integer input "Calificacion: ", califica while califica>=0 and califica<=10 total+=califica contador+=1 input "Calificacion: ", califica wend if total<>0 then print "La suma es: "; total print "El promedio es: "; total/contador endif sleep calificacion.bas

Estructura repetitiva „Haz - Mientras‟ (do-while)
A diferencia de las estructuras for y while, que analizan la condición de paro al principio del ciclo, la estructura do-while comprueba la condición al final. Esto significa que el bloque de instrucciones se ejecutará al menos una vez. Generalmente, esta estructura se emplea para validar datos que se reciben desde el teclado; sin embargo, puede emplearse en cualquier otro tipo de solución que involucra iteraciones.

Lizbeth Gallardo - Pedro Lara

UAM Azcapotzalco

Página 48

Notas de Programación Estructurada
do{ bloque_V; }while(condicion);
bloque_V

donde: bloque_V: es el conjunto de instrucciones que se va a repetir mientras la condición sea verdadera condicion: una ó varias condiciones relacionadas con operadores lógicos.

condicion V

F

Ejercicio: escribir un algoritmo que obtenga el promedio de los números pares ingresados por el usuario y el promedio de los impares. El programa se detiene cuando el usuario introduce cero o un valor negativo.
#include <stdio.h> int main(void){ int num=0; float tpar=0.0,timp=0.0,npar=0.0,nimp=0.0; do{ printf("Introduce un entero positivo: "); scanf("%d",&num); if(num>0){ if(num%2==0){ tpar+=num; npar+=1; } else{ timp+=num; nimp+=1; } } }while(num>0); if(npar==0) printf("\nNo hubo numeros pares\n"); else printf("\nPromedio de los pares = %f \n",tpar/npar); if(nimp==0) printf("\nNo hubo numeros impares\n"); else printf("\nPromedio de los impares = %f \n",timp/nimp); return 0; } sumaPar-Impar.c
dim tpar as double, timp as double, npar as double, nimp as double do input "Introduce un entero positivo: ", num if num>0 then if num mod 2=0 then tpar+=num : npar+=1 else timp+=num : nimp+=1 end if loop while num>0 if npar=0 then print "No hubo numeros pares" else print "Promedio de los pares = "; tpar/npar

Lizbeth Gallardo - Pedro Lara

UAM Azcapotzalco

Página 49

Notas de Programación Estructurada
print endif if nimp=0 then print "No hubo numeros impares" else print "Promedio de los impares = "; timp/nimp print endif sleep sumaPar-Impar.bas

Ejercicio: recordando que es un número perfecto, escriba un programa que reciba desde el teclado un número natural y determine si éste es un número perfecto. El programa debe validad que la entrada del usuario sea un número natural mayor que 0. Si el usuario introduce un 0 entonces el programa debe terminar.
#include<stdio.h> int main(void){ int num=0, i=0; int sum=0; printf("Numero perfecto? \n"); do{ printf("Teclee un numero entero positivo (0 para salir): "); scanf("%d", &num); }while(num<0); if(num!=0){ for(i=1; i<num; i++){ if(num%i==0) sum=sum+i; } if(sum==num) printf("%d es un numero perfecto\n",num); else printf("%d no es un numero perfecto\n",num); } return(0); } perfecto.c

dim num, i, sum as integer print "Numero perfecto?" do input "Teclee un numero entero positivo (0 para salir): ", num loop while num<0 if num<>0 then for i=1 to num-1 if num mod i=0 then sum=sum+i next i if sum=num then print num, "es un numero perfecto" else print num, "no es un numero perfecto" endif endif sleep perfecto.bas

Lizbeth Gallardo - Pedro Lara

UAM Azcapotzalco

Página 50

Notas de Programación Estructurada
Ejercicio: escriba un programa que genere la siguiente figura en pantalla, se debe de validar el dato de entrada para el siguiente programa. 1 1 1 1 1 1 1
#include <stdio.h> int pideDato(void); void figura(int); int main(void){ int num=0; do{ num=pideDato(); }while(num<0); if(num>0) figura(num); else printf("\n Escogiste salir!!"); return(0); } int pideDato(void){ int num=0; printf("\n\n Cortina de numeros. Para salir introduce un 0, o bien"); printf("\n introduce un numero entero positivo menor a 14"); printf("\n\n N = "); scanf("%d",&num); return(num); } void figura(int num){ int i=0, j=0, k=0, aux=num; for(i=1; i<=num; i++){ //define numero de renglones for(j=1; j<=aux; j++){ //primera serie de numeros printf("%3d",j); } for(k=1; k<=(2*i-1); k++){ //serie de espacios printf(" "); } for(j=aux; j>0; j--){ // serie en orden inverso printf("%3d",j); } printf("\n"); aux--; // aux determina el limite de cada renglón } return; } cortinaNumeros.c function pideDato as integer print : print print "Cortina de numeros. Para salir introduce un 0, o bien" print "introduce un numero entero positivo menor a 12" print : print : input "N = ", num return num end function

2 2 2 2 2 2

3 3 3 3 3

4 5 6 7 7 6 5 4 4 5 6 6 5 4 4 5 5 4 4 4

3 3 3 3 3

2 2 2 2 2 2

1 1 1 1 1 1 1

Lizbeth Gallardo - Pedro Lara

UAM Azcapotzalco

Página 51

Notas de Programación Estructurada
sub cortina(num as integer) aux=num for i=1 to num 'define numero de renglones for j=1 to aux 'primera serie de numeros print using "###"; j; next j for k=1 to (2*i-1) 'serie de espacios print " "; next k for j=aux to 1 step -1 'serie en orden inverso print using "###"; j; next j print aux-=1 'aux determina el limite de cada renglón next i end sub do num=pideDato loop while num<0 if num>0 then cortina(num) else print: print"Escogiste salir!!" sleep cortinaNumeros.bas

Ejercicio: escriba un programa que muestre en pantalla todos los números perfectos comprendidos en el rango de 1 a n, donde n es un número dado por el usuario. Nota: - El programa debe incluir una función - Si n = 0 termina el programa - Si n < 0 insiste con el usuario en solicitar un valor para n.
#include <stdio.h> void numPerfecto(int); int main(void){ int n=0; do{ printf("Limite para encontrar numeros perfectos: "); scanf("%d",&n); }while(n<0); if (n!=0){ numPerfecto(n); } return 0; } void numPerfecto(int n){ int i=0,sum=0,j=0; for (i=1;i<n;i++){ sum=0; for (j=1;j<=(i/2);j++){ if(i%j==0) sum=sum+j; } if (sum==i) printf("%d es numero perfecto \n",i); } return; } serie-perfectos.c

Lizbeth Gallardo - Pedro Lara

UAM Azcapotzalco

Página 52

Notas de Programación Estructurada
sub numPerfecto(n as integer) for i=1 to n sum=0 for j=1 to i/2 if i mod j=0 then sum=sum+j next j if sum=i then print i; " es numero perfecto" next i end sub do input "Limite de la serie para encontrar numeros perfectos: ", n loop while n<0 if n<>0 then numPerfecto(n) print "Hecho!" sleep serie-perfectos.bas

Lizbeth Gallardo - Pedro Lara

UAM Azcapotzalco

Página 53

Notas de Programación Estructurada
CAPÍTULO VII TIPOS DE DATOS ESTRUCTURADOS
Un arreglo es una colección de variables del mismo tipo, que se referencian por un nombre común. En el lenguaje C, las celdas de memoria correspondientes a las variables de un arreglo son contiguas; por lo tanto, la dirección de memoria más baja corresponde al primer elemento del arreglo y la dirección de memoria más alta corresponde al último elemento. Dado que un arreglo está formado por celdas de memoria contigua, para acceder a un elemento es suficiente con emplear un índice, el cual denota la posición de un elemento en el arreglo.

Arreglos unidimensionales
Declarar un arreglo unidimensional es similar a declarar una variable, pero indicando su tamaño, por ejemplo:
int vector[10]; float num[40]; //corresponde a un arreglo llamado vector de tamaño 10 y cuyos elementos deberán ser de tipo entero //corresponde a un arreglo llamado num de tamaño 40 y cuyos elementos deberán ser de tipo real

Cuando declaramos un arreglo, es posible darle valores iniciales, por ejemplo:
int vector[8]={2,4,6,7,5,1,9,3}; float num[3]={2.45,4.56,1.23}; float calificaciones[7]={0,0}; // todos elementos del arreglo son 0.0

int datos[]= {36,21,23} ; // cuando se omite el tamaño de un arreglo, debe inicializarse con valores, y su tamaño corresponderá al número de valores de inicio

Se asigna un valor a cada celda. La asignación se hace en el orden en que aparecen los valores. En tiempo de ejecución, el arreglo vector se vería, en la memoria principal, como sigue: 0 1 2 3 4 5 6 7 vector 2 4 6 7 5 1 9 3 Todos los arreglos comienzan en con una posición 0 (cero); por lo tanto, el tamaño de vector es 8, pero su última posición es 7. En general, para un arreglo de tamaño n, su última posición será n-1. Para acceder a cualquier elemento, nos referimos a él a través de su posición, por ejemplo:

Lizbeth Gallardo - Pedro Lara

UAM Azcapotzalco

Página 54

Notas de Programación Estructurada
Referencia vector[2] “vector en su posición 2” vector[6] “vector en su posición 6” vector[2+3]=vector[5] elemento 6 9 1

Arreglos unidimensionales y funciones Cuando una función requiere pasar un arreglo (como parámetro) a otra función, éste pasa únicamente por referencia. Por lo tanto, cualquier modificación que se realice sobre el arreglo, en la función que lo recibe, afectará al arreglo original que se localiza en la función que realizó el llamado. La siguiente tabla muestra una comparación entre las dos notaciones que podemos emplear en el lenguaje C para manejar un arreglo que pasa como parámetro por referencia. El resultado de ambos es el mismo.
Prototipo: void calcula(int datos[], int n); Llamado: int main(void){ int datos[10]; calcula(datos, 10); : return 0; } Declaración de función:
void calcula(int datos[], int n) { for(int i=0; i<n;i++) datos[i]= datos[i]-2; return;

Prototipo: void calcula(int* datos, int n); Llamado: int main(void){ int datos[10]; calcula(datos, 10); : return 0; } Declaración de función:
void calcula(int* datos, int n) { for(int i=0; i<n;i++) *(datos+i)= *(datos+i)-2; return;

}

}

Ejercicio: Escriba un programa que calcule la suma de 2 arreglos unidimensionales de tipo entero. El resultado debe almacenarse en un tercer arreglo.

Lizbeth Gallardo - Pedro Lara

UAM Azcapotzalco

Página 55

Notas de Programación Estructurada
#include <stdio.h> #define MAX 100 int tamVEC(void); void leeVEC(int X[],char nom,int n); void sumVEC(int A[],int B[],int C[],int n); void impVEC(int X[],char nom,int n); int main(void){ int A[MAX]={0}; int B[MAX]={0}; int C[MAX]={0}; int tam=0; tam=tamVEC(); leeVEC(A,'A',tam); leeVEC(B,'B',tam); sumVEC(A,B,C,tam); impVEC(A,'A',tam); impVEC(B,'B',tam); impVEC(C,'C',tam); return 0; } int tamVEC(void){ int n=0; do{ printf("Dame el tamaño de los arreglos (1-100)"); scanf("%d",&n); }while(n<=0 || n>=MAX); return (n); } void leeVEC(int X[], char nom, int n){ int i=0; printf("\nLectura del vector %c:\n",nom); for (i=0;i<n;i++){ printf("\n%c[%d]=", nom, i); scanf("%d",&X[i]); } return; } void sumVEC(int A[],int B[],int C[],int n){ int i=0; for (i=0; i<n; i++){ C[i]=A[i]+B[i]; } return; } void impVEC(int X[], char nom, int n){ int i=0; printf("\n Vector %c: ", nom); for (i=0; i<n; i++){ printf("%d ",X[i]); } return; }

sumaVectores.c
#define MAX 100 function tamVEC do input "Dame el tamaño de los arreglos (1-100)", n

Lizbeth Gallardo - Pedro Lara

UAM Azcapotzalco

Página 56

Notas de Programación Estructurada
loop while n<=0 or n>=MAX return n end function sub leeVEC(X() as integer, nom as string , n as integer) print "Lectura del vector "; nom for i=1 to n print nom; "["; i; " ]="; input X(i) next i end sub sub sumVEC(A() as integer,B() as integer, C() as integer, n as integer) for i=1 to n C(i)=A(i)+B(i) next i end sub sub impVEC(X() as integer, nom as string, n as integer) print "Vector "; nom; " ="; for i=1 to n print X(i); next i print end sub dim as integer A(MAX), B(MAX), C(MAX) tam=tamVEC leeVEC(A(),"A",tam) : leeVEC(B(),"B",tam) sumVEC(A(),B(),C(),tam) impVEC(A(),"A",tam) : impVEC(B(),"B",tam) impVEC(C(),"C",tam) sleep

sumaVectores.bas

Ejercicio: construir un programa que simule el lanzar 4 dados 1e7 veces; para luego, obtener la frecuencia con la que se presentó cada suma de caras en los lanzamientos.
#include <stdio.h> #include <stdlib.h> #include <time.h> #define NDADOS 3 #define ITERA 1.0e7 void tiraDados(int []); void imprimeRes(int []); void imprimeCad(int lim, char car); int main(void){ int cara[100]={0}; time_t tiempo1, tiempo2; srand(time(NULL)); time(&tiempo1); tiraDados(cara); imprimeRes(cara); time(&tiempo2); printf("\nEl tiempo de ejecucion es: %f \n", (float)(tiempo2-tiempo1)); return(0); } void tiraDados(int cara[]){

Lizbeth Gallardo - Pedro Lara

UAM Azcapotzalco

Página 57

Notas de Programación Estructurada
int i=0, j=0, suma=0; for(i=0; i<ITERA; i++){ suma=0; for(j=1; j<=NDADOS; j++){ suma+=(rand()%6)+1; } cara[suma]++; } return; } void imprimeRes(int cara[]){ int i=0; printf("Probabilidades para la suma de caras de %d dados son: \n",NDADOS); for(i=NDADOS; i<=NDADOS*6; i++){ printf("%d \t %f \t ", i, cara[i]/ITERA); imprimeCad((int)((100*cara[i])/ITERA), '*'); printf("\n"); } return; } void imprimeCad(int lim, char car){ int i=0; for(i=1; i<=lim; i++) printf("%c",car); return; } dados.c

RANDOMIZE TIMER DIM a(100) as double tempo=TIMER iterac=1e6 tms=3 FOR i=1 TO iterac sum=0 FOR j=1 TO tms sum=sum+INT(RND*6+1) NEXT j a(sum)=a(sum)+1 NEXT i FOR i=tms TO tms*6 PRINT USING "###\\";i; PRINT USING " ######.######"; a(i)/iterac; PRINT " ",STRING$(CINT(100*a(i)/(iterac)),120) NEXT i PRINT "tiempo transcurrido: ";TIMER-tempo; " segs." INPUT; "ENTER para continuar" , b END dados.bas

Ejercicio: construir un programa que permita recibir dos valores: 1) un valor entero positivo a convertir a cualquier base numérica; y 2) un valor entero positivo correspondiente a la base para la conversión. Es importante mencionar que el programa funcionará bajo el siguiente criterio: si la base es 8 su nomenclatura estará formada por (1, 2,…7); si la base es 16 su nomenclatura estará formada por (1, 2,…15).

Lizbeth Gallardo - Pedro Lara

UAM Azcapotzalco

Página 58

Notas de Programación Estructurada
#include <stdio.h> #define MAX 560 int main(void){ int decimal=0, base=0, i=0, conversion[MAX]={0}; printf("Programa que realiza la conversion entre bases"); printf("\n(de decimal a cualquier otra base) \n"); do{ printf("\nProporciona el valor a convertir (entero positivo)"); printf("\no cero para salir: "); scanf("%d", &decimal); printf("\nProporciona la base numerica para la conversion: "); printf("\no cero para salir: "); scanf("%d", &base); }while(decimal<0 && base<0); if(decimal>0 && base>0){ do{ conversion[i]=decimal%base; decimal=(int)(decimal/base); i++; }while(decimal!=0 && i<MAX); for(i=i-1; i>=0; i--) printf("%d", conversion[i]); } return 0; } DecimalOtraBase.c

dim a(100) as integer print "Decimal a cualquier base" input "Base en que quieres el numero: ", bas input "Dame el numero en decimal: ", num while num<>0 i+=1 a(i)=num mod bas num=(num-num mod bas)/bas max=i wend print "El numero en base "; bas; " es: "; for i=max to 1 step -1 print a(i); next i sleep decimalOtraBase.bas

Arreglos bidimensionales
Un arreglo bidimensional (también llamado tabla ó matriz) consta de renglones y columnas. Para acceder a un elemento debemos emplear dos índices, el primero para denotar el renglón y el segundo para denotar la columna donde se encuentra el elemento. Declarar un arreglo bidimensional es similar a declarar un arreglo unidimensional, pero indicando, además del número de renglones, el número de columnas, por ejemplo:
int matriz[3][4]; //corresponde a un arreglo llamado matriz de 3 renglones y 4 columnas; por lo tanto su tamaño es de 3x4=12 elementos, todos de tipo entero

Lizbeth Gallardo - Pedro Lara

UAM Azcapotzalco

Página 59

Notas de Programación Estructurada
float num[5][5]; //corresponde a un arreglo llamado valores de 5 renglones y 5 columnas; por lo tanto es una matriz cuadrada de 25 elementos de tipo real

Cuando declaramos un arreglo bidimensional, es posible darle valores iniciales, por ejemplo:
int matriz[3][4]={12,24,46,17,25,31,49,63, 42,21,89,96}; // se asignan los valores en el orden de aparición, cubriendo cada renglón int matriz[3][4]={ {12,24,4617},{25,31,49,63},{ 42,21,89,96}}; // esta forma proporciona claridad a quien lee el código int matriz[3][4]={0}; //incorrecto // Una arreglo bidimensional no puede inicializase con 0 (cero) de esta manera

En tiempo de ejecución, el arreglo matriz se vería, en la memoria principal, como sigue:
r0 r1 r2 c0 12 25 42 c1 24 31 21 c2 46 49 89 c3 17 63 96

Observe que también los arreglos bidimensionales comienzan en con una posición 0 (cero) tanto en los renglones como en las columnas; por lo tanto, el número de renglones matriz es 3, pero su última posición es 2; mientras que el número de columnas es de 4 pero su última posición es 3, y el tamaño de la matriz es de 3x4. En general, en tamaño de una matriz está determinado por el producto nrenglonesxmcolumnas correspondiente al número de elementos que puede albergar el arreglo bidimensional. Para acceder a cualquier elemento, nos referimos a él a través de su posición, por ejemplo:
Referencia matriz[2][3] “matriz en su posición 2,3” matriz[0][1] “matriz en su posición 0,1” Elemento 96 24

Ejercicio: construir un programa que dada una matriz, obtenga la matriz traspuesta. Para este ejercicio emplear funciones.
#include <stdio.h> #define MAX 50 void leeMatriz(float MAT[][MAX], int* n, int* m); void traspuesta(float MAT1[][MAX],float MAT2[][MAX],int n, int m); void imprMatriz(float MAT[][MAX], int n, int m);

Lizbeth Gallardo - Pedro Lara

UAM Azcapotzalco

Página 60

Notas de Programación Estructurada
int main(void){ float MAT1[MAX][MAX], MAT2[MAX][MAX]; int n=0, m=0; leeMatriz(MAT1,&n,&m); traspuesta(MAT1,MAT2,n,m); imprMatriz(MAT1,n,m); imprMatriz(MAT2,m,n); return 0; } void leeMatriz(float MAT[][MAX], int *n, int *m){ int i=0, j=0; printf("Dimension de la matriz m x n (MAXIMO 50): "); scanf("%d %d",n, m); for(i=0; i<(*n); i++){ for (j=0; j<(*m); j++){ printf("MAT[%d,%d]= ",i,j); scanf("%f",&MAT[i][j]); } printf("\n"); } return; } void traspuesta(float MAT1[][MAX], float MAT2[][MAX], int n, int m){ int i=0, j=0; for (i=0; i<n; i++){ for (j=0; j<m; j++){ MAT2[j][i]=MAT1[i][j]; } } return; } void imprMatriz(float MAT[][MAX], int n, int m){ int i=0, j=0; printf("\n"); for (i=0; i<n; i++){ for (j=0; j<m; j++){ printf("%.2f ",MAT[i][j]); } printf("\n"); } printf("\n"); return; } transponer.c #define MAX 50 function leeMatriz(MAT() as double, n as integer, m as integer) input "Dimension de la matriz n x m: ",n , m for i=1 to n for j=1 to m print "MAT["; i; ","; j;"]= "; input MAT(i,j) next j print next i return n end function sub transponer(MAT1() as double, MAT2() as double, n as integer, m as integer) for i=1 to n for j=1 to m

Lizbeth Gallardo - Pedro Lara

UAM Azcapotzalco

Página 61

Notas de Programación Estructurada
MAT2(j,i) = MAT1(i,j) next j next i end sub sub imprMatriz(MAT() as double, n as integer, m as integer) for i=1 to n for j=1 to m print MAT(i,j), next j print next i end sub dim as double MAT1(MAX,MAX), MAT2(MAX,MAX), MAT(MAX,MAX) leeMatriz(MAT1(),n,m) transponer(MAT1(),MAT2(),n, m) print "La transpuesta de la matriz: " imprMatriz(MAT1(),n,m) print "Es: " imprMatriz(MAT2(),m,n) sleep transponer.bas

Ejercicio: Escriba un programa que al recibir como dato un arreglo bidimensional (matriz) cuadrado, determine si el mismo es simétrico. El programa debe incluir las siguientes funciones: 1) leeMatriz, 2) simetrica, 3) imprimeMatriz.
#include <stdio.h> #define MAX 50 int leeMatriz(float[][MAX]); int simetrica(float[][MAX],int); int main(void){ float MAT[MAX][MAX]; int n=0,resp=0; n=leeMatriz(MAT); resp=simetrica(MAT,n); if (resp==0) printf("\nLa matriz es simetrica\n"); else printf("\nLa matriz no es simetrica\n"); return 0; } int leeMatriz(float MAT[][MAX]){ int i=0, j=0, n=0; printf("Cual es el tamanio de la matriz cuadrada: "); scanf("%d",&n); for(i=0; i<n; i++){ for (j=0; j<n; j++){ printf("MAT[%d,%d]= ",i,j); scanf("%f",&MAT[i][j]); } printf("\n"); } return n; } int simetrica(float MAT[][MAX],int n){ int i=0, j=0, flag=0; for (i=0; i<n; i++){ for (j=i+1; j<n; j++){ if (MAT[i][j]!=MAT[j][i])

Lizbeth Gallardo - Pedro Lara

UAM Azcapotzalco

Página 62

Notas de Programación Estructurada
flag=1; j=n; i=n; } } return flag; } matrizSimetrica.c #define MAX 50 function leeMatriz(MAT() as double) input "Cual es el tamaño de la matriz cuadrada: ",n for i=1 to n for j=1 to n print "MAT["; i; ","; j;"]= "; input MAT(i,j) next j print next i return n end function function simetrica(MAT() as double, n as integer) for i=1 to n for j=i+1 to n if MAT(i,j) <> MAT(j,i) then flag=1 : j=n : i=n next j next i return flag end function dim MAT(MAX,MAX) as double n=leeMatriz(MAT()) resp=simetrica(MAT(),n) print "La matriz "; if resp=0 then print "es simetrica" else print "no es simetrica" sleep matrizSimetrica.bas

Cadenas
Una cadena es un arreglo unidimensional empleado para guardar elementos de tipo caracter char. Una cadena se declara igual que los arreglos, por ejemplo:
char cad[10]; //corresponde a una cadena llamada cad de tamaño 10 y cuyos elementos deberán ser de tipo caracter

En el leguaje C, todas las cadenas terminan con un caracter nulo denotado por una diagonal inversa y el número cero „\0‟; por lo tanto, al momento de definir el tamaño de la cadena tenemos que contar la celda que ocupará este caracter. El caracter nulo „\0‟ sirve para marcar el fin de una cadena. Cuando declaramos una cadena, es posible darle valores iniciales, por ejemplo:
char cadena[5]={„h‟,‟o‟,‟l‟,‟a‟}; //los valores se asignan a cadena en el orden en que aparecen char cad[5]=”hola”; // otra forma válida de inicializar a cad

Lizbeth Gallardo - Pedro Lara

UAM Azcapotzalco

Página 63

Notas de Programación Estructurada
char cad[5]=” ”; caracter espacio // todos elementos del arreglo tienen como valor inicial al

char cad[]= “hola”; //el tamaño del arreglo queda definido como 5

En tiempo de ejecución, el arreglo cadena se vería, en la memoria principal, como sigue:
0 1 2 3 4 cadena h o l a \0

Observe que si bien el tamaño de la palabra “hola” es 4, la cadena es declarada como de tamaño 5, y el caracter nulo „\0‟ ocupa la última posición en el arreglo, es decir la posición 4. Al manipular una cadena se debe cuidar de no sustituir al caracter nulo „\0‟ con algún otro valor. Los operadores de asignación (=) y los relacionales (==, !=) no se emplean en el manejo de cadenas, salvo la asignación al declarar e inicializar una cadena; tal y como vimos en los ejemplos anteriores. Para manipular a las cadenas en un programa, debemos emplear un conjunto de funciones que encontramos en las bibliotecas: string.h, stdlib.h y ctype.h. Entrada /Salida para cadenas y caracteres
Cadenas
scanf(“%s”,&cadena)

Caracteres
scanf(“%c”,&caracter) getc(caracter) Printf(“%c”,caracter) putc(caracter)

Entrada gets(cadena)
Printf(“%s”,cadena)

Salida

puts(cadena)

Cuando quiero leer una nueva cadena, debemos emplear la función fflush(stdin), para limpiar el buffer que permite recibir una cadena desde el teclado.
Descripción
strcpy(destino, origen) Copia el valor de cadena origen hacia la cadena destino. Igual que la función strcpy de dos argumentos, sólo que se copian cuando mucho el límite caracteres. Concatena el valor de cadena origen con el final de la cadena destino Igual que la función strcat de dos argumentos, sólo que se anexan cuando mucho límite caracteres Devuelve un entero igual a la longitud de la cadena origen; el

Precauciones
No verifica que la cadena destino sea lo bastante grande como para almacenar el valor de la cadena origen. Si limite se elige con cuidado, esta función es más segura que la versión strcpy. No verifica que la cadena destino sea lo bastante grande como para almacenar el resultado de la concatenación Si limite se elige con cuidado, esta función es más segura que la versión srtcat.

strncpy(destino, origen, limite) strcat(destino, origen)

strncat(destino, origen, limite) strlen(origen)

Lizbeth Gallardo - Pedro Lara

UAM Azcapotzalco

Página 64

Notas de Programación Estructurada
carácter nulo „\0‟ no se cuenta en la longitud Devuelve 0 si cadena_1 y cadena_2 son iguales Devuelve un valor menor a 0 si cadena_1 es menor que cadena_2. Devuelve un valor mayor a 0 si cadena_1 es mayor que cadena_2 Por lo tanto, devuelve un valor distinto de cero si cadena_1 y cadena_2 son distintas. Cada carácter tiene un valor entero, según la tabla de ascii Igual que la función strcmp de dos argumentos, solo que se comparan cuando mucho limite caracteres.

strcmp (cadena_1, cadena_2)

Si cadena_1 es igual a cadena_ 2 esta función devuelve 0, lo que la convierte en falsa cuando se evalúa. Esto es lo inverso de lo que podríamos esperar dado que las cadenas son iguales. Tener cuidado con la lógica que sigue esta función

strncmp (cadena_1, cadena_2, limite)

Si limite se elige con cuidado, esta función es más segura que la función strcmp de dos argumentos

Ejercicio: construir un programa que dada una cadena, determine si ésta es una cadena palíndrome. Se dice que una cadena es palíndrome si al invertir el orden de los caracteres (de derecha a izquierda) se lee igual.
#include<stdio.h> #include<string.h> #define MAX 50 int palindrome(char cad[]); int main(void){ char cad[MAX]={'\0'}; int resp=0; printf("Ingresa la cadena a ser evaluada como palindrome,"); printf("\npero SIN ESPACIOS ENTRE LAS LETRAS:\n"); scanf("%s",cad); printf("la cadena mide %i y contiene %s", strlen(cad), cad); resp=palindrome(cad); if (resp==0) printf("\nLa cadena no es palindrome\n"); else printf("\nLa cadena es palidrome\n"); return 0; } int palindrome(char cad[]){ int i=0, j=0, flag=1; for (i=0, j=strlen(cad)-1; i<strlen(cad)/2 && j>=strlen(cad)/2; i++, j--){ printf("\n %c %c", cad[i],cad[j]); if(cad[i]!=cad[j]){ flag=0; j=-1; i=strlen(cad)+1; } } return flag; } palindrome.c

#define MAX 50 declare function palindrome(cad as string) as integer dim cad as string input "Ingresa la cadena a ser evaluada como palindrome: ", cad print "la cadena mide"; len(cad); " y contiene '"; cad; "'"

Lizbeth Gallardo - Pedro Lara

UAM Azcapotzalco

Página 65

Notas de Programación Estructurada
resp=palindrome(cad) : print : print "La cadena "; if resp=0 then print "no es palindrome" else print "es palidrome" sleep function palindrome(cad as string) flag=1 : l=len(cad) for i=1 to l/2 print mid$(cad,i,1);mid$(cad,l-i+1,1) if mid$(cad,i,1) <> mid$(cad,l-i+1,1) then flag=0 : exit for next i return flag end function palindrome.bas

Ejercicio: construir un programa que reciba desde el teclado el nombre del usuario; el programa debe iterar n veces, donde n es el tamaño de la cadena que ingresó el usuario; El propósito del programa es mezclar o desordenar la cadena en cada iteración. El programa debe imprimir la cadena obtenida en cada iteración.
#include <stdio.h> #include <time.h> #include <stdlib.h> #include<string.h> #define MAX 50 void desordena(char nom[]); int main(void){ char nom[MAX]={'\0'}; srand(time(NULL)); printf("Cual es tu nombre? "); scanf("%s",nom); desordena(nom); return 0; } void desordena(char nom[]){ int i=0, j=0, esc=0; char aux='\0'; for(j=1; j<=strlen(nom); j++ ){ for (i=0; i<strlen(nom); i++){ esc=rand()%(strlen(nom)-i)+i; aux=nom[i]; nom[i]=nom[esc]; nom[esc]=aux; } printf("\n"); printf("Hola %s !",nom); } return; } desordena.c
randomize timer dim as string nom, aux input "Cual es tu nombre? ", nom for i=1 to len(nom) for j=1 to len(nom)-1 esc=int(rnd*(len(nom)-j))+i+1 aux=mid$(nom,j,1) : mid$(nom,j,1)= mid$(nom,esc,1) : mid$(nom,esc,1)=aux

Lizbeth Gallardo - Pedro Lara

UAM Azcapotzalco

Página 66

Notas de Programación Estructurada
next j print "Hola ";nom; "!" next i sleep desordena.bas

Lizbeth Gallardo - Pedro Lara

UAM Azcapotzalco

Página 67

Notas de Programación Estructurada
CAPÍTULO VIII ARCHIVOS

Las cosas se simplifican cuando separamos el programa de los datos con los que opera, si los datos se mantienen en archivos aparte y los problemas vuelven a ser cortos y simples de leer. Tenemos varios tipos de archivos, aquellos que usaremos para consulta, otros que usaremos para poner la información de una ejecución en el mismo, y también archivos ya existentes donde se agregarán los datos recién procesados.

Conceptos básicos
Un archivo es un conjunto de datos de distintos tipos: int, float, double, char, etc., que se guardan juntos, bajo un nombre común, en un dispositivo secundario, a saber: disco duro, memoria USB, etc. Por ejemplo „texto.txt‟ sería un archivo de datos.

Los nombres de los archivos son reconocidos por el sistema operativo a través de los comandos ls (unix) y dir (dos). Actualmente Unix y Windows (desde la versión 95) aceptan 255 caracteres para nombrar un archivo. El contenido de un archivo perdura hasta que una persona o programa lo modifica.

Funciones usuales para el manejo de archivos
Para manipular archivos, dentro de un programa escrito en lenguaje C, empleamos un conjunto de funciones, la cuales están contenidas en la biblioteca stdio.h Función
fopen() fclose() fputc() fgetc() fputs() fprintf() fscanf() feof() ferror() rewind() remove() fflush()

Descripción Abrir archivo Cerrar un archivo Escribir un carácter en el archivo Lee un carácter de un archivo Escribir una cadena en un archivo Imprimir a un archivo Leer sobre un archivo Devuelve cierto cuando llega al fin del archivo Devuelve vierto si se ha producido un error colocar el indicador de posición de un archivo al principio del mismo. eliminar un archivo vaciar el buffer que sirve para leer o escribir en el archivo. UAM Azcapotzalco Página 68

Lizbeth Gallardo - Pedro Lara

Notas de Programación Estructurada
En el lenguaje C es necesario indicar la acción que vamos a realizar sobre un archivo; a esto se le conoce como “modo de apertura de un archivo”. Modo de apertura r w Significado “read” “write” Descripción de la acción Abrir un archivo de texto para lectura. Abrir un archivo de texto para escribir en él Abrir un archivo para agregar texto en él abrir un archivo para lectura y escritura

a r+

“append” “read” and “write”

exit(valor_entero) es una función que termina de inmediato la ejecución de un programa yforma parte de la biblioteca stdlib.h. Se puede usar cualquier valor entero, pero por convención se emplea: 1 – para indicar que el programa terminará porque durante la ejecución del programa se incurrió en algún error, previsto por el programador. 0 – para indicar que el programa terminará sin que esto lo cause algún error. Ejercicio: construir un programa que permita escribir un conjunto de caracteres en un archivo llamado texto.txt. Los caracteres deberán ser ingresados desde el teclado por un usuario.
#include <stdio.h> int main(void){ char car; FILE *ap; printf("Escriba una cadena para ser guardada en un archivo"); printf("\n El fin de la cadena lo marca un <ENTER>\n"); ap=fopen("texto.txt","w"); if (ap!=NULL){ while ((car=getchar())!='\n'){ fputc(car,ap); } fclose(ap); } else printf("No se puede abrir el archivo"); return 0; } escribirArchivo.c dim cad as string print "Escriba una cadena para ser guardada en un archivo" print " El fin de la cadena lo marca un <ENTER>"

Lizbeth Gallardo - Pedro Lara

UAM Azcapotzalco

Página 69

Notas de Programación Estructurada
f=open("texto.txt" for output as #1) cad="x" if (f=0) then while cad <> "" line input, cad print #1, cad wend close #1 print "El archivo ha sido salvado!" else print "No se puede abrir el archivo" end if sleep escribirArchivo.bas

Ejercicio: construir un programa que permita leer el contenido de un archivo llamado texto.txt. El contenido del archivo deberá desplegarse en pantalla.
#include <stdio.h> int main(void){ char car; FILE *ap; if ((ap=fopen("prueba.txt","r"))!=NULL){ while (!feof(ap)){ car=fgetc(ap); putchar(car); } fclose (ap); } else printf("No se puede abrir el archivo"); printf("\n"); return 0; } leerArchivo.c dim cad as string f=open("texto.txt" for input as #1) if f = 0 then while not eof(1) line input #1, cad print cad wend close #1 : print : print print " ---- FIN DE ARCHIVO ---" else print "No se puede abrir el archivo" end if sleep leerArchivo.bas

Ejercicio: Construir un programa que lea un archivo de texto fuente y lo codifique. El criterio para codificarlo es sumar 2 al caracter ascii que lea del archivo fuente. Todos los caracteres codificados deberán guardarse en un nuevo archivo. Nota: el programa debe recibir desde el teclado, los nombres de los archivos (fuente y destino).

Lizbeth Gallardo - Pedro Lara

UAM Azcapotzalco

Página 70

Notas de Programación Estructurada
#include <stdio.h> #include <stdlib.h> int main(int argc, char *argv[3]) { char mytext[80], encrtext[80]; FILE *ap1, *ap2; int i=0, desplaza=2; if(argc!=3){ printf("el numero de parametros es erroneo"); exit(1); //Termina el programa } else if((ap1=fopen(argv[1],"r"))!=NULL && (ap2=fopen(argv[2],"w"))!=NULL){ while(!feof(ap1)){ fflush(stdin); i=0; fgets(mytext, 79, ap1); while (mytext[i]!='\0') { encrtext[i]=mytext[i]+desplaza; i++; } encrtext[i]='\0'; fputs(encrtext, ap2); } fclose(ap1); fclose(ap2); } else printf("No es posible abrir el archivo"); return 0; } codificaTexto.c dim as string myText, encrText, cad myText=command$(1) : encrText=command$(2) desplaza=2 if myText="" or encrText="" then print "el numero de parametros es erroneo" : end else f1=open(myText for input as #1) f2=open(encrText for output as #1) if f1=0 and f2<>2 then while not eof(1) line input #1, cad print #2, cad wend close #1 print "El archivo ha sido copiado!" else print "No se puede abrir el archivo" end if end if sleep decoficaTexto.bas

Ejercicio: Construir un programa que lea un archivo de texto codificado y lo decodifique. El criterio para decodificarlo es restar 2 al caracter ascii que lea del archivo que contiene texto codificado con el criterio de sumar 2 al caracter ascci. Todos los caracteres decodificados deberán guardarse en un nuevo archivo. Nota: el programa debe recibir desde el teclado, los nombres de los archivos (codificado y decodificado).
#include<stdio.h> #include<stdlib.h>

Lizbeth Gallardo - Pedro Lara

UAM Azcapotzalco

Página 71

Notas de Programación Estructurada
int main(int argc, char *argv[3]) { char mychar, yourchar; FILE *ap1, *ap2; int i=0, desplaza=-2; if(argc!=3){ printf("el numero de parametros es erroneo"); exit(1); //Termina el programa } else if((ap1=fopen(argv[1],"r"))!=NULL && (ap2=fopen(argv[2], "w"))!=NULL){ while(!feof(ap1)){ fscanf(ap1,"%c",&mychar); yourchar=mychar+desplaza; fprintf(ap2,"%c",yourchar); } fprintf(ap2,"\0"); fclose(ap1); fclose(ap2); } return 0; } decoficaTexto.c dim as string myText, encrText, cad myText=command$(1) : encrText=command$(2) desplaza=-2 if myText="" or encrText="" then print "el numero de parametros es erroneo" : end else f1=open(myText for input as #1) f2=open(encrText for output as #1) if f1=0 and f2<>2 then while not eof(1) line input #1, cad print #2, cad wend close #1 print "El archivo ha sido copiado!" else print "No se puede abrir el archivo" end if end if sleep decoficaTexto.bas

Construir un programa que simule una “bola 8 magica” que adivina el futuro del usuario quien realiza una pregunta. Este juguete, que es muy parecida a una bola de billar, se agita y en la parte de atrás, se puede leer una de 20 respuestas (la bola tiene un icosaedro sumergido en tinta negra con una respuesta en cada cara); la bola debe dar 10 respuestas afirmativas, 5 ambiguas y 5 negativas, como se muestra en el archivo magica8.txt En particular, el programa que vamos a construir debe contar con dos funciones aparte de la función “main”. Una de ellas debe encargarse de solicitar al usuario preguntas o la palabra fin que pone término al juego. La otra debe proporcionar una respuesta. Como entrada, el programa recibe una cadena desde el teclado del usuario; y como salida, debe imprimir en pantalla una respuesta tomada al azar de un conjunto de respuestas previamente definidas por el programador. Si el usuario introduce la palabra fin o FIN, debe terminar el juego.

Lizbeth Gallardo - Pedro Lara

UAM Azcapotzalco

Página 72

Notas de Programación Estructurada
Ejemplo de entrada: Me sacare la loteria? Ejemplo de salida: Sin lugar a dudas
// Programa que simula una bola 8 magica #include<stdio.h> #include<string.h> #include<stdlib.h> #include<time.h> void leeArchivo(char resp[][50]); void generaPreg(char preg[]); void generaResp(char resp[][50]); int main(void){ char preg[100]={ }, resp[20][50]; srand(time(NULL)); printf("\n\n Este programa es magico, respondera a tus preguntas \n"); leeArchivo(resp); do{ generaPreg(preg); if(strcmp(preg,"fin") && strcmp(preg,"FIN")) generaResp(resp); }while(strcmp(preg,"fin") && strcmp(preg,"FIN")); return 0; } void generaPreg(char preg[]){ fflush(stdin); printf("\n Haz tu pregunta o la palabra \"fin\" para terminar: \n"); gets(preg); return; } void leeArchivo(char resp[][50]){ int i=0; FILE *arch; arch=fopen("magica.txt", "r"); if(arch!=NULL){ while(!feof(arch)){ fflush(stdin); fgets(resp[i], 49, arch); i++; } return; } void generaResp(char resp[][50]){ int seleccion=0; seleccion=(rand()%20)+1; printf("%s", resp[seleccion]); return; } magica8.c

dim respuesta(20) as string, pregunta as string open "8 magica.txt" for input as #1 for i =1 to 20 input #1, respuesta(i) next i randomize timer : print "Bola 8 magica" input "Realiza una pregunta: ", pregunta while pregunta<>"" sel=int(20*rnd)+1

Lizbeth Gallardo - Pedro Lara

UAM Azcapotzalco

Página 73

Notas de Programación Estructurada
print respuesta(sel) input "Otra pregunta? (ENTER para salir): ", pregunta wend magica8.bas como lo veo... si Es seguro Decididamente si Es lo mas probable Positivamente Parece ser que si Sin lugar a dudas Si Si - definitivo Puedes confiar en eso Respuesta ambigua... intente de nuevo Preguntame despues Mejor no te digo ahorita No puedo predecirlo ahora Concentrate y vuelve a preguntar No cuentes con ello Mi respuesta es no Mis fuentes dicen que no No parece que pase Lo dudo mucho archivo: magica8.txt

Ejercicio: una papelería necesita contar con un programa que le permita obtener la lista de sus precios con el iva correspondiente. El usuario deberá proporcionar el nombre del archivo donde se encuentran los precios originales, en forma de lista; y a partir de este archivo, el programa debe calcular el nuevo precio con iva y colocarlo en el archivo que le indique el usuario.
#include<stdio.h> #include<stdlib.h> #define MAX 50 #define LON 15 void nombreArchivo(char[], char[]); int cargaDatos(float[]); float calculaTotal(float[],int); void guardaDatos(float[], float, int); int main(void){ float precios[MAX]={0.0}, total=0.0; int tam=0; tam = cargaDatos(precios); total = calculaTotal(precios, tam-1); guardaDatos(precios, total, tam-1); return(0); } void nombreArchivo(char tipo[], char nom[]){ printf("Cual es el nombre del archivo de %s: \n", tipo); gets(nom); return; }

Lizbeth Gallardo - Pedro Lara

UAM Azcapotzalco

Página 74

Notas de Programación Estructurada
int cargaDatos(float precios[]){ int n=0; char nomArch[LON]; char aux1[LON]="entrada"; FILE *ap; nombreArchivo(aux1,nomArch); ap=fopen(nomArch, "r"); if(ap!=NULL){ while(!feof(ap)){ fscanf(ap, "%f", &precios[n]); n++; } fclose(ap); return(n); } else{ printf("\n no puede abrir el archivo"); exit(1); } } float calculaTotal(float precios[],int tam){ float total=0.0; int i=0; for(i=0; i<tam; i++){ precios[i]*= 1.15; total+=precios[i]; } return(total); } preciosTienda.c
#define MAX 50 declare declare declare declare sub nombreArchivo(tipo as string, char as string) function cargaDatos(precios() as double) function calculaTotal(precios() as double, tam as integer) as double sub guardaDatos(precios() as double, total as double, tam as integer)

dim as double precios(MAX), total tam = cargaDatos(precios()) total = calculaTotal(precios(), tam-1) guardaDatos(precios(), total, tam-1) sub nombreArchivo(tipo as string, nom as string) print "Cual es el nombre del archivo de "; tipo input nom end sub function cargaDatos(precios() as double) dim as string nomArch, aux1 aux1="entrada" nombreArchivo(aux1,nomArch) dim cad as string f=open(nomArch for input as #1) if f = 0 then while not eof(1) input #1, precios(n)

Lizbeth Gallardo - Pedro Lara

UAM Azcapotzalco

Página 75

Notas de Programación Estructurada
n+=1 wend close #1 return n else print "No se puede abrir el archivo" end end if end function function calculaTotal(precios() as double, tam as integer) as double dim total as double for i=1 to tam precios(i)*= 1.15 total+=precios(i) next i return(total) end function sub guardaDatos(precios() as double, total as double, tam as integer) dim as string nomArch, aux1 aux1="salida" nombreArchivo(aux1,nomArch) f=open(nomArch for output as #1) if (f=0) then for i=1 to tam print #1, precios(i) next i print #1, "Suma total de los precios con iva: "; total close #1 else print "No puede abrir el archivo" end if end sub preciosTienda.bas

Lizbeth Gallardo - Pedro Lara

UAM Azcapotzalco

Página 76

Notas de Programación Estructurada
Bibliografía
Adamis, E. Fórmulas y programas usuales en BASIC, 1ra. ed. McGrawHill, 1985. Bronson, G.J., C++ para ingeniería y Ciencias, 2da ed. Internacional Thomson, 2000. Brookshear, J.G., Introducción a las ciencias de la computación, 4ta. ed., AddisonWesley, 1995. Kernighan, B.W., Ritchie, D. M. The C programming language, 2da ed. Prentice Hall, 2011. Kemeny, J. G., Kurtz, T. E. Back to BASIC. Addison Wesley, 1995. Levine, Guillermo, Computación y programación moderna, Addison-Wesley, 2001. Strouptrup, B., El lenguaje de programación C++. Edición especial, Pearson Education, 2002

Lizbeth Gallardo - Pedro Lara

UAM Azcapotzalco

Página 77

Sign up to vote on this title
UsefulNot useful