<repo_name>EmanuelLP/Jose_Emanuel_Lopez_Paez_IC_602_Taller_SO<file_sep>/Practica_Sockets/servidor.c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <arpa/inet.h>

#define PORT 4455
#define MAX_DATA 1024

void main(){
	//Estructuras de tipo sockaddr para guardar la informacion 
	int sockfd;
	struct sockaddr_in serverAddr;
	
	int newSocket;
	struct sockaddr_in newAddr;
	
	socklen_t addr_size;
	char buffer[MAX_DATA];
	char *buf;

	//Definir socket
	/*SI el resultado es -1 hubo un error*/
	sockfd=socket(PF_INET,SOCK_STREAM,0);
	if(sockfd<0){
		printf("[**]NO se puedo crear el servidor[**]\n");
		exit (-1);
	}else{
		printf("[**]SERVIDOR CREADO EXITOSAMENTE[**]\n");
		
		memset(&serverAddr,'\0',sizeof(serverAddr));
		//Configuracion del servidor 
		serverAddr.sin_family=AF_INET;//Familia tcp/ip
		serverAddr.sin_port=htons(PORT); //Puerto 
		serverAddr.sin_addr.s_addr=inet_addr("127.0.0.1");//DIreccion en especifico
		/*Se puede moficar para que cualquiera pudiera conectar cambiando la direccion por: INADDR_ANY*/
	
		//Avisar al sistema que se creo un socket
		/*SI el resultado es -1 hubo un error*/
		if(bind(sockfd,(struct sockaddr*)&serverAddr,sizeof(serverAddr))<0){
			printf("[++]Error en el bind[++]\n");
			printf("++Intente más tarde++\n");
			exit (-1);
		}else{
			printf("[++]Numero de puerto %d[++]\n",4455);
			
			//Poner el socket en modo escucha 
			/*SI el resultado es -1 hubo un error*/
			if(listen(sockfd,5)<0){
				printf("[//]Error en el listen[\\]");
				exit (-1);
			}else{
				printf("[//]Listen[\\]\n");
				
				addr_size=sizeof(newAddr);
				//Aceptar conexion
				newSocket=accept(sockfd,(struct sockaddr*)&newAddr,&addr_size);
				strcpy(buffer,"HOLA, servidor disponible\n");
				//SE envia al cliente la cadena 
				send(newSocket,buffer,strlen(buffer),0);
				printf("[~~]Enviando informacion al cliente[~~]\n");
	
				//Primer valor
				printf("[~~]Recibiendo valores[~~]\n");
				//LImpiar buffer
				memset(&buffer,'\0',sizeof(buffer));
				recv(newSocket,buffer,MAX_DATA,0);
				printf("[^^]INF. RECIVIDA[^^]: %s \n",buffer);
				//Tamaño de numeros
				unsigned long int numbytes=strlen(buffer);
				printf ("Bytes:%lu\n",numbytes);
				//Convertir cadena a entero
				//unsigned long int valor1=atoi(buffer);
				unsigned long  int valor1=strtoul(buffer, &buf, 0);
				printf("Numero en entero %lu\n",valor1);
				if(strlen(buf)>=1){
					printf("ERROR ~~Ingreso caracteres~~\n");
					printf("%s\n",buf);
				}
	
				//SE envia al cliente la cadena 
				memset(&buffer,'\0',sizeof(buffer));
				strcpy(buffer,"Envie el segundo valor\n");
				send(newSocket,buffer,strlen(buffer),0);
				printf("[~~]Enviando informacion al cliente[~~]\n");	

				//Segundo valor
				//LImpiar buffer
				memset(&buffer,'\0',sizeof(buffer));
				recv(newSocket,buffer,MAX_DATA,0);
				printf("[^^]INF. RECIVIDA[^^]: %s \n",buffer);
				//Tamaño de numeros
				numbytes=strlen(buffer);
				printf ("Bytes:%lu\n",numbytes);
				//Convertir cadena a entero
				//unsigned long long int valor2=atoi(buffer);
				unsigned long int valor2=strtoul(buffer, &buf, 0);
				printf("Numero en entero %lu\n",valor2);
				if(strlen(buf)>=1){
					printf("ERROR ~~Ingreso caracteres~~\n");
					printf("%s\n",buf);
				}
	

				memset(&buffer,'\0',sizeof(buffer));
				unsigned long int suma=valor1+valor2;
				/*itoa no funcina en Ubuntu*/
				//itoa(suma,buffer,10);
				sprintf(buffer, "%lu",suma);
	
				//SE envia al cliente la cadena 
				send(newSocket,buffer,strlen(buffer),0);
				printf("[~~]Enviando informacion al cliente[~~]\n");
		
			}
	
	
		}
	
	
	}
	
	
	
	

}






<file_sep>/Scheduler/scheduler.c
#include "scheduler.h"

int num_procesos(){
	int num_proc;
	printf("Ingrese la cantidad de procesos a ejecutar\n");
	printf("\tNum procesos= ");
	fflush(stdin);
	scanf("%d",&num_proc);		
	return num_proc;
}

int quantum(){
	int time_ejec;
	printf("Ingrese la cantidad de tiempo que tendra un proceso en ejecucion en la CPU (Seg)\n");
	printf("\tQuantum= ");
	fflush(stdin);
	scanf("%d",&time_ejec);
	return time_ejec;
}

Proceso *llenar_proceso(char *nombre, int tiempo){
	Proceso *proc=(Proceso *)malloc(sizeof(Proceso));
	char *SI="Inicializado";
	strcpy(proc->nombre,nombre);
	proc->tiempo=tiempo;
	strcpy(proc->estado,SI);
	return proc;
}

void imprimir(Proceso vproc[], int num_proc){
	printf("\t\t TABLA DE PROCESOS\n");
	printf("Nombre del proceso |\tTiempo\t|\tEstado\t|\n");
	int i;	
	for(i=0;i<num_proc;i++){
		printf("\t%s\t", vproc[i].nombre);
		printf("\t%d\t", vproc[i].tiempo);
		printf("\t%s\n", vproc[i].estado);
	}	
}

void agregar(Proceso vproc[],Proceso *proc,int posicion){
	strcpy(vproc[posicion].nombre,proc->nombre);
	vproc[posicion].tiempo=proc->tiempo;
	strcpy(vproc[posicion].estado,proc->estado);
}

void llenar_estructura(Proceso vproc[],Proceso *proc,int num_proc){
	char nombre[TAM_TEXTO];
	int tiempo,i;
	for(i=0; i<num_proc; i++){		
		printf("Ingrese el nombre del procesos a ejecutar[%d]\n",(i+1));
		printf("\tNombre: ");
		memset(nombre,'\0',TAM_TEXTO);
		scanf("%s",nombre);
		printf("Ingrese la cantidad de tiempo del  proceso a ejecutar (Seg)\n");
		printf("\tTiempo= ");
		fflush(stdin);
		scanf("%d",&tiempo);
		proc=llenar_proceso(nombre,tiempo);
		agregar(vproc,proc,i);		
	}

}

bool vector_finalizado(Proceso vproc[],int num_proc){
	bool bandera;
	int i,cn=0;
	for(i=0;i<num_proc;i++){
		if(vproc[i].tiempo == 0 && strcasecmp(vproc[i].estado,"Finalizado")==0 ){
			cn++;
		}
	}
	if(cn==num_proc){
		printf("\nSimulacion terminada");
		bandera=true;
	}else{
		bandera=false;
	}
	return bandera;
}

void imprimir_posicion(Proceso vproc[], int posicion){
	printf("\n\t%s\t", vproc[posicion].nombre);
	printf("\t%d\t", vproc[posicion].tiempo);
	printf("\t%s\n", vproc[posicion].estado);
}


void round_robin(Proceso vproc[], int time_ejec,int num_proc){
	int i=0,time_cpu=0;
	bool bandera;
	char *SE="Ejecucion",*SB="Bloqueado",*SF="Finalizado";
	do{
		if(strcasecmp(vproc[i].estado,"Inicializado") == 0 ){
				imprimir_posicion(vproc,i);
		}
		bandera=vector_finalizado(vproc,num_proc);
		if(bandera==false){									
			if(strcasecmp(vproc[i].estado,"Finalizado") == 0 ){
				i++;
			}
			if(vproc[i].tiempo > 0){
				strcpy(vproc[i].estado,SE);
				imprimir_posicion(vproc,i);
			}			
			if(vproc[i].tiempo > 0 && vproc[i].tiempo >= time_ejec){			
				vproc[i].tiempo=vproc[i].tiempo-time_ejec;
				if(vproc[i].tiempo == 0){
					strcpy(vproc[i].estado,SF);
				}
				if(vproc[i].tiempo > 0){
					strcpy(vproc[i].estado,SB);
				}
				time_cpu=time_cpu+time_ejec;
			} else if(vproc[i].tiempo > 0 && vproc[i].tiempo < time_ejec){
				vproc[i].tiempo=0;
				strcpy(vproc[i].estado,SF);
				time_cpu=time_cpu+vproc[i].tiempo;
			}			
			imprimir_posicion(vproc,i);	
		}
		i++;	
		if(i==num_proc){
			i=0;	
		}
	}while(bandera==false);	
	printf("\nEl tiempo en la CPU fue %d\n",time_cpu);
}

<file_sep>/Multiprogramacion/simulacion.c
#include <stdio.h>
#include <stdlib.h>
//Para usar variables tipo boolean
#include <string.h>
#include <math.h>
typedef struct {
	char nombre[20];
	int tiempo;
	char estado[20];
}Proceso;
typedef struct {
	char nombre[20];
	int tiempo;
	char estado[20];
	int gantt;
}DGantt;
int main(){
//Datos iniciales
	int num_proc, time_ejec;
	printf("Ingrese la cantidad de tiempo que tendra un proceso en ejecucion en laPU (Seg)\n");
	printf("Quantum= ");
	fflush(stdin);
	scanf("%d",&time_ejec);
	printf("Ingrese la cantidad de procesos a ejecutar\n");
	printf("Num procesos= ");
	fflush(stdin);
	scanf("%d",&num_proc);	
//Lenado de las estrcturas deprocesos
	Proceso proc[num_proc];
	int i;
	char *SI,*SE,*SF,*SB;
	for(i=0; i<num_proc; i++){
		printf("Ingrese el nombre del procesos a ejecutar[%d]\n",(i+1));
		printf("Nombre: ");
		fflush(stdin);
		gets(proc[i].nombre);
		printf("Ingrese la cantidad de tiempo del  proceso a ejecutar (Seg)\n");
		printf("Tiempo= ");
		fflush(stdin);
		scanf("%d",&proc[i].tiempo);
		SI="Inicializado";
		strcpy(proc[i].estado,SI); 	
	}
	//Tabla de procesos
	printf("\t\t TABLA DE PROCESOS\n");
	printf("Nombre del proceso |\tTiempo\t|\tEstado\t|\n");	
	for(i=0;i<num_proc;i++){
		printf("\t%s\t", proc[i].nombre);
		printf("\t%d\t", proc[i].tiempo);
		printf("\t%s\n", proc[i].estado);
	}	
//Simulacion multiprogramacion (Método Round Robin)	[tamaño de tabla]
	int bandera=0,j=0,contador=0,time_act,k=0;
	int suma=0,total=0, l=0, tm=0, cn=0;
	Proceso temporal[num_proc];
	//Llenamos un array temporal
	for(i=0;i<num_proc;i++){
		temporal[i]=proc[i];
	}
	//Determinacion del tamaño del segundo vector
	do{
		//Se verifica que todos los valores en tiempo, for para recorrer  
		//if para que el tiempo sea <= 0 y que este se ejecute hasta la ultima 
		//posicion del array
		for(i=0;i<num_proc;i++){
			if(temporal[i].tiempo <= 0 && (l+1)==num_proc ){
				cn++;
			}
		}
		if(temporal[l].tiempo>0){
			total++;
			tm=temporal[l].tiempo-time_ejec;
			temporal[l].tiempo=tm;
		}
		if((l+1)==num_proc){
			l=0;
			suma++;
		}else{
			l++;
		}
		if(cn==num_proc){
			bandera=1;
		}
	}while(bandera==0);
	int tam;
	tam=(total+suma)+(num_proc*3);
//Simulacion multiprogramacion (Método Round Robin)	[Estados y tiempo ]
	i=0;
	cn=0;
	bandera=0;
	DGantt tabla[tam];
	char *n="Vuelta>",*s="---------";
	int t=0, timecpu=0, m=0;
	do{		
		for(m=0;m<num_proc;m++){
			if(proc[m].tiempo == 0 && (i+1)==num_proc ){
				cn++;
			}
		}	
		//Se toma los valores iniciales como son declarados
		if(strcasecmp(proc[i].estado,"Inicializado")==0 ){
			strcpy(tabla[j].nombre,proc[i].nombre); 
			tabla[j].tiempo=proc[i].tiempo;
			strcpy(tabla[j].estado,proc[i].estado); 	
			tabla[j].gantt=timecpu;
		}

		//Si el proceso tiene un estado finalizado y tiempo en 0, se es ignorado y continua
	//	if(strcasecmp(proc[i].estado,"Finalizado")==0 && proc[i].tiempo==0){
	//		i++;
	//	}


		if(proc[i].tiempo<time_ejec && proc[i].tiempo != 0){
			timecpu=timecpu+proc[i].tiempo;
			time_act=0;
			SF="Finalizado";
			//Se hace el recorrido +1 en j la cual ayuda a llenar valores en el vector tabla
			j++;
			//Se actualiza el estado en el vector proc[i]
			strcpy(proc[i].estado,SF);
			proc[i].tiempo=time_act;
			//Se llena los datos del atributo para el vector tabla
			strcpy(tabla[j].nombre,proc[i].nombre); 
			tabla[j].tiempo=proc[i].tiempo;
			strcpy(tabla[j].estado,proc[i].estado); 
			//Se guarda el estado que se finalizo el proceso	
			tabla[j].gantt=timecpu;
		}else if(proc[i].tiempo>=time_ejec){
			//Optencion del tiempo restante del proceso
			time_act=proc[i].tiempo-time_ejec;
			//Si el tiempo restante es igual a cero se declara el estado finalizado
			if(time_act==0){
				//Se suma el tiempo en el cpu
				timecpu=timecpu+time_ejec;
				SF="Finalizado";
				j++;
				strcpy(proc[i].estado,SF);
				proc[i].tiempo=time_act;
				strcpy(tabla[j].nombre,proc[i].nombre); 
				tabla[j].tiempo=proc[i].tiempo;
				strcpy(tabla[j].estado,proc[i].estado); 
				tabla[j].gantt=timecpu;
			}
			else{
				SE="Ejecucion";
				//Se actualiza el el vector proc[i]
				proc[i].tiempo= time_act;
				strcpy(proc[i].estado,SE); 	
				//Se recorre una posicion para el vector tabla "Ejecucion"
				j++;
				//Se llena los datos del atributo para el vector tabla
				strcpy(tabla[j].nombre,proc[i].nombre); 
				tabla[j].tiempo=proc[i].tiempo;
				strcpy(tabla[j].estado,proc[i].estado); 	
				tabla[j].gantt=timecpu;

				//Se suma el tiempo en la cpu con el quantum 
				timecpu=timecpu+time_ejec;
				SB="Bloqueado";
				//Se actualiza el el vector proc[i]
				strcpy(proc[i].estado,SB);
				//Se recorre una posicion para el vector tabla "Bloqueado"
				j++;
				//Se llena los datos del atributo para el vector tabla
				strcpy(tabla[j].nombre,proc[i].nombre); 
				tabla[j].tiempo=proc[i].tiempo;
				strcpy(tabla[j].estado,proc[i].estado); 	
				tabla[j].gantt=timecpu;	
			}
		}	
		//Si i es igual al numero de procesos de coloca en 0 
		//para que el ciclo del vector se realice de nuevo
		if((i+1)==num_proc){
			i=0;
			//Posicion para llenar un vector de detalles
			j++;
			//Numero de vuelta=t
			t++;
			//Se llena un espacio en el vector tabla
			// para especidcar el numero de vuelta
			strcpy(tabla[j].nombre,n);
			tabla[j].tiempo=t;
			strcpy(tabla[j].estado,s);
			tabla[j].gantt=t;
		}else{
			i++;
		}

		if(cn==num_proc){
			bandera=1;
		}

	}while(bandera==0);	
//Tabla de estados de los procesos
	printf("\n\n\t\t HISTORAL DE PROCESOS\n");
	printf("Nombre del proceso|\tTiempo\t|\tEstado\t|\tTiempo en el CPU\n");
	//Se recorre el vector tabla para imprimir sus datos
	for(i=0;i<tam;i++){
		printf("\t%s\t", tabla[i].nombre);
		printf("\t%d\t", tabla[i].tiempo);
		printf("\t%s", tabla[i].estado);
		printf("\t%d\n", tabla[i].gantt);
	}	
//Tabla de procesos finalizado
	printf("\t\t TABLA DE PROCESOS RESULTADO\n");
	printf("Nombre del proceso |\tTiempo\t|\tEstado\t|\n");	
	for(i=0;i<num_proc;i++){
		printf("\t%s\t", proc[i].nombre);
		printf("\t%d\t", proc[i].tiempo);
		printf("\t%s\n", proc[i].estado);
	}
return 0;
}
<file_sep>/Practica_Sockets/cliente.c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <arpa/inet.h>

