Programacion Estructurada v14

PEdro
Notas de
Programacin
Estructurada
Lizbeth Gallardo Lpez
Pedro Lara Velzquez
Departamento de Sistemas
Divisin de Ciencias Bsicas e Ingeniera
Universidad Autnoma Metropolitana Azcapotzalco
Julio de 2011
Notas de Programacin Estructurada

Lizbeth Gallardo - Pedro Lara UAM Azcapotzalco Pgina 1

ndice

Presentacin .. 2

1. Arquitectura de la Computadora.. 3
o Modelo actual de la computadora
o Software de base
2. Algoritmos .. 9
o Componentes principales de un algoritmo
o Programacin
o Programacin estructurada
o Diagramas de Flujo
3. Lenguaje C y FreeBasic ............. 14
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 seleccin .. 25
o Seleccin simple (if)
o Seleccin binaria (if-else)
o Seleccin encadenada (if - else if - else)
o Seleccin mltiple (case)
5. Funciones .... 35
o Conceptos bsicos
o Paso de parmetro por valor
o Paso de parmetro por referencia
6. Estructuras repetitivas . 43
o Durante (for)
o Mientras (while)
o Haz - mientras (do-while)
7. Tipos de datos estructurados .. 54
o Arreglos unidimensionales
o Arreglos bidimensionales
o Cadenas
8. Archivos . 68
o Conceptos bsicos
o Funciones usuales para el manejo de archivos

Referencias .......... 77


PRESENTACIN

Desde finales de 1953, cuando John Backus propuso el lenguaje FORTRAN como una
alternativa ms prctica a la programacin en lenguaje Ensamblador (muy cercano al
lenguaje mquina), se han desarrollado una infinidad de lenguajes de programacin, as
como dialectos de los mismos. Estos programas nos sirven para desarrollar algoritmos
de solucin para resolver problemas de programacin concretos.

A los algoritmos de solucin para un problema especfico 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 despus puede ser repetido por otras personas. As,
un algoritmo se propone una sola vez y despus puede ser traducido a varios lenguajes.

En la actualidad existen distintos paradigmas de programacin: imperativo, funcional,
orientado a objetos y lgico por mencionar solo algunos. La programacin imperativa
estructurada la define Edsger Dijkstra como una filosofa para la implementacin de
algoritmos a travs de un conjunto finito de estructuras bien organizadas. Dicho en
otras palabras, la programacin estructurada parte un gran problema en pedazos ms
pequeos, de tal forma que el programa final es el resultado de resolver cada
subproblema de una manera ms sencilla. En estos apuntes se utilizan dos lenguajes de
programacin estructurada: C y FreeBasic.

Dentro de los lenguajes imperativos estructurados, C es el lenguaje ms 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 especficos, por ejemplo: integracin y derivacin de
funciones matemticas, 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 mquina, 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 clculo numrico, el cual es comparable con la rapidez
proporcionada por compiladores C. A diferencia de C, FreeBasic permite hacer grficos
bidimensionales con notable facilidad.

Estas notas se dividen de la siguiente forma: los captulos 1 y 2 presentan una
introduccin a la arquitectura actual de una computadora y al concepto de algoritmos;
el captulo 3 hace una breve presentacin de los lenguajes C y FreeBasic; en el captulo
4 se presentan las estructuras de seleccin; el captulo 5 presenta el concepto de funcin,
el cual es indispensable en el paradigma de programacin estructurada; el captulo 6
presenta las estructuras iterativas; el captulo 7 presenta el concepto de datos
estructurados; finalmente, el captulo 8 presenta el manejo de archivos de texto.


CAPTULO I

ARQUITECTURA DE LA COMPUTADORA

Una computadora est formada por:
Hardware: Parte fsica o tangible: CPU, monitor, DD, etc.
Software: Sistema Operativo, programas, algoritmos, etc.

Modelo actual de la Computadora

La arquitectura de hardware de una computadora que prevalece hasta nuestros das 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 aritmtico-lgicas con los datos, la forman: la
Unidad Aritmtico Lgica, la Unidad de Control y la Unidad de Memoria.
Unidad aritmtico-lgica (ALU)
Unidad de
control
ALU
Registros
Contador de programa
a) UNIDAD CENTRAL DE
PROCESAMIENTO

b) MEMORIA
c) DISPOSITIVOS DE ENTRADA / SALIDA



Encargada de realizar operaciones: aritmticas y lgicas. Dentro de las operaciones
aritmticas, 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 lgicas son: NOT (unaria), AND, OR, XOR. A excepcin de la
operacin de negacin, el resto son binarias. Ejemplo:

p= llueve afuera; q= hay sol

Diagrama Operacin lgica Resultado

NOT (p) No llueve afuera
NOT (q) No hay sol

p AND q llueve afuera y hay sol

p OR q Llueve afuera o hay sol

p XOR q
Llueve afuera o hay sol,
pero solo uno de los dos

Unidad de Control

Es la responsable de seleccionar las operaciones aritmtico-lgicas. Esto se logra a
partir de varias lneas de control que pueden estar activas o inactivas. Por ejemplo para
una ALU simple con 10 operaciones diferentes se necesitan cuatro lneas de control, las
cuales pueden definir 16 (2
4
) situaciones diferentes, diez de las cuales pueden usarse
para las operaciones aritmtico-lgicas y el resto para otros propsitos. Ejemplo:

0000 Neutro (no hay operacin por hacer)
0001 Operacin suma
0010 Operacin resta
0011 Operacin de multiplicacin. etc.

Registros
1. Registros de entrada. En el pasado las computadoras solo tenan un registro de
entrada para alojar, por turnos, uno de los datos de entrada (el otro dato de
entrada vena directamente de la memoria). Actualmente las computadoras
utilizan docenas de registros para acelerar las operaciones, las cuales son cada
vez ms complejas y requieren de varios registros para mantener los resultados
intermedios.

2. Registros de instruccin (I). El CPU es el responsable de buscar las
instrucciones en la memoria, una a una; luego debe almacenarlas en el registro
de instruccin, interpretarlas y ejecutarlas.

3. Contador de programa (PC): Hace un seguimiento de la instruccin que se
ejecuta actualmente; concluida la ejecucin, el contador se incrementa para
apuntar a la direccin (de memoria) de la siguiente instruccin.



b) Memoria

Es una coleccin de localidades o celdas de almacenamiento. Cada localidad tiene un
identificador nico conocido como direccin . Los datos se transfieren hacia y desde
la memoria en grupos de bits llamados palabras.

