Estructuras Secuenciales (Ejercicios 5 - 6)

Programa 5:
Que permita el ingreso de dos números , los sume y reste.
#include<stdio.h>
#include<conio.h>
    void main()
{ 
    clrscr();
    int n1, n2,s ;
    printf("Primer numero");/* Presentación por pantalla*/
    scanf("%d",&n1); /*Ingreso por teclado*/

    printf("Segundo numero"); /* Presentación por pantalla*/ 
    scanf("%d",&n2);  /*Ingreso por teclado*/
    r=n1-n2;   /*A la variable r se le asigna la resta de n1 y n2*/
    s=n1+n2; /*A la variable s  se le asigna la suma de n1 y n2*/

    printf("La suma es:  %d\nLa resta es: %d ",s,r); 
    getch();

}
NOTA:
El primer %d representa a la primera variable que es 's', el segundo %d a la segunda 'r' y así sucesivamente según el numero de variables a presentar.


Programa 6:
Que permita el ingreso de un numero, calcule el cuadrado y la raíz cuadrada.
#include<stdio.h>
#include<conio.h>
#include<math.h>  /* Nueva librería que usaremos*/
   void main()
{ 
    clrscr();
    int n, r,c ;
    printf("Número");/* Presentación por pantalla*/
    scanf("%d",&n); /*Ingreso por teclado*/

    r=sqrt(n); /* sqrt(); funcion trabaja con libreria 
                                math.h calcula la raiz cuadrada*/
    c=pow(n,2);/* pow(a,b); trabaja con libreria math.h 
                                   calcula la potencia de un numero donde 
                                   'a' es la base y 'b' es el exponente*/

    printf("La raiz cuadrada es:  %d\nEl cuadrado es: %d ",r,c); 
    getch();

}


NOTA:
Por el momento asumiremos que solo se ingresan números positivos, ya que la raíz cuadrada de números negativos esta indefinida o no existe.
Luego veremos como validar que solo se pueda ingresar números positivos. 

Estructuras Secuenciales (Ejercicios 3 - 4)

Programa 3:
Que permita el ingreso de dos números y los sume.
#include<stdio.h>
#include<conio.h>
    void main()
{ 
    clrscr();
    int n1, n2,s ;
    printf("Primer numero");/* Presentación por pantalla*/
    scanf("%d",&n1); /*Ingreso por teclado*/

    printf("Segundo numero"); /* Presentación por pantalla*/ 
    scanf("%d",&n2);  /*Ingreso por teclado*/
    s=n1+n2; /*A la variable s de suma se le asigna la suma de n1 y n2*/

    printf("La suma es:  %d",s); /*Presenta por pantalla mensaje y

                                  resultado donde %d representa 

                                 numero entero y fuera de las comillas 

                                 dobles una coma y la variable a quien nos 

                                 referimos con el %d*/
    getch();
}



Programa 4:
Que permita el ingreso del nombre, año de nacimiento y año actual; con eso calcular la edad.
#include<stdio.h>
#include<conio.h>
    void main()
{ 
    clrscr();
    char name[20];
    int aa, an ,r ;
    printf("Nombre: ");/* Presentación por pantalla*/
    scanf("%[^\n]",&name);    
    printf("Año actual: ");/* Presentación por pantalla*/
    scanf("%d",&aa); /*Ingreso por teclado*/

    printf("Año nacimiento: "); /* Presentación por pantalla*/ 
    scanf("%d",&an);  /*Ingreso por teclado*/
    r=aa-an; /*A la variable r se le asigna la resta de aa y an*/

    printf("%s, nació en %d y tiene %d años",name, an, r); 

    getch();
}

NOTA:
Como vemos en el ultimo printf(); hemos puesto:
  printf("%s nació en %d y tiene %d años",name, an, r); 
en donde hay dos %d, pues cada uno corresponde a las variables que están fuera de las comillas dobles, para ubicarlas se pone las variables en el orden de como queremos que se presenten, así sea de caso de dos o mas datos de un solo tipo.

Estructuras Secuenciales (Ejercicios 1 - 2)

Comenzaremos con escribir ejemplos de códigos en Lenguaje C de este tipos de estructuras, explicarlos e ir subiendo de nivel de fácil hasta llegar a programas un poco mas complejos.

Programa 1:

Permite la presentación de un mensaje por pantalla.

Como lo más común siempre se usa la frase "Hola mundo" pues para no perder la costumbre usemosla :)