#define PORT 4455
#define MAX_DATA 1024

void main(){
	int clientSocket;
	//Estrcutura para guardar informacion sel servidor remoto
	struct sockaddr_in serverAddr;
	char buffer[MAX_DATA];
	
	//Creacion del socket
	/*SI el resultado es -1 hubo un error*/
	clientSocket=socket(PF_INET, SOCK_STREAM, 0);
	if(clientSocket<0){
		printf ("[**]No puedo establecer conexion con el servidor[**]\n");
		exit (-1);
	}else{
	
		printf("[**]CLIENTE CREADO EXITOSAMENTE[**]\n");
		memset(&serverAddr,'\0',sizeof(serverAddr));	
		//Datos del servidor
		serverAddr.sin_family=AF_INET;//Familia tcp/ip
		serverAddr.sin_port=htons(PORT);//Puerto 	
		serverAddr.sin_addr.s_addr=inet_addr("127.0.0.1");//Direccion en especifico
	
		//Conectarse al servidor
		/*SI el resultado es -1 hubo un error*/
		if(connect(clientSocket, (struct sockaddr*)&serverAddr,sizeof(serverAddr))<0){
			printf("[++]Conexion fallida[++]\n");
			exit (-1);
		}
		else{
			printf("[++]Coneccion a servidor[++]\n");
			memset(&buffer,'\0',sizeof(buffer));
	
			//Revibir datos del servidor
			recv(clientSocket,buffer,MAX_DATA,0);
			printf("[^^]INF. RECIVIDA[^^]: %s \n",buffer);
	
			//Pedir primer valor
			char valor1[MAX_DATA];
			printf("Ingrese el primer valor de  (1-19 digitos)\n");
			scanf("%s",valor1);
			//Enviando valor1
			//strcpy(valor1,"1111111111111111111");
			send(clientSocket,valor1,strlen(valor1),0);
			printf("[~~]Valor 1 enviado[~~]\n");
	
			memset(&buffer,'\0',sizeof(buffer));
			//Recibir datos del servidor
			recv(clientSocket,buffer,MAX_DATA,0);
			printf("[^^]INF. RECIVIDA[^^]: %s \n",buffer);
	
			//Pedir segundo valor
			char valor2[MAX_DATA];	
			printf("Ingrese el segundo valor de  (1-19 digitos)\n");
			scanf("%s",valor2);
			//Enviando valor2
			//strcpy(valor2,"2222222222222222222");
			send(clientSocket,valor2,strlen(valor2),0);
			printf("[~~]Valor 2 enviado[~~]\n");
	
			memset(&buffer,'\0',sizeof(buffer));
			//Recibir datos del servidor
			recv(clientSocket,buffer,MAX_DATA,0);
			printf("[^^]Suma[^^]: %s \n",buffer);

	
			printf("[##]Cerrando conexion[##]\n");
		
		}
	
	
	
	
	
	}
	
	

	
}

<file_sep>/Bash/ingresar_Usuarios.sh
#!/bin/bash
ROOT_UID=0
SUCCESS=0

# Run as root, of course. (this might not be necessary, because we have to run the script somehow with root anyway)
if [ "$UID" -ne "$ROOT_UID" ]
then
  echo "Se debe estar como root para ejecutar este script"
  exit $E_NOTROOT
fi  

file=$1

if [ "${file}X" = "X" ];
then
   echo "Debe indicar el archivo con el listado de usuarios a ingresar..."
   exit 1
fi

# Del archivo con el listado de usuarios a ingresar:
# Este es el formato:
# ejemplo
#    |
#    f1:f2:f3:f4:f5:f6:f7
#$f1 = username
#$f2 = password (por defecto <PASSWORD>)
#$f3 = User ID (no se utiliza si se deja en blanco)
#$f4 = Group ID, debe de existir en /etc/group
#$f5 = User ID Info
#$f6 = home directory
#$f7 = Comand Shell

ingresarUsuario(){
	#se puede realizar tambien con cut -d y asignando que cada : sea la variable
	#echo "----> Ingresar Usuario <----"
	eval user="$1"
	eval password="$2"
	eval userid="$3"
	eval grupoid="$4"
	eval info="$5"
	eval home="$6"
	eval shell="$7"
	#echo "Username 		  = ${user}"
	#echo "-------------------------"

	#Si existe grupoid(f4) se crea el usuario en la direccion /etc/group
	if grep -q ${grupoid} /etc/group
	then
		#echo "GrupoID                     =${grupoid}"
		#echo "Shell                       =${shell}"

		#Se comprueba el nombre(f1) (existe) el usuaruo en /etc/passwd
		if grep -q ${user} /etc/passwd 
		then
			echo "--->Username      existe        =${user}<---"
		else
			#echo "Username     no existe      =${user}"
			#echo "Directorio                  =${home}"
			#Creacion del usaurio con el shell
			#-c comenetario campos GECOS
			#-p contraseña cifrada
			#-d home-dir DIR_PERSONAL 
			#-s sell consola de acceso a la nueva cuenta
			#-u UID identificador de la nueva cuenta 
			#-g identificador de grupo
			useradd -c "${info}" -p "${password}" -d "${home}${user}" -s "${shell}" "${user}"  -g "${grupoid}" 			
			if [ $? -eq $SUCCESS ];
			then
				#echo "Grupo [${nombreGrupo}] agregado correctamente..."
				echo "--->Usuario creado  USER= ${user}   PASSWORD= ${password}<---"
				echo "[${user}:${password}:${userid}:${grupoid}:${info}:${home}${user}:${shell}]"
			else
				echo "Usuario no  creado"
				#echo "Grupo [${nombreGrupo}] No se pudo agregar..."
			fi
			#echo "Usuario creado  USER= ${user}   PASSWORD= ${password}"
		fi
	#echo "Usuario repetido  USER= ${user}   PASSWORD= ${<PASSWORD>}"
	else
		echo "No existe el grupo"
		echo "Debe crear grupo  ${grupoid} antes de ingresar el usuario ${user}"
	fi
}

while IFS=: read -r f1 f2 f3 f4 f5 f6 f7
do
	#Argumentos de entrada f1:f2:f3:f4:f5:f6:f7
	ingresarUsuario "\${f1}" "\${f2}" "\${f3}" "\${f4}" "\${f5}" "\${f6}" "\${f7}"
done < ${file}
exit 0
<file_sep>/gestion_archivos/code.c
#include <stdio.h>
#include <string.h>

#define TAM_NOMBRE 100
#define TAM_LECTURA 100

#define MAXIMA_LONGITUD_CADENA 1000

FILE *abrir_Archivo_solo_Lectura(char *nombre_arch){
	FILE *ptrArchivo;
	ptrArchivo = fopen(nombre_arch, "r");
	if( ptrArchivo == NULL ){
		// con r Abre un archivo para lectura.
		printf("---> El archivo -> %s <- NO pudo abrirse (uso de r).\n", nombre_arch);
	}	
	else{
		printf("---> Archivo -> %s <- Abierto (uso de r).\n", nombre_arch);
	}
	return ptrArchivo;
}

void cerrar_archivo(FILE *ptrArchivo, char *nombre_arch){
	fclose(ptrArchivo);
	printf("----> Archivo -> %s <- Cerrado Correctamente.\n", nombre_arch);
}


int existe_archivo(char *nombre_arch){
	FILE *ptrArchivo;
	int existe = 0;
	// Con r abre un archivo para lectura.
	ptrArchivo = fopen(nombre_arch, "r");
	if( ptrArchivo != NULL ){
		existe = 1;
		cerrar_archivo(ptrArchivo, nombre_arch);
	}	
	return existe;
}

int comparar(const void *a, const void *b){
		const char *cp1 = a, *cp2 = b;
		for (; toupper(*cp1) == toupper(*cp2); cp1++, cp2++)
	        if (*cp1 == '\0')
        return 0;
	return ((toupper(*cp1) < toupper(*cp2)) ? -1 : +1);
	} 

FILE *abrir_Archivo_lectura_escritura(char *nombre_arch){
	FILE *ptrArchivo;
	ptrArchivo = fopen(nombre_arch, "r+");
	if( ptrArchivo == NULL ){
		// con r+ Abre un archivo para actualización (lectura y escritura).
		printf("---> El archivo -> %s <- NO pudo abrirse (uso de r+).\n", nombre_arch);
	}	
	else{
		printf("---> Archivo -> %s <- Abierto (uso de r+).\n", nombre_arch);
	}
	return ptrArchivo;
}

// Implementación del método de la burbuja en C, para arreglos de cadenas
void burbuja(char arreglo[][MAXIMA_LONGITUD_CADENA], int longitud)
{
    // Útil para hacer intercambio de cadenas
    char temporal[MAXIMA_LONGITUD_CADENA];
    int x, indiceActual;
    for (x = 0; x < longitud; x++)
    {
        for (indiceActual = 0; indiceActual < longitud - 1;
             indiceActual++)
        {
            int indiceSiguienteElemento = indiceActual + 1;
            // Si la cadena es mayor que la siguiente (alfabeticamente) entonces intercambiamos
            if (strcmp(arreglo[indiceActual], arreglo[indiceSiguienteElemento]) > 0)
            {
                // Movemos la cadena actual a la temporal
                memcpy(temporal, arreglo[indiceActual], MAXIMA_LONGITUD_CADENA);
                // Movemos al actual el siguiente elemento
                memcpy(arreglo[indiceActual], arreglo[indiceSiguienteElemento], MAXIMA_LONGITUD_CADENA);
                // Y en el siguiente elemento, lo que había antes en el actual pero ahora está en temporal
                memcpy(arreglo[indiceSiguienteElemento], temporal, MAXIMA_LONGITUD_CADENA);
            }
        }
    }
    // No hay necesidad de devolver nada, pues modificamos al arreglo de manera interna
}

