LIBRERIAS EN LENGUAJE C

#include <stdio.h>clearerr fclose feof ferror fflush fgetc fgetposfgets fopen formato fprintf fputc fputs freadfreopen fscanf fseek fsetpos ftell fwrite getcgetchar gets perror printf putc putchar putsremove rename rewind scanf setbuf setybuf sprintfsscanf tmpfile tmpnam ungetc vfprintf vprintf vsprintf#include <stdlib.h>abort abs atexit atof atoi atol bsearch

calloc div exit free getenv labs ldiv

malloc mblen mbstowcs mbtowc qsort rand Realloc

srand strtod strtol strtoul system wctomb  #include <string.h>memchr memcmp memcpy memmove memset strcat strchr

strcmp strcoll strcpy strcspn strerror strlen strmcat

strmcmp strmcpy strpbrk strrchr strspn strstr strtok

strxfrm            #include <ctype.h>tolower toupper          

#include <locale.h>localeconv setlocale            #include <math.h>Acos Asin atan atan2 ceil cos cosh

Exp Fabs floor fmod frexp ldexp log

log10 modf pow sin sinh sqrt tan

tanh            #include <setjmp.h>longjmp setjmp          #include <signal.h>raise signal          #include <time.h>asctime clock ctime difftime Gmtime localtime mktime

strftime time          Otras librerias que no tienen funciones asociadas. Pero tienen macros constantes y/o estructuras.·         #include <assert.h>·         #include <errno.h>·         #include <float.h>

·         #include <limits.h>·         #include <stdarg.h>·         #include <stddef.h>

RESUMEN DE LIBRERIAS

Ø  assert.h Contiene una macro para el diagnóstico dentro de los programas.Ø  ctype.h Contiene varias funciones para comprobación de tipos y transformación de caracteres.Ø  errno.h Contiene varias macros usadas para informar de errores.Ø  limits.h Contienen varias macros que definen constantes para el tamaño de tipo enteros.Ø  float.h Contienen varias macros que definen constantes para el tamaño de tipo flotante.Ø  locale.h Contienen varias macros, funciones y tipos para unidades locales, como unidad monetaria, tiempo, dígitos, etc.Ø  math.h Contiene una macro y varias funciones matemáticas.Ø  setjmp.h Contienen declaraciones que proporcionan una forma de evitar la secuencia normal de llamada y regreso de funciones.Ø  signal.h Contiene un tipo, dos funciones y varias macros para manejar condiciones excepcionales que aparecen durante la ejecución, tal como una señal de interrupción de una fuente externa o un error en la ejecución.Ø  stdarg.h Contiene un tipo y tres macros que proporcionan recursos para recorrer una lista de argumentos de función de tamaño y tipo desconocido.Ø  stddef.h Contiene varios tipos y macros que también están definidas en otras librerías, como size_t.Ø  stdio.h Contiene tipos, macros y funciones para la realización de tareas de E/S.Ø  stdlib.h Contiene tipos, macros y funciones para la conversión numérica, generación de números aleatorios, búsquedas y ordenación, gestión de memoria y tareas similares.Ø  string.h Contiene tipos, macros y funciones para la manipulación de cadenas de caracteres.Ø  time.h Contiene tipos, macros y funciones para la la manipulación de información sobre fechas y horas.

Funcionabilidad de la Función System, que pertenece a la librería <stlib.h>Colores de Fondo0 = Negro1 = Azul2 = Verde3 = Aguamarina4 = Rojo5 = Púrpura6 = Amarillo7 = Blanco8 = Gris9 = Azul claroColores de Fuentea = Verde claro

b = Aguamarina claroc = Rojo clarod = Púrpura claroe = Amarillo clarof = Blanco brillante

#include "stdio.h"

FUNCIONES

fclose Cierra un fichero a través de su puntero.

fopen, freopen, fdopen

Abre un fichero para lectura, para escritura/reescritura o para adición.

remove Elimina un fichero.

rename Cambia al fichero de nombre.

rewind Coloca el indicador de posición de fichero para el stream apuntado por stream al comienzo del   fichero.

tmpfile Crea y abre un fichero temporal que es borrado cuando cerramos con la función fclose().

clearerr Despeja los indicadores de final de fichero y de posición de fichero para el stream apuntado por stream al comienzo del fichero.

feof Comprueba el indicador de final de fichero.

ferror Comprueba el indicador de errores.

fflush Si stream apunta a un stream de salida o de actualización cuya operación más reciente no era de entrada, la función fflush envía cualquier dato aún sin escribir al entorno local o a ser escrito en el fichero; si no, entonces el comportamiento no está definido. Si stream es un puntero nulo, la función fflush realiza el despeje para todos los streams cuyo comportamiento está descrito anteriormente.

fgetpos Devuelve la posición actual del fichero.

fgetc Devuelve un carácter de un fichero.

fgets Consigue una cadena de caracteres de un fichero.

fputc Escribe un carácter en un fichero.

fputs Escribe una cadena de caracteres en un fichero.

ftell Devuelve la posición actual del fichero como número de bytes.

fseek Sitúa el puntero de un fichero en una posición aleatoria.

fsetpos Cambia la posición actual de un fichero.

fread lee diferentes tamaños de datos de un fichero.

fwrite Envía, desde el array apuntado por puntero, hasta nmemb de elementos cuyo tamaño es especificado por tamaño. El indicador de posición de ficheros es avanzado por el número de caracteres escritos correctamente. Si existe un error, el valor resultante del indicador de posición de ficheros es indeterminado.

getc Devuelve un carácter desde un fichero.

getchar Igual que getc.

gets Lee caracteres de entrada hasta que encuentra un salto de línea, y los almacena en un único argumento.

printf, fprintf, sprintfsnprintf

Usados para imprimir salidas de datos.

vprintf También utilizado para imprimir salidas.

perror Escribe un mensaje de error a stderr.

putc Devuelve un carácter de un fichero.

putchar, fputchar

Igual que putc(stdout).

scanf, fscanf, sscanf

Utilizado para introducir entradas.

vfscanf, vscanf, vsscanf

También utilizado para introducir entradas.

setbuf Esta función es equivalente a la función setvbuf pasando los valores _IOFBF para modo y BUFSIZ para tamaño, o (si acumulador es un puntero nulo), con el valor _IONBF para modo.

setvbuf Sólo puede ser usada después de que el stream apuntado por stream ha sido asociado con un fichero abierto y antes de otra operación cualquiera es llevada acabo al stream. El argumento modo determina cómo stream será almacenado según lo siguiente: _IOFBF ocasiona la entrada/salida a ser completamente almacenado; _IOLBF ocasiona la entrada/salida a almacenar por líneas; _IONBF ocasiona la entrada/salida a no ser almacenado. Si acumulador no es un puntero nulo, el array al que es apuntado puede ser usado en vez de la acumulación adjudicada por la función setvbuf. El argumento tamaño especifica el tamaño del array.

tmpnam Genera una cadena de caracteres que es un nombre válido para ficheros y que no es igual al nombre de un fichero existente. La función tmpnam genera una cadena diferente cada vez que es llamada, hasta un máximo de TMP_MAX veces. Si la función es llamada más veces que TMP_MAX, entonces el comportamiento de la función está definido según la implementación del compilador.

puts Imprime una de cadena de caracteres.

#include "stdlib.h"

atof (ascii to float) cadena de caracteres a coma flotante

atoi  cadena de caracteres a entero

atol (C Standard Library) (ascii to long)

cadena de caracteres a entero tamaño largo

strtod cadena de caracteres a coma flotante tamaño doble

strtol  cadena de caracteres a entero largo

strtoul  cadena de caracteres a entero largo sin signo (positivo)

rand Genera un número pseudo-aleatorio

srand Establece la semilla para el generador de números pseudo-aleatorios

malloc, calloc, realloc Reservan memoria dinámica del heap

free Liberan memoria devolviéndola al heap

abort terminar ejecución anormalmente

atexit registrar una función callback callback para la salida del programa

exit terminar ejecución del programa

getenv recuperar una variable de entorno

system ejecutar un comando externo

bsearch búsqueda binaria en un array