#include<stdio.h> /*Libreria que contiene las funcion print();*/

#include<conio.h> /*Libreria que contiene funciones clrscr(); y getch();*/

void main()  /*Inicio del programa principal*/

{ /*Llave de abrir*/

  clrscr();  /*llamada Clear Screen "limpiar pantalla" borra los datos de la 
                       pantalla o si se corrio previamente otro programa */
     printf("Hola mundo");  /*presenta por pantalla solo el mensaje que esta 
                              entre comillas dobles*/
  getch();  /* getchar o ingresar caracter se usa para hacer una pausa y se 
                     continua precionando algun caracter*/

}/*Llave de cerrar*/


Programa 2:

Permite la presentación de un mensaje por pantalla y un dato ingresado.


#include<stdio.h> /*Libreria que contiene las funcion print();*/

#include<conio.h> /*Libreria que contiene funciones clrscr(); y getch();*/

void main()  /*Inicio del programa principal*/

{ /*Llave de abrir*/

  clrscr();  /*llamada Clear Screen "limpiar pantalla" borra los datos de la 
                        pantalla o si se corrio previamente otro programa */
 char nom[20]; /*Declaracion de variable de tipo cadena de caracter 
                 tamaño 20*/
printf("Ingrese su nombre");
scanf("%[^\n]",nom);
printf("Hola, %s, ¿como esta?",nom);/*presenta por pantalla solo el mensaje    
                                     que esta entre comillas dobles, el %s 
                                     indica en que posicion va a ir 
                                     ubicado el dato y para saber a que 
                                     dato nos referimos debemos poner la 
                                     variable fuera de las comillas*/
  getch();  /* getchar o ingresar caracter se usa para hacer una pausa y se 
                     continua precionando algun caracter*/

}/*Llave de cerrar*/

Introducción (Tipos de estructuras de programas)

Hay tres tipos de estructuras de programas y tenemos que son:

1. Estructuras secuenciales
2. Estructuras selectivas. 
3. Estructuras repetitivas.

1.- Estructuras Secuenciales:Como su nombre mismo lo dice es el que al momento de correr la linea de código el compilador lo hace secuencialmente línea por línea sin ningún salto.

2.- Estructuras Selectivas:

Este tipo de estructuras al evaluar una sentencia que nos da un valor de verdadero o falso realiza la tarea asignada. Trabaja con las funciones if() y else.

Dentro del paréntesis de la función if() se ubica la sentencia que para ayudarnos a evaluar usamos los operadores lógicos o relacionales vistos en Introducción (Operadores Aritméticos, Lógicos y Relacionales), según sea el caso, el if() se realiza cuando la sentencia nos da un valor de verdadero.

La función else no lleva paréntesis y se la usa en el momento que quisiéramos hacer el caso del valor de verdad falso de la función if().
Con este tipo de función hay Simples que es solamente con un if(); que tiene una sentencia o compuestas que tienen mas de una sentencia entre sus paréntesis, así como también hay if(); anidados es decir un if(); dentro de otro.

También tenemos en este tipo de estructura la función switch() y la función case.

switch es la función que nos permite, que al ingresar en una variable un valor o un caracter (una letra) nos resulte o seleccione el caso (case) correspondiente al ingresado.

A diferencia del if() que trabaja con el else, el switch trabaja con el default y este funciona cuando ninguno de los casos corresponde al del ingresado.

3.-Estructuras Repetitivas:

Las estructuras repetitivas las dividimos en tres tipos que son:

    3.1.    while()
    3.2.   do/ while();
    3.3.    for()

Comunmente estas funciones tienen en su funcionamiento unos términos representadas por variables que las acompañara y se denominan CONTADOR y ACUMULADOR. 

El contador es una variable que se va aumentando o disminuyendo de uno en uno o más según sea el caso en cada vuelta que se realice en el bucle, con esto evitaremos que se nos vuelva un bucle infinito.

y el otro término denominado Acumulador, existen dos tipos de suma y multiplicación, con esto guardaremos el resultado acumulado en cada una de las vueltas dadas en el bucle.

while()

Este tipo de estructura primero evalúa una sentencia dando el valor de verdadero o falso, si el valor de verdad resulta verdadero el while() realizara las lineas de código que se encuentre dentro de ella hasta que la sentencia sea falsa..

Es decir mientras la sentencia sea verdadera se repetirá 'n'veces las sentencias. 
Formato:
while(sentencia_a_evaluar)
{
  [Sentencias_a_repetir];
}

