3-PI2019-Ejemplos - Vectores - Matrices - Cadenas

FACULTAD DE CIENCIAS EXACTAS Y TECNOLOGÍA (UNT) PROGRAMACIÓN I (E07)
Arreglos
Arreglos unidimensionales o vectores de variables simples
Realizar un programa en lenguaje C que permita cargar un arreglo de caracteres alfabéticos y luego lo presente por
pantalla. Resolver empleando una función para cargar el arreglo, otra para controlar los valores que se ingresan y
otra para presentar por pantalla el arreglo resultante.
//Ejemplo 30
#include <stdio.h>//entrada y salida estándar
#include <ctype.h>//manejo de caracteres
int verificaAlfa(char car);

void cargarArregloAlfabetico(int orden, char V[]);
void mostrarArregloCar(int orden, char V[]);
int main (int argc, char *argv[])

{
char ARREGLO[30];//declaración del vector que contendrá caracteres
int i, orden;
do{
printf("Ingrese el orden del arreglo que desea cargar, menor a 30: ");
scanf("%d", &orden);
}while(orden <0 || orden >30);
//controla que la cantidad de elementos a utilizar no supere la cantidad
máxima de elementos //declarado o que no se ingrese un tamaño negativo
fgetc(stdin);//cuidado!!!! función que lee el enter que se ingresó con el

scanf() anterior
printf("\n\n*** Cargar el arreglo ***\n\n");

cargarArregloAlfabetico(orden, ARREGLO);
/*la variable ARREGLO es el nombre del vector y como el nombre del vector es
un puntero
se está utilizando en este caso llamada por referencia
por definición el nombre de un arreglo es un puntero, que apunta al primer
elemento que se //encuentra en la posición 0
*/
printf("\n\n*** Presentar el arreglo de caracteres por pantalla ***\n\n");

mostrarArregloCar(orden, ARREGLO);
return 0;
}
void cargarArregloAlfabetico(int orden, char V[30]){

//el parámetro V, que es nombre del arreglo es un puntero, por lo tanto es una
llamada por
//referencia, todos los valores ingresados en el arreglo V en realidad se le
están asignando
//al vector llamado ARREGLO, dado que el puntero V apunta a ARREGLO
int i;
char car;
for(i=0; i<orden; )
Cartilla de Ejemplos - 2019 28 | 66

{
printf("Ingrese el caracter %d del arreglo: ", i);
scanf("%c", &car);
fgetc(stdin);
//de vuelta es necesario absorber el enter ingresado en el scanf()
anterior
if(verificaAlfa(car)){
V[i]=car;
i++;
}
else
printf("\n* No es alfabetico*\n");
}
}
void mostrarArregloCar(int orden, char V[]){

int i;
for(i=0;i<orden;i++)
printf("\nElemento %d del arreglo: %c", i, V[i]);
}
int verificaAlfa(char car){

if(isalpha(car))
//la función isalpha() retorna un valor distinto de cero (en lenguaje C
equivale a verdadero)
//si el caracter es alfabético, en caso contrario retorna cero (falso en
lenguaje C)
return 1;
return 0;
}
Arreglos unidimensionales: ordenamiento y búsqueda
Realizar un programa en lenguaje C que permita cargar un arreglo de caracteres alfabéticos y luego lo presente por
pantalla, ordenado en forma descendente. Resolver empleando funciones.
//Ejemplo 31
/*
Arreglos de caracteres - Ordenamiento
*/
#include <stdio.h>
#include <ctype.h>
void ordenarArregloCaracteres(int orden,char A[]);

void cargarArregloAlfabetico(int orden, char V[]);

{
char A[30]; // pueden ser más de 30 los elementos del arreglo
int i, orden;
do{

fgetc(stdin);

cargarArregloAlfabetico(orden, A);
//el nombre del arreglo A, es un puntero, por lo tanto es un parámetro por
referencia
ordenarArregloCaracteres(orden, A);
mostrarArregloCar(orden, A);
return 0;
}
void cargarArregloAlfabetico(int orden, char V[]){

int i;
char car;
for(i=0; i<orden; )
{
printf("Ingrese el caracter %d del arreglo: ", i);
scanf("%c", &car);
fgetc(stdin);
if(verificaAlfa(car)){
V[i]=car;
i++;
}
else
printf("\n* No es alfabetico*\n");
}
}

/*el nombre del arreglo V es un puntero que apunta al arreglo A (son
parámetros por
referencia dado que por definición el nombre de un arreglo es un puntero que
apunta al
primer elemento que se encuentra en la posición 0
*/
int i;
printf("\nElemento %d del arreglo: %c", i, V[i]);
}