qsort ordena un vector usando quicksor

abs, labs valor absoluto

div, ldiv división entera o euclidiana

     #include <string.h>

memcpy copia n bytes entre dos áreas de memoria que no deben solaparse

memmovecopia n bytes entre dos áreas de memoria; al contrario que memcpy las áreas deben solaparse

memchr busca un valor a partir de una dirección de memoria dada y devuelve un puntero a la primera   ocurrencia del valor buscado o null  si no se encuentra

memcmp compara los n primeros caracteres de dos áreas de memoria

memset sobre escribe un área de memoria con un patrón de bytes dado

strcat añade una cadena al final de otra

strncat añade los n primeros caracteres de una cadena al final de otra

strchr localiza un carácter en una cadena, buscando desde el principio

strrchr localiza un carácter en una cadena, buscando desde el final

strcmp compara dos cadenas alfabéticamente ('a'!='A')

strncmp compara los n primeros caracteres de dos cadenas numéricamente ('a'!='A')

strcoll compara dos cadenas según la colación actual ('a'=='A')

strcpy copia una cadena en otra

strncpy copia los n primeros caracteres de una cadena en otra

strerror devuelve la cadena con el mensaje de error correspondiente al número de error dado

strlen devuelve la longitud de una cadena

strspn devuelve la posición del primer carácter de una cadena que no coincide con ninguno de los caracteres de otra cadena dada

strcspn devuelve la posición del primer carácter que coincide con alguno de los caracteres de otra cadena dada

strpbrk encuentra la primera ocurrencia de alguno de los caracteres de una cadena dada en otra

strstr busca una cadena dentro de otra

strtok parte una cadena en una secuencia de tokens

strxfrm transforma una cadena en su forma de colación (??)

strrev invierte una cadena

                                                        #include <ctype.h>

tolower: Convierte un carácter, en un parámetro entero ch, a minúscula.

toupper: Convierte un carácter, en un parámetro entero ch, a mayúscula

#include <locale.h>

localeconv: La función localeconv asigna los componentes de un objeto con tipo struct lconv con valores apropiados para elformateo de cantidades numéricas (monetarias y otras) según las reglas de la localidad actual.

setlocale La función setlocale selecciona la porción apropiada de la localidad del programa especificado por los argumentoscategoria y localidad. La función setlocale puede ser usada para cambiar o preguntar la localidad actual total delprograma o porciones de ello.

#include <math.h>

acos arcocoseno

asien arcoseno

atan arcotangente

atan2 arcotangente de dos parámetros

ceil menor entero no menor que el parámetro

cos coseno

cosh coseno hiperbólico

exp(double x)función exponencial, computa ex

abs valor absoluto

floor mayor entero no mayor que el parámetro

fmod residuo de la division de flotantes

frexp fracciona y eleva al cuadrado.

ldexp tamaño del exponente de un valor en punto flotante

log logaritmo natural

log10 logaritmo en base 10

modf obtiene un valor en punto flotante íntegro y en partes

pow(x,y) eleva un valor dado a un exponente, xy

sin seno

sinh seno hiperbólico

sqrt raíz cuadrada

tan tangente

tanh tangente hiperbólica

#include <setjmp.h>

longjmp: Restaura el entorno guardado por la invocación más reciente de la función setjmp en la mismainvocación del programa, con el argumento correspondiente entorno

setjmp: Guarda su entorno de llamadas en el argumento entorno para uso posterior por la función longjmp

#include <signal.h>raise: La función envía la señal señal al programa en ejecución.

signal:La función signal retorna el valor de func para la llamada más reciente a signal para la señal especificada, señal, si la operación fue realizada con éxito

#include <time.h>

char * asctime(struct tm *)

Recibe una variable de tipo puntero a estructura tm (struct tm*) y devuelve una cadena de caracteres

clock_t clock (void) Devuelve el número de pulsos de reloj desde que se inició el proceso

char * ctime(time_t *) Recibe una variable de tipo puntero a time_t (time t*) y devuelve una cadena con el mismo formato que asctime()

double difftime(time_t, time t)

Recibe dos variables de tipo time_t, calcula su diferencia y devuelve el resultado (double) expresado en segundos.

struct tm *gmtime(time_t *)

Recibe un puntero a una variable de tiempo (time_t*) y devuelve su conversion como fecha/hora UTC a struct tm a través de un puntero.

struct tm Similar funcionalidad a gmtime(), pero devuelve la conversión como

*localtime(time_t *) fecha/hora LOCAL.

time_t mktime(struct_tm *)

Inversamente a gmtime() y localtime(),l recibe un puntero a struct tm (struct tm*) y devuelve su conversión al tipo time t.

time_t time(time_t *) Devuelve la fecha/hora (time_t) actual o -1 en caso de no ser posible. Si el argumento que se le pasa no es NULL, también asigna la fecha/hora actual a dicho argumento.

size_t strftime(char *,size_t,char *,struct tm *)

Formatea la información pasada mediante la estructura (struct tm*) mediante el formato indicado en una cadena (char*) e imprime el resultado sobre otra cadena (char*) hasta un límite de caracteres (size_t).

Otras librerias que no tienen funciones asociadas. Pero tienen macros constantes y/o estructuras.

·         #include <assert.h>·         #include <errno.h>·         #include <float.h>·         #include <limits.h>·         #include <stdarg.h>·         #include <stddef.h>

RESUMEN DE LIBRERIAS

Ø  assert.h Contiene una macro para el diagnóstico dentro de los programas.

Ø  ctype.h Contiene varias funciones para comprobación de tipos y transformación de caracteres.

Ø  errno.h Contiene varias macros usadas para informar de errores.

Ø  limits.h Contienen varias macros que definen constantes para el tamaño de tipo enteros.

Ø  float.h Contienen varias macros que definen constantes para el tamaño de tipo flotante.

Ø  locale.h Contienen varias macros, funciones y tipos para unidades locales, como unidad monetaria, tiempo, dígitos, etc.

Ø  math.h Contiene un macro y varias funciones matemáticas.Ø  setjmp.h Contienen declaraciones que proporcionan una forma

de evitar la secuencia normal de llamada y regreso de funciones.

Ø  signal.h Contiene un tipo, dos funciones y varias macros para manejar condiciones excepcionales que aparecen durante la ejecución, tal como una señal de interrupción de una fuente externa o un error en la ejecución.

Ø  stdarg.h Contiene un tipo y tres macros que proporcionan recursos para recorrer una lista de argumentos de función de tamaño y tipo desconocido.

Ø  stddef.h Contiene varios tipos y macros que también están definidas en otras librerías, como size_t.

Ø  stdio.h Contiene tipos, macros y funciones para la realización de tareas de E/S.

Ø  stdlib.h Contiene tipos, macros y funciones para la conversión numérica, generación de números aleatorios, búsquedas y ordenación, gestión de memoria y tareas similares.

Ø  string.h Contiene tipos, macros y funciones para la manipulación de cadenas de caracteres.

Ø  time.h Contiene tipos, macros y funciones para la la manipulación de información sobre fechas y horas.

#include <stdio.h>void main(){ printf("Hola"); }

777777777777777#include <stdio.h>main(){ printf("Hola"); return 0;}

777777777777777777777777

mira:

int funcion(int x){if (x==8) {cout<<"mi valor es"<<x;return 1;}

x=8;cout<<"mi valor es"<<x;getch();return 0;}

observa que el return se utiliza para cortar una función cuando llega a un resultado satisfactorio.....o continuar hasta que lo hagaobserva:

void funcion(int x){if (x==8) {cout<<"mi valor es"<<x;return;}

x=8;cout<<"mi valor es"<<x;getch();return;}

como la funcion es void no retorna nada y tambien podemos cortarla cuando queramos... esto sirve bastante y nos ahorra en cierta forma la mamera de los if largos hasta el final como por ejemplo:

void funcion(int x){if (x==8) {cout<<"mi valor es"<<x;}else{x=8;cout<<"mi valor es"<<x;}getch();}

777777777777777777777777777777777777777777777777777777

main ()

{...... return 0;}

le estás diciendo a tu programa que si en la función principal no se regresa ese valor, se marque un error de ejecución, ya que hubo algún error en el programa. Pero cuando utilizas:

void main (){...... }

el programa cuando tenga un error de ejecución, no le importará ese error y no marcará nada.

Espero esto te haya aclarado tu duda.

system() es una función del lenguaje de programación C incluida en su biblioteca estándar, dentro de la cabecera <stdlib.h>. Sirve para ejecutar subprocesos o comandos del sistema operativo.

«system» permite ejecutar a su vez otras funciones como: «cls», «dir» o «pause». Por

ejemplo, al escribir system ("pause") se está incorporando una pausa en el programa, es

decir, que se espera a que el usuario presione alguna tecla para continuar con la ejecución

del mismo. La siguiente línea de código no se ejecutará hasta que el usuario presione una

tecla.

A continuación se muestra un ejemplo sencillo de programa en C en el que se incluye la

función system ("pause"):

#include <stdio.h>

#include <stdlib.h>

#include <windows.h>

int main(void)

{

printf("Hola, mundo.\n");

system("pause");

return 0;

}

Las funciones getch(), getche() y getchar() nos sirve para capturar un solo carácter ingresado por medio del teclado, pero aunque las 3 funciones tienen el mismo propósito pertenecen a diferentes librerías y difieren un poco en su funcionamiento.

Funciones getch() y getche()

Estas funciones pertenecen a la librería conio.h, hablando un poco sobre

esta, cabe destacar que no es una librería estándar del lenguaje C, fue

desarrollada originalmente para el compilador Borland y debido a este

detalle no todos los compiladores cuentan con esta librería, en nuestro

caso en el IDE codeblocks si se puede utilizar.

La función getch() lee u obtiene un solo carácter ingresado desde el

teclado, este carácter no es mostrado en pantalla al ingresarlo

(tendríamos que utilizar un printf() para mostrarlo) y al terminar de

pulsar la tecla se ejecuta inmediatamente la instrucción siguiente,

ejemplo.-

#include <stdio.h>#include <conio.h>

int main(){ char caracter;

printf("Ingrese un caracter \n");

caracter = gecth();

printf("\n El caracter que ingreso es %c", caracter);

return 0;}Nota: en la línea char caracter; cabe destacar que utilizamos una

variable del tipo char, no profundizaremos en este tema por el momento,

solo lo utilizamos para el ejemplo.

La función getche() obtiene el mismo resultado que la función getch(),

con la diferencia de que si se muestra el carácter al momento de

presionar la tecla, ejemplo.-

#include <stdio.h>#include <conio.h>

int main(){ char caracter;

printf("Ingrese un caracter \n");

caracter = gecthe();

printf("\n El caracter que ingreso es %c", caracter);

return 0;}

Función getchar()

Esta función es equivalente a la función getch(), pertenece a la librería

stdio.h la cual es estándar del lenguaje C, y por ello se recomienda su

uso (aunque si es necesario utilicen las dos anteriores), ejemplo.-

#include <stdio.h>

int main(){ char caracter;

printf("Ingrese un caracter \n");

caracter = gecthar();

printf("\n El caracter que ingreso es %c", caracter);

return 0;}A diferencia de la función gecth(), esta función necesita que se presione

enter después de ingresar el carácter para que se ejecute la siguiente

instrucción.

En este articulo aprenderemos a utilizar los operadores a nivel de bit en el lenguaje C, el manejo de bits es una de las herramientas mas potentes del lenguaje C, ya que nos permiten manejar internamente, es decir bit a bit, las variables o mejor dicho sus valores.

Operadores a nivel de bit

Los operadores a nivel de bit solo se puede utilizar con valores

numéricos y estos deben ser enteros (no se pueden utilizar números con

decimales), por tal motivo solo se podrán utilizar los siguientes tipos de

datos.-

·char 1byte (8bits)

·int 2 bytes (16 bits)

Y también cabe mencionar que los únicos modificadores de datos que se

pueden utilizar son short y unsigned, los operadores a nivel de bit son

los siguientes.-

·& operador and bit a bit.

·^ operador or exclusivo.

·| operador or inclusivo.

·>> recorrer bits a la derecha.

·<< recorrer bits a la izquierda.

Para entender mejor el funcionamiento de los operadores a nivel de bit

vamos a trabajar con los valores de las variables pero utilizando su

similar en binario, solo hay una dificultad con el lenguaje C, y es que no

tiene una función nativa para poder mostrar el valor binario de una

variable, por este motivo vamos a crear una, les dejo el código

completo.-

#include <stdio.h>

int main()

{ unsigned int contador = 128; // 2^(n - 1)

for(contador; contador > 0, contador >> 1){ if(contador & numero){ printf("1"); } else { printf("0"); } }}La variable que llamamos contador, como su nombre lo indica nos

servirá de contador, el numero 128 nos indica el numero de bits a

mostrar, y este numero lo sacamos elevando el numero 2 a la n potencia

menos 1, donde n es el numero de bits a utilizar, por ejemplo tenemos

una variable tipo char, por lo tanto es una variable de tamaño de 8 bits,

la formula quedaría asi 2^ (8 - 1) y resumiéndola mas quedaría asi 2^7

(que es equivalente a 2 x 2 x 2 x 2 x 2 x 2 = 128).

Ahora vamos a recorrer bit a bit la siguiente variable.-

// Esta variable la declaramos antes de la variable contadorchar numero = 5;Cuando el valor de la variable entre al bucle for por cada ciclo que este

complete el contador se desplazara un bit a la derecha hasta recorrer

todo el valor de la variable numero (en binario).

Con este sencillo procedimiento ya podemos obtener el valor binario de

una variable, ejecutamos el programa anterior buscando el valor binario

de 5 y -5.-

·El valor binario de 5 es 11111011

·El valor binario de -5 es 00000101

Bien, ya teniendo los valores binarios de estos números ya podemos

comenzar a explicar los operadores a nivel de bit.

Operador & and bit a bit

Este operador compara el primer bit del primer operando con el primer

bit del segundo operando, si los dos bit son igual a 1 el bit se establece

en un uno, en caso contrario el bit se establece a 0, terminando esta

comparación sigue con el segundo bit de cada operando y asi

sucesivamente hasta terminar, ejemplo.-

// Declaramos las variableschar num1 = 5;char num2 = -5;

// Utilizamos el operador &char resultado = num1 & num2;La lectura del ejemplo anterior seria la siguiente.-

00000101 este es el valor binario de num1

11111011 este es el valor binario de num2

------------

00000001 resultado después de utilizar el operador &

El valor de la variable resultado seria 1 y el valor binario seria 00000001,

lo podemos comprobar utilizando un printf para mostrar el valor normal

y después con el programa que creamos obtener el valor binario de 1.

Operador ^ or exclusivo

Este operador compara el primer bit del primer operando con el primer

bit del segundo operando, si uno de los bit es 0 y el otro 1 establece el

bit a 1, en caso contrario lo establece en 0, terminando esta

comparación sigue con el segundo bit de cada operando y asi

sucesivamente hasta terminar, ejemplo.-

// Declaramos las variables

char num1 = 5;char num2 = -5;

// Utilizamos el operador ^char resultado = num1 ^ num2;La lectura del ejemplo anterior seria la siguiente.-

00000101 este es el valor binario de num1

11111011 este es el valor binario de num2

------------

11111110 resultado después de utilizar el operador ^

El valor de la variable resultado seria -2 y el valor binario seria

11111110, lo podemos comprobar utilizando un printf para mostrar el

valor normal y después con el programa que creamos obtener el valor

binario de -2.

Operador | or inclusivo

Este operador compara el primer bit del primer operando con el primer

bit del segundo operando, si uno de los dos bit 1 establece el bit a 1, en

caso contrario lo establece en 0, terminando esta comparación sigue con

el segundo bit de cada operando y asi sucesivamente hasta terminar,

ejemplo.-

// Declaramos las variableschar num1 = 5;char num2 = -5;

// Utilizamos el operador |char resultado = num1 | num2;La lectura del ejemplo anterior seria la siguiente.-

00000101 este es el valor binario de num1

11111011 este es el valor binario de num2

------------