do/while();

A lo contrario del while esta función primero realiza lo que se encuentre dentro de ella para luego evaluar una sentencia y así mismo terminara el bucle cuando esta de un valor de falso.

Formato:
do{
       [Sentencias_a_repetir];
      }while(sentencia_a_evaluar);


for()

Esta función dentro de sus paréntesis tiene declaración e inicialización de la variable, la sentencia a evaluar y el contador, y realizara o repetirá cuantas veces sea necesario hasta que la sentencia a evaluar sea falsa.
Formato:

for(inicialización;sentencia_a_evaluar;contador)
{
   [sentencias_a_repetir];
}

NOTA: 

Como apreciamos estas funciones al terminar la línea no terminan en punto y coma, la unica que lo hace es el while del do/ while();

Introducción (Lectura y Escritura de datos)

Tenemos a las funciones scanf(); y printf(); que están incluidas en la librería <stdio.h>, la primera "scanf();" sirve para ingresar datos mediante el teclado, el formato de esta función es:

scanf("Especificador de datos",&"variable");

en donde el tipo de dato lo podemos identificar de las siguientes maneras:

Los tipos de datos más común son:

Especificador                      Tipo
"%d"                             dato entero

"%f"                              dato coma flotante

"%s"                             dato cadena de caracter
"%c"                             dato  caracter

"%[^\n]"                       dato cadena de caracter con espacio

Importante, tener en cuenta que hay que poner un ampersand "&" para que el valor indicado no se pierda.


La segunda función es "printf();" esta trabaja con presentaciones por pantalla, el texto que se introduzca entre los parentesis va entre comillas dobles, el formato es el siguiente:

printf("TEXTO");

• Para presentar un resultado el formato es:

              printf("tipo_de_dato",variable);

• Para presentar un resultado con texto:

             printf("TEXTO tipo_de_dato",variable);

Con el printf(); podemos dar formato al texto con las secuencias de escape: como una sangría (tabulación), un salto de línea etc., veremos los mas usados

Secuencia       Descripción                           
 \a            Sonido audible (bell)
 \b            Retroceso (backspace)
 \f            Salto de formato (formfeed)
 \n            Saltar una línea (linefeed)
 \r            Retorno de carro (carriage return)
 \t            Tabulación horizontal (H Tab)
 \v            Tabulación vertical (V Tab)
 \\            Barra invertida (backslash) [2]
 \'            Apóstrofo (comilla simple)
 \"            Doble comilla

Al momento de identificar el tipo de dato anteriormente se debió declarar las variables que sean necesarias para el uso de programa.

Como se señalo anteriormente hay cuatro tipos de datos mayormente usados que son dato de tipo entero, coma flotante, caracter y cadena de caracter, pero en la declaración se las representa así:

int             entero

float          coma flotante

char          caracter

char []       cadena de caracter

Como vimos en Introducción (partes de un programa) que podíamos declararlas de dos maneras y en que lugar se los hacía, ahora vamos a ver como se las declara.

Usando las variables y el tipo de dato correspondiente se las declara así:

int numero; /* un dato de nombre numero de tipo entero*/

int num, num1; /* dos o más datos separados por una coma con sus respectivos nombres de tipo entero*/

float numd; /* un dato de nombre numd de tipo decimal*/

char letra; /* un dato de nombre letra de tipo caracter*/

char letras[20];/* un dato de nombre letras de tipo cadena de caracter con tamaño 20*/

Debemos también mencionar que las variables debemos darle nombre iniciado con una letra y terminarla con números pero nunca iniciarla con un numero ya que nos daría error y que si las declaramos con minúsculas debemos usarla a lo largo del programa de la misma forma porque el compilador pone diferencias entre las mayúsculas y las minúsculas.

NOTA:

Podemos observar que en esta clase cada linea de código se termina con un punto y coma como vimos en Introducción (Sintaxis)

Introduccion (Operadores Aritméticos, Lógicos y Relacionales)

En C tenemos tres tipos de Operadores como lo son:

• Aritméticos
• Lógicos
• Relacionales

Operadores Aritméticos:

Este tipo de operadores son conocidos en Matemáticas se utilizan para realizar operaciones sea cual sea como de suma, resta, multiplicación y división (residuo y cociente) y que en C se los representa así:

• SUMA                                     +
• RESTA                                    -
• MULTIPLICACIÓN              *
• DIVISIÓN                             %          /