Direccin 0 00000000
.
.
.
Direccin 255 111111111

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 mquina
est encendida. La informacin es automticamente borrada si deja de
alimentarse de energa elctrica a la computadora. Por esta caracterstica, a la
RAM tambin se le llama memoria voltil.

Memoria ROM (Read Only Memory). El contenido de esta memoria es
grabada por el fabricante. De la informacin contenida en esta memoria
podemos citar: datos del fabricante, modelo de la computadora, tipo de
procesador, capacidad de almacenamiento, la fecha, etc. Tambin 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 mnima de almacenamiento en una computadora; ste fsicamente es
un condensador: si est cargado, entonces representa 1 (verdadero); si no est cargado,
entonces representa 0 (falso).

A una celda de memoria tambin se le conoce con el nombre de palabra. Una palabra
puede contener desde un patrn de 8 bits (ej. 10100100) hasta 64 bits (computadoras
recientes).

- - - -
+ + +

1 0


Aqu representamos a una memoria con cinco celdas; donde cada
celda est formada por un patrn de 8 bits.

Otra representacin 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.

La cantidad de celdas que contienen las memorias de las mquinas es variable: de
cientos (un horno de microondas) a miles de millones (computadoras actuales). El
tamao de la memoria principal suele medirse en trminos de unidades de 1048,576
celdas (este valor corresponde a una potencia de 2, as es ms natural como unidad de
medida dentro de la computadora, que un milln exacto).

2
10
1,024 bytes 1 Kilobyte (kb)
2
20
1'048,576 bytes 1 Megabyte (Mb)
2
30
1,024 Mb 1 Gigabyte (Gb)

Para identificar cada celda de la memoria principal se le asigna un identificador nico,
llamado direccin, el cual es un valor numrico consecutivo (ver figuras).

Por ejemplo una computadora de tamao de palabra igual a 8 bits y con 4 Mb tiene
4*1'048,576= 4'192,304 celdas, cada una con un tamao de un byte. Todas con su
direccin 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)

10111010
Contenido
0000000000000001
10111010
celda 0000000000000000
celda 0000000000000010
.
.
celda 1111111111111111
Contenido
Direccin


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 volmenes de
informacin. Entrada: Esta informacin 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 aplicacin.

En nuestro curso, nosotros construiremos programas de aplicacin. Un programa de
aplicacin que ser escrito en un lenguaje de alto nivel (C); luego ser traducido por un
compilador a lenguaje mquina (lenguaje binario 0-apagado y 1-encendido); y
finalmente, la CPU los ejecutar.
Programas
E/S
Sistema de
Archivos
Bibliotecas Manejo
de memoria
Despachador
de alto nivel
(scheduler)
Manejo de
Dispositivos
Programa de aplicacin
Compiladores Ensambladores Macro-procesadores
enlazadores Cargadores Editores de texto Depuradores
Sistema Operativo
Hardware de la computadora


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
cdigo mquina (lenguaje binario).

Un compilador realiza las siguientes operaciones: anlisis lxico (lexical analysis), pre-
procesamiento (preprocessing), anlisis sintctico (parsing), anlisis semntico
(semantic analysis), generacin de cdigo (code generation) y optimizacin de cdigo
(code optimization).

Para obtener un programa ejecutable intervienen dos programas (o software de base)
ms, a saber: el ligador (linker) y el cargador (loader).

Un enlazador es un programa que toma los archivos: 1) del cdigo objeto generados en
el proceso de compilacin y 2) el cdigo objeto de las funciones empleadas por el
programador en su programa de aplicacin (las cuales forman parte de una biblioteca
proporcionada por el lenguaje de alto nivel); finalmente, enlaza ambos tipos de cdigos
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
ejecucin.



CAPITULO II

ALGORITMOS

Un algoritmo es un conjunto de pasos precisos y ordenados, que nos permiten alcanzar
un resultado, o bien resolver un problema.

Caractersticas de un algoritmo:

Precisin. Los pasos a seguir e el algoritmo deben evitar, en la medida de lo
posible, la ambigedad.
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

Ejemplo de un algoritmo:

darse de alta en el aula virtual

1.- Acceder a la direccin de aula virtual.
2.- Acceder a CBI.
3.- Seleccionar la UEA Introduccin a la Programacin.
4.- Leer instrucciones para el registro.
5.- Realizar el registro.
5.1. Escribir matrcula.
5.2. Escribir fecha de nacimiento.
5.3. Escribir datos generales.
6.- Acceder a aula virtual.
7.- Escribir contrasea.
8.- Matricularse.

Datos
de
entrada

Procesamiento de
datos

Impresin de
resultados


Las etapas para resolver un problema proponiendo un algoritmo son: 1) anlisis del
problema, 2) construccin de un algoritmo y 3) verificacin del algoritmo.

El Anlisis del problema nos permite determinar su naturaleza; identificar motivos,
razones o causas de un problema especfico; dividir el problema en subproblemas.
Luego, hacemos un proceso de sntesis donde elaboramos escenarios, diseamos una
solucin para cada subproblema, para luego integrarlas y as solucionar el problema
inicial; este proceso tambin incluye mejorar esta solucin. La verificacin del
algoritmo consiste en ejecutar (o realizar) cada paso sealado en el algoritmo, con datos
de entrada para los cuales conocemos los resultados.

Programacin

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

La codificacin consiste en traducir el algoritmo a un lenguaje de programacin, 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 especfico. El
programa se escribe en un lenguaje de programacin, a partir de un diagrama de flujo o
de un algoritmo expresado en pseudocdigo.

Un lenguaje de programacin est constituido por un conjunto de reglas sintcticas y
semnticas. Las reglas sintcticas especifican la correcta formacin de palabras y
oraciones en un lenguaje. Las reglas semnticas especifican el sentido o significado de
un smbolo, una palabra o una oracin.
Planteamiento de un problema
Comprensin del problema
Solucin del problema
Expresar los pasos a seguir para obtener la
solucin (algoritmo), empleando un lenguaje
claro, estricto y universal: pseudocdigo
PROGRAMAR
CODIFICACIN:
Traducir el algoritmo a un lenguaje de
programacin adecuado (lenguaje de
alto nivel)
PROCESO MENTAL


Programacin Estructurada

La programacin estructurada es una filosofa para la implementacin de algoritmos a
travs 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 bsicas para
construir cualquier programa.

1. Una estructura de proceso.

2. Una estructura de decisin binaria.

3. Una estructura de repeticin.

Diagramas de Flujo

Un diagrama de flujo es la representacin grfica de un algoritmo; la construccin
correcta de ste es muy importante porque nos permite escribir un programa en
cualquier lenguaje de programacin estructurada. A continuacin presentamos los
principales smbolos para representar a un algoritmo.