int crear_archivo(char *nombre_arch){
	int creado = 0;
	FILE *ptrArchivo;
	ptrArchivo = fopen(nombre_arch, "w");
	if( ptrArchivo == NULL ){
		// con w crea un archivo para escritura. Si el archivo ya existe, descarta el contenido actual.
		printf("----> El archivo -> %s <- no pudo crearse (abrir; uso de w).\n", nombre_arch);
	}	
	else{
		creado = 1;
		printf("----> Archivo -> %s <- Creado (abierto; uso de w).\n", nombre_arch);
		cerrar_archivo(ptrArchivo, nombre_arch);
	}
	return creado;
}


FILE *abrir_Archivo_escritura(char *nombre_arch){
	FILE *ptrArchivo;
	ptrArchivo = fopen(nombre_arch, "w+");
	if( ptrArchivo == NULL ){
		// con r+ Abre un archivo para actualización (lectura y escritura).
		printf("---> El archivo -> %s <- NO pudo abrirse (uso de w+).\n", nombre_arch);
	}	
	else{
		printf("---> Archivo -> %s <- Abierto (uso de w+).\n", nombre_arch);
	}
	return ptrArchivo;	
}

int main(int argc, char const *argv[]){
	// FILE es una estructura
	/*  ptrCF apuntado al archivo
	Open apuntador que si no puede abrir el programa se cierra*/
	FILE *ptrCf = NULL;
	FILE *ptrCd = NULL;
	char nom_archivo[TAM_NOMBRE];
	char nom_archivod[TAM_NOMBRE];
	int existe_arch = 0;
	char cadena[TAM_LECTURA];
	char cadena1[TAM_LECTURA];
	char cadena2[TAM_LECTURA];
	char separadores[]=" \n\t";
	char *puntero;
	int palabras=0;
	//VERIFICACION DE UN ARCHIVO EXISTENTE
	do{
		printf("\tIntroduzca el Nombre del Archivo de Entrada: ");
		gets(nom_archivo);
		existe_arch = existe_archivo(nom_archivo);
		if(existe_arch){
			printf("---------------------------------------------------------------\n");
			printf("\tEl archivo -> %s <-EXISTE.\n", nom_archivo);
			printf("---------------------------------------------------------------\n");
		}else{
			printf("---------------------------------------------------------------\n");
			printf("\tEl archivo -> %s <- NO EXISTE.\n", nom_archivo);
			printf("---------------------------------------------------------------\n");
		}
	}while(!existe_arch);	
	//ABRIR ARCHIVO 	
	ptrCf = abrir_Archivo_solo_Lectura(nom_archivo);
	if(ptrCf == NULL){
		printf("****************************************************************\n");
		printf("\tEl archivo -> %s <- NO pudo Abrirse.\n", nom_archivo);			
		printf("****************************************************************\n");
	}
	else{
		printf("****************************************************************\n");
		printf("\tArchivo -> %s <- Abierto Correctamente.\n", nom_archivo);			
		printf("****************************************************************\n");
		while(!feof(ptrCf)){
			fgets(cadena,TAM_LECTURA,ptrCf);
			printf("%s",cadena);
		}			
		printf("---------------------------------------------------------------------------\n");
		printf("\t---> LECTURA TERMINADA <---\n");					
		printf("---------------------------------------------------------------------------\n");
		cerrar_archivo(ptrCf, nom_archivo);
	}
	//NUMERO PALABRAS PALABRAS
	printf("****************************************************************\n");
	printf("\tPalabras separadas\n");			
	printf("****************************************************************\n");
	ptrCf = abrir_Archivo_solo_Lectura(nom_archivo);
	//setear la cadena con el valor 0=\0 es vacio
	memset(cadena1,0,TAM_LECTURA);
	while(!feof(ptrCf)){
		fgets(cadena1,TAM_LECTURA,ptrCf);
		/*strtok=token particionar la cadena por separadores*/
		puntero=strtok(cadena1,separadores);
		palabras++;
		strcpy(cadena1,puntero);
		printf("%s\n",cadena1);
		while((puntero=strtok(NULL,separadores))!=NULL){
			palabras++;
			strcpy(cadena1,puntero);
			printf("%s\n",cadena1);
		}	
	}			
	cerrar_archivo(ptrCf, nom_archivo);
	
	//GUARADAR PALABRAS EN ARREGLO
	int contador=0;
	char texto[palabras][MAXIMA_LONGITUD_CADENA];
	char buffer[MAXIMA_LONGITUD_CADENA];
	char pd[MAXIMA_LONGITUD_CADENA];
	//LLENAR VECTOR DE PALABRAS
	ptrCf = abrir_Archivo_lectura_escritura(nom_archivo);
	/*while(fgets(buffer,MAXIMA_LONGITUD_CADENA,ptrCf)){
		strtok(buffer,"\n");
		memcpy(texto[contador],buffer,MAXIMA_LONGITUD_CADENA);
		contador++;
	}
*/	
	while(!feof(ptrCf)){
		fgets(cadena1,TAM_LECTURA,ptrCf);
		/*strtok=token particionar la cadena por separadores*/
		puntero=strtok(cadena1,separadores);
		strcpy(cadena1,puntero);
		printf("%s\n",cadena1);
		strcpy(memcpy(texto[contador],buffer,MAXIMA_LONGITUD_CADENA),cadena1);
		//memcpy(texto[contador],buffer,MAXIMA_LONGITUD_CADENA);
		while((puntero=strtok(NULL,separadores))!=NULL){
			//palabras++;
			strcpy(cadena1,puntero);
			printf("%s\n",cadena1);
			contador++;
			strcpy(memcpy(texto[contador],buffer,MAXIMA_LONGITUD_CADENA),cadena1);
			//memcpy(texto[contador],buffer,MAXIMA_LONGITUD_CADENA);
		}	
	}		


		
	//LEER ARCHIVO SALIDA		
	printf("\tIntroduzca el Nombre del Archivo Destino: ");
	gets(nom_archivod);
	existe_arch = existe_archivo(nom_archivod);
	if(existe_arch){
		printf("---------------------------------------------------------------\n");
		printf("\tEl archivo -> %s <- YA EXISTE.\n", nom_archivod);
		printf("---------------------------------------------------------------\n");
	}
	else{
		printf("---------------------------------------------------------------\n");
		printf("\tEl archivo -> %s <- NO EXISTE.\n", nom_archivod);
		printf("---------------------------------------------------------------\n");	
	}		
	if(crear_archivo(nom_archivod)){
		printf("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n");
		printf("\tEl archivo -> %s <- Fue creado/modificado EXITOSAMENTE.\n", nom_archivod);	
		printf("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n");
	}
	else{
		printf("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n");
		printf("\tEl archivo -> %s <- NO pudo crearse.\n", nom_archivod);			
		printf("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n");
	}
	
	//Abrir FILE Destino
	ptrCd=abrir_Archivo_escritura(nom_archivod);
	//Cerrar Dile Entrada
	cerrar_archivo(ptrCf, nom_archivo);
	//Longitud del arreglo
	int longitud = sizeof(texto) / sizeof(texto[0]);
	
 	/*// Imprimimos el arreglo antes de ordenarlo, solo para ilustrar
 	printf("---Imprimiendo arreglo sin ordenar---\n");*/
 	int i;
 	/*for (i = 0; i < longitud; i++){
       	printf("%s\n", texto[i]);
	}*/
	/*printf("\t\t\t%d\n",longitud);
	printf("\t\t\t%d\n",palabras);
	longuitud y palabras es el mismo numero*/
	//Metodo de ordenamiento 
	qsort((void*)texto,longitud,sizeof(texto[0]),comparar);    
        for (i =0; i < longitud; i++){
		printf("%s\n", texto[i]);
		fputs(texto[i],ptrCd);
	        fputs("\n",ptrCd);
	    }	
	//Cerrar archivo de salida
	cerrar_archivo(ptrCd, nom_archivod);	    
	//Abrir archivo para solo lectura de salida
	ptrCd = abrir_Archivo_solo_Lectura(nom_archivod); 
	while(!feof(ptrCd)){
		fgets(cadena2,TAM_LECTURA,ptrCd);
		printf("%s",cadena2);
	}	
	cerrar_archivo(ptrCd, nom_archivod);  
    
	// Lo ordenamos
	//burbuja(texto, longitud);
	// Volvemos a imprimir
	//printf("---Imprimiendo arreglo ordenado---\n");
	//for (i = 0; i < longitud; i++){
        //	printf("%s\n", texto[i]);
    	//} 
	
	printf("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n");
	printf("\tFin del programa");			
	printf("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n");
	
return 0;
}
<file_sep>/Examen/ejercicio2.c
#include <stdio.h>
int main(){
char arrayChar[5];
int bd=0;
char letra='a';
do{
	arrayChar[bd]=letra;
	letra++;
	bd++;
}while(letra<='e');
/*int i;
for(i=0;i<5;i++){
	printf("%c\n",arrayChar[i]);
}*/

char *punteroChar;
punteroChar=&arrayChar[0];
	
char *punteroCharDos;
punteroCharDos=&arrayChar[0];

printf("\nArray primer valor: %c",arrayChar[0]);
printf("\nPrimer elemento del punteroChar: %c",*punteroChar);
printf("\nPrimer elemento del pubteroCharDos: %c",*punteroCharDos);	
printf("\nQuinto elemento del array: %c",arrayChar[4]);	
printf("\nQuinto elemento del punteroChar: %c",*(punteroChar+4));
printf("\nQuinto elemento del punteroCharDos: %c",*(punteroCharDos+4));
int i;
printf("\n11.-PunteroCharDos ");
for (i = 0; i < 5; ++i){
	printf("\nLetra: %c", *(punteroCharDos+i));
}
printf("\n12.-PunteroCharDos ");
for (i = 0; i < 5; ++i){
	printf("\nLetra: %c", *(punteroCharDos+i)); 
}
/*printf("\n-PunteroChar ");
for (i = 0; i < 5; ++i){
	printf("\nLetra: %c", *(punteroChar+i)); 
}*/

return 0;
}
<file_sep>/Banco/main.c
#include "banco.h"