11111111 resultado después de utilizar el operador |

El valor de la variable resultado seria -1 y el valor binario seria

11111111, lo podemos comprobar utilizando un printf para mostrar el

valor normal y después con el programa que creamos obtener el valor

binario de -1.

Operador >> desplazar bits a la derecha

Este operador nos permite desplazar 1 o mas bits a la derecha de un

valor binario, veamos un ejemplo de como funciona.-

// Declaramos una variablechar numero = 5;

// Desplazamos un bit a la derechachar resultado = numero >> 1;

// Imprimimos el resultadoprintf("%i", resultado);Si ejecutamos el código anterior el programa nos dará como resultado un

2, esto es debido a que en realidad lo que hace este operador es dividir

el valor de la variable entre 2, si recordamos un poco explicábamos al

principio del articulo que los operadores a nivel de bit no aceptan valores

decimales, entonces la división de 5 (valor de la variable numero) entre

2 nos da un 2.5 este valor se redondea para obtener un entero y nos da

un 2 que en binario seria 00000010.

Operador << desplazar bits a la izquierda

Este operador nos permite desplazar 1 o mas bits a la izquierda de un

valor binario, veamos un ejemplo de como funciona.-

// Declaramos una variablechar numero = 5;

// Desplazamos un bit a la derechachar resultado = numero << 1;

// Imprimimos el resultadoprintf("%i", resultado);Ejecutamos el código anterior y veremos que el resultado obtenido es un

10, esto es debido a que el operador lo que hace es multiplicar por 2 el

valor de la variable y el valor binario seria 00001010.

. Objetivo. Al finalizar la práctica el estudiante será capaz de: • Definir estructuras de datos y arreglos.• Utilizar arreglos en una dimensión para resolver problemas.II. Introducción Teórica.Los Arreglos (Vectores o Array)Un array (lista o tabla9 es una secuencia de datos del mismo tipo. Los datos se llaman elementos del array y se numeran consecutivamente 0, 1, 2, 3, ,, etc. Estos números se denominan valores índice o subíndice del array. El tipo de elementos almacenados en el array pueden ser cualquier tipo de dato de C, incluyendo estructuras definidas por el usuario.Entonces, podemos entender los arrays (también conocidos como arreglos o formaciones) como variables que contienen diferentes tipos de datos homogéneos. Se puede acceder a cada elemento de datos individual de la variable mediante un subíndice, o índice. En los lenguajes C y C++, un array no se corresponde con un tipo de dato estándar; en su lugar, se trata de un tipo agregado que se obtiene a partir de otros tipos de datos. Es posible tener un array de cualquier cosa: caracteres, enteros, números en coma flotante, arrays, etc. Un array se declara de modo similar a otros tipos de datos, excepto que se debe indicar al compilador el tamaño o longitud del array. Para indicar al compilador el tamaño o longitud del array se debe hacer seguir al nombre, el tamaño encerrado entre corchetes.Los arrays tienen cuatro propiedades básicas:• Los elementos individuales de datos de un array se denominan elementos.• Todos los elementos deben ser del mismo tipo de dato.• Todos los elementos se almacenan en posiciones contiguas de la memoria de la computadora y el subíndice (o índice) del primer elemento es cero.• El nombre de un array es un valor constante que representa la dirección del primer elemento del array.Para acceder a un elemento especifico del array, se utiliza el nombre de éste seguido por uno o más “índices” (donde cada uno representa una dimensión del arreglo o array) encerrado entre corchetes. Supongamos que tenemos un arreglo unidimensional llamado X con un tamaño de “n” elementos, su esquema grafico es el siguiente:

Como puede verse en el esquema, aunque el arreglo es de “n” elementos, en realidad tienen “n-1” elementos porque comienzan a enumerarse desde cero.En términos generales para definir un array se especifica el tipo de almacenamiento (atributo opcional), el tipo de datos, el identificador y entre corchetes el tamaño del arreglo. Abajo se muestra algunos ejemplos de definición de arreglos:

a) int num[100]; (un array de 100 enteros)b) char apellido[25]; (un array de 25 caracteres)c) float prom[30]; (un array de 30 coma flotante)d) char contrasena[16]; (un array de 16 caracteres)

La necesidad de definir arrays en función de constantesA veces es conveniente definir el tamaño de un array en términos de una constante, en lugar de estar especificando una cantidad entera fija. Esto se realiza por facilidad de mantenimiento. Por ejemplo, suponga que tenemos un programa (con 350 líneas de código) donde se halle un array de 20 items, y a lo largo del programa se hace referencia unas 12 veces al arreglo, y supongamos también que se necesita cambiar el tamaño del arreglo. Sin usar la constante se tendría que revisar todo el programa para localizar las líneas de código y efectuar el cambio al nuevo tamaño, en cambio con el uso de constantes sólo se le cambia el tamaño a la misma y el problema esta resuelto. La definición de un array a través de una constante se muestra en el siguiente ejemplo:# include stdio.h># include stdlib.h>/* Definición de la constante */#define tamano 20main(){/* Utilización de la constante para definir la dimensión del arreglo */int promedios[tamano];/* Leer valores utilizando la variable i como contador dentro del ciclo FOR y ++i como acumulador*/for (i=0; i < tamano; ++i)scanf(“%d”,&promedios[i]);..........}La utilización de constantes definidas garantiza que las siguientes referencias al array no sobrepasen el tamaño definido para el mismo.C no comprueba que los índices del array están dentro del rango definido.

Inicialización de arreglosEn ciertas circunstancias puede ser necesario darle valores iniciales a los arreglos, para ello basta con colocar entre llaves el conjunto de valores deseados separados por comas y en el orden requerido. A continuación se muestran algunos ejemplos:a) int cant[6]={12,-3,0,15,8};

b) double DesvTipica[8]={0.23, 3.1416, -0.5, 2.16789, -56.78, 25, 0.15, -14 };c) char meses[12]={‘E’, ‘F’, ‘M’, ‘A’, ‘M’, ‘J’, ‘J’, ‘A’, ‘S’, ‘O’, ‘N’, ‘D’};

Para el caso del arreglo “cant” es como tener:Cant[0]=12Cant[1]= -3Cant[2]=0Cant[3]=15Cant[4]=8

Cuando los elementos del arreglo no tienen asignados valores iniciales explícitos, éstos son puestos a cero, a continuación tenemos un ejemplo:int edades[8]={25,13,18};

El resultado de la asignación seria el siguiente:Edades[0]=25;Edades[1]=13;Edades[2]=18;Edades[3]=0;Edades[4]=0;Edades[5]=0;Edades[6]=0;Edades[7]=0;

Este método de inicializar arrays mediante valores constantes después de su definición, es adecuado cuando el número de elementos del arreglo es pequeño.Una nota interesante en cuanto a la inicialización de arreglos, es que el tamaño no necesita ser indicado explícitamente. Con los arrays numéricos el tamaño será fijado igual al número de valores incluidos. En cuanto a las cadenas, el tamaño se fijará igual al número de caracteres del string o cadena mas uno (el carácter nulo “\0”).C puede dejar los corchetes vacíos, sólo cuando se asignan valores al array, tal comoint cuenta[ ] = { 15, 25, -45 , 0 , 50 };char c[ ] = { ‘L’, ‘u’, ‘i’, ‘s’ }; /* declara un array de 4 elementos */El compilador asigna automáticamente cinco elementos a cuenta.Otros ejemplos:a) Int porcent[ ]={8, 6, 10, -15, 23};b) Char mes[ ]=”octubre”;que vienen siendo equivalente a:

Porcent[0]=8;porcent[1]=6;porcent[2]=10;porcent[3]= -15;porcent[4]=23;

mes[0]=‘o’;

mes[1]=‘c’; mes[2]=‘t’; mes[3]=‘u’; mes[4]=‘b’; mes[5]=‘r’; mes[6]=‘e’; mes[7]=‘\0’

Ejemplo 1: Elabore un programa que permita leer una lista de números en un arreglo, calcule la suma, promedio, cuadrado , cubo y desviación estándar de los mismos:#include stdio.h>#include stdlib.h>#include conio.h>#include math.h>#define tam 4/* programa para calcular la suma, promedio, cuadrado, cubo y desviaciónestandar de una serie de números */main ( ){double vector[tam],cuadrado, cubo;float prom, desv,suma=0;int i, j;