Podemos darnos cuenta que el la división tenemos dos signo (operadores) cada uno tiene una función distinta el operador % que representa el módulo nos da como resultado de la división el residuo y el signo / nos da como resultado de la división el cociente.

Podemos usar los operadores así:

a+1;

b*2;

c-a;

d/4;

b%2;

Operadores Lógicos:

Este tipo de operadores comúnmente conocidos en español como Y, O, NO en inglés como AND, OR, NOT se los representa en C como:

• Y       AND      &&
• O       OR         ||
• NO    NOT      !

Cada uno de los operadores lógicos trabaja de una manera diferente al dar valores de Verdadero o Falso o de Uno (1) o Cero (0) a dos proposiciones o depende sea el caso.

 AND:

Trabaja de la siguiente manera:

   p       q      p&&q  

0        0          0

0        1          0

1        0          0

1        1          1

El operador AND como podemos ver nos da un valor verdadero solo y solo cuando tenemos dos proposiciones positivas o reales.

OR: 

Opera de la siguiente forma:

 p       q      p||q 

0        0         0

0        1         1

1        0         1

1        1         1

OR a diferencia de AND nos da un valor de 1 cuando por lo menos una de las preposiciones es verdadera.

NOTA:

Este operador es totalmente diferente a los otros dos porque solo se necesita de una sola proposición, y trabaja de la siguiente manera:

  p       !p 

 0         1

 1         0

Como vemos nos da un valor de verdad opuesto al de la proposición es decir si esta es falsa la hace verdadera y viceversa. 

Operadores Relacionales

Este tipo e operadores nos permiten evaluar las relaciones sean estas de igualdad, no igualdad verificar si los términos a evaluar son mayores o menores.

Y al igual que los operadores lógicos estos dan valores de Unos o Ceros según sea el caso en donde Uno representa a Verdadero y Cero a Falso.

Entre los operadores relacionales tenermos:

= =      Igual

>=       Mayor o igual que
>          Mayor que
<=     Menor o igual que
<       Menor que
!=      NO igual (o diferente)

NOTA:

Apreciando a simple vista el signo de Igualdad es diferente al de las Matemáticas en el que solo usamos =. En Borland se usa ese signo (=) para la asignación, es decir asignar o dar un valor real a una varibable.

Ejemplo:

7 == 7    V

8<= 14   V

5 >= 6    F

45 > 3    V

63 < 51  F

8 != 3    V

Introducción (Sintaxis)

Continuando con la Introducción, hay que tener bien en claro que en Borland C cada línea de código debe terminar en punto y coma (;) exceptuando algunas funciones como por ejemplo:

for(i=0;i<=n;i++) /*Esto es de estructuras repetitivas función FOR*/

como vemos esa linea no termina en punto y coma, y así también tenemos que en la inclusión de las librerías, en la línea del main(), y otras funciones más que veremos en el transcurso de los post no deben llevar punto y coma .

Pero, a la vez tenemos algunas funciones en donde si es necesario como lo son la función de presentación por pantalla printf(); y en la de ingreso de datos scanf();

El punto y coma también se lo usa al final de la línea de la asignación de datos como vemos:
a=b;
c=1;
b=1;

Otra aclaración de sintaxis es que en Borland existen diferencias entre las letras mayúsculas de las minúsculas es decir, no es correcto decir que:

a es igual a A o que
B es igual a b.
Una vez visto esto se evita el cometer errores declarando una variable en minúscula y usándola en el resto del programa en mayúsculas o viceversa.

Introducción (partes de un programa)

Esta será nuestro primer post en donde entramos a codificar, pero antes de sumergirnos más en el tema debemos tener conocimiento de las partes de las líneas de código. 

Importante siempre indispensable son las Librerías las cuales se las declara al inicio del programa o antes del void main() unas de las mas conocidas tenemos.

dos.h

string. h
math.h
stdio.h
time.h
stdlib.h
ctype.h
locale.h
signal.h
setjmp.h
conio.h
graphics.h

No las usaremos todas a menos q sea necesario, las mas utilizadas de las antes mencionadas son:  math.h,  stdio.h,  time.h,  conio.h,  string. h, dos.h.

Al momento de declararlas lo hacemos de la siguiente manera:

#include<conio.h>

#include<mat.h>
#include<stdio.h>......