Smbolo Descripcin

Se utiliza para marcar el inicio y fin de un programa.

V
F


Se utiliza para introducir datos de entrada. Expresa lectura.

Representa un proceso. En su interior se colocan asignaciones,
operaciones aritmticas, etc.

Se utiliza para representar una decisin y dependiendo del
resultado, el flujo del diagrama sigue por uno de los caminos
alternativos.

Se utiliza para representar una decisin mltiple 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 impresin de resultados. Expresa
escritura.

Expresan la direccin del flujo del diagrama.

Expresa conexin dentro de una misma pgina.

Expresa conexin entre diferentes pginas.

Se utiliza para expresar un mdulo 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 lneas de direccin deben ser rectas
3. Las lneas de direccin deben estar conectadas a un smbolo que exprese lectura,
proceso, decisin, escritura, conexin o fin del programa.
4. Un diagrama de flujo debe construirse de arriba haca abajo y de izquierda a
derecha.
5. La notacin utilizada en el diagrama de flujo debe ser independiente del
lenguaje de programacin.
6. Al realizar una tarea compleja, es conveniente poner comentarios que ayuden a
entenderla.
7. Si la construccin de un diagrama de flujo requiere ms de una hoja, debemos
emplear los conectores adecuados y enumerar las pginas.
si
no
O
P


2. No deben de ser inclinadas
2. No se deben cruzar
3. Conectadas a un smbolo
8. Invlido 8. Vlido
8. No es posible que a un smbolo determinado llegue ms de una lnea de
direccin.



CAPTULO III

CONCEPTOS BSICOS DE Lenguaje C y FreeBasic

Lenguaje C

C es un lenguaje de programacin 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)
economa en su forma de expresar operaciones y 4) un conjunto de operadores.
Originalmente C fue diseado para el sistema operativo UNIX; sin embargo, el lenguaje
C no esta ligado a ningn 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 Computacin, 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 ms inclinada, pero como se
mencion anteriormente, esto permite hacer un uso ms 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: bsicos y estructurados

a) Bsicos:
Constituye un solo valor que puede ser: 1) entero, 2) real, 3) entero largo, 4) real de
doble precisin o 5) carcter.

Tipo de
Dato
Bits Descripcin Rango
int 16 Entero -32,768 a 32,767
long 32 Entero largo -2147,483,648 a 2147,483,647
float 16 Real -3.4x10
-38
a 3.4x10
38
-1

double 64
Real de doble
precisin
-1.7x10
-308
a 1.7x10
308
-1

char 8 Caracter 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 bsico.
Cadenas: Es un vector que guarda valores de tipo caracter.


Registros: Hacen referencia a un grupo de valores, donde cada uno de ellos
puede ser de un tipo bsico; 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 contendrn datos simples o estructurados. Un identificador se forma por medio
de letras, dgitos y el carcter subrayado (_).

Un identificador siempre comienza con una letra. El lenguaje, C distingue entre
minsculas y maysculas, Ejemplo: Aux y aux son identificadores diferentes. La
longitud mxima ms comn 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 guardarn un valor temporalmente; es decir que el valor
cambiar durante el tiempo de ejecucin 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, asignacin. 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 guardarn un valor que no cambia durante el tiempo de
ejecucin del programa.

#define PI 3.14169
const float PI=3.14169;

Operadores

Distinguiremos tres tipos de operadores: 1) aritmticos, 2) relacionales y 3) lgicas.
Tambin analizaremos los operadores simplificados, operadores incremento/decremento
y el operador coma (,).



Operadores aritmticos
Suponga que declaramos dos variables una de tipo real y otra de tipo entera:

float v;
int x;

Smbolo Descripcin Ejemplos Resultados
+ Suma
x=4.5+3;
v=4.5+3;
x=7
v=7.5
- Resta
x=4.5 - 3;
v=4.5 - 3;
x=1
v=1.5
* multiplicacin
x=4.5 * 3;
v=4.5*3;
v=4*3;
x=12
v=13.5
v=12.0
/ divisin
x= 4 / 3;
x=4.0 / 3.0;
v=4 / 3;
v=4.0 / 3;
v=(float) 4 / 3;
v=((float) 5+3) / 6;
x=1
x=1
v=1.0
v=1.33
v=1.33
v=1.33
%
mdulo (residuo de
una divisin)
x=15%2;
v=(15%2)/2;
v=((float)(15%2))/2;
x=1
v=0.0
v=0.5

Al evaluar expresiones aritmticas debemos respetar la jerarqua de los operadores y
aplicarlos de izquierda a derecha.

Mayor
prioridad
*, /, %
Menor
prioridad
+, -

Operadores aritmticos simplificados. Nos permiten realizar la misma operacin
utilizando una notacipon ms compacta.

Operador Operacin larga
Operacin
simplificada
+= x=x+5 X+=5
-= y=y-2 y-=2
*= x=x*y x*=y
/= x=x/y x/=y
%= x=x%y x%=y


Operadores de incremento y decremento. Se pueden utilizar antes o despus de la
variable, pero los resultados son diferentes. Suponga que declaramos las variables x y y
como enteras:

int x,y;
x=7;
Operacin Resultados
y=x++
y=7
x=8
y=++x
y=8
x=8
y=x--
y=7
x=6
y=--x
y=6
x=6

Expresiones lgicas o booleanas. Estn formadas por nmeros, constantes, variables y
operadores lgicos y relacionales. El valor que pueden tomar estas expresiones al ser
evaluadas, es 1 (verdaderas) 0 (falso). Las expresiones lgicas se utilizan
frecuentemente en estructuras selectivas y en estructuras repetitivas.

Operadores relacionales.

Se utilizan para comparar 2 operando nmeros, caracteres, cadenas, constantes o
variables.

Operador
relacional
Descripcin Ejemplo Resultado
== igual a h==p 0 (F)
!= diferente de h!=p 1 (V)
< menor que 7<5 0 (F)
> mayor que 22>11 1 (V)
<= Menor o igual que 15<=2 0 (F)
>= Mayor o igual que 35>=20 1 (V)

Operadores lgicos. Permiten formular condiciones complejas a partir de condiciones
simples.

Operadores
lgicos
Diagrama de Venn asociado Operador
!

NOT


&&

AND
||

OR

P Q !P !Q P||Q P&&Q
1 1 0 0 1 1
1 0 0 1 1 0
0 1 1 0 1 0
0 0 1 1 0 0

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 evalan de izquierda a derecha, pero los operadores se aplican
segn su prioridad.

Prioridad
(+) ( )

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


FreeBasic