system("cls" );printf ("PROGRAMA PARA CALCULAR \n");printf(" PROMEDIO, SUMA, CUADRADO, CUBO Y DESV. EST.\n\n") ;//Captura de valores y suma de los mismosfor(i = 0 ; i < tam ; ++i){printf ("num [%d] = " , i) ;scanf ("%lf" , &vector[i]) ;suma+= vector[i] ;}prom = suma / tam ;printf (" \n El promedio de los numeros es: %4.2f\n ", prom) ;//Calculo e impresión de cuadrado, cubo y desviación estandarprintf(" \n \n NUMERO CUADRADO CUBO DESV. EST.\n");for( i = 0 ; i < tam ; ++i ){cuadrado = vector[i] * vector[i] ;cubo = pow (vector[i], 3) ;desv = vector [i] - prom ;printf ("%.2lf", vector[i] ) ;printf (" \t%.2lf", cuadrado) ;printf (" \t%.2lf", cubo) ;printf (" \t%.2f\n", desv) ;}

system("pause");return(0);}

Nota que los valores fueron declarados de tipo double no enteros, por el tamaño de los valores que se generan en los cálculos.

Ejemplo 2:El siguiente programa lee 5 valores de teclado y los guarda en un arreglo a. Luego los escribe.

#include stdio.h>#include stdlib.h>main(){int a[5],i,num;for(i=0; i<5;i++){printf("Digite el numero:\n");scanf("%d",&num);a[i]=num;}

printf("\nEscribiendo el arreglo con los datos leidos:\n\n");for(i=0; i<5;i++){printf("a[%d]= %d\n\n",i,a[i]);}system("pause");return 0;}

Ejemplo 3:El siguiente programa, pide 5 numeros y calcula los cubos de ellos, los cuales son guardados en un arreglo y son desplegados.

#include stdio.h>#include stdlib.h>#include math.h>main(){int i;double a[5], num;for (i=0; i<5; i++){printf("\n Digite numero:");scanf("%lf", &num);a[i]=num;}printf("_________________________________________\n");

printf("Los cubos de los numeros leidos son:\n");for (i=0; i<5; i++){a[i]=pow(a[i],3);printf("%.0lf\n",a[i]);}printf("\n");system("pause");return 0;}

EJERCICIOS:

Ejercicio 1:Digite, compile y ejecute el siguiente programa. #include stdio.h>#include stdlib.h>main(){int a,b=0;int c[10]={1,2,3,4,5,6,7,8,9,0};for (a=0;a<10;++a)if ((c[a]%2)==0) b+=c[a];printf("%d\n",b);system(“pause”); return 0;}

¿Qué hace el programa? _________________________________________________________________________________________________________Cuál es la salida? _______

Ejercicio 2:Digite, compile y ejecute el siguiente programa. #include stdio.h>#include stdlib.h>main(){int a,b=0;int c[10]={1,2,3,4,5,6,7,8,9,0};for (a=0;a<10;++a)if ((a%2)==0)b+=c[a];printf("%d\n",b);system(“pause”); return 0;}¿Qué hace el programa? __________________________________________

_______________________________________________________________Cuál es la salida? _______¿En qué se diferencia del ejemplo anterior? ___________________________________________________________________________________________Ejercicio 3Elabore un programa que sume los primeros 25 números enteros guardados en un vector. Se desea imprimir la lista de números y al final la suma de los mismos.Ejercicio 4Generar e imprimir un vector de 10 números enteros y encontrar el mayor de ellos. Desplegar el resultado.Ejercicio 5Dadas dos listas A y B de igual número de elementos, se desea generar e imprimir una lista C conteniendo las sumas: A[i] + B[i] = C[i]PUBLICADO POR SALOMONAQUINO EN 20:36 47 COMENTARIOS: DOMINGO, 23 DE SEPTIEMBRE DE 2007

Clase 10: Estructuras de datos y arreglos.Materia: Lógica ComputacionalProfesor: Lic. Salomón Aquino.Objetivos de la clase:Al final de la clase los alumnos y alumnas serán capaces de:Asimilar los conceptos generales de estructuras de datos y arreglos.Resolver problemas usando arreglos en una dimensión (vectores).

Introducción:Todas las variables que se han considerado hasta ahora son de tipo simple. Una variable de tipo simple consiste de una sola caja de memoria y sólo puede contener un valor cada vez.Una variable de tipo estructurado consiste en toda una colección de casillas de memoria.Los tipos de datos estudiados: entero, real, alfabético son considerados como datos de tipo simple, puesto que una variable que se define con alguno de estos tipos sólo puede almacenar un valor a la vez, es decir, existe una relación de uno a uno entre la variable y el número de elementos (valores) que es capaz de almacenar. En cambio un dato de tipo estructurado, como el arreglo, puede almacenar más de un elemento (valor) a la vez, con la condición de que todos los elementos deben ser del mismo tipo, es decir, que se puede tener un conjunto de datos enteros, reales, etc.Estructuras de datos:Estructura de Datos es una colección de datos que se caracterizan por su organización y las operaciones que se definen en ella.Los datos de tipo estándar pueden ser organizados en diferentes estructuras de datos: estáticas y dinámicas.Estructura de Datos estáticas:

Son aquellas en las que el espacio ocupado en memoria se define en tiempo de compilación y no puede ser modificado durante la ejecución del programa.Corresponden a este tipo los arrays y registrosEstructuras de Datos Dinámicas:Son aquellas en las que el espacio ocupado en memoria puede ser modificado en tiempo de ejecución. Corresponden a este tipo las listas, árboles y grafos . Estas estructuras no son soportadas en todos los lenguajes.La elección de la estructura de datos idónea dependerá de la naturaleza del problema a resolver y, en menor medida, del lenguaje. Las estructuras de datos tienen en común que un identificador, nombre, puede representar a múltiples datos individuales.Arreglos o Arrays:Un arreglo (array) es una colección de datos del mismo tipo, que se almacenan en posiciones consecutivas de memoria y reciben un nombre común. Para referirse a un determinado elemento de un array se deberá utilizar un índice, que especifique su posición relativa en el array. Un arreglo es una colección finita, homogénea y ordenada de elementos.Finita:Todo arreglo tiene un límite; es decir,debe determinarse cuál será el número máximo de elementos que podrán formar parte del arreglo.Homogénea: Todos los elementos del arreglo deben ser del mismo tipo.Ordenada: Se puede determinar cuál es el primer elemento, el segundo, el tercero,.... y el n-ésimo elmento.Los arreglos se clasifican de acuerdo con el número de dimensiones que tienen. Así se tienen los:Unidimensionales (vectores)Bidimensionales (tablas o matrices)Multidimensionales (tres o más dimensiones)

Tipos de arreglos:

Arreglos unidimensionales:Están formados por un conjunto de elementos de un mismo tipo de datos que se almacenan bajo un mismo nombre, y se diferencian por la posición que tiene cada elemento dentro del arreglo de datos.dentro del arreglo, los programas especifican el nombre de éste y el número del elemento, colocándolo dentro de corchetes, como en calificación[3].Al declarar un arreglo, se debe inicializar sus elementos antes de utilizarlos.Para declarar un arreglo tiene que indicar su tipo, un nombre único y la cantidad de elementos que va a contener. Por ejemplo, las siguientes instrucciones declaran tres arreglos distintos:Float costo_partes[50];Int edad_empleados[100];Float precios_acciones[25];

Ejemplo de arreglo unidimensional:

Para acceder a valores específicos del arreglo, use un valor de índice que apunte al elemento deseado. Por ejemplo, para acceder al primer elemento del arreglo calificaciones debe utilizar el valor de índice 0 (calificaciones[0]). Los programas en C++ siempre indizan el primer elemento de un arreglo con 0 y el último con un valor menor en una unidad al tamaño del arreglo.Inicialización y asignación de valores:Como se decía anteriormente, antes de utilizar un arreglo es necesario inicializarlo:Para inicializar todos los elementos de una vez, se colocan dentro de una estructura for que va del primer elemento al último que contiene el arreglo.Para asignar un valor a un elemento del arreglo se hace por ejemplo:Calificaciones[0] <- 100;Cuando se usan arreglos, una operación común es usar una variable índice para acceder a los elementos de un arreglo. Suponiendo que la variable índice I contiene el valor 3, la siguiente instrucción asigna el valor 400 a valores[3]:valores[I] <- 400;Partes de un arreglo:Los componentes. Hacen referencia a los elementos que forman el arreglo, es decir, a los valores que se almacenan en cada una de las casillas del mismo.Los índices. Permiten hacer referencia a los componentes del arreglo en forma individual, especifican cuántos elementos tendrá el arreglo y además, de qué modo podrán accesarse esos componentes.Operaciones con vectores:Las operaciones que se pueden realizar con vectores durante el proceso de resolución de un problema son:Lectura/ escrituraAsignaciónActualización ( inserción, eliminación, modificación)Recorrido (acceso secuencial)OrdenaciónBúsqueda

Lectura y escritura de vectores:LecturaEl proceso de lectura de un arreglo consiste en leer y asignar un valor a cada uno de sus elementos. Normalmente se realizan con estructuras repetitivas, aunque pueden usarse estructuras selectivas.Usamos los índices para recorrer los elementos del arreglo:desde i = 1 hasta 70 hacerleer ( arre[i])fin_desdeEscritura:Es similar al caso de lectura, sólo que en vez de leer el componente del arreglo, lo escribimos.

leer (N)desde i = 1 hasta N hacerescribir (arre[i])fin_desdeAsignación e Inicialización de vectores:Asignación:No es posible asignar directamente un valor a todo el arreglo; sino que se debe asignar el valor deseado en cada componente. Con una estructura repetitiva se puede asignar un valor a todos los elementos del vector.Por ejemplo:arre[1] <- 120 (asignación de un valor constante único a una casilla del vector)arre[3] <- arre[1] / 4 (asignar una operación)Se puede asignar un valor constante a todos los elementos del vector: desde i = 1 hasta 5 hacerarre[i] <- 3fin_desdeO bienarre <- 3 (con arre del tipo arreglo)InicializaciónPara inicializar con cero todos los elementos del arreglo:desde i = 1 hasta 70 hacerarre[i] <- 0fin_desdeAcceso secuencial y Actualización de vectores:Acceso Secuencial. (Recorrido)El acceso a los elementos de un vector puede ser para leer en él o para escribir (visualizar su contenido).Recorrido del vector es la acción de efectuar una acción general sobre todos los elementos de ese vector.Actualización.Incluye añadir (insertar), borrar o modificar algunos de los ya existentes. Se debe tener en cuenta si el arreglo está o no ordenado.Añadir datos a un vector consiste en agregar un nuevo elemento al final del vector, siempre que haya espacio en memoria.Fin de la clase.Gracias por asistir.PUBLICADO POR SALOMONAQUINO EN 22:25 9 COMENTARIOS: LUNES, 17 DE SEPTIEMBRE DE 2007

Practica 9: Ejercicios con While y Do While.Materia: Lógica Computacional.Profesor: Lic. Salomón Aquino.

Objetivos. Al finalizar la práctica los estudiantes serán capaces de: • Resolver Problemas usando estructuras While Y Do While• Aplicar el concepto de centinelas y banderas con estructuras While y Do While.

Estructura Mientras (While)

Al igual que el bucle for, el bucle While es un bucle de precondición. Esto significa que el programa evalúa la condición antes de entrar en la instrucción o instrucciones del cuerpo del bucle. Como consecuencia de esto, los bucles de precondición se pueden ejecutar desde cero hasta varias veces.La sentencia while se utiliza para generar bucles repetidamente, hasta que la condición deje de ser verdadera.Sintaxis:while ( [condición] ) {Sentencias;}

Como en todas las estructuras que hemos visto, si se cuenta con una sola sentencia de repetición, no es necesario escribir las llaves.Estructura Repetir (Do While)La sentencia do – while se utiliza para especificar un bucle condicional que se ejecuta al menos una vez. Esta situación se suele dar en algunas circunstancias en las que se ha de tener la seguridad de que una determinada acción se ejecutará una o varias veces, pero al menos una vez.Cuando se construye un bucle usando while, la evaluación de la condición para la continuación del bucle se realiza al comienzo de cada pasada. Sin embargo, a veces es deseable disponer de un bucle en el que se realice el examen al final de cada pasada.Con esta sentencia se controla la condición al final del bucle. Si ésta se cumple, el programa vuelve a ejecutar las sentencias del bucle.La única diferencia entre las sentencias while y do...while es que con la segunda el cuerpo del bucle se ejecutará por lo menos una vez.Sintaxis:do {sentencia1;.......sentenciaN;} while ([evaluación]);

Ejemplo 1Elabore un programa en lenguaje C para calcular el promedio de una lista de x números.Solucion en WHILE:

#include stdio.h>#include stdlib.h>main ( ){int n , contar=1;float x , promedio , suma=0;printf ("Cuantos números desea leer?: ");scanf ("%d",&n);while (contar <= n) {printf ("x= ");scanf ("%f",&x);

suma +=x;++contar;}promedio=suma/n;printf ("\nEl promedio es: %.2f\n",promedio);

system(“pause”);return 0;}

Solucion en DO-WHILE#include stdio.h>#include stdlib.h>main ( ){int n, contar = 1;float x, promedio, suma = 0;printf ("Cuantos numeros?: ");scanf ("%d",&n);do {printf("x= ");scanf ("%f", &x);suma +=x;++contar;} while (contar <= n);promedio = suma/n;printf ("\nEl promedio es: %.2f\n",promedio);system(“pause”); return 0;}

Ejemplo 3 : Uso de centinelasEn el ejemplo se introducen notas mientras que ésta sea distinta de centinela, al final imprime cuántas notas se ingresaron, su suma y un mensaje de final. Nota se ha declarado de tipo entero.#include stdio.h>#include stdlib.h>main(){const int centinela = -1;int nota,suma=0;int cuenta =0;printf("Introduzca primera nota:\n");scanf("%d",¬a);while (nota != centinela){cuenta++;

suma+= nota;printf("Introduzca la siguiente nota:\n");scanf("%d",¬a);}printf("la suma es: %d\n",suma);printf("la cuenta fue: %d\n", cuenta);puts("final");system(“pause”);return 0;}Ejemplo 4: Uso de centinelas.Elabore un programa para solicitar el nombre, apellido, edad y la nota promedio de 5 estudiantes de un curso de computación, el programa debe realizar la petición de los datos hasta que se hallan completado los datos.Solución:#include stdio.h> #include conio.h> #include stdlib.h> main(){int op,edad;float nota;char nombre[20], apellido[20];op=1;while (op<=5){system("cls");if(op==5){printf("\n\n\t"); printf("ESTE ES EL ULTIMO ALUMNO");}printf("\n\n\t"); printf("REGISTRO DE ALUMNO # %d",op);printf("\n\n\t\t"); printf ("Nombre: ");scanf ("%s",nombre);printf("\n\n\t\t"); printf ("Escriba su Apellido: ");scanf ("%s",apellido);printf("\n\n\t\t"); printf ("Escriba su Edad: ");scanf ("%d",&edad);printf("\n\n\t\t"); printf ("Escriba su Nota Promedio: ");scanf ("%f",¬a);++op;}