y así con las demás que vayamos a utilizar, se preguntaran el ¿por qué del #include? pues es para hacer la inclusión del archivo que se encuentra en la carpeta Bin del Borland con extención .h.

Luego si es que vemos que es necesario tenemos la declaración de las Funciones creadas por el usuario, las cuales veremos más adelante por este mismo medio, después sigue la declaración de las variables globales, si lo creemos necesario.

Continuando con el void main(), que es la función principal que le da inicio a nuestro programa indispensables son las llaves de cerrar y abrir '{','}', y tenemos también la declaración de variables es uno de los puntos mas importantes porque sin ellas nuestro programa no tendría sentido podemos declarar las variables de dos formas:

• Forma Global
• Forma Local

Globalmente las declaramos para cuando vamos a usarlas en todo el programa incluyendo las funciones declaradas por el usuario.

Localmente lo hacemos cuando vamos a usarlas solo donde es dentro del main().

Así tenemos el siguiente ejemplo:

#include<conio.h> /* Inclusión Librerias*/
/* declaración de variables globales*/ 
void main() /*principal*/
{/*Llave de abrir*/
   /* declaración de variables locales*/
  /*Código, Funciones y demás sentencias*/
}/*Llave de cerrar*/
Como podemos ver tenemos un texto encerrado en "*/ /*" pues es un comentario de programa el cual al momento de compilarlo no intervendrá para nada en nuestro código y podremos ponerlo en cualquier parte de nuestro programa.

Introducción (Teclas funcionales)

Como una pequeña introducción vamos a dar unos trucos con teclas funcionales en C, comunmente cuanto trabajamos en Word, Excel, Power Point; o cualquier programa que sea editor de cualquier tipo usamos los atajos Ctrl+C, Ctrl+V, Ctrl+X; para Copiar, Pegar y Cortar respectivamente; pues Borland C también los tiene pero  con un cambio de teclas.

En este caso usaremos las teclas Ctrl+Insert para Copiar, Shift+Insert para Pegar, Ctrl+Supr (o Delete) para Eliminar y Shift+Supr para Cortar.

También tenemos para Deshacer presionamos Alt+Back Space, para Rehacer Shift+Alt+Back Space.

Para Abrir tenemos la tecla F3 y Guardar F2.

Al momento de tener una línea de código terminada o en proceso podemos Compilarlo que es ver los Errores o Warnings (Peligros) presionamos las teclas Atl+F9 o ir al menú Compile-> Compile, y para correr el código una vez estado terminado pulsamos Ctrl+F9 o ir al menu en la parte superior Run->Run.

O si en el caso de toparnos con un bucle que se nos convierte en infinito (es decir es imposible salir de la pantalla) presionamos Ctrl+Pause.

• Entre las ayudas que podremos brindar se encuentran la realización de pseudocódigos, algoritmos, diagramas de flujo, y la misma codificación en mención.

• Comenzaremos con lo mas básico en programación como lo son las estructuras  secuenciales, luego las estructuras selectivas ("if(); else" switch/case), y las estructuras repetitivas ("for(), while(), do/while()").

• En el transcurso de la enseñanza se receptara cualquier tipo de criterio, ayuda o aportación.

Instalación de Borland C

1.- Descargar el Borland desde nuestro blog o aquí.
2.- Una vez descargado descomprimirlo.

3.- Ir al archivo INSTALL.

4.- Nos aparecerá una ventana como la de la imagen, presionar ENTER.

5.-Escribir el Disco que queremos usar, por defecto aparece A, borrarla y escribir C.

6.- Con los cursores ir a "Start Installation" y darle ENTER.

7.- Esperar hasta que aparezca una ventana como esta:

8.- Presionar cualquier tecla y sigue esto:

9.- Para salir de la ventana anterior presionar Esc.
10.- Luego cerrar la siguiente ventana.
11.- Para abrir el Borland ir a esta dirección. C:/BORLANDC/BIN/BC.exe

Información

• Esta sección es para responder cualquier inquietud o duda que, Uds, nuestros usuarios necesiten despejar.

• InfotecknoC esta dispuesto a ayudar sobre codigos, pseudocodigos pequeñas definiciones de algunos terminos de este lenguaje.

• Trataremos de responder o solucionar cualquier pregunta lo mas rapido posible que se pueda, daremos a conocer la BibliografíaWeb de donde podrian buscar más información.

• Tambien se aceptan aportaciones les quedaremos sumamente agradecidos.

                                                                                        INFOTECKNOWEB