if(isalpha(car))
return 1;
return 0;
}
void ordenarArregloCaracteres(int orden,char A[]){

int i,t;
char aux;
for(i=0; i<orden -1 ; i++)//primera estructura de repetición que maneja el
índice i

{
for(t=i+1; t<orden ; t++){
//segunda estructura de repetición que maneja el índice t
//para comparar A[i] con todos los demás elementos
if(A[i]<A[t]){
//comparación para decidir si se debe intercambiar los elementos
//compara el valor del elemento ubicado en la posición i con el de
la //posición t
aux = A[i];
A[i]= A[t];
A[t]=aux;
//si es menor, entonces se realiza el intercambio entre los
elementos
//para esto hace falta utilizar una variable auxiliar
}
}
}
}
Realizar un programa en lenguaje C que permita cargar un arreglo de números enteros y luego lo presente por
pantalla con los números pares del mismo ordenados en forma ascendente. Resolver empleando funciones.
//Ejemplo 32
/*
Año 2018 - Programación I
Arreglos de caracteres - Ordenamiento
*/
#include <stdio.h>
void ordenarArregloEnteros(int orden,int vector[]);
void cargarArregloEnteros(int orden, int vector[]);
void mostrarArregloEnteros(int orden, int vector[]);
int esPar (int numero);

{
int A[30]; // pueden ser más de 30 los elementos del arreglo
int i, orden;
do{

cargarArregloEnteros(orden, A);
ordenarArregloEnteros(orden, A);
printf("\n\n*** Presentar el arreglo de nros enteros por pantalla ***\n\n");
mostrarArregloEnteros(orden, A);
printf("\n\n");
return 0;
}

void cargarArregloEnteros(int orden, int vector[]){

int i;
for(i=0; i<orden; )
{
printf("Ingrese el elemento %d del arreglo: ", i);
scanf("%d", &vector[i++]);
}
}
void mostrarArregloEnteros(int orden,int vector[]){

int i;
printf("\nElemento %d del arreglo: %d", i, vector[i]);
}
void ordenarArregloEnteros(int orden,int A[]){

int i,t;
int aux;
for(i=0; i<orden -1 ; i++)
{
if(esPar(A[i])){
//antes de intercambiar se debe controlar que el elemento que se
encuentra en //la posición i sea par
for(t=i+1; t<orden ; t++){
if(esPar(A[t])){
//andes de intercambiar también se debe controlar que el
elemento //que se encuentra en la posición t también sea par
if(A[i]>A[t]){
aux = A[i];
A[i]= A[t];
A[t]=aux;
}
}
}
}
}
}
int esPar (int numero){

if(numero%2==0)
return 1;
return 0;//si el número es par, retorna 1, caso contrario 0
}
Ingresar un arreglo de enteros de orden N. Contar cuántos elementos iguales a un valor entero x hay en él.
//Ej3mplo 33
/*
Arreglos de caracteres - Búsqueda
*/
#include <stdio.h>

int buscarEntero (int numero, int orden, int vector[]);

{
int A[30]; // pueden ser más de 30 los elementos del arreglo
int i, orden, veces,numero;
do{

printf("\n\nIngrese el valor a buscar en el arreglo: ");
scanf("%d", &numero);
veces= buscarEntero(numero,orden, A);

if(veces>0)
printf("\n\nEl valor se encontró %d veces en el arreglo: ", veces);
else
printf("\n\nEl valor no se encontró en el arreglo ");
return 0;
}

int i;
for(i=0; i<orden; )
{
}
}

int i;
}
int buscarEntero(int numero,int orden,int A[]){

int t, contar=0;
for(t=0;t<orden;t++)//Estructura de repetición para recorrer cada elemento
del arreglo
if(A[t]==numero)
//Se realiza la búsqueda, comparando el valor de cada elemento con el
número
contar++;//en caso afirmativo se incrementa el contador
return contar;
}
Buscar el menor elemento impar de un arreglo. Usar funciones.

//Ej3mplo 34
/*
Arreglos - Búsqueda
*/
#include <stdio.h>
int buscarMenorImpar (int orden, int vector[], int *pos, int *m);

{
int A[30]; //pueden ser más de 30 los elementos del arreglo
int i, orden, c=0, m=0, posicion;
do{

c=buscarMenorImpar(orden, A, &posicion,&m);
if(c>1 && m==1)
printf("\n\nEl menor impar se encontro en la posicion %d y es el nro
%d\n\n", posicion, A[posicion]);
if(c==2)
printf("\n\nEl arreglo contiene un solo impar\n\n");
if(m>1)
printf("\n\nExiste uno o mas elementos que son los menores\n");
if(c==0)
printf("\n\nNo se encontraron impares en el arreglo ");
printf("\nc=%d m=%d\n",c,m);
printf("\n\n");
return 0;
}

int i;
for(i=0; i<orden; )
{
}
}

int i;
}
int buscarMenorImpar(int orden,int A[], int *posicion, int *m){

int t, menor, b=0, c=0;
*m=0;
for(t=0;t<orden;t++){
if(esPar(A[t])==0 && b==0){
//si el valor del elemento es impar la función esPar() retorna 0
//busca el primer impar para tomarlo como referencia de comparación
inicial
menor=A[t];
b=1;
//al cambiar el valor de b, en las repeticiones en donde se encuentre
//otro impar, ya no ingresará a este bloque de código
*posicion=t;
c++;
}
if(b==1 && esPar(A[t])==0 && A[t]<menor){

menor = A[t];
*posicion=t;
//se actualiza el valor del menor impar, cuando se encuentra otro
//impar y que sea menor al que había como referencia
}
else
if(esPar(A[t])==0 && A[t]==menor && b==1)
(*m)++;
//determina si existe otro impar que sea igual al menor
if(esPar(A[t])==0&& b==1)
c++;
//cuenta la cantidad de impares ingresados, para determinar si
se
//ingresó un solo impar
}
return c;
}