FreeBasic es la versin 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 programacin
que se compare en velocidad al lenguaje C que permitiera: el uso de grficos, la
programacin orientada a objetos y que fuera un lenguaje fcil de aprender. Una ventaja
que ofrece FreeBasic es que se puede utilizar las bibliotecas de C sin ninguna
modificacin. 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, Fsica,
Energa, Ambiental, Diseo de la comunicacin grfica etc., excepto, las Ingenieras en
Computacin y Electrnica, 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 algn
otro lenguaje, por ejemplo Visual Basic, el cual genera interfaces grficas. 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) Bsicos: Son muy similares a los usados en C, solo en lugar de tipo caracter, se
tiene el tipo cadena de caracteres:

Tipo de
Dato
Bits Descripcin Rango
integer 32 Entero largo -2147,483,648 a 2147,483,647
uinteger 32 Entero positivo 0 a 4294,967,295
single 32 Real -3.4x10
-38
a 3.4x10
38
-1

double 64
Real de doble
precisin
-1.7x10
-308
a 1.7x10
308
-1

string -
Cadena de
caracteres
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 bsico.
o Arreglos (vectores y matrices): Todos los valores del arreglo son de un solo
tipo bsico. Se declara una cadena con la instruccin dim
o Registros: Hacen referencia a un grupo de valores, donde cada uno de ellos
puede ser de un tipo bsico; 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 contendrn datos simples o estructurados. Un identificador se forma por medio
de letras, dgitos y el carcter subrayado (_).


Un identificador siempre comienza con una letra y se forma por medio de letras, dgitos
y el carcter subrayado (_). FreeBasic no distingue entre minsculas y maysculas,
Ejemplo: Aux y aux es el mismo identificador, y el lmite 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 instruccin 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 precisin 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 ejecucin 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 aritmticos, relacionales y lgicos
en FreeBasic con exactamente las mismas caractersticas, con las siguientes diferencias
en sintaxis nicamente:

Operador En C En FreeBasic
igualdad == =
desigualdad != <>
modulo entero % mod
lgico AND && and
lgico OR || or
lgico NOT ! not

Primer programa: Hola Mundo!

Funcin main(). El lenguaje de programacin C opera a travs de funciones. Una
funcin es un pedazo de cdigo que realiza una tarea especfica dentro de un
programa. En el Captulo 5 se habla de las funciones a detalle. Cuando ejecutamos un


C
u
e
r
p
o

d
e

l
a

f
u
n
c
i
n

programa, el sistema operativo se comunica con una funcin principal llama main(),
la cual devuelve, al sistema operativo, un valor de 0 indicando que la ejecucin del
programa se realiz con xito; y devuelve un valor de 1 indicando que el programa no
termin su ejecucin correctamente.

int main (void)

{

Declaracin_de_variables
instruccin_1;
Instruccin_2;
return 0;

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

printf (Hola mundo!); //Imprimir en pantalla Hola mundo!
return 0; //Valor que devuelve la funcin al sistema operativo
} //Fin de la funcin 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 funcin o
subrutina, es parte de la funcin principal, por esta razn no requiere definirla.

Entrada y Salida de Datos

Entrada con formato: La lectura desde el teclado se realiza por medio de la funcin
scanf (cdigo de formato, direccin)

El cdigo de formato designar el tipo de dato que se recibir desde el teclado, el cual
se asignar a la direccin de memoria de una variable determinada.

Cdigo de
formato
Descripcin
%u Enteros sin signo de 16 bits (unsigned int)
%d %i Enteros de 16 bits (int)
Tipo de valor que devuelve la funcin.
Nombre (SI N ESPACI OS)
Lista de argumentos que recibe la funcin.


%ld Enteros de 32 bits (long)
%f Reales de 32 bits (float)
%lf Reales de 64 bits (double)
%e Formato exponencial
%g Real o exponencial segn el tamao del nmero
%c Caracter de 8 bits
%s
Cadena de caracteres que termina con el carcter nulo \0
(null)
Es importante destacar que se puede controlar la cantidad de dgitos a imprimir en la
pantalla, por ejemplo

% -6d
Escribe un entero con seis dgitos, con justificacin a la
izquierda
% 4.2f
Escribe un real con 4 dgitos, dos de ellos sern utilizados para
los decimales, con justificacin a la derecha.

En FreeBasic para la entrada de datos se utiliza la funcin 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 especfico,
empleamos la funcin printf (cadena de caracteres, caracter de control y cdigo
de formato, variable);

Observe que printf puede incluir una cadena de caracteres para informar algo al
usuario; luego, puede incluir un formato de impresin para los datos (tabulador, saltar
una lnea), empleando los caracteres de control; adems puede incluir uno o varios
cdigos de formato para indicar el tipo de dato que se va a imprimir; finalmente, incluye
la o las variables que contienen los datos.

Carcter
de control
Descripcin
\n Saltar a una nueva lnea
\t Tabulador horizontal
\v Tabulador vertical
\f Avanzar una pgina
\a Sonido de alerta
\ Imprimir apostrofe
\ Imprimir comillas
\\ Imprimir diagonal inversa

En FreeBasic, para dar salida formateada de nmeros se escribe indicando las cifras
significativas con el smbolo #

print using "Decimales: ###.### - Enteros: ##"; 1/3,2.4
sleep

Ejercicio 1: Conversin Fahrenheit a Centgrados


Escribir un algoritmo que transforme las temperaturas de grados Fahrenheit a grados
centgrados con 5 cifras decimales. La ecuacin de conversin es:

C = (F-32)*5/9
Versin 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);

Versin 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 tendrn una versin
en C seguida una versin en FreeBassic.

Programa 2: El TOEFL (Test of English as a Foreign Language, Prueba de nivel de
Ingls como lengua extranjera) es una prueba que se pide a todos los estudiantes de
intercambio, o aquellos que realizarn estudios de posgrado en pases de habla inglesa y
otros pases (algunas universidades de Alemania y Rusia, por ejemplo). Este examen
consiste en 3 secciones: 50 preguntas de opcin mltiple sobre comprensin de palabra
hablada (listening comprehension), 40 preguntas sobre la habilidad para escribir
correctamente (grammar) y 50 preguntas sobre comprensin de lectura (reading
comprehension). Del nmero total de respuestas correctas en cada seccin, se utiliza la
siguiente frmula para calcular el nmero de puntos obtenidos.
Asigna el valor del teclado en la
localidad de memoria asignada a
fahr
Caracteres
de formato


Puntos TOEFL = 10*(65+LC+G+RC)/3

Hacer un programa que haga este clculo 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