int main(){
	int eleccion;
	int tam_banco;
	tam_banco=validarRango(1,LIMITE_PAISES,"Introduce el número de paises: ");
	Banco banco[tam_banco];
	introducirPaises(banco, tam_banco);
	mostrarLongitudes(banco,tam_banco);
	saltoLinea();
	instrucciones();
	printf("\n Elija una opcion: ");
	scanf("%d",&eleccion);	
	while(eleccion != SALIR){
		switch(eleccion){
                case ALTA:
                	printf(" --- Opcion alta ---\n");                    
                    	if(hayVacioTodaEstructura(banco,tam_banco)==true){
                        	char nombre_pais[20];                        
                        	//PEDIRNOMBREPAIS
                        	strcpy(nombre_pais,nombrePais(tam_banco,banco));              
                        	//Obtener indice 
				int id_pais = getIndicePais(nombre_pais, banco, tam_banco);
				//Obtener indice cliente vacio
				int cliente= indiceVacioPaisEspecifico(id_pais, banco);
                        	if(cliente != -1){
	                        	char nombre_cliente[20];
    	                    		char sexo;
        	                	double saldo;
            	            		strcpy(nombre_cliente,nombreCliente());                  	    	
                        		printf("\nIntroduce el Sexo: ");
                        		scanf("%s",&sexo);
                        		printf("\nIntroduce el Sueldo: ");
                        		scanf("%lf",&saldo);                        		
		                    	//llenar datos
		                    	strcpy(banco[id_pais].clientes[cliente].nombre,nombre_cliente);
		                    	banco[id_pais].clientes[cliente].sexo=sexo;
		                    	banco[id_pais].clientes[cliente].saldo=saldo;
		                    	banco[id_pais].clientes[cliente].ocupado=true;
                        	}else{
                            		printf("No existe indice vacio en el pais %s",banco[id_pais].nombrePais);
                            	     }
                    	}else {
                        	printf("---------------------------------------------------------------------\n");
                        	printf("\t\t La estructura esta completamente llena.\n");
                        	printf("---------------------------------------------------------------------\n");
                    	}                
                break;
                case BAJA:
                    printf(" --- Opción baja ---\n");                    
                    if(estaTodoVacioEstructura(banco, tam_banco)==false){
                        char nombre_pais[20];					
			//PEDIRNOMBREPAIS                       						
			strcpy(nombre_pais,nombrePais(tam_banco,banco)); 						
			//Obtener indice 
			int pais = getIndicePais(nombre_pais, banco, tam_banco);
                       //Obtener indice cliente
			int cliente = validarRango(0, getTotalClientes(banco,pais)-1, "\tIntroduce el indice del cliente: ");
                        if(getIsOcupadoCliente(banco,pais,cliente)==true){
                            printf("\t--> Cliente %s  dado de baja.",banco[pais].clientes[cliente].nombre);
                            eliminarCliente(banco,pais,cliente);
                        }else{
                            printf("\tEl cliente %i del pais %s  no tiene datos.",cliente,banco[pais].nombrePais);
                        }                       
                    }else{
                       printf("---------------------------------------------------------------------\n");
                       printf("\t\t La estructura esta toda vacia.\n");
                       printf("---------------------------------------------------------------------\n");
                    }
                break;
                case MOSTRAR_TODO:
                    printf(" --- Opción mostrar todo ---\n");
                    imprimirTodo(banco,tam_banco);
                break;
                case MOSTRAR_ESPECIFICO:
                    printf(" --- Opción mostrar especifico ---\n");
                    if(estaTodoVacioEstructura(banco, tam_banco)==false){                    
                        char nombre_pais[20];                        
                        //PEDIRNOMBREPAIS
                        strcpy(nombre_pais,nombrePais(tam_banco,banco));
                        int pais= getIndicePais(nombre_pais, banco, tam_banco);
                        int cliente = validarRango(0, getTotalClientes(banco,pais)-1, "\tIntroduce el indice del cliente: ");
                        if(getIsOcupadoCliente(banco,pais,cliente)==true){
                            imprimirEspecifico(banco,pais,cliente);
                        }else{
                            printf("\tEl cliente %i del pais %s  no tiene datos.",cliente,banco[pais].nombrePais);
                        }
                    }else {
                        printf("---------------------------------------------------------------------\n");
                        printf("\t\t La estructura esta toda vacia.\n");
                        printf("---------------------------------------------------------------------\n");
                    }
                break;
                case MOSTRAR_OCUPADOS:
                    printf(" --- Opción mostrar solo ocupados ---\n");
                    imprimirSoloOcupados(banco, tam_banco);
                break;
                case ABONAR:
                    printf(" --- Opción abonar ---\n");
                    if(estaTodoVacioEstructura(banco, tam_banco)==false){                   
                        char nombre_pais[20];                        
                        //PEDIRNOMBREPAIS
                        strcpy(nombre_pais,nombrePais(tam_banco,banco));				
                        int pais = getIndicePais(nombre_pais, banco, tam_banco);
                        int cliente = validarRango(0, getTotalClientes(banco,pais)-1, "\tIntroduce el indice del cliente: ");
                        if(getIsOcupadoCliente(banco,pais,cliente)==true){
                            double cuanto;
                            printf("\tIntroduce cuanto ingresarás a tú cuenta:  ");
			     scanf("%lf",&cuanto);
                            abonarSaldoCliente(banco, pais,cliente, cuanto);
                        }else{
                        	printf("\tEl cliente %i del pais %s  no tiene datos.",cliente,banco[pais].nombrePais);
			 }                                
                    }else {
                        printf("---------------------------------------------------------------------\n");
                        printf("\t\t La estructura esta toda vacia.\n");
                        printf("---------------------------------------------------------------------\n");
                    }
                break; 
                case RETIRAR:
                    printf(" --- Opción retirar ---\n");
                    if(estaTodoVacioEstructura(banco, tam_banco)==false){                    
                        char nombre_pais[20];                        
                        //PEDIRNOMBREPAIS
                        strcpy(nombre_pais,nombrePais(tam_banco,banco));				
                        int pais = getIndicePais(nombre_pais, banco, tam_banco);
                        int cliente = validarRango(0, getTotalClientes(banco,pais)-1, "\tIntroduce el indice del cliente: ");
                        if(getIsOcupadoCliente(banco,pais,cliente)==true){
 		         	double cuanto;
				printf("\tIntroduce cuanto retirarás de tú cuenta: ");
				scanf("%lf",&cuanto); 
                           	retirarSaldoCliente(banco, pais, cliente, cuanto);
                        }else{
                            printf("\tEl cliente %i del pais %s  no tiene datos.",cliente,banco[pais].nombrePais);
                        }
                    }else {
                        printf("---------------------------------------------------------------------\n");
                        printf("\t\t La estructura esta toda vacia.\n");
                        printf("---------------------------------------------------------------------\n");
                    }
                break;
                case BUSCAR_ID_VACIO_ESTRUCTURA:
                    printf(" --- Opción buscar id vacio en toda estructura ---\n");
                    if(hayVacioTodaEstructura(banco, tam_banco)==true){
		     	Indices temp;
		  	temp = indiceVacioTodaEstructura(banco, tam_banco);
                       printf("---------------------------------------------------------------------\n");
                       printf("\tEl pais [%d] %s tiene el cliente [%d] vacio\n",temp.pais, banco[temp.pais].nombrePais, temp.cliente);
                       printf("---------------------------------------------------------------------\n");
                    }else {
                        printf("---------------------------------------------------------------------\n");
                        printf("\t\t La estructura esta completamente llena.\n");
                        printf("---------------------------------------------------------------------\n");
                    }
                break;
                case ESTA_LLENA_ESTRUCTURA:
                    printf(" --- Opción esta llena toda la estructura ---\n");
                    if(estaTodoLlenoEstructura(banco, tam_banco)==true) {
                        printf("---------------------------------------------------------------------\n");
                        printf("\ttrue, la estructura esta toda llena.\n");
                        printf("---------------------------------------------------------------------\n");
                    }else {
                        printf("---------------------------------------------------------------------\n");
                        printf("\tfalse, la estructura no esta toda llena.\n");
                        printf("---------------------------------------------------------------------\n");
                    }
                break;
                case ESTA_VACIA_ESTRUCTURA:
                    printf(" --- Opción esta vacia toda la estructura ---\n");
                    if(estaTodoVacioEstructura(banco, tam_banco)==false){
                        printf("---------------------------------------------------------------------\n");
                        printf("\ttrue, la estructura esta toda vacia.\n");
                        printf("---------------------------------------------------------------------\n");
                    }else {
                        printf("---------------------------------------------------------------------\n");
                        printf("\tfalse, la estructura no esta toda vacia.\n");
                        printf("---------------------------------------------------------------------\n");
                    }
                break;
                case IMPRIMIR_NOM_PAISES:
                    printf(" --- Opción imprimir nombre de paises ---\n");
                    imprimirPaises(banco, tam_banco);
                break;
                case ACTUALIZAR:
                    printf(" --- Opción actualizar ---\n");
                    if(estaTodoVacioEstructura(banco, tam_banco)==false){                    
                    	char nombre_pais[20];                        
                        //PEDIRNOMBREPAIS
                        strcpy(nombre_pais,nombrePais(tam_banco,banco));						
                        int pais = getIndicePais(nombre_pais, banco, tam_banco);                        
                        int cliente = validarRango(0, getTotalClientes(banco,pais)-1, "\tIntroduce el indice del cliente: ");
			  if(getIsOcupadoCliente(banco,pais,cliente)==true){                                                  
                         	instrucciones_actualizar();
                         	printf(" Elija una opción: ");
                         	scanf("%d",&eleccion);                            
                         	while(eleccion != SALIR_ACTUALIZAR) {
                               	switch (eleccion) {
                                    		case ACTUALIZAR_NOMBRE:
                                        	printf(" --- Opción actualizar nombre ---\n");                                        
                                        	char nuevoNombre[20];
	            	            		strcpy(nuevoNombre,nombreCliente());					
                                        	cambiarNombreCliente(banco,pais,cliente,nuevoNombre);
                                        	printf("-----------------------------------------------------------------\n");
                                        	printCliente(banco, pais,cliente);
                                        	printf("-----------------------------------------------------------------\n");
                  			break;
                  			case ACTUALIZAR_SEXO:
                                       	printf(" --- Opción actualizar sexo ---\n");
                                       	char nuevoSexo;                                        
                                       	printf("Introduce el nuevo Sexo: ");
                                       	fflush(stdin);
						scanf("%s",&nuevoSexo);
						cambiarSexoCliente(banco,pais,cliente,nuevoSexo);
 	                                       printf("-----------------------------------------------------------------\n");
                                        	printCliente(banco, pais,cliente);
                                        	printf("-----------------------------------------------------------------\n");
                                       break;
                                    	case ACTUALIZAR_MOSTRAR_MENU:
                                        	instrucciones_actualizar();
                                       break;
                                    	default:
                                       	printf("******************************************\n");
                                       	printf(" --- Opción Desconocida ---\n");
                                       	printf("******************************************\n");                                   
                                        	instrucciones_actualizar();
                                }
                                printf(" Elija una opción: ");
                                scanf("%d",&eleccion);                                
                            }
                            instrucciones();
                        }else{
                        	printf("\tEl cliente %i del pais %s  no tiene datos.",cliente,banco[pais].nombrePais);
			}                            
                    }else {
                        printf("---------------------------------------------------------------------\n");
                        printf("\t\t La estructura esta toda vacia.\n");
                        printf("---------------------------------------------------------------------\n");
                    }
                break;
                case MOSTRAR_LONGITUDES:
                    printf(" --- Opción mostrar longitudes ---\n");
                    printf("---------------------------------------------------------------------\n");
                    mostrarLongitudes(banco,tam_banco);
                    printf("---------------------------------------------------------------------\n");
                break;		
		case MOSTRAR_MENU_PRIN:
                    instrucciones();
                break;
		default:
                    printf("******************************************\n");
                    printf(" --- Opción Desconocida ---\n");
                    printf("******************************************\n");                    
                    instrucciones();				                 
            }
        instrucciones();
        printf(" Elija una opción: ");
        scanf("%d",&eleccion);    
    }
    printf("--- Fin de la Ejecución del Sistema ---\n");	
return 0;
}

<file_sep>/Banco/banco.c
#include "banco.h"

void instrucciones(){
        printf("\n-------------------------------");
        printf("---- Menu ----\n");
        printf(" 0 Mostrar menu.\n");
        printf(" 1 Dar de alta Cliente.\n");
        printf(" 2 Dar de baja Cliente.\n");
        printf(" 3 Mostrar todos los clientes.\n");
        printf(" 4 Mostrar cliente en especifico.\n");
        printf(" 5 Mostrar solo clientes dados de alta.\n");
        printf(" 6 Abonar saldo a cliente.\n");
        printf(" 7 Retirar saldo de cliente.\n");
        printf(" 8 Buscar indice vacio en toda la estructura.\n");
        printf(" 9 Mostrar si esta toda llena la estructura.\n");
        printf(" 10 Mostrar si esta toda vacia la estructura.\n");
        printf(" 11 Mostrar nombre de paises.\n");
        printf(" 12 Mostrar longitudes.\n");
        printf(" 13 Actualizar datos de cliente especifico.\n");
        printf(" 14 Salir.\n");
        printf("-------------------------------");
}

void saltoLinea(){
        printf("\n");
}

int validarRango(int inicio, int fin, char *mensaje){
	printf("%s",mensaje);
	int numero;
	scanf("%d",&numero);
    while(numero < inicio || numero > fin){
        if(numero < inicio || numero > fin){
            printf("\t\tNo esta dentro del Rango...\n");
            printf("\t\t\t--> El rango va de %d a % d\n",inicio,fin);
        }
        puts(mensaje);
        scanf("%d",&numero);
    }
    return numero;
}

bool estaNombreRepetido(int tam_banco, char *nombrePais, Banco banco[]){
        bool se_encuentra;
        int i;
        for(i = 0; i < tam_banco ; i++){
        	//Se comparan las cadenas para saber si son las mismas
        	if(  strcasecmp(banco[i].nombrePais,nombrePais) == 0 ){ 
                	se_encuentra = true;    
                	break;            	
	        }else{
	        	se_encuentra = false;	        	                	
	        }
        }
  
        return se_encuentra;
}

char *nombrePaisR(int tam_banco, Banco banco[]){
	bool bandera;
	char nombrePais[20];
	char* cadena = malloc(20);
 	do{
		printf("\nIntroduce el nombre del País\t");
		memset(nombrePais,'\0',20);
		scanf("%s",nombrePais); 
		bandera=estaNombreRepetido(tam_banco, nombrePais, banco);
		if(bandera==true){
               	printf("\t\tEl nombre %s ya se encuentra registrado...\n",nombrePais);
                	printf("\t\t\t--> Intenta de nuevo.\n");
            	}            					
	}while(bandera==true);
	strcpy(cadena,nombrePais);	
	return cadena;
}
 
 char *nombrePais(int tam_banco, Banco banco[]){
	char nombrePais[20];
	char* cadena = malloc(20);
	bool bandera;
	do{
		printf("\nIntroduce el nombre del País\t");
		memset(nombrePais,'\0',20);
		scanf("%s",nombrePais); 
		bandera=estaNombreRepetido(tam_banco, nombrePais, banco);
		if(bandera==false){
               	printf("\t\tEl nombre %s no se encuentra registrado...\n",nombrePais);
                	printf("\t\t\t--> Intenta de nuevo.\n");
            	} 
	}while(bandera==false);	           					
	strcpy(cadena,nombrePais);	
	return cadena;
}	

void introducirPaises(Banco banco[], int tam_banco){
	int i,tam_cliente;
	for(i = 0; i < tam_banco; i++){
		strcpy(banco[i].nombrePais,nombrePaisR(tam_banco,banco));	
		tam_cliente=validarRango(1, LIMITE_CLIENTES, "\tIntroduce el total de clientes\t");
		banco[i].clientes[tam_cliente];	
		banco[i].num_clientes=tam_cliente;
    }
} 

void mostrarLongitudes(Banco banco[],int tam_banco){
	int i;
	for(i=0;i<tam_banco;i++){
		printf("--> Del Pais %s ------existen %d clientes.\n",banco[i].nombrePais,banco[i].num_clientes);
	}
	
}

bool getIsOcupadoCliente(Banco banco[],int indice_pais,int index){
        bool ocupado=false;
        if(banco[indice_pais].clientes[index].ocupado != true){
        	ocupado=false;
	}else{
		ocupado=true;
	}
	return ocupado;
} 

int getTotalClientes(Banco banco[], int posicion){
    return banco[posicion].num_clientes;
}


bool isTodoOcupado(Banco banco[], int indice_pais){
	bool todo_ocupado = false;
	int contador = 0,i;
	for(i = 0; i < getTotalClientes(banco, indice_pais) ; i++){
    		if(getIsOcupadoCliente(banco,indice_pais,i)){
            		contador++;
        	}
    	}
	if(contador == getTotalClientes(banco,indice_pais)){	
    		todo_ocupado = true;
    	}
    	return todo_ocupado;
}