if(numero%2==0)
return 1;
return 0;
}
Arreglos unidimensionales: registros y variables simples
Ingresar los datos de N monitores en un arreglo de estructuras, los campos de la estructura deben almacenar los
siguientes datos: año de fabricación, precio y la inicial de la marca. Luego presentar por pantalla el contenido de
dicho arreglo.
//Ej3mplo 35
#include <stdio.h>
typedef struct {

int anio;
float precio;
char inicial;
}monitor;
void ingresar(int n,monitor v[]);

//v es un arreglo, en donde cada elemento del mismo es una estructura tipo
monitor
void mostrar(int n,monitor v[]);
int main(int argc, char *argv[]){

monitor A[50];//el arreglo A contiene elementos que son estructuras tipo
monitor
//puede contener en este caso a lo sumo 50 estructuras
int orden;
do{
printf("Ingrese el orden del arreglo que desea cargar, <= 50: ");

ingresar(orden, A);
//el nombre del parámetro A en un parámetro por referencia, dado que el
mismo es un
//puntero
printf("\n\n*** Presentar el arreglo por pantalla ***\n\n");
mostrar(orden, A);
printf("\n\n");
return 0;
}
void ingresar(int orden, monitor v[]){

//el puntero v apunta al puntero A, por lo tanto todas las modificaciones que se
//realicen en el arreglo v se hacen en realidad en el arreglo A
int i;
for(i=0; i<orden; i++)
{
printf("\nIngrese el elemento %d del arreglo: \n", i);
printf("Ingrese el anio de fabricacion: ");
scanf("%d", &v[i].anio); //el elemento v[i] es una estructura
//se ingresan valores en cada campo de cada estructura
//para tener acceso a algún campo de la estructura que se encuentra en
la //posición i, se debe escribir el nombre del arreglo con la posición i, luego
//el selector de campo y finalmente el nombre del campo al cual se quiere
//acceder
printf("Ingrese el precio del monitor: ");
scanf("%f", &v[i].precio);
printf("Ingrese la inicial de la marca: ");
fgetc(stdin);
scanf("%c", &v[i].inicial);
}
}
void mostrar(int orden,monitor v[]){

int i;

for(i=0;i<orden;i++){
printf("\nElemento %d del arreglo: \n", i);
printf("Anio de fabricacion: %d\n", v[i].anio);
//se muestran los valores de los campos contenidos en la estructura
ubicada en
//la posición i, dado que v[i] es la estructura ubicada en la posición i
printf("Precio: %.2f\n", v[i].precio);
printf("Inicial de la marca: %c\n\n", v[i].inicial);
//e esta manera se muestran los valores de los campos de cada una de las
//estructuras que se encuentren en el arreglo
}
Ingresar los datos de N teléfonos en un arreglo de estructuras, los campos de la estructura deben almacenar los
siguientes datos: año de fabricación, precio y la inicial de la marca. Luego presentar por pantalla el contenido de
dicho arreglo y el arreglo ordenado por precio en forma ascendente
//Ejemplo 36
#include <stdio.h>
typedef struct {
int anio;
float precio;
char inicial;
}telefono;
void ingresar(int n,telefono v[]);

void mostrar(int n,telefono v[]);
void ordenar(int n,telefono v[]);

telefono A[50];
int orden;
do{

ingresar(orden, A);
mostrar(orden, A);
ordenar(orden, A);
printf("\n\n*** Presentar el arreglo ordenado por pantalla ***\n\n");
mostrar(orden, A);
printf("\n\n");
return 0;
}
void ingresar(int orden, telefono v[]){

int i;
{

scanf("%d", &v[i].anio);
printf("Ingrese el precio del telefono: ");
fgetc(stdin);//para eliminar el enter ingresado en el scanf() anterior
}
}
void mostrar(int orden,telefono v[]){

int i;
}
void ordenar(int orden,telefono v[]){

telefono aux;
int i,j;
for(j=i+1;j<orden-1;j++){
if(v[i].precio>v[j].precio){//se compara el valor de los campos
precio
aux=v[i];//se copia la estructura completa
v[i]=v[j];//por tal motivo la variable aux
v[j]=aux;//debe ser del mismo tipo de estructura que v[i] o v[j]
//estas tres últimas asignaciones realizan el intercambio
entre
//el elemento que se encuentra en la posición i con el de
//la posición j
}
}
}
}
Ingresar los datos de N teléfonos en un arreglo de estructuras, los campos de la estructura deben almacenar los
siguientes datos: año de fabricación, precio y la inicial de la marca. Luego buscar por inicial de una marca ingresada
por teclado. Presentar por pantalla un mensaje indicando si se encuentra dicha marca, presentar por pantalla el
contenido de dicho arreglo.
//Ejemplo 37
#include <stdio.h>
typedef struct {
int anio;
float precio;
char inicial;
}telefono;
void ingresar(int n,telefono v[]);

void mostrar(int n,telefono v[]);

int buscar(int n,telefono v[], char m);

telefono A[50];
int orden,b;
char m;
do{

ingresar(orden, A);
printf("\n\n*** Ingresar la inicial de la marca a buscar: ");
fgetc(stdin);
scanf("%c",&m);
b=buscar(orden, A, m);
if(b==1)
printf("La inicial de la marca ingresada SI se encuentra en el
arreglo\n");
else
printf("La inicial de la marca ingresada NO se encuentra en el
arreglo\n");
mostrar(orden, A);
printf("\n\n");
return 0;
}
void ingresar(int orden, telefono v[]){

int i;
{
scanf("%d", &v[i].anio);
printf("Ingrese el precio del telefono: ");
fgetc(stdin);
}
}
void mostrar(int orden,telefono v[]){

int i;
}

int buscar(int orden, telefono v[], char m){

int i,b=0;
if(v[i].inicial==m){
//compara el valor del campo inicial de la estructura v[i] con el valor de m
b=1;
//en caso de que se encuentre la inicial, se asigna 1 a b
//de manera tal que al retornar la función devuelve el valor de b
//para indicar si es que se encontró o no dicha inicial
}
}
return b;
}
Ingresar los datos de N televisores en un arreglo de estructuras, los campos de la estructura deben almacenar los
siguientes datos: cantidad, precio y la inicial de la marca. Luego reemplazar los valores de la cantidad de las
estructuras en los casos en donde exista coincidencia, entre una inicial de una marca ingresada por teclado y la
inicial registrada en el arreglo, buscando por inicial. Presentar por pantalla un mensaje indicando si se encuentra
dicha inicial, presentar por pantalla el contenido de dicho arreglo antes y después de la modificación.
//Ejemplo 38
#include <stdio.h>
typedef struct {
int cantidad;
float precio;
char inicial;
}televisor;
void ingresar(int n,televisor v[]);

void mostrar(int n,televisor v[]);
int reemplazar(int n,televisor v[], char m);

televisor A[50];
int orden,b;
char m;
do{

ingresar(orden, A);
printf("\n\n*** Presentar el arreglo ingresado por pantalla ***\n\n");
mostrar(orden, A);
printf("\n\n*** Ingresar la inicial de la marca a buscar: ");
fgetc(stdin);
scanf("%c",&m);
b=reemplazar(orden, A, m);
if(b==1){
printf("La inicial de la marca ingresada SI se encuentra en el
arreglo\n");
printf("\n\n*** Presentar el arreglo modificado por pantalla ***\n\n");
mostrar(orden, A);

}
else
printf("La inicial de la marca ingresada NO se encuentra en el
arreglo\n");
printf("\n\n");
return 0;
}
void ingresar(int orden, televisor v[]){

int i;
{
printf("Ingrese la cantidad: ");
scanf("%d", &v[i].cantidad);
printf("Ingrese el precio del televisor: ");
fgetc(stdin);
}
}
void mostrar(int orden,televisor v[]){

int i;
printf("cantidad: %d\n", v[i].cantidad);
}
}
int reemplazar(int orden, televisor v[], char m){

int i,b=0;
char r;
if(v[i].inicial==m){
//se realiza la comparación para determinar si se encontró la estructura
//en donde coincida el valor del campo con el valor de la variable m
b=1;
//se cambia el valor de la variable para indicar que se
//encontró coincidencia
printf("cantidad: %d\n", v[i].cantidad);
printf("Modificar cantidad s/n?");
fgetc(stdin);
scanf("%c",&r);
if(r=='s'){
//luego se realiza el cambio del contenido del campo cantidad
printf("Ingrese la cantidad: ");
scanf("%d", &v[i].cantidad);
}

}
}
return b;
}
Arreglos bidimensionales o matrices de variables simples

Realizar un programa que permita cargar un arreglo bidimensional con caracteres y luego lo presente por pantalla.
Resuelto sin funciones.
//Ejemplo 39
/* Arreglos Bidimensionales de caracteres */
#include <stdio.h>
{
char caracteres[50][50];//la matriz puede contener a lo sumo 50 filas y 50
columnas
int i, j, columnas, filas;
printf("La cantidad de columnas y filas debe ser menor a 50!!!\n");

do{
printf("Ingrese la cantidad de columnas : ");
scanf("%d", &columnas);
}while(columnas <0 || columnas >50);
do{
printf("Ingrese la cantidad de filas : ");
scanf("%d", &filas);
}while(filas <0 || filas >50);
fgetc(stdin);//se elimina el enter para poder ingresar a continuación un

caracter
//esto solo es necesario cuando se lee un caracter y que anteriormente exista
algún scanf()
printf("\n\n*** Cargar el arreglo bidimensional ***\n\n");

for(i=0; i<filas; i++)//para recorrer el arreglo es necesario recorrer las
filas
{
for(j=0; j<columnas; j++)
//luego, por cada fila, se recorre las columnas de dicha fila
//de esta manera se recorre entonces cada uno de los elementos del
arreglo
{
printf("Ingrese el caracter [%d][%d] del arreglo: ",i, j);
scanf("%c", &caracteres[i][j]);
//para acceder a un elemento, se indica el nombre del arreglo y
//entre corchetes la fila y la columna en donde se encuentra
//ubicado dicho elemento
fgetc(stdin);//elimina el enter, para que se pueda leer
//luego el siguiente caracter
}
}

printf("\n\n*** Presentar el arreglo bidimensional de caracteres por

pantalla ***\n\n");
for(i=0; i<filas;i++){
for(j=0; j<columnas;){
printf("\t%c ",caracteres[i][j++]);
}
printf("\n");
}
return 0;
}
Realizar un programa en lenguaje C que permita cargar un arreglo bidimensional de caracteres alfabéticos y luego
lo presente por pantalla. Resolver empleando una función para cargar el arreglo, otra para controlar los valores que
se ingresan y otra para presentar por pantalla el arreglo resultante.
/*
Ejemplo 40
Arreglos Bidimensional de caracteres
*/
#include <stdio.h>
#include <ctype.h>

void cargarMatrizAlfabetico(int filas,int columnas, char M[30][30]);
void mostrarMatrizCar(int filas,int columnas, char M[30][30]);

{
char MATRIZ[30][30];
int i, filas, columnas;

do{
do{
fgetc(stdin); //cuidado!!!!
printf("\n\n*** Cargar la Matriz ***\n\n");

cargarMatrizAlfabetico(filas, columnas, MATRIZ);
printf("\n\n*** Presentar la matriz de caracteres por pantalla ***\n\n");

mostrarMatrizCar(filas, columnas, MATRIZ);

return 0;
}
void cargarMatrizAlfabetico(int filas, int columnas, char M[30][30]){

int i,j;
char car;
for(i=0; i<filas; i++)
{
for(j=0; j<columnas;)
{
printf("Ingrese el caracter [%d][%d] de la matriz: ", i, j);
scanf("%c", &car);
fgetc(stdin);
if(verificaAlfa(car))
{
M[i][j] = car;
j++;
}
else
printf("\n* No es alfabetico *\n");
}
}
}
void mostrarMatrizCar(int filas,int columnas, char M[30][30]){

int i, j;
printf("Elemento [%d][%d]: %c\n", i,j, M[i][j++]);
}
}

if(isalpha(car))
return 1;
return 0;
}
Ejemplo: usando la biblioteca de usuario que contenga el desarrollo de funciones para el uso de arreglos,
bajo el nombre arreglos.h (la biblioteca debe estar ubicada en el mismo directorio en donde se encuentre
el archivo fuente que incluya a dicha biblioteca)
Realizar un programa en lenguaje C que permita cargar un arreglo bidimensional de caracteres alfabéticos y luego
lo presente por pantalla. Resolver empleando la biblioteca de usuario “arreglos.h” que deberá contener todas las
funciones necesarias.
/*
Ejemplo 41
Arreglos Bidimensional de caracteres
*/

#include <stdio.h>
#include “arreglos.h”

{
char MATRIZ[30][30];
int i, filas, columnas;
do{
do{

cargarmatrizchar(filas, columnas, MATRIZ);
printf("\n\n*** Presentar la Matriz de caracteres por pantalla ***\n\n");

mostrarmatrizchar (filas, columnas, MATRIZ);
return 0;
}
Combinados: arreglos unidimensionales y bidimensionales
Realizar un programa en lenguaje C que permita cargar un arreglo bidimensional de caracteres, presentarlos por
pantalla; luego tomar los elementos del arreglo bidimensional y generar un arreglo unidimensional con las letras ‘a’
o ‘A’; finalmente presente por pantalla el arreglo con las letras. Resolver empleando funciones.
/*
Ejemplo 42
Arreglos Uni y Bidimensionales de caracteres
*/
#include <stdio.h>
#include <ctype.h>
void cargarMatrizAlfabetico(int filas,int columnas, char M[30][30]);

void mostrarMatrizCar(int filas,int columnas, char M[30][30]);
int cargarArregloA( char V[],int filas, int columnas, char M[30][30]);
int esLetraA (char letra

{
char MATRIZ[30][31],V[30];
int i, filas, columnas, orden=0;
do{
do{

cargarMatrizAlfabetico(filas, columnas, MATRIZ);
printf("\n\n*** Presentar la matriz de caracteres por pantalla ***\n\n");

mostrarMatrizCar(filas, columnas, MATRIZ);
printf("\n\n*** Cargando el arreglo.... ***\n\n");

orden = cargarArregloA( V, filas, columnas, MATRIZ);

mostrarArregloCar(orden, V);
return 0;
}
void cargarMatrizAlfabetico(int filas, int columnas, char M[30][30]){

int i,j;
char car;
{
{
printf("Ingrese el caracter [%d][%d] del arreglo: ", i, j);
scanf("%c", &car);
fgetc(stdin);
if(verificaAlfa(car))
{
M[i][j] = car;
j++;
}
}
}
}

void mostrarMatrizCar(int filas,int columnas, char M[30][30]){

int i, j;
for(j=0; j<columnas;j++)
printf("Elemento [%d][%d]: %c\n", i,j, M[i][j]);
}
}

if(isalpha(car))
return 1;
return 0;
}
int cargarArregloA( char V[30],int filas, int columnas, char M[30][30]){

int i, j, orden = 0;
for(j=0; j<columnas;j++){
if(esLetraA(M[i][j]))
{
V[orden] =M[i][j];
//cuando se encuentra el valor buscado, se realiza la copia de dicho
//valor al arreglo V indicando la posición correspondiente
orden++;
}
}
}
return orden;
}

int i;
printf("\nElemento V[%d]: %c \n", i, V[i]);
}
int esLetraA (char letra){

if(letra == 'a' || letra == 'A')
return 1;
return 0;
}
Realizar un programa en lenguaje C que permita cargar un arreglo bidimensional de números enteros, presentarlos
por pantalla; luego tomar los elementos del arreglo bidimensional y generar un arreglo unidimensional con los
números pares; finalmente presente por pantalla el arreglo de pares. Resolver empleando funciones.
/*
Ejemplo 43
Arreglos Uni y Bidimensionales de Enteros

*/
#include <stdio.h>
void cargarMatrizEnteros(int filas,int columnas, int matriz[30][30]);
void mostrarMatrizEnteros(int filas,int columnas, int matriz[30][30]);
int cargarArregloEnteros( int vector[], int filas, int columnas, int
matriz[30][30]);

{
int M[30][30],V[30],i, filas, columnas, orden=0;

do{
do{
printf("\n\n*** Cargar la matriz ***\n\n");

cargarMatrizEnteros(filas,columnas,M);
printf("\n\n*** Presentar el matriz de nros enteros por pantalla ***\n\n");

mostrarMatrizEnteros(filas,columnas,M);
printf("\n\n*** Cargando el arreglo ***\n\n");

orden = cargarArregloEnteros(V, filas, columnas,M);
printf("\n\n*** Presentar el arreglo de nros pares por pantalla ***\n\n");

mostrarArregloEnteros(orden, V);
printf("\n\n");
return 0;
}
void cargarMatrizEnteros(int filas, int columnas, int M[30][30]){

int i,j;
{
for(j=0; j<columnas;j++)
{
printf("Ingrese el caracter [%d][%d] del arreglo: ", i, j);
scanf("%d", &M[i][j]);
}

}
}
void mostrarMatrizEnteros(int filas,int columnas, int M[30][30]){

int i, j;
printf("Elemento [%d][%d]: %d\n", i,j, M[i][j++]);
}
}
int cargarArregloEnteros(int vector[], int filas, int columnas, int M[30][30]){

int i, j, orden = 0;
for(j=0; j<columnas;j++){
if(esPar(M[i][j]))
{
vector[orden] =M[i][j];
orden++;
}
}
}
return orden;
}

int i;
}

if(numero%2==0)
return 1;
return 0;
}
Cadena de caracteres
Ingresar una cadena de caracteres, luego mostrar cuántas vocales se encuentran dentro de dicha cadena o un
mensaje en caso que no se encuentre ninguna vocal.
//Ejemplo 44
#include<stdio.h>//entrada y salida estándar
#include<string.h>// manejo de cadenas
#include<ctype.h>//manejo de caracteres
void ingresarcadena(char c[], int n);

int contar (char c[]);

int main() {
char c[50];//declaración de la variable c como cadena
//la cadena c también es un arreglo de caracteres
int n=50;
printf("Ingresar una cadena de caracteres:");
ingresarcadena(c,n);
printf("La cadena %s contiene %d vocales", c,contar(c));
return 0;
}
void ingresarcadena(char c[], int n){

fgets(c,n,stdin);//la función fgets lee la cadena ingresada por teclado
c[strlen(c)-1]='\0';//al final de la cadena se encuentra
//el caracter enter y luego el terminador nulo
//entonces se sobreescribe el enter por el terminador nulo
return;
}
int contar (char c[]){

int i, vocal=0;
char x;
for (i=0; i<strlen(c); i++){
x=toupper(c[i]);
if (x =='A' || x =='E' || x =='I' || x =='O' || x =='U')
vocal++;
}
return(vocal);
}
Ingresar una cadena de caracteres, controlar que dicha cadena contenga únicamente dígitos, en caso contrario
solicitar nuevamente la cadena. Luego realizar la conversión de cadena a número entero. Presentar por pantalla la
cadena ingresada y el número convertido.
//Ejemplo 45
#include<stdio.h>//entrada y salida estándar
#include<string.h>//para utilizar funciones que manejan cadenas
#include<ctype.h>//para utilizar funciones de caracteres
#include<stdlib.h> //para utilizar la función atoi()

int control(char c[50]);
int main() {
char c[50];
int N,n=50;
do{
printf("Ingresar una cadena que contenga solamente dígitos: ");
ingresarcadena(c,n);
}while(control(c)==1);
N=atoi(c);//la funcion atoi() realiza la conversión de cadena a entero

//pero la cadena solamente debe contener caracteres numericos
printf("La cadena ingresada es: %s y el número entero equivalente es: %d",

c,N);

return 0;
}
int control(char c[]){

int i,b=0;
for(i=0;i<strlen(c);i++){
if(isdigit(c[i])==0) b=1;}
return (b);
}

fgets(c,n,stdin);
c[strlen(c)-1]='\0';
return;
}
Arreglos o vectores de cadena de caracteres

Ingresar N apellidos, luego presentar por pantalla los apellidos ordenados en forma alfabética.
//Ejemplo 46
#include<stdio.h>
#include<string.h>
#include<ctype.h>

void ordenar(char c[50][50], int N);
int main() {
int N,i, n=50 ;
char c[50][50];
//c es una matriz de caracteres, en lenguaje c se puede utilizar una matriz
de caracteres
//como un vector de cadenas, donde cada fila de la matriz es una cadena de
caracteres
printf("Ingrese la cantidad de apellidos:");

scanf("%d",&N);
fgetc(stdin);
for(i=0;i<N;i++){
printf("Ingrese el apellido Nº %d:",i+1);
ingresarcadena(c[i],n);
//utilizando solamente el índice de filas de la matriz c, se utiliza a c
como
//vector de cadenas, donde i será la posición de cada cadena en el
vector
}
ordenar(c,N);
printf("\n\nApellidos ordenados\n\n");
for(i=0;i<N;i++){
printf("%s\n",c[i]);

}
return 0;
}
void ordenar(char c[50][50], int N){

char aux[50];
int i,j;
for(i=0;i<N-1;i++)
for (j=i+1;j<N;j++)
if(strcmp(c[i],c[j])>0){
//la función strcmp() retorna mayor que cero en caso de que
//la cadena c[i] se encuentre alfabéticamente después que la cadena
c[j]
strcpy(aux,c[i]);//la función strcpy() copia la cadena c[i] en
la cadena aux
strcpy(c[i],c[j]);
strcpy(c[j],aux);
}
//estas copias se realizan con la finalidad de intercambiar las
//cadenas del arreglo, para poder realizar el ordenamiento
return;
}

int i;
fgets(c,n,stdin);
c[strlen(c)-1]='\0';
return;
}
Arreglos o vectores de estructuras
Ingresar datos de N partidos políticos y mostrar el partido ganador!!!
//Ejemplo 47
#include"stdio.h"
struct partido
{
int codigo;
char nombre[30];
int cantidadVotos;
};
void alta (int *i, struct partido p1[40]);