CAPTULO IV

ESTRUCTURAS DE SELECCIN

Estas estructuras se utilizan cuando en la solucin de un problema, debemos tomar una
decisin, la cual determinar el flujo que seguir el programa que estamos
construyendo. La toma de una decisin se basa en la evaluacin de una o ms
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 mltiple (switch)

Estructura selectiva simple (if)

En tiempo de ejecucin, al llegar a este punto del programa se evala la condicin; si es
verdadera entonces se ejecuta un bloque de instrucciones especfico; pero si la
condicin es falsa entonces este bloque es ignorado y se contina con el flujo normal
del programa.

condicion
bloque_V
V
F

if(condicion){
bloque_V;
}
:

donde:

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

Ejercicio: Descuento en dulces para los nios menores de 12 aos
En la tienda de Don Pascual hay una promocin que consiste en otorgar el 20% de
descuento solo para los nios menores de 12 aos, cuya compra sea mayor o igual a
100. Realice un programa para que de manera automtica, Don Pascual no tenga que
utilizar su calculadora cada que atienda a un nio con esas caractersticas.

#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);


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 decisin solo se ejecutar
uno de ellos, dependiendo del valor lgico que resulte al evaluar la condicin.

condicion
bloque_V
V
F
bloque_F

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 lgico (v-verdadero f-
falso).
bloque_V denota un conjunto de instrucciones
que se ejecuta nicamente cuando el resultado de la
condicin es verdadera
bloque_F denota un conjunto de instrucciones
que se ejecuta nicamente cuando la condicin es
falsa

Ejercicio: Races de un polinomio de segundo grado.
Hacer un algoritmo que encuentre las races de un polinomio de segundo grado. El
algoritmo debe proporcionar las races imaginarias, si ese fuera el caso.

x=((-b(b2-4ac))/(2a))


#include <stdio.h>
#include <math.h>

int main(void){
float a, b, c, det, aux;
printf("Dame los 3 coeficientes de la ecuacin 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 trminos generales, una estructura selectiva puede contener a otras estructuras, por
ejemplo: una estructura de proceso, una estructura de repeticin e incluso una nueva
estructura selectiva. En particular, cuando una condicin que es verdadera nos lleva a
evaluar una nueva condicin, decimos que las estructuras selectivas estn 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 tambin, se debe tener cuidado
de cerrarlas en el lugar adecuado.



condicion1
bloque1_F
V F
condicion2
bloque2_F
F
condicion3
bloque3_V
V
V
bloque3_F
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 nmeros, 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 sealar que para simular
la tirada de la computadora, en el programa deber seleccionarse uno de los tres valores
de manera aleatoria, empleando la funcin que genere un nmero aleatorio (random en
ingls) del lenguaje de programacin 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 Gan
3-Tijera Ganaste Ganaste Empate

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


#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 Piedra - Empatamos!"
if num = 2 then print "Yo escog Papel - Gane!"
if num = 3 then print "Yo escog Tijeras - Ganaste!"
end if
if opc = 2 then
if num = 1 then print "Yo escog Piedra - Ganaste!"
if num = 2 then print "Yo escog Papel - Empatamos!"
if num = 3 then print "Yo escog Tijeras - Gane!"
end if
if opc = 3 then
if num = 1 then print "Yo escog Piedra - Gan!"
if num = 2 then print "Yo escog Papel - Ganaste!"
if num = 3 then print "Yo escog Tijeras - Empatamos!"


end if
sleep

piedra-papel-tijera.bas

Estructura selectiva encadenada (if - else if - else)

Cuando una condicin que es falsa nos lleva a evaluar una nueva condicin, decimos
que las estructuras selectivas estn encadenadas. Cada condicin se evala 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 ms sencillo manipularlas durante la solucin de un problema.

condicion1
bloque1_V
V F
condicion2
bloque2_V
F
condicion3
bloque3_V
V
V
bloque3_F
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, tambin 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 accin que los jugadores deben realizar. La tabla de abajo
determina el valor y la accin asociada.


Salida:
Todos ponen
Valor Accin
1 Pon uno
2 Pon dos
3 Toma uno
4 Toma dos
5 Todos toman
6 Todos ponen
7 Pierdes todo

#include<stdio.h>
#include<stdlib.h>
#include<time.h>

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"
print "Toma uno"
print "Toma dos"
print "Toma Todo"
print "Todos Ponen"
else
print "Pierdes todo"
endif
sleep

pirinola.bas


Ejercicio: construya un algoritmo que calcule el resultado de la siguiente funcin.

#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 mltiple (switch select)

En algunos problemas que involucran tomar una decisin entre mltiples opciones conviene
emplear la estructura switch, en lugar de emplear estructuras condicionales encadenada. Esta
estructura proporciona un cdigo ms claro para quienes lo leen. Un uso comn de la estructura
selectiva mltiple es la construccin de un men de opciones para el usuario del programa.

3*y+36 si 0< y 11
y
2
-10 si 11< y 33
y
3
+ y
2
-1 si 33 < y 64
0 en otro caso

x=


selector
bloque1
case 1
bloque2 bloque3 bloqueD
case 2 case 3 default

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 opcin particular.
selector: solo puede tomar valores de tipo enteros o de tipo carcter
opcionN: denota un nmero entero un carcter, 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 categora y el costo por una hora extra de trabajo, calcular el sueldo
total de un empleado en base a la siguiente tabla:

Categora Precio por hora extra
1 30
2 38
3 50
4 70

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



#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



CAPTULO V

FUNCIONES

Para resolver un problema de gran tamao es conveniente descomponerlo en
subproblemas, de tal manera que cada uno de ellos pueda ser resuelto de una manera
ms sencilla. El lenguaje C emplea el trmino funcin para denotar el cdigo 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 asignacin de responsabilidades
El cdigo de la funcin se escribe una sola vez y se utiliza tantas veces como sea
necesario.
Facilita el mantenimiento de los programas.

Conceptos bsicos

Formalmente: Sea L(p) la longitud de un programa cualquiera y sean l(p
1
) y l(p
2
) 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(p
1
) + l(p
2
); donde
p designa al programa completo y p
i
denota los subprogramas (cdigos) que conforman
a p.

Sean adems E(p), e(p
1
) y e(p
2
) los esfuerzos necesarios para obtener L(p), l(p
1
) y l(p
2
)
respectivamente; en general se tendr que: E(p) >e(p
1
) + e(p
2
)

Principios de diseo de una funcin: 1) Las partes altamente relacionadas, deben
pertenecer a la misma funcin; y 2) las partes no relacionadas deben residir en otras
funciones.