bool hayVacioTodaEstructura(Banco banco[], int tam_banco){
	bool hayLugar = false;
	int i;
	for(i=0;i<tam_banco;i++){
		bool ocupado=isTodoOcupado(banco,i);
            if (ocupado==false) {
                hayLugar = true;
            }
        }
	return hayLugar;
}

int getIndicePais(char *nombrePais, Banco banco[], int tam_banco){
        int indexPais;
        int i;
        for(i = 0; i < tam_banco; i++){
        	if(strcasecmp(banco[i].nombrePais,nombrePais)){
        		indexPais = i;
        		break;
		}
        }
        return indexPais;
}

int indiceVacio(Banco banco[], int pais){
    int index_vacio=-1;
    int i;
    for(i = 0; i < getTotalClientes(banco,pais) ; i++){
        if(getIsOcupadoCliente(banco,pais,i)==false){ 
        	index_vacio = i;
        	break;
        }
    }
    return index_vacio;
}

int indiceVacioPaisEspecifico(int pais, Banco banco[]){
	int index_vacio=-1;
	index_vacio=indiceVacio(banco, pais);
        return index_vacio;
}
    
char *nombreCliente(){
	char nombreCliente[20];
	char* cadena = malloc(20);
	printf("\nIntroduce el nombre del cliente\t");
	memset(nombreCliente,'\0',20);
	scanf("%s",nombreCliente); 
	strcpy(cadena,nombreCliente);	
	return cadena;
}

void eliminarCliente(Banco banco[],int pais,int index){
	strcpy(banco[pais].clientes[index].nombre," ");
	banco[pais].clientes[index].sexo=' ';
	banco[pais].clientes[index].saldo=0.0;
	banco[pais].clientes[index].ocupado=false;
}

bool existeEspacioOcupado(Banco banco[], int pais){
    bool existeOcupado = false;
    int i;
    for(i = 0; i < getTotalClientes(banco, pais); i++){
            if(getIsOcupadoCliente(banco,pais,i)==true){
                existeOcupado = true;
                break;
            }
        }
    return existeOcupado;
}

bool estaTodoVacioEstructura(Banco banco[], int tam_banco){
        bool all_vacio = true;
        int i;
        for (i=0; i<tam_banco;i++) {
            if (existeEspacioOcupado(banco,i)==true) {
                all_vacio = false;
                break;
            }
        }
        return all_vacio;
}

void imprimirTodo(Banco banco[], int tam_banco){
	int i;
	for(i = 0; i < tam_banco; i++){
    	int j;
		for(j=0;j<getTotalClientes(banco, i);j++){			printf("----------------------------------------------------------------------------------------------------------------");
        	printf("\n\t---->Del pais %s",banco[i].nombrePais);
            printf("\n\t\tCliente[%i]",j);
            printf("\n\t\t\tNombre: %s",banco[i].clientes[j].nombre);
            printf("\n\t\t\tSexo: %c",banco[i].clientes[j].sexo);
            printf("\n\t\t\tSaldo: %lf",banco[i].clientes[j].saldo);
		}            
    }
    printf("----------------------------------------------------------------------------------------------------------------");
}

void imprimirEspecifico(Banco banco[],int pais,int cliente){
    printf("----------------------------------------------------------------------------------------------------------------");
    printf("\n\t---->Del pais %s: ",banco[pais].nombrePais);
    printf("\n\t\t\tNombre: %s",banco[pais].clientes[cliente].nombre);
    printf("\n\t\t\tSexo: %c",banco[pais].clientes[cliente].sexo);
    printf("\n\t\t\tSaldo: %lf",banco[pais].clientes[cliente].saldo);
    printf("----------------------------------------------------------------------------------------------------------------");
}

bool printSoloOcupados(Banco banco[],int pais){
    bool imprimio = false;
    if(existeEspacioOcupado(banco, pais)==true){
        imprimio = true;
        printf("----------------------------------------------------------------------------------------------------------------");
        printf("\tDel pais [%s] los clientes disponibles son:",banco[pais].nombrePais);
        int i;
        for(i = 0; i < getTotalClientes(banco,pais); i++){
                if(getIsOcupadoCliente(banco,pais,i)){
                    printf("El cliente %d es: ",i);
                    printf("\n\t\t\tNombre: %s",banco[pais].clientes[i].nombre);
    		    printf("\n\t\t\tSexo: %c",banco[pais].clientes[i].sexo);
    		    printf("\n\t\t\tSaldo: %lf",banco[pais].clientes[i].saldo);
                }
            }
            printf("----------------------------------------------------------------------------------------------------------------");
        }
        return imprimio;
}

void imprimirSoloOcupados(Banco banco[], int tam_banco){
        int contador = 0;
        int i;
        for(i = 0; i < tam_banco; i++){
            if(printSoloOcupados(banco,i))
                contador++;
        }
        if(contador == 0){
            printf("\t\t ---> No existen clientes que mostrar...");
        }
}

bool tieneDatos(Banco banco[], int pais, int indice){
	bool tiene_Datos=false;	
	if(strcasecmp(banco[pais].clientes[indice].nombre," ")==0 ||
		banco[pais].clientes[indice].sexo==' '){	
			tiene_Datos=false;
    }else{
    	tiene_Datos=true;    	 
	}
	return tiene_Datos;           
}

void abonarSaldo(Banco banco[], int pais, int indice ,double cuanto){
    if(tieneDatos(banco, pais,indice)==true) {
        if(cuanto > 0.0){
        	banco[pais].clientes[indice].saldo=banco[pais].clientes[indice].saldo+cuanto;
        }
        else{
            printf("\tImposible, no puedes abonar saldos negativos o nada.");
        }
    }
}

void abonarSaldoCliente(Banco banco[], int pais, int index, double cuanto){
		abonarSaldo(banco,pais,index,cuanto);
}

bool tieneSaldo(Banco banco[], int pais, int indice){
	bool tiene_Saldo=false;
	if(banco[pais].clientes[indice].saldo > 0.0){
		tiene_Saldo=true;
	}else{
		tiene_Saldo=false;
	}
        return tiene_Saldo;
}

void retirarSaldo(Banco banco[], int pais, int indice,double cuanto){
    if(tieneDatos(banco, pais,indice)==true) {
        if(cuanto > 0.0){
                if(tieneSaldo(banco, pais, indice)==true){
                    if(banco[pais].clientes[indice].saldo >= cuanto){
                        banco[pais].clientes[indice].saldo= banco[pais].clientes[indice].saldo-cuanto;
                    }else{					
                        printf("\tImposible, tú saldo es insuficiente para retirar %f",cuanto);
                	}
                }
                else{				
                    printf("\tImposible, no hay saldo.");
            	}
            }
        else{		
            printf("\tImposible, no puedes retirar saldos negativos o nada.");
        }
    }
}

void retirarSaldoCliente(Banco banco[], int pais, int index, double cuanto){
        retirarSaldo(banco, pais, index, cuanto);
}
						    
Indices indiceVacioTodaEstructura(Banco banco[],int tam_banco) {
	Indices temp;//new Indices();
	temp.pais=-1;
	temp.cliente=-1;
	int i;
	for(i = 0; i < tam_banco; i++) {
		int indice;
		indice = indiceVacio(banco, i);
		if(indice != -1) {
			temp.pais = i;
            temp.cliente = indice;
			break;            					
		}
	}
	return temp;
}

bool existeEspacioVacio(Banco banco[], int pais){
    bool existeVacio = false;
    int i;
    for(i = 0; i < banco[pais].num_clientes ; i++){
            if(getIsOcupadoCliente(banco,pais, i)==true){
                existeVacio = true; 
                break;
            }
        }
        return existeVacio;
    }

bool estaTodoLlenoEstructura(Banco banco[], int tam_banco){
    bool all_lleno = true;
    int i;
    for (i=0;i<tam_banco;i++) {
        if (existeEspacioVacio(banco,i)==true) {
                all_lleno = false;
                break;
            }
        }
        return all_lleno;
}

void imprimirPaises(Banco banco[], int tam_banco){
        printf("---------------------------------------------------------------------\n");
        printf("\tLos paises son: \n");
        int i;
        for(i = 0; i < tam_banco; i++){
            printf("\t---->País [%s] ",banco[i].nombrePais);
        }
        printf("---------------------------------------------------------------------\n");
}

void instrucciones_actualizar(){
        printf("\n-------------------------------");
        printf("---- Menú Actualizar ----\n");
        printf(" 0 Mostrar menú.\n");
        printf(" 1 Actualizar Nombre.\n");
        printf(" 2 Actualizar Sexo.\n");
        printf(" 3 Regresar a ménu principal.\n");
        printf("-------------------------------");
}

void setTodosDatos(Banco banco[],int pais, int indice){	
    strcpy(banco[pais].clientes[indice].nombre, " ");
    banco[pais].clientes[indice].sexo = ' ';
    banco[pais].clientes[indice].saldo = 0.0;
    banco[pais].clientes[indice].ocupado = false;
}

void setOcupado(Banco banco[], int pais, int indice) {
    if(tieneDatos(banco, pais,indice)==false){
        setTodosDatos(banco, pais, indice);
    }
    else{
        banco[pais].clientes[indice].ocupado = true;
    }
}

void cambiarNombre(Banco banco[], int pais, int indice, char nuevoNombre[20]){
	/*Si primer cadena > a segunda resultado es mayor a 0
		Si primer cadena > a segunda resultado es menor a 0
			Si cadenas iguales resultado 0*/
	if(strcasecmp(nuevoNombre," ")>0){	        
            strcpy(banco[pais].clientes[indice].nombre,nuevoNombre);
        }
    setOcupado(banco, pais, indice);
}

void cambiarNombreCliente(Banco banco[], int pais, int index, char nuevoNombre[20]){
        cambiarNombre(banco,pais, index,nuevoNombre);
}

void printCliente(Banco banco[], int pais,int index){
    printf("-->Nombre: %s\n",banco[pais].clientes[index].nombre);
    printf("-->Sexo: %c\n",banco[pais].clientes[index].sexo);
    printf("-->Saldo: %f\n",banco[pais].clientes[index].saldo);
}

void cambiarSexo(Banco banco[], int pais, int indice, char sexo){
    if(sexo == 'M' || sexo == 'F'){
        banco[pais].clientes[indice].sexo = sexo;
    }
    setOcupado(banco, pais, indice);
}

void cambiarSexoCliente(Banco banco[], int pais, int index, char nuevoSexo){
    cambiarSexo(banco, pais, index, nuevoSexo);
}


<file_sep>/POSIX_Threads/version_1/README.md
#Creacion de hilos en lenguaje C POSIX
<file_sep>/Examen/ejercicio1.c
#include <stdio.h>

int  main(){
char x;
char *p;
char y;
char *puntero;
x='x';
p=&x;
//printf("\nDireccion de memoria: %p",&x);
printf("\nEL contenido del puntero p es: %c",*p);
p++;
printf("\nEL contenido del puntero p+1 es: %c",*p);
p+=2;
printf("\nEL contenido del puntero p+2 es: %c",*p);
y='y';
puntero=&y;
printf("\nEL contenido del puntero puntero es: %c\n",*puntero);
return 0;
}
<file_sep>/POSIX_Threads/version_1/main.c
#include "scheduler.h"


void reproducir_musica(void);
void abrir_youtube(void);
void escribir_texto_word(void);
void descargar_archivo(void);
void subiendo_archivo(void);
void compilando_programa(void);
void ejecutando_programa(void);
void usando_terminal(void);

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

	//Creacion de llamadas al hilo
	pthread_t h1;
	pthread_t h2;
	pthread_t h3;
	pthread_t h4;
	pthread_t h5;
	pthread_t h6;
	pthread_t h7;
	pthread_t h8;
	pthread_t h9;
	
	process p1 = {1, UN_SEGUNDO, "Proceso_1", reproducir_musica, ACTIVO}; 		//<--
	process p2 = {1, DOS_SEGUNDOS, "Proceso_1", abrir_youtube, NO_ACTIVO};
	process p3 = {3, TRES_SEGUNDOS, "Proceso_2", escribir_texto_word, ACTIVO}; 	//<--
	process p4 = {4, TRES_SEGUNDOS, "Proceso_3", descargar_archivo, ACTIVO};   	//<--
	process p5 = {3, TRES_SEGUNDOS, "Proceso_4", subiendo_archivo, ACTIVO};		
	process p6 = {4, TRES_SEGUNDOS, "Proceso_5", compilando_programa, NO_ACTIVO};
	process p7 = {0, TRES_SEGUNDOS, "Proceso_6", ejecutando_programa, ACTIVO};	//<--	
	process p8 = {2, CUATRO_SEGUNDOS, "Proceso_7", usando_terminal, ACTIVO};		//<--
	process p9 = {5, CUATRO_SEGUNDOS, "Proceso_8", usando_terminal, NO_ACTIVO};	//<--
	
	//Crear hilo

	pthread_create(&h1,NULL,(void *)crear_Proceso,&p1);
	pthread_create(&h2,NULL,(void *)crear_Proceso,&p2);	
	pthread_create(&h3,NULL,(void *)crear_Proceso,&p3);	
	pthread_create(&h4,NULL,(void *)crear_Proceso,&p4);	
	pthread_create(&h5,NULL,(void *)crear_Proceso,&p5);	
	pthread_create(&h6,NULL,(void *)crear_Proceso,&p6);	
	pthread_create(&h7,NULL,(void *)crear_Proceso,&p7);	
	pthread_create(&h8,NULL,(void *)crear_Proceso,&p8);	
	pthread_create(&h9,NULL,(void *)crear_Proceso,&p9);	
		
	
	//Ejecutar hilo
	pthread_join(h1,NULL);
	pthread_join(h2,NULL);
	pthread_join(h3,NULL);
	pthread_join(h4,NULL);
	pthread_join(h5,NULL);
	pthread_join(h6,NULL);
	pthread_join(h7,NULL);
	pthread_join(h8,NULL);
	pthread_join(h9,NULL);

	
	array_procesos *array = crear_ArrayProcesos();
	
	
	agregar_Proceso(array, p1);
	agregar_Proceso(array, p2);
	agregar_Proceso(array, p3);
	agregar_Proceso(array, p4);
	agregar_Proceso(array, p5);
	agregar_Proceso(array, p6);
	agregar_Proceso(array, p7);
	agregar_Proceso(array, p8);
	agregar_Proceso(array, p9);

	ejecutar_Procesos(array);
	free(array);
	/*free(p1);
	free(p2);
	free(p3);
	free(p4);
	free(p5);
	free(p6);
	free(p7);
	free(p8);
	free(p9);*/

	return 0;
}