void listado (int i, struct partido p1[40]);
partido partidoGanador(int i, struct partido p1[40]);
int main()
{
struct partido p1[40],ganador;
int n,i=0,b;
do//estructura de repetición para realizar el menú interactivo de opciones

{
printf(" \n\nIngresar opcion\n\n\n\n");
printf("Alta -------> 1\n");//Alta corresponde a ingresar nuevos datos
printf("Listado ----> 2\n");
printf("Ganador ----> 3\n");
printf("Salir ------> 4\n\n");//finaliza el programa
printf("Ingresar opcion: ");
scanf("%d",&n);
getchar();
switch(n)
{//permite seleccionar múltiples opciones, según el valor de n
case 1: alta(&i,p1);
/*se le envía a la función: la cantidad de registros ingresados
en i, luego al retornar i queda incrementado en una unidad,
también
se envía el arreglo de estructuras p1, en donde se almacenarán
los nuevos datos*/
break;
case 2: listado(i,p1);
break;
case 3: ganador=partidoGanador(i,p1);
printf("El ganador es!!!!!\n\n El partido ganador es: %s con %d
votos",ganador.nombre,ganador.cantidadVotos );
break;
case 4: printf("\nSaliendo del programa... \n");
break;
default: printf("\nOpcion incorrecta\n");
break;
}
}while(n>0 && n!=4);
return(0);
}
void alta (int *i, struct partido p1[40]){

printf("\nIngresar codigo de partido: ");
scanf("%d",&p1[*i].codigo);
fgetc(stdin);
printf("\nIngresar nombre: ");
fgets(p1[*i].nombre,30,stdin);//lee una cadena de caracteres
printf("\nIngresar cantidad votos: ");
scanf("%d",&p1[*i].cantidadVotos);
(*i)=(*i)+1;
}
void listado (int i, struct partido p1[40]){

int c=0;
printf(" \n\nListado\n\n\n");
while(c<=i-1){
printf("Codigo: %d \n",p1[c].codigo);
printf("Cantidad de votos: %d \n",p1[c].cantidadVotos);
printf("nombre: %s \n",p1[c].nombre);
printf("Presionar una tecla para ver el siguiente...\n");
fgetc(stdin);
c++;
}

partido partidoGanador(int i, struct partido p1[40]){

int c=0;
int mayor = p1[0].cantidadVotos;
partido ganador;
while(c<=i-1){
if(p1[c].cantidadVotos > mayor){
mayor = p1[c].cantidadVotos;
ganador = p1[c];
}
c++;
}
return ganador;
}

3-PI2019-Ejemplos - Vectores - Matrices - Cadenas

Hochgeladen von

Dokumentinformationen

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

3-PI2019-Ejemplos - Vectores - Matrices - Cadenas

Hochgeladen von

Copyright:

Verfügbare Formate

FACULTAD DE CIENCIAS EXACTAS Y TECNOLOGÍA (UNT) PROGRAMACIÓN I (E07)

int verificaAlfa(char car);

int main (int argc, char *argv[])

fgetc(stdin);//cuidado!!!! función que lee el enter que se ingresó con el

printf("\n\n*** Cargar el arreglo ***\n\n");

printf("\n\n*** Presentar el arreglo de caracteres por pantalla ***\n\n");

void cargarArregloAlfabetico(int orden, char V[30]){

Cartilla de Ejemplos - 2019 28 | 66

void mostrarArregloCar(int orden, char V[]){

int verificaAlfa(char car){

Arreglos unidimensionales: ordenamiento y búsqueda

void ordenarArregloCaracteres(int orden,char A[]);

int main (int argc, char *argv[])

Cartilla de Ejemplos - 2019 29 | 66

printf("\n\n*** Cargar el arreglo ***\n\n");

void cargarArregloAlfabetico(int orden, char V[]){

void mostrarArregloCar(int orden, char V[]){

int verificaAlfa(char car){

void ordenarArregloCaracteres(int orden,char A[]){

Cartilla de Ejemplos - 2019 30 | 66

int main (int argc, char *argv[])

printf("\n\n*** Cargar el arreglo ***\n\n");

Cartilla de Ejemplos - 2019 31 | 66

void cargarArregloEnteros(int orden, int vector[]){

void mostrarArregloEnteros(int orden,int vector[]){

void ordenarArregloEnteros(int orden,int A[]){

int esPar (int numero){

Cartilla de Ejemplos - 2019 32 | 66

int buscarEntero (int numero, int orden, int vector[]);

int main (int argc, char *argv[])

printf("\n\n*** Cargar el arreglo ***\n\n");

veces= buscarEntero(numero,orden, A);

void cargarArregloEnteros(int orden, int vector[]){

void mostrarArregloEnteros(int orden,int vector[]){

int buscarEntero(int numero,int orden,int A[]){

Buscar el menor elemento impar de un arreglo. Usar funciones.

Cartilla de Ejemplos - 2019 33 | 66

int main (int argc, char *argv[])

printf("\n\n*** Cargar el arreglo ***\n\n");

void cargarArregloEnteros(int orden, int vector[]){

void mostrarArregloEnteros(int orden,int vector[]){

Cartilla de Ejemplos - 2019 34 | 66

int buscarMenorImpar(int orden,int A[], int *posicion, int *m){

if(b==1 && esPar(A[t])==0 && A[t]<menor){

int esPar (int numero){

Cartilla de Ejemplos - 2019 35 | 66

void ingresar(int n,monitor v[]);

int main(int argc, char *argv[]){

printf("\n\n*** Cargar el arreglo ***\n\n");

void ingresar(int orden, monitor v[]){

void mostrar(int orden,monitor v[]){

Cartilla de Ejemplos - 2019 36 | 66

void ingresar(int n,telefono v[]);

int main(int argc, char *argv[]){

printf("\n\n*** Cargar el arreglo ***\n\n");

void ingresar(int orden, telefono v[]){

Cartilla de Ejemplos - 2019 37 | 66

void mostrar(int orden,telefono v[]){

void ordenar(int orden,telefono v[]){

void ingresar(int n,telefono v[]);

Cartilla de Ejemplos - 2019 38 | 66

int buscar(int n,telefono v[], char m);

int main(int argc, char *argv[]){

printf("\n\n*** Cargar el arreglo ***\n\n");

printf("\n\n* Cargar el arreglo *\n\n");

printf("\n\n* Presentar el arreglo de caracteres por pantalla *\n\n");

printf("\n\n* Cargar el arreglo *\n\n");

printf("\n\n* Cargar el arreglo *\n\n");

printf("\n\n* Cargar el arreglo *\n\n");

printf("\n\n* Cargar el arreglo *\n\n");

int buscarMenorImpar(int orden,int A[], int posicion, int m){

printf("\n\n* Cargar el arreglo *\n\n");

printf("\n\n* Cargar el arreglo *\n\n");

printf("\n\n* Cargar el arreglo *\n\n");

printf("\n\n* Cargar el arreglo *\n\n");

printf("\n\n* Cargar el arreglo bidimensional *\n\n");

printf("\n\n* Cargar la Matriz *\n\n");

printf("\n\n* Presentar la matriz de caracteres por pantalla *\n\n");

printf("\n\n* Cargar la Matriz *\n\n");

printf("\n\n* Presentar la Matriz de caracteres por pantalla *\n\n");

printf("\n\n* Cargar la Matriz *\n\n");

printf("\n\n* Presentar la matriz de caracteres por pantalla *\n\n");

printf("\n\n* Cargando el arreglo.... *\n\n");

printf("\n\n* Presentar el arreglo de caracteres por pantalla *\n\n");

printf("\n\n* Cargar la matriz *\n\n");

printf("\n\n* Presentar el matriz de nros enteros por pantalla *\n\n");

printf("\n\n* Cargando el arreglo *\n\n");

printf("\n\n* Presentar el arreglo de nros pares por pantalla *\n\n");