system("cls");printf("\n\n\n\t"); printf ("\nE L P R O G R A M A H A T E R M I N A D O\n");system("pause"); return 0;}Nota: Este ejemplo aplica el uso de tabuladores para ordenar la informaciónEjemplo 5: Uso de banderas.El siguiente programa utiliza un juego de adivinación de un número, indicando las veces que se necesitan para encontrar el valor de 77. Note el uso de la instrucción continue que provoca que se ignoren todas las instrucciones que siguen a dicha instrucción.La instrucción while (!iadivinado) indica que mientras sea verdadero que entre al bucle, esto es porque la variable iadivinado se inicializó a FALSO. Esta variable es la bandera del programa, en el momento en que el usuario digite el número 77, la bandera cambia a verdadero y la condición del bucle deja de ser verdadera y se sale.Observa también que se definieron dos constantes para que la comparación sea numérica, ya que decimos que verdadero vale 1 y falso vale cero, al escribir por ejemplo, la palabra VERDADERO, en realidad, lo que toma la variable es el valor de 1.#include #include #define VERDADERO 1#define FALSO 0int main(){int inumero_correcto,iadivinado;int ivalor_introducido,inumero_intentos;inumero_correcto=77;iadivinado=FALSO;inumero_intentos=0;while (!iadivinado){printf("por favor, introduzca el numero de la suerte:");scanf("%d", &ivalor_introducido);inumero_intentos++;if(ivalor_introducido== inumero_correcto)iadivinado=VERDADERO;elsecontinue;printf ("¡Usted ha necesitado %d intentos para adivinarlo!\n", inumero_intentos);}system("pause");return 0;}

EJERCICIOS:Ejercicio 1:

Escriba un programa que calcule el resultado de todos los números del uno al cien (1+2+3+4......).Ejercicio 2:Escriba un programa que genere las tablas de multiplicar del 1 al 10.Ejercicio 3:Haga un programa que pida el número de alumnos de una clase y luego debe permitir ingresar los nombres de dichos alumnos.Ejercicio 4:Una compañía de seguros tiene contratados a n vendedores. Cada uno hace tres ventas a la semana. Su política de pagos es que un vendedor recibe un sueldo base y un 10% extra por comisiones de sus ventas.El gerente de la compañía desea saber cuánto dinero obtendrá en la semana cada vendedor por concepto de comisiones y cuánto tomando en cuenta su sueldo base y sus comisionesEjercicio 5:Haga un programa usando bucle do-While, que pida números y luego calcule la media de esos números. El usuario debe introducir los datos hasta que escriba –1 para finalizar la lectura.

Ejercicio 6:Escriba un programa usando banderas para imprimir y sumar los términos de la serie 2,5,7,10,12,15....50. Nota que a la serie se le suma 2 y a veces 3. (Puedes auxiliarte del algoritmo visto en clase teórica)Ejercicio 7:Elabora el programa que escriba los números del 1 al 100 excepto el número 25. Utiliza la función continue.PUBLICADO POR SALOMONAQUINO EN 19:59 17 COMENTARIOS: DOMINGO, 16 DE SEPTIEMBRE DE 2007

Clase 9: Estructura Mientras y Repetir.Materia: Lógica ComputacionalProfesor: Lic. Salomón Aquino.Objetivos de la clase:• Al final de la clase los alumnos y alumnas serán capaces de:1) Aplicar las estructuras mientras y repetir, en la solución de problemas. 2) Entender y aplicar el uso de centinelas y banderas.

Estructura Mientras (While):• Se llama Mientras a la estructura algorítmica que se ejecuta mientras la condición evaluada resulte verdadera.• Se evalúa la expresión booleana y, si es cierta, se ejecuta la instrucción especificada, llamada el cuerpo del bucle. Entonces se vuelve a evaluar la expresión booleana, y si todavía es cierta se ejecuta de nuevo el cuerpo. Este proceso de evaluación de la expresión booleana y ejecución del cuerpo se repite mientras la expresión sea cierta. Cuando se hace falsa, finaliza la repetición.

Estructura repetir (repeat o Do While)

• Se llama Repetir a la estructura algorítmica que se ejecuta un número definido de veces hasta que la condición se torna verdadera.

Representación en pseudocodigo:• Mientras:Mientras AccionesFin_mientras • Repetir:Repetir AccionesHasta que EJEMPLO:Calcular la suma de los cuadrados de los primeros 100 números enteros y escribir el resultado.

Solución estructura Repetir:

Centinelas:• En un ciclo While controlado por tarea, la condición de While especifica que el cuerpo del ciclo debe continuar ejecutándose mientras la tarea no haya sido completada.• En un ciclo controlado por centinela el usuario puede suspender la introducción de datos cuando lo desee, introduciendo una señal adecuada llamada centinela.• Un ciclo Repetir controlado por centinela es cuando el usuario digita una letra para salir como por ejemplo S o N para indicar si desea continuar o no. El bucle debe repetirse hasta que la respuesta del usuario sea “n” o “N”.• Cuando una decisión toma los valores de –1 o algún posible valor que no esté dentro del rango válido en un momento determinado, se le denomina centinela y su función primordial es detener el proceso de entrada de datos en una corrida de programa.• Por ejemplo, si se tienen las calificaciones de un test (comprendida entre 0 y 100); un valor centinela en esta lista puede ser –999, ya que nunca será una calificación válida y cuando aparezca este valor se terminará de ejecutar el bucle.• Si la lista de datos son números positivos, un valor centinela puede ser un número negativo.• Los centinelas solamente pueden usarse con las estructuras Mientras y Repetir, no con estructuras Desde/Para Ejemplo de centinelas:• Suponga que debemos obtener la suma de los gastos que hicimos en nuestro último viaje, pero no sabemos exactamente cuántos fueron.Si definimos gasto1, gasto2, gasto3, ...., -1 donde

gastoi: real es el gasto número i ysumgas: real es el acumulador de gastos efectuados.-1 es el centinela de fin de datos.• Algoritmo:InicioSumgas <--0Leer (gasto)Mientras gasto <> -1 hacerSumgas <-- sumgas + gastoLeer (gasto)Fin_mientrasEscribir (sumgas) FinBanderas:• Conocidas también como interruptores, switch, flags o conmutadores, son variables que pueden tomar solamente dos valores durante la ejecución del programa, los cuales pueden ser 0 ó 1, o bien los valores booleanos True o False.• Se les suele llamar interruptores porque cuando toman los valores 0 ó 1 están simulando un interruptor abierto/cerrado o encendido/apagado.Ejemplo de banderas:• Ejemplo 1: Leer un número entero N y calcular el resultado de la siguiente serie: 1 – 1/2+ 1/3 – 1/4 +.... +/- 1/N.• Algoritmo:InicioSerie <-- 0I <-- 1 Leer (N)Band <-- “T”Mientras I <= N hacerSi band = “T” entoncesSerie <--serie + (1/I)Band <-- “F”SinoSerie <-- serie – (1/I)Band <-- “T”Fin_siI <-- I + 1Fin_mientrasEscribir (serie)FinFin de la clase.Gracias por asistir.PUBLICADO POR SALOMONAQUINO EN 21:38 2 COMENTARIOS: LUNES, 10 DE SEPTIEMBRE DE 2007

Practica 8: Ejercicios con Estructura FOR.Materia: Lógica Computacional.Profesor: Lic. Salomón Aquino.

Objetivos. Al finalizar la práctica los estudiantes serán capaces de: • Resolver Problemas usando estructuras desde con contadores y acumuladores.

Repetición: El bucle For.Es el bucle más adecuado para implementar bucles controlados por contador que son bucles en los que un conjunto de sentencias se ejecutan una vez por cada valor de un rango especificado.Es quizá la más frecuente estructura usada para crear ciclos en C. Esta sentencia incluye una expresión que especifica el valor inicial de un índice, otra expresión que determina cuándo se continúa o no el bucle y una tercera expresión que permite que el índice se modifique al final de cada pasada.De forma general el ciclo FOR se representaría así:

for ( [valor inicial]; [valor final]; [incremento o decremento])sentencia;

Y en el caso que el ciclo FOR esté compuesto por más de una línea de sentencias se escribiría así:for ([valor inicial]; [valor final]; [incremento o decremento]){ sentencia 1;sentencia 2;sentencia N;}La inicialización indica una variable (variable de control) que condiciona la repetición del bucle. Si hay más, van separadas por comas:

for (a=1,b=100;a!=b;a++,b- -){Normalmente se utilizan los bucles For siempre que exista un número necesario y predefinido de iteraciones.Ejemplo 1:El siguiente ejemplo muestra como utilizar el for para mostrar un listado de números del 1 al 15.#include stdio.h>#include stdlib.h>main (){int i;printf ("Numeros del 1 al 15\n\n\n");for (i=1;i<=15;i++)printf ("%d\n",i);system(“pause”); return 0;}

Ejemplo 2:Escriba un programa que escriba los números del 15 al 1 (descendente).

#include stdio.h>#include stdlib.h>main (){int i;printf ("Numeros del 15 al 1\n\n\n");for (i=15;i>=1;i--)printf ("%d\n",i);system(“pause”); return 0;}Ejemplo 3. El siguiente ejemplo suma los cinco primeros números enteros. #include stdio.h>#include stdlib.h>main (){int isuma,ivalor;isuma=0;for (ivalor=1; ivalor<=5; ivalor++){ isuma+= ivalor;printf(“\n%d”,isuma);}Printf(“\n”);system(“pause”); return 0; }En C++ se podría haber escrito el fragmento de código del for, de la siguiente manera:For (int ivalor=1; ivalor<=5; ivalor++);C++ permite declarar e inicializar la variable de control del bucle dentro del bucle for. Se pueden declarar variables inmediatamente antes de la instrucción que realmente las utiliza.Los rangos de incremento/ decremento de la variable o expresión de control del bucle pueden ser cualquier valor y no siempre 1, por ejemplo:#include stdio.h>#include stdlib.h>main(){int n;for (n=0; n<100; n+=20)printf("%d \t %d \n", n, n*n);system(“pause”); return 0;}Otros ejemplos:1) int c;for (c=’A’; c<=’Z’; c++)

printf("%c", c);2) for (i=9; I>=0; I-=3)printf("%d", (i*i));3) for (i=1; i<100; I*=2)printf("%d", i);4) # define MAX 25int i,j;for (i=0, j=MAX; i<=j; i++,j--)printf("%d", (i+2*j));5) double p;for (p=0.75; p<=5; p+=0.25)printf(“la respuesta es: %.21f”,p);6) double x;for (x=pow(y,3.0); x>2.0; x=sqrt(x))printf(“x vale %.5e”,x);Naturalmente, cuando la variable de control no es de tipo int, se tendrán menos garantías de precisión.Se debe tener cuidado con el uso de las condiciones del bucle For, ya que debemos estar seguros de que en algún momento el bucle terminará y no que seguirá ejecutándose infinitamente. Por eso no es recomendable modificar la condición de incremento como parte de las instrucciones del cuerpo del ciclo, o se corre el riesgo de que se vuelva infinito.

Para abortar un bucle infinito se presiona CTRL + C

La sentencia Continue hace que la ejecución de un bucle vuelva a la cabecera del bucle.Ejemplo:#include stdio.h>#include stdlib.h>int main(){int clave,i;puts ("introduzca -9 para finalizar");clave =1;for (i=0; i<8; i++){if (clave== -9) continue;scanf("%d", &clave);printf("clave %d\n",clave);}printf("valores finales i=%d clave=%d", i,clave);system(“pause”);return 0;}Ejemplo 6El siguiente ejemplo nos pide una cadena de 10 caracteres y nos muestra dicha cadena en forma invertida.

/* Uso de la sentencia FOR. */#include stdio.h>#include stdlib.h>#define ctam_array 10

int main (){int idespl;char carray[ctam_array];printf("Escriba una palabra de 10 espacios:\n");for (idespl=0; idespl carray[idespl]=getchar();for (idespl=ctam_array -1; idespl>=0;idespl--)putchar(carray[idespl]);printf("\n");system("pause");return 0;}

EJERCICIOS

Desarrolla los siguientes programas:1. Escriba un programa que pida N números y nos diga cuál es el mayor y cuál es el menor y la posición en que fueron leidos cada uno.2. Escriba un programa que pida las notas y nombres de cinco alumnos y calcule el promedio general.3. Escriba un programa que presente en pantalla la tabla de multiplicar entre 1 y 10, requerida por el usuario.4. Escribir un programa que visualice un triángulo isósceles de 10 filas, como se muestra a continuación:*******************************************************PUBLICADO POR SALOMONAQUINO EN 21:56 43 COMENTARIOS: DOMINGO, 9 DE SEPTIEMBRE DE 2007

Clase 8: Estructuras repetitivas e iterativas.Materia: Lógica ComputacionalProfesor: Lic. Salomón Aquino.Objetivos de la clase:Al final de la clase los alumnos y alumnas serán capaces de:Identificar y diferenciar el uso de las estructuras repetitivas e iterativas.

Entender el uso de contadores y acumuladores y aplicarlo en la solución de problemas repetitivos e iterativos.ESTRUCTURAS REPETITIVAS E ITERATIVAS:Son operaciones que se deben ejecutar un número repetido de veces.El conjunto de instrucciones que se ejecuta repetidamente cierto número de veces, se llama Ciclo, Bucle o Lazo.Iteración es cada una de las diferentes pasadas o ejecuciones de todas las instrucciones contenidas en el bucle.Fases de un Programa Cíclico:Entrada de datos e instrucciones previasLazo o bucleInstrucciones finales o resto del procesoSalida de resultados

Ejemplo de bucle infinito:

Ejemplo de bucle finito:

Estructura Desde/Para

Se usa frecuentemente cuando se conoce de antemano el número de veces que se ejecutarán las acciones de un bucle.A la estructura Desde/Para se le conoce como Repetitiva. Para utilizar esta estructura en algoritmos, debemos hacer uso de contadores y algunas veces de acumuladores, cuyos conceptos se describen a continuación:Contador y Acumulador:Un contador es una variable cuyo valor se incrementa o decrementa en una cantidad constante cada vez que se produce un determinado suceso o acción.La inicialización consiste en asignarle al contador un valor. Se situará antes y fuera del bucle.Representación: + Si en vez de incremento es decremento se coloca un menos en lugar del más.Ejemplo: i = i + 1Acumulador: Es una variable que suma sobre sí misma un conjunto de valores para de esta manera tener la suma de todos ellos en una sola variable.La diferencia entre un contador y un acumulador es que mientras el primero va aumentando de uno en uno, el acumulador va aumentando en una cantidad variable.Representación: + Ejemplo de contador y acumulador:

Fin de la clase.Gracias por asistir.PUBLICADO POR SALOMONAQUINO EN 22:29 3 COMENTARIOS: LUNES, 3 DE SEPTIEMBRE DE 2007

Solucion a ejerciciosEjercicio 1:

#include iostream.h>#include stdlib.h>#include stdio.h>

int main(){float venta, comision;printf("introduzca la cantidad vendida: ");scanf("%f",&venta);printf("\n");if ((venta>=2000 && venta <=10000))comision = venta*0.07;elseif (venta>10000 && venta <=20000)comision = venta * 0.1;elseif (venta>20000)comision = venta *0.15;elseprintf("valor menor de 2000\n");printf("la comision es: %.2f \n",comision);system("PAUSE");return 0;}

Ejercicio 2:

#include iostream.h>#include stdlib.h>#include stdio.h>

int main(){int a,b;printf("introduzca el valor de a: ");

scanf("%f",&a);printf("\n");printf("introduzca el valor de b: ");scanf("%f",&b);printf("\n");if (a==b)printf(" a = b \n");else{printf(" no son iguales \n");if (a > b)printf("a > b \n");elseprintf("a < b \n");}

system("PAUSE");return 0;}

Ejercicio 4:

#include iostream.h>#include stdlib.h>#include stdio.h>

int main(){float a, b, r;int opc=0;char ch;printf("introduzca el valor de a: ");scanf("%f",&a);printf("\n");printf("introduzca el valor de b: ");scanf("%f",&b);printf("\n");

printf( "Elige el numero en el menu:\n\n" );printf( "1 - Sumar\n" );printf( "2 - Restar\n" );printf( "3 - Multiplicar\n" );printf( "4 - Dividir\n" );fflush(stdin);//opc= getchar();

//printf("opc = %d \n",opc);ch = getchar();

switch (ch) {case ('1'):r = a+b;break;case ('2'):r = a - b;break;case ('3'):r = a * b;break;case ('4'):r = a / b;break;default:printf("La opcion No. %c no esta definida\n", ch);}

printf("el resultado es : %f \n",r);system("PAUSE");return 0;}