Existen algunas reglas bsicas para definir y emplear las funciones en el lenguaje C: 1)
declarar la funcin (tambin llamado prototipo de la funcin), 2) Definicin de la
funcin, y 3) llamado de una funcin.

1) Para que el compilador reconozca una funcin 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 funcin al concluir su ejecucin,
por elemplo: int, float, char

Lista_parametros corresponde al conjunto de valores que recibir de la funcin
que la llam. Los valores estn contenidos en variables, por lo tanto debern
recibirse estos valores en variables locales (propias de la funcin receptora)



Nota: una funcin no necesariamente devuelve un valor y no necesariamente
recibe parmetros, en este caso se indica con la palabra reservada void

NOTA: Si no se escribe el prototipo de una funcin, entonces su definicin debe
presentarse antes de la funcin principal.

2) Definir una funcin significa especificar el conjunto de instrucciones que
realizarn 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 funcin para
realizar su tarea.

Bloque de instrucciones que determinan el comportamiento de la funcin

return marca el fin de la funcin y devuelve, cuando as se requiera, un resultado
cuyo tipo corresponde al definido en el prototipo de la funcin

Nota: una funcin no necesariamente devuelve un valor y no necesariamente
recibe parmetros, en este caso se indica con la palabra reservada void

3) El llamado a una funcin se realiza desde la funcin principal o desde cualquier
otra funcin. Durante la ejecucin del programa, el llamado a una funcin
implica un salto hacia ella para ejecutar su conjunto de instrucciones; al
terminar se devuelve el control de la ejecucin a la funcin que la llam; en este
caso a la funcin main(). Al hacer el llamado debe especificarse: 1) el nombre
de la funcin; y 2) los valores que va a requerir para realizar su tarea, los
valores contenidos en variables se escriben dentro del parntesis, siguiendo el
orden y respetando el tipo de dato declarado.

int main(void){
:
nombre_funcion(lista_de_valores)
:
return 0;
}

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



#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 nmeros 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


a=leeValor(): b=leeValor(): c=leeValor()
max = encuentraMax(a,b,c)
imprime(max)
sleep
maxNum.bas

Paso de parmetros por valor

La comunicacin entre las funciones se lleva a cabo mediante el paso de parmetros, el
cual se puede hacer de dos formas; por valor y por referencia se describir primero el
paso de parmetros por valor.

En el paso de parmetros por valor, la funcin receptora recibe parmetros que son
copia de los valores contenidos en las variables originales (propias de la funcin que
hace el llamado); por lo tanto, si una variable local (propia de la funcin receptora)
sufre una alteracin 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 cdigo,
empleando una funcin 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");


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 parmetros por referencia

Aqu los parmetros no son copias de los valores, sino las direcciones de las variables
originales; por lo tanto, si un parmetro sufre una alteracin en la funcin que lo recibe, la
variable original tambin se ve afectada.
En el lenguaje C, el paso de parmetros por referencia se realiza mediante el concepto de
apuntador. Un apuntador es una direccin de memoria (por ejemplo 00X00X101010). Dado
que debemos manipular una direccin de memoria, se vuelve necesario poder declarar variables
que puedan guardar direcciones; las cuales no corresponden a ninguno de los tipos de datos
bsicos vistos hasta ahora (int, float, char, etc.). Por lo tanto, emplearemos una notacin
especial que nos permita denotar una variable de tipo apuntador, a saber los operadores de:
direccin (&), declaracin de variable tipo apuntador (*) e indireccin (*). En efecto el operador
* tiene un doble propsito.


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 direccin 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 ejecucin, el manejo de la memoria sera como se muestra en la siguiente figura:

Ejemplo:

Escribir un programa que realice el intercambia de valores entre tres variables empleando paso
de parmetros 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



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 funcin denominada convertir que reciba como parmetro,
por valor, la cantidad de segundos; y los parmetros, por referencia, hora, min. La funcin 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



#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



CAPTULO VI

ESTRUCTURAS REPETITIVAS

En la solucin algunos problemas es comn 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 condicin que detenga la ejecucin del ciclo
(suele llamarse condicin de paro). En cada iteracin esta condicin de paro es evaluada para
decidir si el ciclo contina si debe detenerse.

Estructura repetitva Durante (for)
Generalmente, la estructura for se utiliza en soluciones donde se conoce el nmero de veces que
deber repetirse el ciclo. Por lo tanto, se establece un contador inicial; este contado se va
incrementando decrementando en cada iteracin, hasta alcanzar un valor mximo mnimo;
una vez alcanzado este valor, el ciclo termina y se contina con el flujo normal del programa.

exp1, exp2, exp3
bloque_V
F
V

for (exp1, exp2, exp3){
bloque_V;
}

donde:

exp1: establece un valor inicial a un contador.
exp2: correspondiente a la condicin de paro donde se determina
el valor mximo o mnimo que podr alcanzar el contador.
exp3: corresponde al incremento decremento para el contador.
bloque_V: conjunto de instrucciones que se repetir hasta que la
condicin sea falsa. Cuando la condicin es falsa.

Ejercicio: Se dice que un nmero entero es perfecto si la suma de sus divisores excepto l
mismo es igual al propio nmero. Por ejemplo seis es nmero perfecto porque 1*2*3=6 y
1+2+3 = 6. Escriba un programa que obtenga los nmeros 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



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 nmero
comprendido entre 1 y 100. El usuario tiene 7 oportunidades para lograrlo. El programa
debe generar aleatoriamente el nmero y luego solicitar al usuario que lo adivine. Si el
nmero del usuario es menor que el nmero aleatorio, se le indica mi nmero es
mayor; pero si el nmero del usuario es mayor que el nmero aleatorio, se le indica
mi nmero es menor; si el nmero del usuario es igual que el nmero aleatorio, se le
indica Acertaste; si el usuario agota sus oportunidades simplemente termina el
programa.

Entrada:
50
Salida:
Mi nmero es mayor

#include<stdio.h>
#include<stdlib.h>
#include<time.h>

