Arreglos Unidimensionales (Lectura y Escritura)

Como vimos anterior mente la estructura repetitiva for() es la mas usada para trabajar con los arreglos, a continuación veremos como se ingresan datos en el arreglos, y a su vez como se los presentan por pantalla.
Ingreso de datos en un arreglo unidimensional.
Sabemos que para el ingreso por teclado se usa la función scanf(); y también que para cada tipo de dato se necesita un especificador del dato como por ejemplo el "%d" para datos de tipo enteros.
En arreglos se usa el mismo formato de ingreso de cuando nos referimos a datos normales, es decir:
scanf("Especificador de datos",&"Arreglo"[tamaño/posición]);

La única diferencia que se puede divisar es que junto a la variable debemos poner el tamaño o la posición del dato del arreglo.

A continuación veremos como es la escritura de un arreglo con la función for().

#include<stdio.h>
#include<conio.h>
void main()
{
  int num[10];
  int i;
  for(i=0;i<10;i++)
   {
     scanf("%d ",&num[i]);
   }
}


Así mismo para mostrar por pantalla se usa la función printf(); dentro de un bucle repetitivo a continuación se muestra:


#include<stdio.h>
#include<conio.h> 
void main()
{ 
  int num[10];
  int i;
  for(i=0;i<10;i++)
   { 
     printf("%d ",num[i]);
   }
}

Arreglos Unidimensionales (Vectoriales)

Como su nombre lo dice poseen una sola dimensión. Como ya vimos anteriormente se las declara de la siguiente manera:
En el caso de que fuera un arreglo de enteros:
int numeros[4];
Esto nos indica que es un arreglo unidimensional de tamaño cuatro, es decir del cero (0) al tres (3).
Para que nuestro arreglo no obtenga valores basuras es preferible inicializarlo si es que es un arreglo que sirva como contador, acumulador o que sea alguna respuesta de alguna operación matemática y se lo hace de la siguiente manera:
numeros[0]=0;
numeros[1]=0;
numeros[2]=0;
numeros[3]=0;
Como podemos apreciar esta manera de hacerlo es muy tediosa ya que si en el caso de tener un arreglo de tamaño 10 tendríamos que usar 10 lineas inicializando del cero al nueve. Pero como sabemos el uso de las estructuras repetitivas se le puede dar el uso para recorrer e inicializar nuestro arreglo así:


*/Do /While/*                                                                    */While/*
#include<stdio.h>                      #include<stdio.h> 
#include<conio.h>                      #include<conio.h> 
void main()                            void main()                                     

{                                       { 
int num[10];                            int num[10];
int i=0;                                int i=0;
do                                       while(i<10)
  {                                       {
   num[i]=0;                               num[i]=0; 
   i++;                                    i++; 
  }while(i<10);                           }
}                                       }
*/For/*
#include<stdio.h>           
#include<conio.h>           
void main()

{ 
int num[10];
int i;
for(i=0;i<10;i++)
  {          
   num[i]=0;
  }
}   
La estructura repetitiva que es mas comun usar  para los arreglos es la estructura repetitiva for() ya que su uso es mas sencillo debido a que en su interior tenemos la condición y el contador

ARREGLOS

En este nuevo e interesante tema como lo son los arreglos se trata de la capacidad de la declaración de datos en forma de arrays (arreglos) es decir podemos asignar varios valores a una sola variable.
Hay dos tipos de arreglos mas usados que son:

• Arreglos Unidimensionales o Vectoriales
• Arreglos Bidimensionales o Matriciales

Arreglos Unidimensionales.- Son conocidos como vectoriales porque poseen una sola dimensión, como sabemos y hemos usado las cadenas de carácter se las declara como un arreglo de este tipo en donde cada carácter se ubica en cada espacio de memoria. Pero también se las puede declarar de los otros tipos de datos como los son los enteros. 

Se los declara de la siguiente manera:

char cad[10];

int num[25];

char, int: Tipos de datos.

cad, num: Son variables de ejemplo, el programador las puede definir.

[10],[25]: Tamaño del arreglo unidimensional el numero entre los corchetes [] debe ser positivo.

Arreglos Bidimensionales.- Comunmente referenciados como matrices, porque las matrices poseen en su estructura filas y columnas, la diferencia en la declaracion con los unidimensionales es que al momento de hacerlo se acompaña la variable con dos valores entre corchetes el primero refiriéndose a las filas y el segundo a las columnas.

Entonces tenemos que:

char cad[5][3];

int num[4][4];

char, int: Tipos de datos.

cad, num: Son variables de ejemplo, el programador las puede definir.

[5],[4]: Tamaño del arreglo bidimensional de las filas.(Filas o renglones son horizontales)

[3],[4]: Tamaño del arreglo bidimensional de las columnas.(Columnas son verticales)

Sea arreglo de una o dos dimensiones que vaya a recibir los resultados de alguna operación se recomienda inicializarlo.

Estructuras Repetitivas (Ejercicio 15-16)

Ahora veremos la estructura repetitiva for()
Anteriormente en  Tipos de estructuras de programas la función for() entre sus paréntesis tiene en este orden:
for([Declaracion_e_Inicializacion];[Condición];[Contador])
Cada uno de los elementos van separados por un punto y coma.
Haremos como ejemplo los mismos ejercicios de las estructuras repetitivas anteriores pero usando la función for().

Programa 15:
Ingresa 10 numeros y los sume.

#include<stdio.h>
#include<conio.h>
    void main()
{ 
    clrscr();
    int n, c=0,s=0;/*es importante inicializar para que al
                     momento de trabajar con estos no tomen 
                     algun valor "basura"*/
    for(c=1;c<=10;c++)
    {
     
     printf("Numero %d: ",c);/* Presentación por pantalla*/
     scanf("%d",&n); /*Ingreso por teclado*/

     s=s+n; /*Acumulador, por cada vez que el bucle continue se
               suma el numero que se ingrese y esta variable 
               acumulara el valor resultante hasta terminar el ciclo*/

    };
    printf("La suma es:  %d",s); 

    getch();
}
A diferencia de los ejemplos anteriores el contador 'c' se lo inicializa a 1 y la condición es que 'c' sea menor o igual a 10.