void reproducir_musica(void){
	printf("Reproduciendo Música\n");
}

void abrir_youtube(void){
	printf("Usando Youtube\n");
}

void escribir_texto_word(void){
	printf("Escribiendo Texto en Word\n");
}

void descargar_archivo(void){
	printf("Descargando Archivo\n");
}

void subiendo_archivo(void){
	printf("Subiendo Archivo\n");
}

void compilando_programa(void){
	printf("Compilando programa\n");
}

void ejecutando_programa(void){
	printf("Ejecutando programa\n");
}

void usando_terminal(void){
	printf("Usando la terminal\n");
}


<file_sep>/Scheduler/main.c
#include "scheduler.h"

int main(){

//Datos iniciales
	int num_proc=num_procesos();
	int time_ejec=quantum();
	
//Lenado de las estrcturas de procesos
	Proceso *proc;
	Proceso vproc[num_proc];
	llenar_estructura(vproc,proc,num_proc);
//Tabla de procesos entrada
	imprimir(vproc,num_proc);
//Ejecucion multiprogramacion (Round Robin)
	printf("\t\t EJECUCION DE PROCESOS\n");
	printf("Nombre del proceso |\tTiempo\t|\tEstado\t|\n");
	round_robin(vproc,time_ejec,num_proc);	
return 0;
}
<file_sep>/Scheduler/scheduler.h
#ifndef __scheduler
#define __scheduler

#include <stdio.h>
#include <stdlib.h>
//Para usar variables tipo boolean
#include <string.h>
#include <stdbool.h>

#define TAM_TEXTO 50

typedef struct {
	char nombre[TAM_TEXTO];
	int tiempo;
	char estado[TAM_TEXTO];
}Proceso;

int num_procesos();

int quantum();

Proceso *llenar_proceso(char *nombre, int tiempo);

void imprimir(Proceso vproc[], int num_proc);

void agregar(Proceso vproc[],Proceso *proc,int posicion);

void llenar_estructura(Proceso vproc[],Proceso *proc,int num_proc);

bool vector_finalizado(Proceso vproc[],int num_proc);

void imprimir_posicion(Proceso vproc[], int posicion);


void round_robin(Proceso vproc[], int time_ejec,int num_proc);


#endif

<file_sep>/Sys_Banco/Banco_Sys.c
#include <stdbool.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
//#include <malloc.h>


#define	MOSTRAR_MENU_PRIN			0
#define	LIMITE_PAISES				5
#define	LIMITE_CLIENTES				10
#define	ALTA						1
#define	BAJA						2
#define	MOSTRAR_TODO				3
#define	MOSTRAR_ESPECIFICO			4
#define	MOSTRAR_OCUPADOS			5
#define	ABONAR						6
#define	RETIRAR						7
#define	BUSCAR_ID_VACIO_ESTRUCTURA	8
#define	ESTA_LLENA_ESTRUCTURA		9
#define	ESTA_VACIA_ESTRUCTURA		10
#define	IMPRIMIR_NOM_PAISES			11
#define	MOSTRAR_LONGITUDES			12
#define	ACTUALIZAR					13
#define	SALIR						14
#define	ACTUALIZAR_MOSTRAR_MENU		0
#define	ACTUALIZAR_NOMBRE			1
#define	ACTUALIZAR_SEXO				2
#define	SALIR_ACTUALIZAR			3


typedef struct {
	char nombre[20];
	char sexo;
	double saldo;
	bool ocupado;
}Cliente;

typedef struct {
	char nombrePais[20];
	int num_clientes;
	Cliente clientes[];
}Banco;


void instrucciones(){
        printf("\n-------------------------------");
        printf("---- Menu ----\n");
        printf(" 0 Mostrar menu.\n");
        printf(" 1 Dar de alta Cliente.\n");
        printf(" 2 Dar de baja Cliente.\n");
        printf(" 3 Mostrar todos los clientes.\n");
        printf(" 4 Mostrar cliente en especifico.\n");
        printf(" 5 Mostrar solo clientes dados de alta.\n");
        printf(" 6 Abonar saldo a cliente.\n");
        printf(" 7 Retirar saldo de cliente.\n");
        printf(" 8 Buscar indice vacio en toda la estructura.\n");
        printf(" 9 Mostrar si esta toda llena la estructura.\n");
        printf(" 10 Mostrar si esta toda vacia la estructura.\n");
        printf(" 11 Mostrar nombre de paises.\n");
        printf(" 12 Mostrar longitudes.\n");
        printf(" 13 Actualizar datos de cliente especifico.\n");
        printf(" 14 Salir.\n");
        printf("-------------------------------");
}
    
void saltoLinea(){
        printf("\n");
}

int validarRango(int inicio, int fin, char mensaje[100]){
    puts(mensaje);
	int numero;
	scanf("%d",&numero);
    while(numero < inicio || numero > fin){
        if(numero < inicio || numero > fin){
            printf("\t\tNo esta dentro del Rango...\n");
            printf("\t\t\t--> El rango va de %d a % d\n",inicio,fin);
        }
        puts(mensaje);
        scanf("%d",&numero);
    }
    return numero;
}

bool estaNombreRepetido(int inicio, char nombrePais[20], Banco banco[]){
        bool se_encuentra = false;
        int i;
        for(i = inicio; i > 0; i--){
        	if(strcasecmp(banco[i-1].nombrePais,nombrePais)==0){
                se_encuentra = true;
                //break;
            }
        }
        return se_encuentra;
    }

void introducirPaises(Banco banco[], int tam_banco){
	int i;
	int tam_cliente;
    for(i = 0; i < tam_banco; i++){
    	printf("Introduce el nombre del País [%d]    ",i);
    	char *mensaje;//="Introduce el nombre del País [%d]",i;
        char nombrePais[20];
        fflush(stdin);
        fgets(nombrePais,20,stdin);
        int inicio=i;
        while(estaNombreRepetido(inicio, nombrePais, banco)){//mientras exista
            if(estaNombreRepetido(inicio, nombrePais, banco)){
                printf("\t\tEl nombre %s ya se encuentra registrado...\n",nombrePais);
                printf("\t\t\t--> Intenta de nuevo.\n");
            }
            printf("Introduce el nombre del País [%d]    ",i);
        	fflush(stdin);
        	fgets(nombrePais,20,stdin);
        }
        mensaje= "\tIntroduce el total de clientes del pais %s :  ",nombrePais;
        strcpy(banco[i].nombrePais,nombrePais);
        tam_cliente=validarRango(1, LIMITE_CLIENTES, mensaje);
        banco[i].clientes[tam_cliente];
        banco[i].num_clientes=tam_cliente;
    }
    
} 
 
int getTotalClientes(Banco banco[], int posicion){
    return banco[posicion].num_clientes;
}
 
bool getIsOcupadoCliente(Banco banco[],int indice_pais,int index){
        bool ocupado=false;
        if(banco[indice_pais].clientes[index].ocupado != true){
        	ocupado=false;
		}else{
			ocupado=true;
		}
		return ocupado;
    } 
	
bool isTodoOcupado(Banco banco[], int indice_pais){
	bool todo_ocupado = false;
    int contador = 0;
    int i;
    for(i = 0; i < getTotalClientes(banco, indice_pais) ; i++){
    	if(getIsOcupadoCliente(banco,indice_pais,i)){
            contador++;
        }
    }
    if(contador ==getTotalClientes(banco,indice_pais)){	
    	todo_ocupado = true;
    }
    return todo_ocupado;
}

bool hayVacioTodaEstructura(Banco banco[], int tam_banco){
	bool hayLugar = false;
    //for(Banco item : banco) {
    int j;
    for(j=0;j<tam_banco;j++){
            //if(banco[i].existeEspacioVacio()) { // funciona también.
            if (isTodoOcupado(banco,j)==false) {
                hayLugar = true;
               // break;
            }
        }
        return hayLugar;
    }

void mostrarLongitudes(Banco banco[],int tam_banco){
	int i;
	for(i=0;i<tam_banco;i++){
		printf("--> Del Pais %s ------existen %d clientes.\n",banco[i].nombrePais,banco[i].num_clientes);
	}
	
}

int getIndicePais(char nombrePais[20], Banco banco[], int tam_banco){
        int indexPais = -1;
        int i;
        for(i = 0; i < tam_banco; i++){
        //	if(strcasecmp(banco[i].nombrePais,nombrePais)){
        		indexPais = i;
		//	}
            //if(banco[i].getNombrePais().equalsIgnoreCase(nombrePais)){
                
               // break;
            //}
        }
        return indexPais;
    }
    
int indiceVacio(Banco banco[], int pais){
    int index_vacio = -1;
    int i;
    for(i = 0; i < getTotalClientes(banco,pais) ; i++){
        if(getIsOcupadoCliente(banco,pais,i)==false){ 
        	index_vacio = i;
        	break;
        }
    }
    return index_vacio;
}

int indiceVacioPaisEspecifico(int pais, Banco banco[]){
		int index_vacio;
		index_vacio=indiceVacio(banco, pais);
        return index_vacio;
}
    
bool existeEspacioOcupado(Banco banco[], int pais){
    bool existeOcupado = false;
    int i;
    for(i = 0; i < getTotalClientes(banco, pais); i++){
            if(getIsOcupadoCliente(banco,pais,i)==true){
                existeOcupado = true;
                break;
            }
        }
        return existeOcupado;
    }
    
bool estaTodoVacioEstructura(Banco banco[], int tam_banco){
        bool all_vacio = true;
        int i;
        for (i=0; i<tam_banco;i++) {
            if (existeEspacioOcupado(banco,i)==true) {
                all_vacio = false;
                break;
            }
        }
        return all_vacio;
    }

void eliminarCliente(Banco banco[],int pais,int index){
	strcpy(banco[pais].clientes[index].nombre," ");
	banco[pais].clientes[index].sexo=' ';
	banco[pais].clientes[index].saldo=0.0;
	banco[pais].clientes[index].ocupado=false;
}
   
void imprimirTodo(Banco banco[], int tam_banco){
	int i;
    for(i = 0; i < tam_banco; i++){
    	int j;
		for(j=0;j<getTotalClientes(banco, i);j++){
			printf("----------------------------------------------------------------------------------------------------------------");
        	printf("\n\t---->Del pais %s",banco[i].nombrePais);
            printf("\n\t\tCliente[%i]",j);
            printf("\n\t\t\tNombre: %s",banco[i].clientes[j].nombre);
            printf("\n\t\t\tSexo: %c",banco[i].clientes[j].sexo);
            printf("\n\t\t\tSaldo: %s",banco[i].clientes[j].saldo);
		}            
    }
    printf("----------------------------------------------------------------------------------------------------------------");
}

void imprimirEspecifico(Banco banco[],int pais,int cliente){
    printf("----------------------------------------------------------------------------------------------------------------");
    printf("\n\t---->Del pais %s: ",banco[pais].nombrePais);
    printf("\n\t\t\tNombre: %s",banco[pais].clientes[cliente].nombre);
    printf("\n\t\t\tSexo: %c",banco[pais].clientes[cliente].sexo);
    printf("\n\t\t\tSaldo: %s",banco[pais].clientes[cliente].saldo);
    printf("----------------------------------------------------------------------------------------------------------------");
}
    
bool printSoloOcupados(Banco banco[],int pais){
    bool imprimio = false;
    if(existeEspacioOcupado(banco, pais)==true){
        imprimio = true;
        printf("----------------------------------------------------------------------------------------------------------------");
        printf("\tDel pais [%s] los clientes disponibles son:",banco[pais].nombrePais);
        int i;
        for(i = 0; i < getTotalClientes(banco,pais); i++){
                if(getIsOcupadoCliente(banco,pais,i)){
                    printf("El cliente %d es: ",i);
                    printf("\n\t\t\tNombre: %s",banco[pais].clientes[i].nombre);
    				printf("\n\t\t\tSexo: %c",banco[pais].clientes[i].sexo);
    				printf("\n\t\t\tSaldo: %s",banco[pais].clientes[i].saldo);
                }
            }
            printf("----------------------------------------------------------------------------------------------------------------");
        }
        return imprimio;
}

void imprimirSoloOcupados(Banco banco[], int tam_banco){
        int contador = 0;
        int i;
        for(i = 0; i < tam_banco; i++){
            if(printSoloOcupados(banco,i))
                contador++;
        }
        if(contador == 0){
            printf("\t\t ---> No existen clientes que mostrar...");
        }
    }
    