int main(){
int num, tuNum, i;
srand(time(NULL));
printf("Adivina un nmero 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


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 nmeros primos comprendidos entre 1 y 1e4.
Un nmero es primo, si sus nicos divisores son l mismo y la unidad. No hay entrada
por parte del usuario; como salida enlistar los nmeros 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


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 nmero 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 evala primero una condicin, si esta resulta verdadera entonces se ejecuta
el bloque de instrucciones; de lo contrario, se contina con el flujo normal del programa.
Generalmente, la estructura while se emplea en soluciones donde no se conoce previamente la


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 nmero de iteraciones.

condicion
bloque_V
V
F

while(condicion){
bloque_v;
}

Donde:

condicion: mientras la condicin sea verdadera, el ciclo contina
en ejecucin . La condicin de paro puede implicar varias condiciones
unidas por los operadores lgicos && y ||

bloque_V: es el conjunto de instrucciones que conformarn 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



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]. Adems, 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 condicin de paro al principio del
ciclo, la estructura do-while comprueba la condicin 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 solucin que involucra iteraciones.



condicion
V
F
bloque_V

do{
bloque_V;
}while(condicion);

donde:

bloque_V: es el conjunto de instrucciones que se va a repetir mientras
la condicin sea verdadera

condicion: una varias condiciones relacionadas con operadores
lgicos.

Ejercicio: escribir un algoritmo que obtenga el promedio de los nmeros 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


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 nmero perfecto, escriba un programa que reciba desde
el teclado un nmero natural y determine si ste es un nmero perfecto. El programa
debe validad que la entrada del usuario sea un nmero 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



1 2 3 4 5 6 7 7 6 5 4 3 2 1
1 2 3 4 5 6 6 5 4 3 2 1
1 2 3 4 5 5 4 3 2 1
1 2 3 4 4 3 2 1
1 2 3 3 2 1
1 2 2 1
1 1
Ejercicio: escriba un programa que genere la siguiente figura en pantalla, se debe
de validar el dato de entrada para el siguiente programa.

#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 rengln
}
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



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 rengln
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 nmeros perfectos
comprendidos en el rango de 1 a n, donde n es un nmero dado por el usuario. Nota:
- El programa debe incluir una funcin
- 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


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



CAPTULO VII

TIPOS DE DATOS ESTRUCTURADOS

Un arreglo es una coleccin de variables del mismo tipo, que se referencian por un
nombre comn. En el lenguaje C, las celdas de memoria correspondientes a las
variables de un arreglo son contiguas; por lo tanto, la direccin de memoria ms baja
corresponde al primer elemento del arreglo y la direccin de memoria ms 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 posicin de un elemento en el arreglo.

Arreglos unidimensionales

Declarar un arreglo unidimensional es similar a declarar una variable, pero indicando su
tamao, por ejemplo:

int vector[10]; //corresponde a un arreglo llamado vector de tamao
10 y cuyos elementos debern ser de tipo entero

float num[40]; //corresponde a un arreglo llamado num de tamao 40 y
cuyos elementos debern 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 tamao de un arreglo, debe inicializarse con
valores, y su tamao corresponder al nmero de valores de inicio

Se asigna un valor a cada celda. La asignacin se hace en el orden en que aparecen los
valores. En tiempo de ejecucin, el arreglo vector se vera, en la memoria principal,
como sigue:

vector
0 1 2 3 4 5 6 7
2 4 6 7 5 1 9 3

Todos los arreglos comienzan en con una posicin 0 (cero); por lo tanto, el tamao de
vector es 8, pero su ltima posicin es 7. En general, para un arreglo de tamao n, su
ltima posicin ser n-1.

Para acceder a cualquier elemento, nos referimos a l a travs de su posicin, por
ejemplo:



Referencia elemento
vector[2]
vector en su posicin 2
6
vector[6]
vector en su posicin 6
9
vector[2+3]=vector[5] 1

Arreglos unidimensionales y funciones

Cuando una funcin requiere pasar un arreglo (como parmetro) a otra funcin, ste
pasa nicamente por referencia. Por lo tanto, cualquier modificacin que se realice
sobre el arreglo, en la funcin que lo recibe, afectar al arreglo original que se localiza
en la funcin que realiz el llamado. La siguiente tabla muestra una comparacin entre
las dos notaciones que podemos emplear en el lenguaje C para manejar un arreglo que
pasa como parmetro por referencia. El resultado de ambos es el mismo.

Prototipo:

void calcula(int datos[], int n);
Prototipo:

void calcula(int* datos, int n);

Llamado:

int main(void){
int datos[10];
calcula(datos, 10);
:
return 0;
}
Llamado:

int main(void){
int datos[10];
calcula(datos, 10);
:
return 0;
}
Declaracin de funcin:

void calcula(int datos[], int n) {
for(int i=0; i<n;i++)
datos[i]= datos[i]-2;
return;
}
Declaracin de funcin:

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.



#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 tamao 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 tamao de los arreglos (1-100)", n


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[]){


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 numrica; y 2) un valor entero positivo
correspondiente a la base para la conversin. 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).



#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 (tambin llamado tabla matriz) consta de renglones y
columnas. Para acceder a un elemento debemos emplear dos ndices, el primero para
denotar el rengln 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, adems del nmero de renglones, el nmero de columnas, por ejemplo:

int matriz[3][4]; //corresponde a un arreglo llamado matriz de 3 renglones y
4 columnas; por lo tanto su tamao es de 3x4=12 elementos,
todos de tipo entero


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 aparicin, cubriendo cada
rengln

int matriz[3][4]={ {12,24,4617},{25,31,49,63},{ 42,21,89,96}};
// esta forma proporciona claridad a quien lee el cdigo

int matriz[3][4]={0}; //incorrecto
// Una arreglo bidimensional no puede inicializase con 0 (cero) de
esta manera

En tiempo de ejecucin, el arreglo matriz se vera, en la memoria principal, como sigue:

c0 c1 c2 c3
r0 12 24 46 17
r1 25 31 49 63
r2 42 21 89 96

Observe que tambin los arreglos bidimensionales comienzan en con una posicin 0
(cero) tanto en los renglones como en las columnas; por lo tanto, el nmero de
renglones matriz es 3, pero su ltima posicin es 2; mientras que el nmero de
columnas es de 4 pero su ltima posicin es 3, y el tamao de la matriz es de 3x4. En
general, en tamao de una matriz est determinado por el producto n
renglones
xm
columnas

correspondiente al nmero de elementos que puede albergar el arreglo bidimensional.

Para acceder a cualquier elemento, nos referimos a l a travs de su posicin, por
ejemplo:

Referencia Elemento
matriz[2][3]
matriz en su posicin
2,3
96
matriz[0][1]
matriz en su posicin
0,1
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);



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


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 simtrico. 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])


flag=1;
j=n; i=n;
}
}
return flag;
}
matrizSimetrica.c

#define MAX 50

function leeMatriz(MAT() as double)
input "Cual es el tamao 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 tamao 10 y cuyos
elementos debern ser de tipo caracter

En el leguaje C, todas las cadenas terminan con un caracter nulo denotado por una
diagonal inversa y el nmero cero \0; por lo tanto, al momento de definir el tamao 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 vlida de inicializar a cad