Programa 16:
Indica si un numero es perfecto o no.

Como sabemos que un número perfecto es un número natural que es igual a la suma de sus divisores propios positivos, sin incluirse él mismo, entonces tenemos.

#include<stdio.h>

#include<conio.h>
void main()

{

clrscr();
   int x=1,y=0,z=0,a;
  printf("Ingrese un numero: ");
  scanf("%d",&a);
   for(x=1;x<a;x++) 
   {
    z=a%(x);
    if(z==0)
    {
      y=y+x;
    }
   }
  if(y==a)
   printf("\n\tEl numero es perfecto");
    else
     printf("\n\tEl numero no es perfecto");
  getch();
}
NOTA:
Las variables que mas común son usadas para los contadores son las letras: c,i,j,k.
Pero tampoco esta mal usar cualquier letra del abecedario o palabras.

Estructuras Repetitivas (Ejercicio 13-14)

Ahora vamos a realizar Ejercicios con el do/while(); como vimos anteriormente el do/while(); a diferencia de while() es que el segundo primero realiza o revisa condición y luego realiza las sentencias que se encuentran continuamente, y el do/while(); es lo contrario primero realiza las sentencias en su interior y luego realiza la condición. Otra diferencia bien particular es que el while() no tiene punto y coma al finalizar su linea pero el do/while(); si.


Realizaremos los mismos programas que con el while().
Programa 13:
Ingresa 10 numeros y los sume.

#include<stdio.h>
#include<conio.h>
    void main()
{ 
    clrscr();
    int n, c=0,s=0;/*es importante inicializar para que al
                     momento de trabajar con estos no tomen 
                     algun valor "basura"*/
    do
    {
     c=c+1;/*Contador por cada vez que trabaje el bucle se suma en uno*/ 
     printf("Numero %d: ",c);/* Presentación por pantalla*/
     scanf("%d",&n); /*Ingreso por teclado*/

     s=s+n; /*Acumulador, por cada vez que el bucle continue se
               suma el numero que se ingrese y esta variable 
               acumulara el valor resultante hasta terminar el ciclo*/

    }while(c<10);
    printf("La suma es:  %d",s); 

    getch();
}
Este ejercicio realiza la misma función que el Programa 11: y como vemos lo único que cambia es la función while() por la do/while();. 


Programa 14:
Indica si un numero es perfecto o no.

Como sabemos que un número perfecto es un número natural que es igual a la suma de sus divisores propios positivos, sin incluirse él mismo, entonces tenemos.

#include<stdio.h>

#include<conio.h>
void main()

{

clrscr();
   int x=1,y=0,z=0,a;
  printf("Ingrese un numero: ");
  scanf("%d",&a);
  do
   {
    z=a%(x);
    if(z==0)
    {
      y=y+x;
    }
    x++;
   }while(x<a); 
  if(y==a)
   printf("\n\tEl numero es perfecto");
    else
     printf("\n\tEl numero no es perfecto");
  getch();
}
Veremos el mismo caso anterior en este ejercicio.