bool tieneDatos(Banco banco[], int pais, int indice){
	bool tiene_Datos=false;	
	if(strcasecmp(banco[pais].clientes[indice].nombre," ")==0 ||
		banco[pais].clientes[indice].sexo==' '){	
			tiene_Datos=false;
    }else{
    	tiene_Datos=true;    	 
	}
	return tiene_Datos;           
}

void abonarSaldo(Banco banco[], int pais, int indice ,double cuanto){
    if(tieneDatos(banco, pais,indice)==true) {
        if(cuanto > 0.0){
        	banco[pais].clientes[indice].saldo=banco[pais].clientes[indice].saldo+cuanto;
        }
        else{
            printf("\tImposible, no puedes abonar saldos negativos o nada.");
        }
    }
}

void abonarSaldoCliente(Banco banco[], int pais, int index, double cuanto){
		abonarSaldo(banco,pais,index,cuanto);
}

bool tieneSaldo(Banco banco[], int pais, int indice){
	bool tiene_Saldo=false;
	if(banco[pais].clientes[indice].saldo > 0.0){
		tiene_Saldo=true;
	}else{
		tiene_Saldo=false;
	}
        return tiene_Saldo;
}

void retirarSaldo(Banco banco[], int pais, int indice,double cuanto){
    if(tieneDatos(banco, pais,indice)==true) {
        if(cuanto > 0.0){
                if(tieneSaldo(banco, pais, indice)==true){
                    if(banco[pais].clientes[indice].saldo >= cuanto){
                        banco[pais].clientes[indice].saldo= banco[pais].clientes[indice].saldo-cuanto;
                    }else{					
                        printf("\tImposible, tú saldo es insuficiente para retirar %f",cuanto);
                	}
                }
                else{				
                    printf("\tImposible, no hay saldo.");
            	}
            }
        else{		
            printf("\tImposible, no puedes retirar saldos negativos o nada.");
        }
    }
}

void retirarSaldoCliente(Banco banco[], int pais, int index, double cuanto){
        retirarSaldo(banco, pais, index, cuanto);
}

typedef struct {
	int pais;
	int cliente;
}Indices;
						    
Indices indiceVacioTodaEstructura(Banco banco[],int tam_banco) {
	Indices temp;//new Indices();
	temp.pais=-1;
	temp.cliente=-1;
	int i;
	for(i = 0; i < tam_banco; i++) {
		int indice;
		indice = indiceVacio(banco, i);
		if(indice != -1) {
			temp.pais = i;
            temp.cliente = indice;
			break;            					
		}
	}
	return temp;
}

bool existeEspacioVacio(Banco banco[], int pais){
    bool existeVacio = false;
    int i;
    for(i = 0; i < banco[pais].num_clientes ; i++){
            if(getIsOcupadoCliente(banco,pais, i)==true){
                existeVacio = true; 
                break;
            }
        }
        return existeVacio;
    }

bool estaTodoLlenoEstructura(Banco banco[], int tam_banco){
    bool all_lleno = true;
    int i;
    for (i=0;i<tam_banco;i++) {
        if (existeEspacioVacio(banco,i)==true) {
                all_lleno = false;
                break;
            }
        }
        return all_lleno;
}

 void imprimirPaises(Banco banco[], int tam_banco){
        printf("---------------------------------------------------------------------\n");
        printf("\tLos paises son: \n");
        int i;
        for(i = 0; i < tam_banco; i++){
            printf("\t---->País [%s] ",banco[i].nombrePais);
        }
        printf("---------------------------------------------------------------------\n");
}

void instrucciones_actualizar(){
        printf("\n-------------------------------");
        printf("---- Menú Actualizar ----\n");
        printf(" 0 Mostrar menú.\n");
        printf(" 1 Actualizar Nombre.\n");
        printf(" 2 Actualizar Sexo.\n");
        printf(" 3 Regresar a ménu principal.\n");
        printf("-------------------------------");
    }

void setTodosDatos(Banco banco[],int pais, int indice){	
    strcpy(banco[pais].clientes[indice].nombre, " ");
    banco[pais].clientes[indice].sexo = ' ';
    banco[pais].clientes[indice].saldo = 0.0;
    banco[pais].clientes[indice].ocupado = false;
}

void setOcupado(Banco banco[], int pais, int indice) {
    if(tieneDatos(banco, pais,indice)==false){
        setTodosDatos(banco, pais, indice);
    }
    else{
        banco[pais].clientes[indice].ocupado = true;
    }
}

void cambiarNombre(Banco banco[], int pais, int indice, char nuevoNombre[20]){
	/*Si primer cadena > a segunda resultado es mayor a 0
		Si primer cadena > a segunda resultado es menor a 0
			Si cadenas iguales resultado 0*/
	if(strcasecmp(nuevoNombre," ")>0){	        
            strcpy(banco[pais].clientes[indice].nombre,nuevoNombre);
        }
    setOcupado(banco, pais, indice);
}

void cambiarNombreCliente(Banco banco[], int pais, int index, char nuevoNombre[20]){
        cambiarNombre(banco,pais, index,nuevoNombre);
    }

void printCliente(Banco banco[], int pais,int index){
    printf("-->Nombre: %s\n",banco[pais].clientes[index].nombre);
    printf("-->Sexo: %c\n",banco[pais].clientes[index].sexo);
    printf("-->Saldo: %f\n",banco[pais].clientes[index].saldo);
}

void cambiarSexo(Banco banco[], int pais, int indice, char sexo){
    if(sexo == 'M' || sexo == 'F'){
        banco[pais].clientes[indice].sexo = sexo;
    }
    setOcupado(banco, pais, indice);
}

void cambiarSexoCliente(Banco banco[], int pais, int index, char nuevoSexo){
    cambiarSexo(banco, pais, index, nuevoSexo);
}