char cad[5]= ; // todos elementos del arreglo tienen como valor inicial al
caracter espacio

char cad[]= hola; //el tamao del arreglo queda definido como 5

En tiempo de ejecucin, el arreglo cadena se vera, en la memoria principal, como
sigue:

cadena
0 1 2 3 4
h o l a \0

Observe que si bien el tamao de la palabra hola es 4, la cadena es declarada como de
tamao 5, y el caracter nulo \0 ocupa la ltima posicin en el arreglo, es decir la
posicin 4. Al manipular una cadena se debe cuidar de no sustituir al caracter nulo \0
con algn otro valor.

Los operadores de asignacin (=) y los relacionales (==, !=) no se emplean en el manejo
de cadenas, salvo la asignacin 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 Caracteres
Entrada
scanf(%s,&cadena)

gets(cadena)
scanf(%c,&caracter)

getc(caracter)

Salida
Printf(%s,cadena)

puts(cadena)
Printf(%c,caracter)

putc(caracter)

Cuando quiero leer una nueva cadena, debemos emplear la funcin fflush(stdin), para
limpiar el buffer que permite recibir una cadena desde el teclado.

Descripcin Precauciones
strcpy(destino, origen) Copia el valor de cadena origen
hacia la cadena destino.
No verifica que la cadena destino sea
lo bastante grande como para
almacenar el valor de la cadena
origen.
strncpy(destino, origen,
limite)
Igual que la funcin strcpy de
dos argumentos, slo que se copian
cuando mucho el lmite caracteres.
Si limite se elige con cuidado, esta
funcin es ms segura que la versin
strcpy.
strcat(destino, origen) Concatena el valor de cadena origen
con el final de la cadena destino
No verifica que la cadena destino sea
lo bastante grande como para
almacenar el resultado de la
concatenacin
strncat(destino, origen,
limite)
Igual que la funcin strcat de dos
argumentos, slo que se anexan
cuando mucho lmite caracteres
funcin es ms segura que la versin
srtcat.
strlen(origen) Devuelve un entero igual a la
longitud de la cadena origen; el



carcter nulo \0 no se cuenta en
la longitud
strcmp (cadena_1,
cadena_2)
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 carcter tiene un valor entero,
segn la tabla de ascii
Si cadena_1 es igual a cadena_
2 esta funcin devuelve 0, lo que la
convierte en falsa cuando se evala.
Esto es lo inverso de lo que
podramos esperar dado que las
cadenas son iguales. Tener cuidado
con la lgica que sigue esta funcin
strncmp (cadena_1,
cadena_2, limite)
Igual que la funcin strcmp de dos
argumentos, solo que se comparan
cuando mucho limite caracteres.
funcin es ms segura que la funcin
strcmp de dos argumentos

Ejercicio: construir un programa que dada una cadena, determine si sta es una cadena
palndrome. Se dice que una cadena es palndrome 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; "'"


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 tamao de la cadena que ingres el usuario;
El propsito del programa es mezclar o desordenar la cadena en cada iteracin. El
programa debe imprimir la cadena obtenida en cada iteracin.

#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


next j
print "Hola ";nom; "!"
next i
sleep
desordena.bas



CAPTULO 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 informacin de una ejecucin en el mismo, y tambin
archivos ya existentes donde se agregarn los datos recin procesados.

Conceptos bsicos

Un archivo es un conjunto de datos de distintos tipos: int, float, double, char, etc., que
se guardan juntos, bajo un nombre comn, en un dispositivo secundario, a saber: disco
duro, memoria USB, etc. Por ejemplo texto.txt sera un archivo de datos.

Los nombres de los archivos son reconocidos por el sistema operativo a travs de los
comandos ls (unix) y dir (dos). Actualmente Unix y Windows (desde la versin 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 estn contenidas en la biblioteca stdio.h

Funcin Descripcin
fopen()
Abrir archivo
fclose()
Cerrar un archivo
fputc()
Escribir un carcter en el archivo
fgetc()
Lee un carcter de un archivo
fputs()
Escribir una cadena en un archivo
fprintf()
Imprimir a un archivo
fscanf()
Leer sobre un archivo
feof()
Devuelve cierto cuando llega al fin del archivo
ferror()
Devuelve vierto si se ha producido un error
rewind()
colocar el indicador de posicin de un archivo al principio del mismo.
remove()
eliminar un archivo
fflush()
vaciar el buffer que sirve para leer o escribir en el archivo.


En el lenguaje C es necesario indicar la accin que vamos a realizar sobre un archivo; a
esto se le conoce como modo de apertura de un archivo.

Modo de apertura Significado Descripcin de la accin
r read Abrir un archivo de texto para
lectura.
w write

Abrir un archivo de texto para
escribir en l

a append Abrir un archivo para agregar texto
en l
r+ read and write abrir un archivo para lectura y
escritura

exit(valor_entero) es una funcin que termina de inmediato la ejecucin de un programa
yforma parte de la biblioteca stdlib.h. Se puede usar cualquier valor entero, pero por
convencin se emplea:

1 para indicar que el programa terminar porque durante la ejecucin del programa se
incurri en algn error, previsto por el programador.
0 para indicar que el programa terminar sin que esto lo cause algn error.

Ejercicio: construir un programa que permita escribir un conjunto de caracteres en un
archivo llamado texto.txt. Los caracteres debern 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>"



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
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 debern guardarse en un nuevo archivo. Nota: el programa debe
recibir desde el teclado, los nombres de los archivos (fuente y destino).



#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
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 debern 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>



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
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 atrs, 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 funcin main. Una de ellas debe encargarse de solicitar al usuario preguntas o la
palabra fin que pone trmino 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.



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


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 papelera 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;
}


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 sub nombreArchivo(tipo as string, char as string)
declare function cargaDatos(precios() as double)
declare function calculaTotal(precios() as double, tam as integer) as double
declare 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)


n+=1
wend
close #1
return n
else
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



Bibliografa

Adamis, E. Frmulas y programas usuales en BASIC, 1ra. ed. McGrawHill, 1985.

Bronson, G.J., C++ para ingeniera y Ciencias, 2da ed. Internacional Thomson, 2000.

Brookshear, J.G., Introduccin a las ciencias de la computacin, 4ta. ed., Addison-
Wesley, 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, Computacin y programacin moderna, Addison-Wesley, 2001.

Strouptrup, B., El lenguaje de programacin C++. Edicin especial, Pearson
Education, 2002

Programacion Estructurada v14

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Programacion Estructurada v14

Cargado por

Copyright:

Formatos disponibles

PEdro

También podría gustarte