int main(){
	int eleccion;
	int tam_banco;
	tam_banco=validarRango(1,LIMITE_PAISES,"Introduce el número de paises: ");
	Banco banco[tam_banco];
	introducirPaises(banco, tam_banco);
	//int l;for(l=0;l<tam_banco;l++){ puts(banco[l].nombrePais); } //Revision de llenado nombrePais
	mostrarLongitudes(banco,tam_banco);
	saltoLinea();
	instrucciones();
	printf("\n Elija una opcion: ");
	scanf("%d",&eleccion);
	while(eleccion != SALIR){
            switch(eleccion){
                case ALTA:
                	/*printf(" ");
                	int op=1;
                	do{*/
                		printf(" --- Opcion alta ---\n");                    
                    	if(hayVacioTodaEstructura(banco, tam_banco)==true){
                        	char nombre_pais[20];
                        	//PEDIRNOMBREPAIS
                       		// printf("\tIntroduce el nombre del pais: ");        				
        					//fflush(stdin);
							//gets(nombre_pais);						
							//bool seEncuentraNombre(char nombrePais[20], Banco banco[], int tam_banco){
							bool se_encuentra = 0;
							do{	
								printf("\tIntroduce el nombre del pais: ");  
            					fflush(stdin);
								//gets(nombre_pais);											
								fgets(nombre_pais,20,stdin);
        						int i;
        						for (i=0;i<tam_banco;i++) {
	        						if(strcasecmp(banco[i].nombrePais,nombre_pais)==0){
	        							//printf("%s\n",banco[i].nombrePais);
	            						se_encuentra = true;
	            					}
        						}
        						if(se_encuentra==false){
                					printf("\t\tEl nombre %s no se encuentra registrado...\n",nombre_pais);
                					printf("\t\t\t--> Intenta de nuevo.\n");
            					}            												
							}while(se_encuentra==false);        				        			
                        	int id_pais;
							id_pais = getIndicePais(nombre_pais, banco, tam_banco);
                        	//printf("%d id pais\n ",id_pais);//verificar indice
							int cliente;
							cliente= indiceVacioPaisEspecifico(id_pais, banco);
							printf("%d ",cliente);//verificar indice
                        	if(cliente != -1){
	                        	char nombre_cliente[20];
    	                    	char sexo;
        	                	double saldo;
            	            	printf("Introduce nombre del cliente: ");
                	        	fflush(stdin);                        	
                    	    	fgets(nombre_cliente,20,stdin);
                        		printf("\nIntroduce el Sexo: ");
                        		fflush(stdin);
                        		scanf("%c",&sexo);
                        		printf("\nIntroduce el Sueldo: ");
                        		scanf("%d",&saldo);
                            	//llenar datos
                            	strcpy(banco[id_pais].clientes[cliente].nombre,nombre_cliente);
                            	banco[id_pais].clientes[cliente].sexo=sexo;
                            	banco[id_pais].clientes[cliente].saldo=saldo;
                            	banco[id_pais].clientes[cliente].ocupado=true;
                        	}
                        	else
                            	printf("No existe indice vacio en el pais %s",banco[id_pais].nombrePais);
                    		}
                    	else {
                        	printf("---------------------------------------------------------------------\n");
                        	printf("\t\t La estructura esta completamente llena.\n");
                        	printf("---------------------------------------------------------------------\n");
                        	//op=2;
                    	}
                    	/*if(op==1){
                			printf("\n\t Desea dar de alta a otro cliente");
                			printf("\n\t1.-Si\t2.-No\t");
                			scanf("%d",&op);
                		}
					}while(op==1); */                   
                break;
                case BAJA:
                    printf(" --- Opción baja ---\n");                    
                    if(estaTodoVacioEstructura(banco, tam_banco)==false){
                        char nombre_pais[20];					
						//PEDIRNOMBREPAIS                       
						bool se_encuentra = 0;
						do{	
							printf("\tIntroduce el nombre del pais: ");  
            				fflush(stdin);
							//gets(nombre_pais);											
							fgets(nombre_pais,20,stdin);
        					int i;
        					for (i=0;i<tam_banco;i++) {
	        					if(strcasecmp(banco[i].nombrePais,nombre_pais)==0){
	        						//printf("%s\n",banco[i].nombrePais);
	            					se_encuentra = true;
	            				}
        					}
        					if(se_encuentra==false){
                				printf("\t\tEl nombre %s no se encuentra registrado...\n",nombre_pais);
                				printf("\t\t\t--> Intenta de nuevo.\n");
            				}
            												
						}while(se_encuentra==false);																																			
                        int pais;
						pais = getIndicePais(nombre_pais, banco, tam_banco);
                        int cliente;
						cliente =validarRango(0, getTotalClientes(banco,pais)-1, "\tIntroduce el indice del cliente: ");
                        if(getIsOcupadoCliente(banco,pais,cliente)==true){
                            printf("\t--> Cliente %s  dado de baja.",banco[pais].clientes[cliente].nombre);
                            eliminarCliente(banco,pais,cliente);
                        }
                        else
                            printf("\tEl cliente %i del pais %s  no tiene datos.",cliente,banco[pais].nombrePais);
                    }
                    else {
                        printf("---------------------------------------------------------------------\n");
                        printf("\t\t La estructura esta toda vacia.\n");
                        printf("---------------------------------------------------------------------\n");
                    }
                break;
                case MOSTRAR_TODO:
                    printf(" --- Opción mostrar todo ---\n");
                    imprimirTodo(banco,tam_banco);
                break;
                case MOSTRAR_ESPECIFICO:
                    printf(" --- Opción mostrar especifico ---\n");
                    if(estaTodoVacioEstructura(banco, tam_banco)==false){                    
                        char nombre_pais[20];
                        //PEDIRNOMBREPAIS                       
						bool se_encuentra = 0;
						do{	
							printf("\tIntroduce el nombre del pais: ");  
            				fflush(stdin);
							//gets(nombre_pais);											
							fgets(nombre_pais,20,stdin);
        					int i;
        					for (i=0;i<tam_banco;i++) {
	        					if(strcasecmp(banco[i].nombrePais,nombre_pais)==0){
	        						//printf("%s\n",banco[i].nombrePais);
	            					se_encuentra = true;
	            				}
        					}
        					if(se_encuentra==false){
                				printf("\t\tEl nombre %s no se encuentra registrado...\n",nombre_pais);
                				printf("\t\t\t--> Intenta de nuevo.\n");
            				}
            												
						}while(se_encuentra==false);
                        int pais;
						pais= getIndicePais(nombre_pais, banco, tam_banco);
                        int cliente;
						cliente = validarRango(0, getTotalClientes(banco,pais)-1, "\tIntroduce el indice del cliente: ");
                        if(getIsOcupadoCliente(banco,pais,cliente)==true){
                            imprimirEspecifico(banco,pais,cliente);
                        }
                        else
                            printf("\tEl cliente %i del pais %s  no tiene datos.",cliente,banco[pais].nombrePais);
                    }
                    else {
                        printf("---------------------------------------------------------------------\n");
                        printf("\t\t La estructura esta toda vacia.\n");
                        printf("---------------------------------------------------------------------\n");
                    }
                break;
                case MOSTRAR_OCUPADOS:
                    printf(" --- Opción mostrar solo ocupados ---\n");
                    imprimirSoloOcupados(banco, tam_banco);
                break;
                case ABONAR:
                    printf(" --- Opción abonar ---\n");
                    if(estaTodoVacioEstructura(banco, tam_banco)==false){                   
                        char nombre_pais[20];
                        //PEDIRNOMBREPAIS                       
						bool se_encuentra = 0;
						do{	
							printf("\tIntroduce el nombre del pais: ");  
            				fflush(stdin);
							//gets(nombre_pais);											
							fgets(nombre_pais,20,stdin);
        					int i;
        					for (i=0;i<tam_banco;i++) {
	        					if(strcasecmp(banco[i].nombrePais,nombre_pais)==0){
	        						//printf("%s\n",banco[i].nombrePais);
	            					se_encuentra = true;
	            				}
        					}
        					if(se_encuentra==false){
                				printf("\t\tEl nombre %s no se encuentra registrado...\n",nombre_pais);
                				printf("\t\t\t--> Intenta de nuevo.\n");
            				}
            												
						}while(se_encuentra==false);					
                        int pais;
						pais = getIndicePais(nombre_pais, banco, tam_banco);
                        int cliente;                        
						cliente = validarRango(0, getTotalClientes(banco,pais)-1, "\tIntroduce el indice del cliente: ");
                        if(getIsOcupadoCliente(banco,pais,cliente)==true){
                            double cuanto;
                            printf("\tIntroduce cuanto ingresarás a tú cuenta:  ");
							scanf("%f",&cuanto);
                            abonarSaldoCliente(banco, pais,cliente, cuanto);
                        }
                        else{
                        	printf("\tEl cliente %i del pais %s  no tiene datos.",cliente,banco[pais].nombrePais);
						}                                
                    }
                    else {
                        printf("---------------------------------------------------------------------\n");
                        printf("\t\t La estructura esta toda vacia.\n");
                        printf("---------------------------------------------------------------------\n");
                    }
                break; 
                case RETIRAR:
                    printf(" --- Opción retirar ---\n");
                    if(estaTodoVacioEstructura(banco, tam_banco)==false){                    
                        char nombre_pais[20];
                        //PEDIRNOMBREPAIS                       
						bool se_encuentra = 0;
						do{	
							printf("\tIntroduce el nombre del pais: ");  
            				fflush(stdin);
							//gets(nombre_pais);											
							fgets(nombre_pais,20,stdin);
        					int i;
        					for (i=0;i<tam_banco;i++) {
	        					if(strcasecmp(banco[i].nombrePais,nombre_pais)==0){
	        						//printf("%s\n",banco[i].nombrePais);
	            					se_encuentra = true;
	            				}
        					}
        					if(se_encuentra==false){
                				printf("\t\tEl nombre %s no se encuentra registrado...\n",nombre_pais);
                				printf("\t\t\t--> Intenta de nuevo.\n");
            				}
            												
						}while(se_encuentra==false);					
                        int pais;
						pais = getIndicePais(nombre_pais, banco, tam_banco);
                        int cliente;                        
						cliente = validarRango(0, getTotalClientes(banco,pais)-1, "\tIntroduce el indice del cliente: ");                           						                        				                        
                        if(getIsOcupadoCliente(banco,pais,cliente)==true){												
                            double cuanto;
							printf("\tIntroduce cuanto retirarás de tú cuenta: ");
							scanf("%d",&cuanto); 
                            retirarSaldoCliente(banco, pais, cliente, cuanto);
                        }
                        else
                            printf("\tEl cliente %i del pais %s  no tiene datos.",cliente,banco[pais].nombrePais);
                    }
                    else {
                        printf("---------------------------------------------------------------------\n");
                        printf("\t\t La estructura esta toda vacia.\n");
                        printf("---------------------------------------------------------------------\n");
                    }
                break;
                case BUSCAR_ID_VACIO_ESTRUCTURA:
                    printf(" --- Opción buscar id vacio en toda estructura ---\n");
                    if(hayVacioTodaEstructura(banco, tam_banco)==true){																							                    
                        Indices temp;
						temp = indiceVacioTodaEstructura(banco, tam_banco);
                        printf("---------------------------------------------------------------------\n");
                        printf("\tEl pais [%d] %s tiene el cliente [%d] vacio\n",temp.pais, banco[temp.pais].nombrePais, temp.cliente);
                        printf("---------------------------------------------------------------------\n");
                    }
                    else {
                        printf("---------------------------------------------------------------------\n");
                        printf("\t\t La estructura esta completamente llena.\n");
                        printf("---------------------------------------------------------------------\n");
                    }
                break;
                case ESTA_LLENA_ESTRUCTURA:
                    printf(" --- Opción esta llena toda la estructura ---\n");
                    if(estaTodoLlenoEstructura(banco, tam_banco)==true) {
                        printf("---------------------------------------------------------------------\n");
                        printf("\ttrue, la estructura esta toda llena.\n");
                        printf("---------------------------------------------------------------------\n");
                    }
                    else {
                        printf("---------------------------------------------------------------------\n");
                        printf("\tfalse, la estructura no esta toda llena.\n");
                        printf("---------------------------------------------------------------------\n");
                    }
                break;
                case ESTA_VACIA_ESTRUCTURA:
                    printf(" --- Opción esta vacia toda la estructura ---\n");
                    if(estaTodoVacioEstructura(banco, tam_banco)==false){
                        printf("---------------------------------------------------------------------\n");
                        printf("\ttrue, la estructura esta toda vacia.\n");
                        printf("---------------------------------------------------------------------\n");
                    }
                    else {
                        printf("---------------------------------------------------------------------\n");
                        printf("\tfalse, la estructura no esta toda vacia.\n");
                        printf("---------------------------------------------------------------------\n");
                    }
                break;
                case IMPRIMIR_NOM_PAISES:
                    printf(" --- Opción imprimir nombre de paises ---\n");
                    imprimirPaises(banco, tam_banco);
                break;
				case ACTUALIZAR:
                    printf(" --- Opción actualizar ---\n");
                    if(estaTodoVacioEstructura(banco, tam_banco)==false){                    
                        char nombre_pais[20];
						//PEDIRNOMBREPAIS                       
						bool se_encuentra = 0;
						do{	
							printf("\tIntroduce el nombre del pais: ");  
            				fflush(stdin);
							//gets(nombre_pais);											
							fgets(nombre_pais,20,stdin);
        					int i;
        					for (i=0;i<tam_banco;i++) {
	        					if(strcasecmp(banco[i].nombrePais,nombre_pais)==0){
	        						//printf("%s\n",banco[i].nombrePais);
	            					se_encuentra = true;
	            				}
        					}
        					if(se_encuentra==false){
                				printf("\t\tEl nombre %s no se encuentra registrado...\n",nombre_pais);
                				printf("\t\t\t--> Intenta de nuevo.\n");
            				}
            												
						}while(se_encuentra==false);					
                        int pais;
						pais = getIndicePais(nombre_pais, banco, tam_banco);
                        int cliente;                        
						cliente = validarRango(0, getTotalClientes(banco,pais)-1, "\tIntroduce el indice del cliente: ");                           						                        				                        
                        if(getIsOcupadoCliente(banco,pais,cliente)==true){ 						                       	                                                                   
                            instrucciones_actualizar();
                            printf(" Elija una opción: ");
                            scanf("%d",&eleccion);                            
                            while(eleccion != SALIR_ACTUALIZAR) {
                                switch (eleccion) {
                                    case ACTUALIZAR_NOMBRE:
                                        printf(" --- Opción actualizar nombre ---\n");                                        
                                        char nuevoNombre[20];
										printf("Introduce nuevo nombre del cliente: ");
										fflush(stdin);
										fgets(nuevoNombre,20,stdin);
                                        cambiarNombreCliente(banco,pais,cliente,nuevoNombre);
                                        printf("-----------------------------------------------------------------\n");
                                        printCliente(banco, pais,cliente);
                                        printf("-----------------------------------------------------------------\n");
                                        break;
                                    case ACTUALIZAR_SEXO:
                                        printf(" --- Opción actualizar sexo ---\n");
                                        char nuevoSexo;                                        
                                        printf("Introduce el nuevo Sexo: ");
                                        fflush(stdin);
										scanf("%c",nuevoSexo);
										cambiarSexoCliente(banco,pais,cliente,nuevoSexo);
                                        printf("-----------------------------------------------------------------\n");
                                        printCliente(banco, pais,cliente);
                                        printf("-----------------------------------------------------------------\n");
                                        break;
                                    case ACTUALIZAR_MOSTRAR_MENU:
                                        instrucciones_actualizar();
                                        break;
                                    default:
                                        printf("******************************************\n");
                                        printf(" --- Opción Desconocida ---\n");
                                        printf("******************************************\n");                                        
                                        instrucciones_actualizar();
                                }
                                printf(" Elija una opción: ");
                                scanf("%d",&eleccion);                                
                            }
                            instrucciones();
                        }
                        else{
                        	printf("\tEl cliente %i del pais %s  no tiene datos.",cliente,banco[pais].nombrePais);
						}                            
                    }
                    else {
                        printf("---------------------------------------------------------------------\n");
                        printf("\t\t La estructura esta toda vacia.\n");
                        printf("---------------------------------------------------------------------\n");
                    }
                    break;
                case MOSTRAR_LONGITUDES:
                    printf(" --- Opción mostrar longitudes ---\n");
                    printf("---------------------------------------------------------------------\n");
                    mostrarLongitudes(banco,tam_banco);
                    printf("---------------------------------------------------------------------\n");
                break;
				case MOSTRAR_MENU_PRIN:
                    instrucciones();
                break;
				default:
                    printf("******************************************\n");
                    printf(" --- Opción Desconocida ---\n");
                    printf("******************************************\n");                    
                    instrucciones();				                 
            }
        printf(" Elija una opción: ");
        scanf("%d",&eleccion);    
    }
    printf("--- Fin de la Ejecución del Sistema ---\n");	
	return 0;
}    

<file_sep>/Banco/banco.h
#ifndef __banco
#define __banco

#include <stdbool.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
//#include <malloc.h>

#define MOSTRAR_MENU_PRIN 0
#define LIMITE_PAISES	5
#define LIMITE_CLIENTES 10
#define ALTA 1
#define BAJA 2
#define MOSTRAR_TODO 3
#define MOSTRAR_ESPECIFICO 4
#define MOSTRAR_OCUPADOS 5
#define ABONAR 6
#define RETIRAR 7
#define BUSCAR_ID_VACIO_ESTRUCTURA 8
#define ESTA_LLENA_ESTRUCTURA 9
#define ESTA_VACIA_ESTRUCTURA 10
#define IMPRIMIR_NOM_PAISES 11
#define MOSTRAR_LONGITUDES 12
#define ACTUALIZAR 13
#define SALIR 14
#define ACTUALIZAR_MOSTRAR_MENU 0
#define ACTUALIZAR_NOMBRE 1
#define ACTUALIZAR_SEXO 2
#define SALIR_ACTUALIZAR 3


typedef struct {
	char nombre[20];
	char sexo;
	double saldo;
	bool ocupado;
}Cliente;

typedef struct {
	char nombrePais[20];
	int num_clientes;
	Cliente clientes[];
}Banco;

typedef struct {
	int pais;
	int cliente;
}Indices;

void instrucciones();

void saltoLinea();

int validarRango(int inicio, int fin, char *mensaje);

bool estaNombreRepetido(int tam_banco, char *nombrePais, Banco banco[]);

char *nombrePaisR(int tam_banco, Banco banco[]);
 
char *nombrePais(int tam_banco, Banco banco[]);	

void introducirPaises(Banco banco[], int tam_banco);

void mostrarLongitudes(Banco banco[],int tam_banco);

bool getIsOcupadoCliente(Banco banco[],int indice_pais,int index);

int getTotalClientes(Banco banco[], int posicion);

bool isTodoOcupado(Banco banco[], int indice_pais);

bool hayVacioTodaEstructura(Banco banco[], int tam_banco);

int getIndicePais(char *nombrePais, Banco banco[], int tam_banco);

int indiceVacio(Banco banco[], int pais);

int indiceVacioPaisEspecifico(int pais, Banco banco[]);
    
char *nombreCliente();

void eliminarCliente(Banco banco[],int pais,int index);

bool existeEspacioOcupado(Banco banco[], int pais);

bool estaTodoVacioEstructura(Banco banco[], int tam_banco);

void imprimirTodo(Banco banco[], int tam_banco);

void imprimirEspecifico(Banco banco[],int pais,int cliente);

bool printSoloOcupados(Banco banco[],int pais);

void imprimirSoloOcupados(Banco banco[], int tam_banco);

bool tieneDatos(Banco banco[], int pais, int indice);

void abonarSaldo(Banco banco[], int pais, int indice ,double cuanto);

void abonarSaldoCliente(Banco banco[], int pais, int index, double cuanto);

bool tieneSaldo(Banco banco[], int pais, int indice);

void retirarSaldo(Banco banco[], int pais, int indice,double cuanto);

void retirarSaldoCliente(Banco banco[], int pais, int index, double cuanto);
						    
Indices indiceVacioTodaEstructura(Banco banco[],int tam_banco);

bool existeEspacioVacio(Banco banco[], int pais);

bool estaTodoLlenoEstructura(Banco banco[], int tam_banco);

void imprimirPaises(Banco banco[], int tam_banco);

void instrucciones_actualizar();

void setTodosDatos(Banco banco[],int pais, int indice);

void setOcupado(Banco banco[], int pais, int indice);

void cambiarNombre(Banco banco[], int pais, int indice, char nuevoNombre[20]);

void cambiarNombreCliente(Banco banco[], int pais, int index, char nuevoNombre[20]);

void printCliente(Banco banco[], int pais,int index);

void cambiarSexo(Banco banco[], int pais, int indice, char sexo);

void cambiarSexoCliente(Banco banco[], int pais, int index, char nuevoSexo);

#endif
<file_sep>/Banco/Makefile
all:
	gcc -g -c -Wall main.c -o main.o
	gcc -g -c -Wall banco.c -o banco.o
	gcc -g -Wall main.o banco.o -o application

clean:
	rm *.o
	rm application
