Ejercicios de lenguaje C

Ejercicios/0100holamundo.c

@@ -0,0 +1,5 @@
+#include<stdio.h>
+
+int main(){
+    printf("Hola mundo!");
+}

Ejercicios/0101RecogeDatos.c

@@ -0,0 +1,17 @@
+#include<stdio.h>
+
+int main(){
+    
+    int numero1;
+    int numero2;
+    int numero3, numero4, numero5;
+
+    numero1=23;
+    numero2=56;
+
+    printf("\nIntroduce un numero entero: ");
+    scanf("%d", &numero3);
+
+    printf("\nLav ariable numero1 tiene un valor %d, numero2 tiene un valor %d y numero3 %d", numero1, numero2, numero3);
+
+}

Ejercicios/0102calcularArea.c

@@ -0,0 +1,31 @@
+#include<stdio.h>
+
+#define PI 3.14
+
+int main(){
+    
+    int numero1;
+    int numero2;
+    int numero3, numero4, numero5;
+    float radio;
+    float area;
+
+    numero1=23;
+    numero2=56;
+    /*
+
+    printf("\nIntroduce un numero entero: ");
+    scanf("%d", &numero3);
+
+    printf("\nLav ariable numero1 tiene un valor %d, numero2 tiene un valor %d y numero3 %d", numero1, numero2, numero3);
+    */
+
+    printf("\nIndica el radio de una circunferencia:");
+    scanf("%f", &radio);
+
+    area=radio*radio*PI;
+
+    printf("\nEl area de la circunferencia de radio %f es %.3f", radio, area);
+
+
+}

Ejercicios/0103pide2NumerosYCalcula.c

@@ -0,0 +1,22 @@
+#include<stdio.h>
+
+int main(){
+    
+    int numero1, numero2;
+    int suma, diferencia, producto, division;
+
+
+    printf("\nIntroduce un numero entero: ");
+    scanf("%d", &numero1);
+
+    printf("\nIntroduce el segundo numero entero: ");
+    scanf("%d", &numero2);
+    
+    suma = numero1 + numero2;
+    diferencia=numero1-numero2;
+    producto = numero1*numero2;
+    division = numero1/numero2;
+
+    printf("\nLa suma de los valores introducidos da un resultado de: %d , \nLa resta de los valores introducidos da un resultado de: %d \nLa multiplicación de los valores introducidos da un resultado de: %d \nLa división de los valores introducidos da un resultado de: %d  \n\n", suma, diferencia, producto, division);
+
+}

Ejercicios/0104compara3Numeros.c

@@ -0,0 +1,32 @@
+#include<stdio.h>
+
+int main(){
+    
+    /* Variables */
+    int numero1, numero2, numero3;
+
+    /* Solicitamos valores para las variables */
+    printf("\nIntroduce un número entero: ");
+    scanf("%d", &numero1);
+
+    printf("\nIntroduce el segundo número entero: ");
+    scanf("%d", &numero2);
+    
+    printf("\nIntroduce el tercer número entero: ");
+    scanf("%d", &numero3);
+
+    /* Condicional para seleccionar el número mayor */
+    if (numero1 > numero2 && numero1 > numero3) {
+        printf("\nEl primer número introducido es el mayor: %d\n\n", numero1);
+    }
+    else if (numero2 > numero1 && numero2 > numero3) {
+        printf("\nEl segundo número introducido es el mayor: %d\n\n", numero2);
+    }
+    else if (numero3 > numero1 && numero3 > numero2) {
+        printf("\nEl tercer número introducido es el mayor: %d\n\n", numero3);
+    }
+    else {
+        printf("\nHas repetido alguno de los numeros\n");
+    }
+
+}

Ejercicios/0201pedirEdad.c

@@ -0,0 +1,24 @@
+#include<stdio.h>
+
+int main(){
+    
+    /* Variables */
+    int edad;
+
+    /* Solicitamos valores para las variables */
+    printf("\nIntroduce un número entero: ");
+    scanf("%d", &edad);
+
+    /* Condicional para seleccionar el número mayor */
+    if (edad >= 18) {
+        printf("\nEres mayor de edad: %d años\n\n", edad);
+    }
+    else if (edad< 18 && edad>0) {
+        printf("\nEres menor de edad: %d años\n\n", edad);
+    }
+    else if(edad>=99) {
+        printf("\nQue longevo con %d años\n\n", edad);
+    }else{
+        printf("\nHas introducido un número negativo\n\n");
+    }
+}

Ejercicios/0202menuOperAritm.c

@@ -0,0 +1,48 @@
+#include<stdio.h>
+#include<math.h>
+
+int main(){
+    
+    /* Variables */
+    int menu, num1, num2;
+    float potencia;
+
+    /* Solicitamos valores para las variables */
+    printf("\nIntroduce el primer numero para operar\n");
+    scanf("%d", &num1);
+    printf("\nIntroduce el segundo numero para operar\n");
+    scanf("%d", &num2);
+
+    /* Elegir opción */
+    printf("\nIntroduce una opción del 1 al 5: ");
+    printf("\n1 Suma ");
+    printf("\n2 División");
+    printf("\n3 diferencia");
+    printf("\n4 producto");
+    printf("\n5 potencia\n");
+
+    scanf("%d", &menu);
+
+    /* Condicional case para seleccionar el número mayor */
+    switch (menu) {
+        case 1:
+            printf("\nEl resultado de la suma es: %d\n", num1+num2);
+            break;
+        case 2:
+            printf("\nEl resultado de la división es: %d\n", num1/num2);
+            break;
+        case 3:
+            printf("\nEl resultado de la resta es: %d\n", num1-num2);
+            break;
+        case 4:
+            printf("\nEl resultado de la multiplicación es: %d\n", num1*num2);
+            break;
+        case 5:
+            potencia=pow(num1, num2);
+            printf("\nEl resultado de la división es: %f\n", potencia);
+            break;
+
+        default:
+            printf("\nNo es un valor correcto\n\n");
+    }
+}

Ejercicios/0203saludaXVeces.c

@@ -0,0 +1,17 @@
+#include <stdio.h>
+
+int main() {     
+    int final, contador; 
+
+    /* Solicitamos número de veces de repetición */
+    printf("\nIntroduce un número entero: \n");
+    scanf("%d", &final);
+
+
+    for (contador=1; contador<=final; contador=contador+1) { 
+        puts("\nhola");   
+    }     
+    
+    return 0;
+
+}

Ejercicios/0204TablaMultipli.c

@@ -0,0 +1,14 @@
+#include <stdio.h> 
+
+int main() {     
+    int num, contador;     
+    printf ("\nIndica el número de la tabla: \n");     
+    scanf ("%d", &num);     
+    puts(""); 
+    printf("TABLA DEL %d \n", num); 
+
+    for (contador=1; contador<=10; contador++) { 
+        printf ("%d * %d = %d \n",num, contador, num*contador); 
+    }     
+    return 0; 
+}

Ejercicios/0205contarDesdeXHasta100.c

@@ -0,0 +1,33 @@
+#include<stdio.h>
+ 
+int main ()
+{
+   /* variables */   
+   int contador;
+
+    inicio:
+    
+    printf ("\nIndica donde empieza a contar hasta 100: \n");     
+    scanf ("%d", &contador);     
+    puts(""); 
+    printf("CONTAMOS DESDE EL %d \n", contador); 
+
+    /* Control de flujo*/
+
+    if(contador>100){
+        printf("%d no es un número menor de 100\n",contador);
+        goto inicio;
+
+    } else {
+
+        /* bucle */   
+        
+        while( contador <= 100 )
+        {
+            printf("%d\n", contador);
+            contador++;
+        }
+        
+        return 0;
+    }
+}

Ejercicios/0205contarDesdeXHasta100singoto.c

@@ -0,0 +1,37 @@
+#include<stdio.h>
+ 
+int main ()
+{
+   /* variables */   
+   int contador;
+
+  //  inicio:
+    
+    do{
+       printf ("\nIndica donde empieza a contar hasta 100: \n");     
+       scanf ("%d", &contador);     
+
+        if(contador>100){
+            printf("\nDebes introducir un numero menor que 100");
+        }
+
+    }while(contador>100);
+    puts(""); 
+    printf("CONTAMOS DESDE EL %d \n", contador); 
+
+    /* Control de flujo*/
+
+   
+    
+
+        /* bucle */   
+        
+        while( contador <= 100 )
+        {
+            printf("%d\n", contador);
+            contador++;
+        }
+        
+        return 0;
+    
+}

Ejercicios/0206contarParesHasta100.c

@@ -0,0 +1,40 @@
+#include<stdio.h>
+
+int main () {
+
+    /* variables */   
+    int contador,final=100, menu;
+
+    /* Menú de opciones a y b */
+    pregunta:
+
+    printf("Elige una opción:\n");
+    printf("1   -->    Impar\n");
+    printf("2   -->    Par\n\n");
+
+    scanf("%d", &menu);
+
+    /* Opción par o impar */
+    switch (menu) {
+        case 1:
+            contador=1;
+            puts("NÚMEROS IMPARES HASTA 100\n");
+            break;
+        case 2:
+            contador=0;
+            puts("NÚMEROS PARES HASTA 100\n");
+            break;
+        default:
+            printf("\nNo es una opción\n\n");
+            goto pregunta;
+    }
+
+
+   /* bucle */   
+   while(contador<=final) {
+      printf("%d\n", contador);
+      contador=contador+2;
+   }
+ 
+   return 0;
+}

Ejercicios/0207numHasta0.c

@@ -0,0 +1,14 @@
+#include <stdio.h>
+
+/* 
+PROGRAMA QUE LEE CUALQUIER NÚMERO ENTERO INDEFINIDAMENTE 
+HASTA QUE EL USUARIO INTRODUZCA UN CERO.
+*/
+
+int main(){
+    int num;
+
+    do {
+        scanf("%d",&num);
+        } while (num != 0);
+}

Ejercicios/0208numHasta0ySuma.c

@@ -0,0 +1,16 @@
+#include <stdio.h>
+/*
+PROGRAMA QUE LEE NÚMEROS HASTA LLEGAR A UN CERO 
+Y LUEGO MUESTRA LA SUMA DE TODOS LOS NÚMEROS LEÍDOS
+*/
+
+int main(){
+    int x;
+    int suma=0;
+
+    do {
+        scanf("%d",&x);
+        suma+=x;
+    } while ( x != 0);
+    printf("La suma es: %d", suma);
+}

Ejercicios/0301argumentos.c

@@ -0,0 +1,31 @@
+#include<stdio.h>
+#include<stdlib.h>
+
+int main(int argc, char *argv[]){
+
+    int i;
+    int num1;
+    int num2;
+
+
+    printf("\nHaremos un programa para ver como funcionan los argumentos de entrada del programa");
+
+    printf("\nHemos recibido %d argumentos", argc);
+
+    for(i=0;i<argc; i++){
+        printf("\nArgumento %d: %s", i, argv[i]);
+    }
+
+    if(argc<3){
+        printf("\nHemos recibido menos argumentos de los esperados, no podemos operar");
+        return 1;
+    }else{
+        num1=atoi(argv[1]);
+        num2=atoi(argv[2]);
+
+        printf("\nLa suma es %d", (num1+num2));
+    }
+
+    printf("\n");
+    return 0;
+}

Ejercicios/0302conversiones.c

@@ -0,0 +1,84 @@
+#include<stdio.h>
+#include<stdlib.h>
+#include <string.h>
+
+int main(int argc, char *argv[]){
+
+    char cadena[20];
+    int numero;
+ 
+
+    printf("\nIntroduce un número para mostrar: ");
+    scanf("%d", &numero);
+
+    printf("\nEl número en decimal es %d", numero);
+    printf("\nEl número en octal es %o", numero);
+    printf("\nEl número en hexadecimal es %x", numero);
+
+
+// Opción 1
+    // itoa(numero, cadena, 2);
+
+    printf("En binario es : %s");
+
+/* Opción 2
+
+	 // * C++ version 0.4 char* style "itoa":
+	 // * Written by Lukás Chmela
+	 // * Released under GPLv3.
+ 	
+    int base = 2;
+
+    char* itoa(int numero, char* cadena, int base) {
+		// check that the base if valid
+		if (base < 2 || base > 36) { *cadena = '\0'; return cadena; }
+
+		char* ptr = cadena, *ptr1 = cadena, tmp_char;
+		int tmp_value;
+
+		do {
+			tmp_value = numero;
+			numero /= base;
+			*ptr++ = "zyxwvutsrqponmlkjihgfedcba9876543210123456789abcdefghijklmnopqrstuvwxyz" [35 + (tmp_value - numero * base)];
+		} while ( numero );
+
+		// Apply negative sign
+		if (tmp_value < 0) *ptr++ = '-';
+		*ptr-- = '\0';
+		while(ptr1 < ptr) {
+			tmp_char = *ptr;
+			*ptr--= *ptr1;
+			*ptr1++ = tmp_char;
+		}
+		return cadena;
+	}
+*/
+
+
+/* Opción 3
+*/
+
+
+   int bin[8];
+   int aux;
+
+    printf("\nEl número en binario es ");
+
+   for (aux = 7; aux >= 0; aux--) {
+      if (numero % 2 == 0)
+         bin[aux] = 0;
+      else
+         bin[aux] = 1;
+      numero = numero / 2;
+   }
+
+   for (aux = 0; aux < 8; aux++)
+    
+    printf("%d ", bin[aux]);
+    printf("\n");
+
+
+    return 0;
+
+    
+}

Ejercicios/0401paresEntreDosNum.c

@@ -0,0 +1,30 @@
+#include<stdio.h>
+
+int main (){
+
+    int num1, num2, menor, mayor, i;
+
+    printf("\nIntroduce un número donde empieza el conteo de pares: ");
+    scanf("%d", &num1);
+
+    printf("\nIntroduce un número para finalizar el conteo de pares: ");
+    scanf("%d", &num2);
+
+    if(num1<num2){
+        menor=num1;
+        mayor=num2;
+    }else{
+        menor=num2;
+        mayor=num1;
+    }
+
+    for(i=menor; i<=mayor; i++){
+        if (i%2==0){
+            printf("%d ",i);
+        }
+        
+    }
+
+    //hacer una cuenta atrás desde un número pedido al usauario
+
+}

Ejercicios/0402mediaDeLosNum.c

@@ -0,0 +1,26 @@
+#include<stdio.h>
+
+int main (){
+
+    int num;
+    int suma=0;
+    float media;
+    int contador=0;
+
+    printf("\nSi el número que introduces es par");
+
+    do{
+        printf("\nIntroduce un número: ");
+        scanf("%d", &num);
+        
+        suma=suma+num;
+
+        contador++;
+
+    } while (num%2==0);
+    
+    media=(float)suma/contador;
+    printf("%f ",media);
+
+
+}

Ejercicios/0501primos.c

@@ -0,0 +1,34 @@
+#include<stdio.h>
+
+int main (){
+
+    // Variables
+    int numero=0;
+    int divisores=0;
+    int primo=0; // primo = 0 no primo = 1
+    // Solicitar numero entero hasta valor -1
+    do
+    {
+        printf("\nIntroduce un número, si es primo se cerrará el programa: ");
+        scanf(" %d",&numero);
+        if(numero!=-1 && numero>0)
+        {
+            // el numero es mayor que 0, comprobar si es primo
+            primo=0;
+            divisores=2;
+            while(divisores<numero  && primo!=1)
+            {
+                if(numero%divisores==0) primo=1;
+                divisores++;
+            }
+            // Si primo vale 0 es que el numero no es primo
+            printf("\nEl numero %d no es primo",numero);
+            printf("\n");
+        }
+
+
+    // Si primo vale 1 es que el numero es primo y utilizará la condición para salir del bucle
+    } while(primo==1);
+    return 0;
+
+}

Ejercicios/0502numerosAmigos.c

@@ -0,0 +1,63 @@
+#include<stdio.h>
+
+int main (){
+
+    // Variables
+    int numero1,numero2;
+    int amigos=0;
+
+    int divisores1; //aquí acumulamos la suma de los divisores del primer número
+    int divisores2;
+
+    int i;
+
+    // 
+    printf("\nComprueba si dos números son amigos");
+    printf("\n###########");
+    printf("\n");
+
+
+    // Solicitar numero entero hasta valor -1
+    do {
+        printf("\nIntroduce un número: ");
+        scanf(" %d",&numero1);
+
+        printf("\nIntroduce otro número: ");
+        scanf(" %d",&numero2);
+        //if(numero1!=-1 && numero1>0 && numero2!=-1 && numero2>0){
+        if(numero1<=0 || numero2<=0){    
+            // Comprobación
+            //
+            printf("\nUno de los dos numeros (o los dos) no es positivo");
+
+ 
+        }else{
+            divisores1=0;
+            for(i=1; i<numero1; i++){
+                if(numero1%i==0){
+                    divisores1=divisores1+i;
+                }
+            }
+
+            divisores2=0;
+            for(i=1; i<numero2; i++){
+                if(numero2%i==0){
+                    divisores2=divisores2+i;
+                }
+            }
+
+            if(numero1==divisores2 && numero2==divisores1){
+                amigos=1;
+                printf("\n%d y %d son amigos", numero1, numero2);
+                printf("\nSus divisores son %d y %d\n", divisores1, divisores2);
+            }else{
+                amigos=0;
+                printf("\n%d y %d no son amigos", numero1, numero2);
+                printf("\nSus divisores son %d y %d\n", divisores1, divisores2);
+            }
+        }
+    // condición para salir del bucle
+    } while(amigos==0);
+    return 0;
+
+}

Ejercicios/0503menuOperarSencillo.c

@@ -0,0 +1,124 @@
+#include<stdio.h>
+
+
+int main (){
+
+    /* Variables */
+    int numero1,numero2,numero3;
+    int menu;
+    int i,a;
+
+    /* Enunciado*/
+    printf("\nOpera con 3 numeros en un menú");
+    printf("\n###########");
+    printf("\n");
+
+
+    /* Solicitar numeros */
+
+    printf("\nIntroduce un número: ");
+    scanf("%d",&numero1);
+
+    printf("\nIntroduce otro número: ");
+    scanf("%d",&numero2);
+
+    printf("\nIntroduce el tercer número: ");
+    scanf("%d",&numero3);
+
+
+
+    /* Elegir opción */
+    printf("\n### MENÚ ###");
+    printf("\n1 Suma el primer y segundo número.");
+    printf("\n2 Multiplicar el segundo con el tercero.");
+    printf("\n3 Mostrar los tres números en orden.");
+    printf("\n4 Comprobar si el primero es primo.");
+    printf("\n5 Comprobar si el segundo es un número perfecto.");
+    printf("\n5 Salir\n");
+
+    printf("\nIntroduce una opción del 1 al 6: ");
+    scanf("%d", &menu);
+
+    /* menu switch */
+
+    switch (menu){
+        case 1:
+            // sumar el primer y segundo número
+            printf("\nEl resultado de la suma entre el primer y segundo numero es: %d\n", numero1+numero2);
+            break;
+
+        case 2:
+            // multiplicar el segundo con el tercer número
+
+            printf("\nEl resultado de la multiplicación entre el segundo con el tercer número es: %d\n", numero2*numero3);
+            break;
+
+        case 3:
+            // ordenar los números
+            if(numero1<numero2){
+                if (numero1<numero3){
+                    if (numero2<numero3){
+                        printf("Los números ordenados de menor a mayor son: %d %d %d\n\n", numero1,numero2,numero3);
+                    }else{
+                        printf("Los números ordenados de menor a mayor son: %d %d %d\n\n", numero1,numero3,numero2);
+                    }
+                }else{
+                    printf("Los números ordenados de menor a mayor son: %d %d %d\n\n", numero3,numero1,numero2);
+                }
+            }else{
+                if (numero1<numero3){
+                    printf("Los números ordenados de menor a mayor son: %d %d %d\n\n", numero2,numero1,numero3);
+                }else{
+                    if (numero3<numero2){
+                        printf("Los números ordenados de menor a mayor son: %d %d %d\n\n", numero3,numero2,numero1);
+                    }else{
+                        printf("Los números ordenados de menor a mayor son: %d %d %d\n\n", numero2,numero3,numero1);
+                    }
+                }
+            }
+
+            break;
+
+            
+        case 4:
+            
+              // Comprobar si el primer número es primo.
+
+            a=0; /* Variable a 0 para contar divisores */
+
+            for(i=1;i<=numero1;i++){
+                if(numero1%i==0) // si num1 módulo de i es 0, incrementamos a en 1.
+                a++;
+            }
+
+            /* Si al final del bucle, a vale 2, el número es primo, porque tiene solamente 2 divisores. */ 
+            
+            if(a==2) {
+                printf("\nEl primer número es primo\n");
+            }else{
+                printf("\nEl primer número no es primo\n");
+            }
+
+            break;
+
+        case 5:
+            // Comprobar si el segundo es un número perfecto.
+
+
+
+            break;
+
+        case 6:
+
+            printf("\nHasta pronto!\n");
+            break;
+
+        default:
+
+            printf("\nNo es un valor correcto\n\n");
+    }
+
+
+
+
+}

Ejercicios/0504array.c

@@ -0,0 +1,46 @@
+#include<stdio.h>
+
+#define TAM 5
+
+int main(){
+
+
+    int vector[TAM];
+    int i;
+    int j;
+    int temp;
+
+
+    for (i=0; i<TAM; i++){
+        printf("\nIntroduce los valores del array: ");
+        scanf("%d", &vector[i]);
+    }
+
+    for(i=0; i<TAM; i++){
+        printf("\nLos valores del array son %d", vector[i]);
+    }
+
+    printf("\n");
+
+    for (i=1;i<TAM;i++)
+{
+       for (j=0; j < TAM-i ;j++) // for(j=0; j < Nelementos-i; j++) es menor y no menor igual
+       {
+          if (vector[j] > vector[j+1])//Condicion mayor-menor
+          {
+            temp=vector[j];
+            vector[j]=vector[j+1];
+            vector[j+1]=temp;
+          }
+       }
+}
+
+printf("\nY el vector ordenado sería: ");
+for(i=0; i<TAM; i++){
+        printf("\nLos valores del array son %d", vector[i]);
+    }
+    
+    printf("\n");
+
+
+}

Ejercicios/0601ArrayBusqueda (Sin corregir).c

@@ -0,0 +1,98 @@
+#include<stdio.h>
+#include<stdlib.h> // Se suele emplear para memoria dinámica
+
+/*
+Ejercicio 1:
+Sobre un array de números enteros de dimensión 10 se pide:
+- cargar el array
+- mostrarlo
+- buscar y comprobar si un número pedido al usuario se encuentra o no en el array 
+(opcional: indicar su posición)
+- pedir un número al usuario y si está en el array eliminarlo 
+(en caso de que se repita, solamente eliminará la última ocurrencia)
+
+*/
+
+
+#define TAM 10
+
+int main(){
+
+    int vector[TAM];
+    int i;
+    int busca;
+    int posicion=0;
+    int aviso=0;
+    int temp;
+
+    printf("\nVamos a cargar un array de %d posiciones: \n", TAM);
+   
+    for (i=0; i<TAM; i++){
+        printf("\nIntroduce valor para el array: ");
+        scanf("%d", &vector[i]);
+    }
+
+    printf("\nLos valores del array son:\n");
+
+    for(i=0; i<TAM; i++){
+        printf("%d ", vector[i]);
+    }
+    
+    printf("\n");
+
+
+    printf("\nDame un número para buscar:  ");
+    scanf("%d", &busca);
+
+
+    for (i=0; i<TAM; i++){
+        posicion=posicion+1; 
+        // Como pongo el contador antes de la recogida del numero con temp, 
+        // la posicion empieza en 1 y no en 0.
+
+        if(busca==vector[i]) {
+            // El número se encuentra en el array
+            aviso=1;
+            temp=posicion;
+        }
+    }
+
+    if(aviso==0){
+        printf("\nEl número %d no está en el array.", busca);
+    }else{
+        printf("\nEl número %d está en el array en la posición %d.", busca, temp);
+    }
+
+
+    printf("\n");
+
+
+    posicion=-1;
+    for(i=0;i<TAM; i++){
+        if(vector[i]==busca){
+            posicion=i;
+        }
+    }
+
+    if(posicion==-1){
+        printf("\nEl elemento que quieres no está");
+    }else{
+        for(i=posicion;i<TAM;i++){
+            vector[i]=vector[i+1];
+        }
+
+        printf("\nElemento eliminado");
+        vector[9]=0;
+        printf("\nLos valores actuales del array son:\n");
+
+        for(i=0; i<TAM; i++){
+            printf("%d ", vector[i]);
+        }
+
+
+    }
+
+    printf("\n");
+
+
+}

Ejercicios/0601ArrayBusqueda.c

@@ -0,0 +1,98 @@
+#include<stdio.h>
+#include<stdlib.h> // Se suele emplear para memoria dinámica
+
+/*
+Ejercicio 1:
+Sobre un array de números enteros de dimensión 10 se pide:
+- cargar el array
+- mostrarlo
+- buscar y comprobar si un número pedido al usuario se encuentra o no en el array 
+(opcional: indicar su posición)
+- pedir un número al usuario y si está en el array eliminarlo 
+(en caso de que se repita, solamente eliminará la última ocurrencia)
+
+*/
+
+
+#define TAM 10
+
+int main(){
+
+    int vector[TAM];
+    int i;
+    int busca;
+    int posicion=0;
+    int aviso=0;
+    int temp;
+
+    printf("\nVamos a cargar un array de %d posiciones: \n", TAM);
+   
+    for (i=0; i<TAM; i++){
+        printf("\nIntroduce valor para el array: ");
+        scanf("%d", &vector[i]);
+    }
+
+    printf("\nLos valores del array son:\n");
+
+    for(i=0; i<TAM; i++){
+        printf("%d ", vector[i]);
+    }
+    
+    printf("\n");
+
+
+    printf("\nDame un número para buscar:  ");
+    scanf("%d", &busca);
+
+
+    for (i=0; i<TAM; i++){
+        posicion=posicion+1; 
+        // Como pongo el contador antes de la recogida del numero con temp, 
+        // la posicion empieza en 1 y no en 0.
+
+        if(busca==vector[i]) {
+            // El número se encuentra en el array
+            aviso=1;
+            temp=posicion;
+        }
+    }
+
+    if(aviso==0){
+        printf("\nEl número %d no está en el array.", busca);
+    }else{
+        printf("\nEl número %d está en el array en la posición %d.", busca, temp);
+    }
+
+
+    printf("\n");
+
+
+    posicion=-1;
+    for(i=0;i<TAM; i++){
+        if(vector[i]==busca){
+            posicion=i;
+        }
+    }
+
+    if(posicion==-1){
+        printf("\nEl elemento que quieres no está");
+    }else{
+        for(i=posicion;i<TAM;i++){
+            vector[i]=vector[i+1];
+        }
+
+        printf("\nElemento eliminado");
+        vector[9]=0;
+        printf("\nLos valores actuales del array son:\n");
+
+        for(i=0; i<TAM; i++){
+            printf("%d ", vector[i]);
+        }
+
+
+    }
+
+    printf("\n");
+
+
+}

Ejercicios/0602comprobarArray (Sin corregir).c

@@ -0,0 +1,34 @@
+#include<stdio.h>
+#include<stdlib.h> // Se suele emplear para memoria dinámica
+
+/*
+Ejercicio 2:
+Sobre un array de números enteros de dimensión 10 se pide:
+- cargar el array de números pero por cada número introducido 
+se debe comprobar que no está ya contenido en el array.*
+*/
+
+#define TAM 10
+
+int main(){
+
+    int vector[TAM];
+    int i;
+
+    for (i=0; i<TAM; i++){
+        printf("\nIntroduce un valor al array: ");
+        scanf("%d", &vector[i]);
+        if(vector[i]==vector[i-1]||vector[i]==vector[i-2]||vector[i]==vector[i-3]||vector[i]==vector[i-4]||vector[i]==vector[i-5]||vector[i]==vector[i-6]||vector[i]==vector[i-7]||vector[i]==vector[i-8]||vector[i]==vector[i-9]){
+            printf("\nEs un valor repetido, vuelve a intentarlo.");
+            i=i-1;
+        }
+    }
+// Mostrar el resultado
+    printf("\nLos valores del array son:\n");
+    for(i=0; i<TAM; i++){
+        printf("%d ", vector[i]);
+    }
+
+    printf("\n");
+
+}

Ejercicios/0602comprobarArray.c

@@ -0,0 +1,57 @@
+#include<stdio.h>
+#include<stdlib.h> // Se suele emplear para memoria dinámica
+
+/*
+Ejercicio 2:
+Sobre un array de números enteros de dimensión 10 se pide:
+- cargar el array de números pero por cada número introducido 
+se debe comprobar que no está ya contenido en el array.*
+*/
+
+#define TAM 10
+
+int main(){
+
+    int vector[TAM];
+    int i, j, repetido;
+
+//    for (i=0; i<TAM; i++){
+//        printf("\nIntroduce un valor al array: ");
+//        scanf("%d", &vector[i]);
+//        if(vector[i]==vector[i-1]||vector[i]==vector[i-2]||vector[i]==vector[i-3]||vector[i]==vector[i-4]||vector[i]==vector[i-5]||vector[i]==vector[i-6]||vector[i]==vector[i-7]||vector[i]==vector[i-8]||vector[i]==vector[i-9]){
+//            printf("\nEs un valor repetido, vuelve a intentarlo.");
+//            i=i-1;
+//        }
+//    }
+
+// Corregido
+    for (i=0; i<TAM; i++){
+
+        do{
+            printf("\nIntroduce un valor al array del elemento %d: ",i);
+            scanf("%d", &vector[i]);
+
+            repetido=0;  // Hay que darle valor al flag justo antes de comprobar
+            for (j=0; j<i; j++){
+
+                if(vector[j]==vector[i]){
+                    repetido=1;
+                    printf("\nEs un valor repetido, vuelve a intentarlo.");
+
+                }
+            }
+
+        } while(repetido==1);
+    }
+
+
+
+// Mostrar el resultado
+    printf("\nLos valores del array son:\n");
+    for(i=0; i<TAM; i++){
+        printf("%d ", vector[i]);
+    }
+
+    printf("\n");
+
+}

Ejercicios/0603kmFootingArray (Sin corregir).c

@@ -0,0 +1,200 @@
+#include<stdio.h>
+#include<stdlib.h> // Se suele emplear para memoria dinámica
+
+/*
+
+Ejercicio 3:
+
+Miguel quiere controlar cuantos kilómetros ha corrido haciendo footing esta semana. 
+La semana asumimos tiene siete días. 
+Almacenará los kilómetros (número real) en un array de siete posiciones.
+Al comienzo del programa se le pedirá a Miguel que introduzca cuántos kilómetros 
+ha recorrido cada día. A continuación se mostrará un menú con las siguientes opciones:
+
+1) Mostrar la información de todos los días y todos los kilómetros recorridos cada día 
+(mostrar el array)
+
+2) Pedirle a Miguel un día (entre 0 y 6, no puede ser cualquier otro valor, 
+si se trata de un valor no válido se repetirá le pregunta) 
+y se mostrarán los kms recorridos ese día.
+
+3) Pedirle a Miguel un número determinado de kilómetros y mostrar cuántos días ha superado 
+esa cantidad de kms.
+
+4) Mostrar el número de kms recorridos en total durante la semana (suma)
+
+5) Mostrar la media de kms por día durante la semana (media de los números del array)
+
+6) Salir
+
+El menú se repetirá hasta que Miguel decida salir.
+
+*/
+
+#define TAM 8
+
+int main(){
+    
+
+    /* Variables */
+    int tablaKM[TAM];
+    int i, menu, busca, j, km, k;
+    int dia=1;
+    int aviso=0;
+    int total=0;
+    float media;
+    
+
+    /* KM de la semana */
+    printf("\n_____________\n\n¡HOLA MIGUEL!\n_____________\n");
+    printf("\nIntroduce los km de esta semana: \n");
+   
+    for (i=1; i<TAM; i++){
+        printf("Día %d: ", i);
+        scanf("%d", &tablaKM[i]);
+    }
+   
+    printf("\n");
+
+
+    do{
+
+        /* Elegir opción */
+
+        printf("\n+++++++++++++++++\n+\tMENÚ\t+\n+++++++++++++++++\n");
+        printf("\n1 Mostrar la información de todos los días y todos los kilómetros recorridos cada día.");
+        printf("\n2 Mostrar los km recorridos un día concreto.");
+        printf("\n3 Mostrar los días que se han superado x km");
+        printf("\n4 Mostrar el número de kms recorridos en total durante la semana.");
+        printf("\n5 Mostrar la media de kms por día durante la semana.");
+        printf("\n6 Salir\n");
+
+        printf("\nIntroduce una opción del 1 al 6: ");
+        fflush(stdin);
+        scanf("%d", &menu);
+
+        /* Condicional case para seleccionar el número */
+
+
+        switch (menu) {
+            case 1:
+                printf("\n##################################################\n");
+                printf("\nLos km recorridos esta semana son: \n");
+                printf("L\tM\tX\tJ\tV\tS\tD\n");
+                for(i=1; i<TAM; i++){
+                    printf("%d\t", tablaKM[i]);
+                }
+                printf("\n\n##################################################\n");
+                break;
+    
+            case 2:
+                printf("\nDime el día del que quieres saber los km: ");
+                fflush(stdin);
+                scanf("%d", &busca);
+
+                printf("\n##################################\n");
+
+                switch (busca) {
+                    case 1:
+                        printf("\nEl lunes hiciste %d km \t\t:)\n",tablaKM[busca]);
+                        break;
+
+                    case 2:
+                        printf("\nEl martes hiciste %d km \t:)\n",tablaKM[busca]);
+                        break;
+
+                    case 3:
+                        printf("\nEl miércoles hiciste %d km \t:)\n",tablaKM[busca]);
+                        break;
+
+                    case 4:
+                        printf("\nEl jueves hiciste %d km \t:)\n",tablaKM[busca]);
+                        break;
+
+                    case 5:
+                        printf("\nEl viernes hiciste %d km \t:)\n",tablaKM[busca]);
+                        break;
+
+                    case 6:
+                        printf("\nEl sábado hiciste %d km \t:)\n",tablaKM[busca]);
+                        break;
+
+                    case 7:
+                        printf("\nEl domingo hiciste %d km \t:)\n",tablaKM[busca]);
+                        break;
+
+                    default:
+                        printf("\nNo es un valor correcto\n\n");
+                }
+
+                printf("\n##################################\n");
+
+                break;
+
+            case 3:
+
+                printf("\nDime cuantos km quieres saber si has superado: ");
+                scanf("%d", &km);
+
+                printf("\n######################\n");
+                printf("\nSuperaste los %d km:", km);
+                
+                for (j=1; j<TAM; j++){
+                    
+
+                    if(km<=tablaKM[j]) {
+                        aviso=1;
+                    }
+
+                    if(aviso==1){
+                        printf("\n - El dia %d con %d km.", dia, tablaKM[j]);
+                        aviso=0;
+                    }
+                    dia=dia+1;
+                }
+
+                printf("\n\n######################\n");
+
+                break;
+
+            case 4:
+
+                total=0;
+                for (k=1; k<TAM; k++){
+                    total=total+tablaKM[k];
+                }
+
+                printf("\n######################\n");
+                printf("\nEsta semana has hecho %d km.\n\n!ENHORABUENA MIGUEL! ", total);
+                printf("\n\n######################\n");
+
+                break;
+
+            case 5:
+
+                total=0;
+                for (k=1; k<TAM; k++){
+                    total=total+tablaKM[k];
+                }
+
+                media=(float)total/7;
+
+                printf("\n######################\n");
+                printf("\nEsta semana tienes %.2f km de media.\n\n!ERES UN CRACK MIGUEL! ", media);
+                printf("\n\n######################\n");
+
+                break;
+
+            case 6:
+            
+                break;
+
+            default:
+                printf("\nNo es un valor correcto\n\n");
+        }
+    }while ( menu != 6 );
+
+    return 0;
+
+
+}

Ejercicios/0603kmFootingArray.c

@@ -0,0 +1,227 @@
+#include<stdio.h>
+#include<stdlib.h> // Se suele emplear para memoria dinámica
+
+/*
+
+Ejercicio 3:
+
+Miguel quiere controlar cuantos kilómetros ha corrido haciendo footing esta semana. 
+La semana asumimos tiene siete días. 
+Almacenará los kilómetros (número real) en un array de siete posiciones.
+Al comienzo del programa se le pedirá a Miguel que introduzca cuántos kilómetros 
+ha recorrido cada día. A continuación se mostrará un menú con las siguientes opciones:
+
+1) Mostrar la información de todos los días y todos los kilómetros recorridos cada día 
+(mostrar el array)
+
+2) Pedirle a Miguel un día (entre 0 y 6, no puede ser cualquier otro valor, 
+si se trata de un valor no válido se repetirá le pregunta) 
+y se mostrarán los kms recorridos ese día.
+
+3) Pedirle a Miguel un número determinado de kilómetros y mostrar cuántos días ha superado 
+esa cantidad de kms.
+
+4) Mostrar el número de kms recorridos en total durante la semana (suma)
+
+5) Mostrar la media de kms por día durante la semana (media de los números del array)
+
+6) Salir
+
+El menú se repetirá hasta que Miguel decida salir.
+
+*/
+
+#define TAM 8
+
+//prototipos
+void opcion2 (int tablaKM[]);
+int opcion4(int tablaKM[]);
+
+int main(){
+    
+
+    /* Variables */
+    int tablaKM[TAM];
+    int i, menu, j, km, k;
+    int dia=1;
+    int aviso=0;
+    int total=0;
+    float media;
+    
+
+    /* KM de la semana */
+    printf("\n_____________\n\n¡HOLA MIGUEL!\n_____________\n");
+    printf("\nIntroduce los km de esta semana: \n");
+   
+    for (i=1; i<TAM; i++){
+        printf("Día %d: ", i);
+        scanf("%d", &tablaKM[i]);
+    }
+   
+    printf("\n");
+
+
+    do{
+
+        /* Elegir opción */
+
+        printf("\n+++++++++++++++++\n+\tMENÚ\t+\n+++++++++++++++++\n");
+        printf("\n1 Mostrar la información de todos los días y todos los kilómetros recorridos cada día.");
+        printf("\n2 Mostrar los km recorridos un día concreto.");
+        printf("\n3 Mostrar los días que se han superado x km");
+        printf("\n4 Mostrar el número de kms recorridos en total durante la semana.");
+        printf("\n5 Mostrar la media de kms por día durante la semana.");
+        printf("\n6 Salir\n");
+
+        printf("\nIntroduce una opción del 1 al 6: ");
+        fflush(stdin);
+        scanf("%d", &menu);
+
+        /* Condicional case para seleccionar el número */
+
+
+        switch (menu) {
+            case 1:
+                printf("\n##################################################\n");
+                printf("\nLos km recorridos esta semana son: \n");
+                printf("L\tM\tX\tJ\tV\tS\tD\n");
+                for(i=1; i<TAM; i++){
+                    printf("%d\t", tablaKM[i]);
+                }
+                printf("\n\n##################################################\n");
+                break;
+    
+            case 2:
+            
+                opcion2(tablaKM); //en la llamada no ponemos tipos, solo nombres
+                break;
+
+            case 3:
+
+                printf("\nDime cuantos km quieres saber si has superado: ");
+                scanf("%d", &km);
+
+                printf("\n######################\n");
+                printf("\nSuperaste los %d km:", km);
+                
+                dia=1;
+                for (j=1; j<TAM; j++){
+                    
+                    aviso=0; // El flag es mejor cambiarlo justo antes del bucle
+                    if(km<=tablaKM[j]) {
+                        aviso=1;
+                    }
+
+                    if(aviso==1){
+                        printf("\n - El dia %d con %d km.", dia, tablaKM[j]);
+                        aviso=0;
+                    }
+                    dia=dia+1;
+                }
+
+                printf("\n\n######################\n");
+
+                break;
+
+            case 4:
+
+                total=opcion4(tablaKM);
+
+                printf("\n######################\n");
+                printf("\nEsta semana has hecho %d km.\n\n!ENHORABUENA MIGUEL! ", total);
+                printf("\n\n######################\n");
+
+                break;
+
+            case 5:
+
+                total=0;
+                for (k=1; k<TAM; k++){
+                    total=total+tablaKM[k];
+                }
+
+                media=(float)total/7;
+
+                printf("\n######################\n");
+                printf("\nEsta semana tienes %.2f km de media.\n\n!ERES UN CRACK MIGUEL! ", media);
+                printf("\n\n######################\n");
+
+                break;
+
+            case 6:
+                printf("\nAdios Miguel!");
+                break;
+
+            default:
+                printf("\nNo es un valor correcto\n\n");
+        }
+    }while ( menu != 6 );
+
+    return 0;
+
+
+}
+
+//a partir de auqí ponemos otras funciones
+void opcion2 (int tablaKM[]){
+    int busca;
+
+    do{
+            printf("\nDime el día del que quieres saber los km: ");
+            fflush(stdin);
+            scanf("%d", &busca);
+            //busca asegurate que solo puede tener valores entre 1 y 7
+
+            if(busca<1 || busca>7){
+                printf("\nPájaro, ese valor no es correcto,  tiene que ser entre 1 y 7 inclusive");
+            }
+
+        }while(busca<1 || busca>7);
+
+            printf("\n##################################\n");
+
+            switch (busca) {
+                case 1:
+                    printf("\nEl lunes hiciste %d km \t\t:)\n",tablaKM[busca]);
+                    break;
+
+                case 2:
+                    printf("\nEl martes hiciste %d km \t:)\n",tablaKM[busca]);
+                    break;
+
+                case 3:
+                    printf("\nEl miércoles hiciste %d km \t:)\n",tablaKM[busca]);
+                    break;
+
+                case 4:
+                    printf("\nEl jueves hiciste %d km \t:)\n",tablaKM[busca]);
+                    break;
+
+                case 5:
+                    printf("\nEl viernes hiciste %d km \t:)\n",tablaKM[busca]);
+                    break;
+
+                case 6:
+                    printf("\nEl sábado hiciste %d km \t:)\n",tablaKM[busca]);
+                    break;
+
+                case 7:
+                    printf("\nEl domingo hiciste %d km \t:)\n",tablaKM[busca]);
+                    break;
+
+                default:
+                    printf("\nNo es un valor correcto\n\n");
+            }
+
+                printf("\n##################################\n");
+}
+
+int opcion4(int tablaKM[]){
+    int totalKM;
+    int k;
+    totalKM=0;
+    for (k=1; k<TAM; k++){
+        totalKM=totalKM+tablaKM[k];
+    }
+    return totalKM;
+}

Ejercicios/0701salaCine (Sin corregir).c

@@ -0,0 +1,256 @@
+#include<stdio.h>
+#include<stdlib.h> 
+
+
+/*
+Nos han pedido un pequeño programa escrito en C para controlar la afluencia de una sala de cine en
+la que las butacas se distribuyen en filas y asientos (los asientos serían las columnas). Para ello
+utilizaremos un array bidimensional que abarque toda la sala. El encargado nos ha dicho que la sala
+cuenta con 10 filas y 8 asientos por cada fila (el array tendrá una dimensión efectiva de 10 filas y 8
+columnas).
+La manera de indicar si un asiento se encuentra libre o no, es mediante un número entero que tendrá
+valores:
+0 → el asiento está vacío.
+1 → el asiento está ocupado.
+A la hora de mostrar la ocupación de la sala en lugar de con 1 y con 0 lo haremos con los símbolos:
+O → el asiento está vacío.
+X → el asiento está ocupado.
+Así pues, cada vez que mostremos la sala, esta debe tener un aspecto similar al siguiente:
+X X X O O O O O X X
+O O O O O X X O O O
+X X O O X X O O O X
+…
+Y así con todas las filas.
+
+Al comienzo del programa la sala se encuentra con todas sus posiciones vacías. El programa debe
+asegurarse de ello al comienzo (al comienzo el array se carga con todas sus posiciones con valor 0).
+Para que el encargado de la sala pueda manejarla, se le presentará un menú con las siguientes
+opciones:
+
+1. Comprar entrada. Se le pedirá que indique la fila y el asiento (columna) en el que se quiere
+sentar el espectador. Si ese asiento está ocupado se dará un mensaje de error. Si el asiento está libre,
+se cambia su posición a ocupado y se da un mensaje de “entrada comprada”. La fila y columna
+introducida deben ser válidas (entre 0 y su dimensión máxima), en caso contrario se mostrará un
+mensaje de error.
+
+2. Mostrar la ocupación de la sala. Mostrará toda la sala y sus asientos indicando de la manera
+descrita cuales están ocupados y cuales están libres.
+
+3. Devolver entrada. Se pedirá que indique la fila y el asiento (columna) que se quiere liberar. Si el
+asiento ya estaba libre, se indicará mediante un mensaje de error. Si el asiento estaba ocupado, éste
+se libera y se indica un mensaje de “asiento liberado”. La fila y columna introducida deben ser
+válidas (entre 0 y su dimensión máxima), en caso contrario se mostrará un mensaje de error.
+
+4. Calcular recaudación de la sala. Se calculará la recaudación total de la sala teniendo en cuenta
+solo los asientos ocupados y que cada entrada tiene un valor de 5.5 €.
+
+0. Salir.
+
+El menú se repetirá hasta que el encargado de la sala pulse la opción de salir.
+
+*/
+#define FILAS 10
+#define ASIENTOS 8
+
+int main(){
+
+// Variables
+
+    int sala[FILAS][ASIENTOS]={0};
+    int i=0;
+    int j=0;
+    char estado[1];
+    int menu, resFila, resAsiento;
+    float recauda;
+    char salir;
+
+
+// Mostrar el estado de los asientos vacios.
+
+    printf("\n------------------------------");
+    printf("\n|  Estado inicial de la sala  |");
+    printf("\n------------------------------\n\n");
+    printf("     |\t0\t1\t2\t3\t4\t5\t6\t7\t<< Asiento\n");
+    printf("_____|_____________________________________________________________________________\n");
+    printf("     |\n");
+    for(i=0; i<FILAS; i++){
+        printf("  %d  |\t",i);
+        for(j=0; j<ASIENTOS; j++){
+            if(sala[i][j]==0){
+                fflush(stdin);
+                estado[0] = 'O';
+            }else{
+                fflush(stdin);
+                estado[0] = 'X';
+            }
+
+            printf("%s\t", estado);
+            
+        }
+        printf("\n");
+    }
+    printf("     |\n  ^  |\nFila |\n\n");
+
+
+// Empieza el menú de opciones
+do{
+
+    /* Elegir opción */
+
+    printf("\n++++++++++++++\n+    MENÚ    +\n++++++++++++++");
+    printf("\n1 Comprar entrada.");
+    printf("\n2 Mostrar la ocupación de la sala.");
+    printf("\n3 Devolver entrada");
+    printf("\n4 Calcular recaudación de la sala.");
+    printf("\n0 Salir\n");
+
+    printf("\nIntroduce una opción reseñada: ");
+    fflush(stdin);
+    scanf("%d", &menu);
+
+    /* Condicional case para seleccionar el número */
+
+
+    switch (menu) {
+        // OPCIÓN 1
+        case 1:
+
+            printf("\nPara reservar un asiento necesitamos:\nNúmero de fila: ");
+            
+            // Pedir Fila y control de nº de fila correcto
+            do{
+                scanf("%d", &resFila);
+                if(resFila<0||resFila>9){
+                    printf("\nSolo tenemos filas del 0 al 9.\nVuelva a intentarlo: ");
+                }
+            }while (resFila<-1||resFila>9);
+
+
+            printf("Número de asiento: ");
+
+            // Pedir Asiento y control de nº de asiento correcto
+            do{
+                scanf("%d", &resAsiento);
+                if(resAsiento<0||resAsiento>7){
+                    printf("\nSolo tenemos asientos del 0 al 7.\nVuelva a intentarlo: ");
+                }
+            }while (resAsiento<-1||resAsiento>7);
+
+            // Control si el asiento está ocupado o es una reserva correcta
+            if(sala[resFila][resAsiento]==1){
+                printf("\n****************************************");
+                printf("\nLo sentimos, este lugar ya está ocupado.");
+                printf("\n****************************************\n");
+            }else{
+                sala[resFila][resAsiento]=1;
+                printf("\n*****************************************");
+                printf("\nSu reserva se ha efectuado correctamente.");
+                printf("\n¡GRACIAS POR SU COMPRA!");
+                printf("\n*****************************************\n");
+            }
+
+            break;
+
+        // OPCIÓN 2
+        case 2:
+                    
+        // Mostrar el estado de los asientos vacios.
+
+            printf("\n------------------------------");
+            printf("\n|  Estado actual de la sala  |");
+            printf("\n------------------------------\n\n");
+            printf("     |\t0\t1\t2\t3\t4\t5\t6\t7\t<< Asiento\n");
+            printf("_____|_____________________________________________________________________________\n");
+            printf("     |\n");
+            for(i=0; i<FILAS; i++){
+                printf("  %d  |\t",i);
+                for(j=0; j<ASIENTOS; j++){
+                    if(sala[i][j]==0){
+                        fflush(stdin);
+                        estado[0] = 'O';
+                    }else{
+                        fflush(stdin);
+                        estado[0] = 'X';
+                    }
+
+                    printf("%s\t", estado);
+                    
+                }
+                printf("\n");
+            }
+            printf("     |\n  ^  |\nFila |\n\n");
+            break;
+
+        // OPCIÓN 3
+        case 3:
+
+            printf("\nPara devolver una entrada necesitamos su ubicación en la sala:\nNúmero de fila: ");
+            
+            // Pedir Fila y control de nº de fila correcto
+            do{
+                scanf("%d", &resFila);
+                if(resFila<0||resFila>9){
+                    printf("\nSolo tenemos filas del 0 al 9.\nVuelva a intentarlo: ");
+                }
+            }while (resFila<-1||resFila>9);
+
+
+            printf("Número de asiento: ");
+
+            // Pedir Asiento y control de nº de asiento correcto
+            do{
+                scanf("%d", &resAsiento);
+                if(resAsiento<0||resAsiento>7){
+                    printf("\nSolo tenemos asientos del 0 al 7.\nVuelva a intentarlo: ");
+                }
+            }while (resAsiento<-1||resAsiento>7);
+
+            // Control si el asiento está libre (error) o es una anulación correcta
+            if(sala[resFila][resAsiento]==0){
+                printf("\n***********************************");
+                printf("\nLo sentimos, este lugar está libre,\nno puede ser su reserva.");
+                printf("\n***********************************\n");
+            }else{
+                sala[resFila][resAsiento]=0;
+                printf("\n*******************************************");
+                printf("\nSu reserva ha sido cancelada correctamente.");
+                printf("\n¡HASTA PRONTO!");
+                printf("\n*******************************************\n");
+            }
+
+        
+
+            break;
+
+        // OPCIÓN 4
+        case 4:
+            recauda=0;
+            for(i=0; i<FILAS; i++){
+                for(j=0; j<ASIENTOS; j++){
+                    if(sala[i][j]==1){
+                          recauda=recauda+5.5;
+                    }        
+                }
+            }
+            
+            printf("\n***********************************************");
+            printf("\nLa sala lleva recaudado un total de %.2f euros.", recauda);
+            printf("\n***********************************************\n");
+            break;
+
+        // OPCIÓN SALIR
+        case 0:
+
+            
+            break;
+
+        // ERROR EN EL MENÚ 
+        default:
+            printf("\nNo es un valor correcto para este menu.\nVuelva a intentarlo\n\n");
+    }
+}while ( menu != 0 );
+
+return 0;
+
+
+}

Ejercicios/0701salaCine.c

@@ -0,0 +1,256 @@
+#include<stdio.h>
+#include<stdlib.h> 
+
+
+/*
+Nos han pedido un pequeño programa escrito en C para controlar la afluencia de una sala de cine en
+la que las butacas se distribuyen en filas y asientos (los asientos serían las columnas). Para ello
+utilizaremos un array bidimensional que abarque toda la sala. El encargado nos ha dicho que la sala
+cuenta con 10 filas y 8 asientos por cada fila (el array tendrá una dimensión efectiva de 10 filas y 8
+columnas).
+La manera de indicar si un asiento se encuentra libre o no, es mediante un número entero que tendrá
+valores:
+0 → el asiento está vacío.
+1 → el asiento está ocupado.
+A la hora de mostrar la ocupación de la sala en lugar de con 1 y con 0 lo haremos con los símbolos:
+O → el asiento está vacío.
+X → el asiento está ocupado.
+Así pues, cada vez que mostremos la sala, esta debe tener un aspecto similar al siguiente:
+X X X O O O O O X X
+O O O O O X X O O O
+X X O O X X O O O X
+…
+Y así con todas las filas.
+
+Al comienzo del programa la sala se encuentra con todas sus posiciones vacías. El programa debe
+asegurarse de ello al comienzo (al comienzo el array se carga con todas sus posiciones con valor 0).
+Para que el encargado de la sala pueda manejarla, se le presentará un menú con las siguientes
+opciones:
+
+1. Comprar entrada. Se le pedirá que indique la fila y el asiento (columna) en el que se quiere
+sentar el espectador. Si ese asiento está ocupado se dará un mensaje de error. Si el asiento está libre,
+se cambia su posición a ocupado y se da un mensaje de “entrada comprada”. La fila y columna
+introducida deben ser válidas (entre 0 y su dimensión máxima), en caso contrario se mostrará un
+mensaje de error.
+
+2. Mostrar la ocupación de la sala. Mostrará toda la sala y sus asientos indicando de la manera
+descrita cuales están ocupados y cuales están libres.
+
+3. Devolver entrada. Se pedirá que indique la fila y el asiento (columna) que se quiere liberar. Si el
+asiento ya estaba libre, se indicará mediante un mensaje de error. Si el asiento estaba ocupado, éste
+se libera y se indica un mensaje de “asiento liberado”. La fila y columna introducida deben ser
+válidas (entre 0 y su dimensión máxima), en caso contrario se mostrará un mensaje de error.
+
+4. Calcular recaudación de la sala. Se calculará la recaudación total de la sala teniendo en cuenta
+solo los asientos ocupados y que cada entrada tiene un valor de 5.5 €.
+
+0. Salir.
+
+El menú se repetirá hasta que el encargado de la sala pulse la opción de salir.
+
+*/
+#define FILAS 10
+#define ASIENTOS 8
+
+int main(){
+
+// Variables
+
+    int sala[FILAS][ASIENTOS]={0};
+    int i=0;
+    int j=0;
+    char estado;
+    int menu, resFila, resAsiento;
+    float recauda;
+    char salir;
+
+
+// Mostrar el estado de los asientos vacios.
+
+    printf("\n------------------------------");
+    printf("\n|  Estado inicial de la sala  |");
+    printf("\n------------------------------\n\n");
+    printf("     |\t0\t1\t2\t3\t4\t5\t6\t7\t<< Asiento\n");
+    printf("_____|_____________________________________________________________________________\n");
+    printf("     |\n");
+    for(i=0; i<FILAS; i++){
+        printf("  %d  |\t",i);
+        for(j=0; j<ASIENTOS; j++){
+            if(sala[i][j]==0){
+                fflush(stdin);
+                estado = 'O';
+            }else{
+                fflush(stdin);
+                estado = 'X';
+            }
+
+            printf("%c\t", estado);
+            
+        }
+        printf("\n");
+    }
+    printf("     |\n  ^  |\nFila |\n\n");
+
+
+// Empieza el menú de opciones
+do{
+
+    //Elegir opción 
+
+    printf("\n++++++++++++++\n+    MENÚ    +\n++++++++++++++");
+    printf("\n1 Comprar entrada.");
+    printf("\n2 Mostrar la ocupación de la sala.");
+    printf("\n3 Devolver entrada");
+    printf("\n4 Calcular recaudación de la sala.");
+    printf("\n0 Salir\n");
+
+    printf("\nIntroduce una opción reseñada: ");
+    fflush(stdin);
+    scanf("%d", &menu);
+
+    // Condicional case para seleccionar el número 
+
+
+    switch (menu) {
+        // OPCIÓN 1
+        case 1:
+
+            printf("\nPara reservar un asiento necesitamos:\nNúmero de fila: ");
+            
+            // Pedir Fila y control de nº de fila correcto
+            do{
+                scanf("%d", &resFila);
+                if(resFila<0||resFila>=FILAS){
+                    printf("\nSolo tenemos filas del 0 al 9.\nVuelva a intentarlo: ");
+                }
+            }while (resFila<=-1||resFila>=FILAS);
+
+
+            printf("Número de asiento: ");
+
+            // Pedir Asiento y control de nº de asiento correcto
+            do{
+                scanf("%d", &resAsiento);
+                if(resAsiento<0||resAsiento>=ASIENTOS){
+                    printf("\nSolo tenemos asientos del 0 al 7.\nVuelva a intentarlo: ");
+                }
+            }while (resAsiento<=-1||resAsiento>=ASIENTOS);
+
+            // Control si el asiento está ocupado o es una reserva correcta
+            if(sala[resFila][resAsiento]==1){
+                printf("\n****************************************");
+                printf("\nLo sentimos, este lugar ya está ocupado.");
+                printf("\n****************************************\n");
+            }else{
+                sala[resFila][resAsiento]=1;
+                printf("\n*****************************************");
+                printf("\nSu reserva se ha efectuado correctamente.");
+                printf("\n¡GRACIAS POR SU COMPRA!");
+                printf("\n*****************************************\n");
+            }
+
+            break;
+
+        // OPCIÓN 2
+        case 2:
+                    
+        // Mostrar el estado de los asientos vacios.
+
+            printf("\n------------------------------");
+            printf("\n|  Estado actual de la sala  |");
+            printf("\n------------------------------\n\n");
+            printf("     |\t0\t1\t2\t3\t4\t5\t6\t7\t<< Asiento\n");
+            printf("_____|_____________________________________________________________________________\n");
+            printf("     |\n");
+            for(i=0; i<FILAS; i++){
+                printf("  %d  |\t",i);
+                for(j=0; j<ASIENTOS; j++){
+                    if(sala[i][j]==0){
+                        fflush(stdin);
+                        estado = 'O';
+                    }else{
+                        fflush(stdin);
+                        estado = 'X';
+                    }
+
+                    printf("%c\t", estado);
+                    
+                }
+                printf("\n");
+            }
+            printf("     |\n  ^  |\nFila |\n\n");
+            break;
+
+        // OPCIÓN 3
+        case 3:
+
+            printf("\nPara devolver una entrada necesitamos su ubicación en la sala:\nNúmero de fila: ");
+            
+            // Pedir Fila y control de nº de fila correcto
+            do{
+                scanf("%d", &resFila);
+                if(resFila<=0||resFila>=FILAS){
+                    printf("\nSolo tenemos filas del 0 al 9.\nVuelva a intentarlo: ");
+                }
+            }while (resFila<=-1||resFila>=FILAS);
+
+
+            printf("Número de asiento: ");
+
+            // Pedir Asiento y control de nº de asiento correcto
+            do{
+                scanf("%d", &resAsiento);
+                if(resAsiento<=0||resAsiento>=ASIENTOS){
+                    printf("\nSolo tenemos asientos del 0 al 7.\nVuelva a intentarlo: ");
+                }
+            }while (resAsiento<=-1||resAsiento>=ASIENTOS);
+
+            // Control si el asiento está libre (error) o es una anulación correcta
+            if(sala[resFila][resAsiento]==0){
+                printf("\n***********************************");
+                printf("\nLo sentimos, este lugar está libre,\nno puede ser su liberado.");
+                printf("\n***********************************\n");
+            }else{
+                sala[resFila][resAsiento]=0;
+                printf("\n*******************************************");
+                printf("\nSu reserva ha sido cancelada correctamente.");
+                printf("\n¡HASTA PRONTO!");
+                printf("\n*******************************************\n");
+            }
+
+        
+
+            break;
+
+        // OPCIÓN 4
+        case 4:
+            recauda=0;
+            for(i=0; i<FILAS; i++){
+                for(j=0; j<ASIENTOS; j++){
+                    if(sala[i][j]==1){
+                          recauda=recauda+5.5;
+                    }        
+                }
+            }
+            
+            printf("\n***********************************************");
+            printf("\nLa sala lleva recaudado un total de %.2f euros.", recauda);
+            printf("\n***********************************************\n");
+            break;
+
+        // OPCIÓN SALIR
+        case 0:
+
+            
+            break;
+
+        // ERROR EN EL MENÚ 
+        default:
+            printf("\nNo es un valor correcto para este menu.\nVuelva a intentarlo\n\n");
+    }
+}while ( menu != 0 );
+
+return 0;
+
+
+}

Ejercicios/0702tresEnRaya (Sin corregir).c

@@ -0,0 +1,246 @@
+#include<stdio.h>
+#include<stdlib.h> 
+
+/*
+    TRES EN RAYA
+*/
+
+#define TAM 3
+
+int main(){
+    // Variables
+    int tablero[TAM][TAM]={0};
+    int i,j,final, fila, columna, tirada=0;
+    char estado[1]="-";
+
+    // Variables de comprobación
+    int ganador1=3;
+    int ganador2=15;
+
+
+
+    do{
+        
+        //Muestra el estado del tablero
+        printf("\n     |\t0\t1\t2\t<< Columna\n");
+        printf("_____|____________________________________\n");
+        printf("     |\n");
+        for(i=0; i<TAM; i++){
+            printf("  %d  |\t",i);
+            for(j=0; j<TAM; j++){
+                if(tablero[i][j]==0){
+                    fflush(stdin);
+                    estado[0] = '-';
+                }else if(tablero[i][j]==1){
+                    fflush(stdin);
+                    estado[0] = 'X';
+                }else{
+                    fflush(stdin);
+                    estado[0] = 'O';
+                }
+
+
+                printf("%s\t", estado);
+            }
+            printf("\n");
+        }
+        printf("     |\n  ^  |\nFila |\n\n");        
+
+
+        // TURNO JUGADOR 1
+
+        printf("\n ---------------");
+        printf("\n Turno jugador 1");
+        printf("\n ---------------");
+
+        do{
+            printf("\n Elige una fila: ");
+            // Pedir Fila y control de nº fila correcto
+            do{
+                scanf("%d", &fila);
+                if(fila<0||fila>2){
+                    printf("\nSolo hay filas del 0 al 2.");
+                    printf("\nVuelve a intentarlo: ");
+                }
+            }while (fila<-1||fila>2);
+
+
+            printf(" Elige una columna: ");
+
+            // Pedir Columna y control de nº columna correcto
+            do{
+                scanf("%d", &columna);
+                if(columna<0||columna>2){
+                    printf("\nSolo hay columnas del 0 al 3.");
+                    printf("\nVuelve a intentarlo: ");
+                }
+            }while (columna<-1||columna>2);
+
+            // Control si la posición está ocupada (error) o es una posición correcta
+            if(tablero[fila][columna]!=0){ 
+                printf("\nCasilla ocupada.");
+                printf("\nVuelve a intentarlo:\n");
+            }else{
+                tablero[fila][columna]=1;
+                tirada=1;
+            }
+
+        }while(tirada!=1);
+
+        tirada=0;
+
+        //Comprobar si hay ganador o empate
+        if(ganador1==tablero[0][0]+tablero[0][1]+tablero[0][2]||
+            ganador1==tablero[1][0]+tablero[1][1]+tablero[1][2]||
+            ganador1==tablero[2][0]+tablero[2][1]+tablero[2][2]||
+            ganador1==tablero[0][0]+tablero[1][0]+tablero[2][0]||
+            ganador1==tablero[0][1]+tablero[1][1]+tablero[2][1]||
+            ganador1==tablero[0][2]+tablero[1][2]+tablero[2][2]||
+            ganador1==tablero[0][0]+tablero[1][1]+tablero[2][2]||
+            ganador1==tablero[0][2]+tablero[1][1]+tablero[2][0]){
+            printf("\n#########################");
+            printf("\n#   GANADOR JUGADOR 1   #");
+            printf("\n#########################\n");
+            final=1;
+        }
+        
+        if(ganador2==tablero[0][0]+tablero[0][1]+tablero[0][2]||
+            ganador2==tablero[1][0]+tablero[1][1]+tablero[1][2]||
+            ganador2==tablero[2][0]+tablero[2][1]+tablero[2][2]||
+            ganador2==tablero[0][0]+tablero[1][0]+tablero[2][0]||
+            ganador2==tablero[0][1]+tablero[1][1]+tablero[2][1]||
+            ganador2==tablero[0][2]+tablero[1][2]+tablero[2][2]||
+            ganador2==tablero[0][0]+tablero[1][1]+tablero[2][2]||
+            ganador2==tablero[0][2]+tablero[1][1]+tablero[2][0]){
+            printf("\n#########################");
+            printf("\n#   GANADOR JUGADOR 2   #");
+            printf("\n#########################\n");
+            final=1;
+        }
+        
+        if(tablero[0][0]!=0&&tablero[1][0]!=0&&tablero[2][0]!=0&&
+                tablero[0][1]!=0&&tablero[1][1]!=0&&tablero[2][1]!=0&&
+                tablero[0][2]!=0&&tablero[1][2]!=0&&tablero[2][2]!=0){
+            printf("\n##############");
+            printf("\n#   EMPATE   #");
+            printf("\n##############\n");
+            final=1;
+        }
+
+
+        //Muestra el estado del tablero
+        printf("\n     |\t0\t1\t2\t<< Columna\n");
+        printf("_____|____________________________________\n");
+        printf("     |\n");
+        for(i=0; i<TAM; i++){
+            printf("  %d  |\t",i);
+            for(j=0; j<TAM; j++){
+                if(tablero[i][j]==0){
+                    fflush(stdin);
+                    estado[0] = '-';
+                }else if(tablero[i][j]==1){
+                    fflush(stdin);
+                    estado[0] = 'X';
+                }else{
+                    fflush(stdin);
+                    estado[0] = 'O';
+                }
+
+
+                printf("%s\t", estado);
+            }
+            printf("\n");
+        }
+        printf("     |\n  ^  |\nFila |\n\n");  
+
+
+        // TURNO JUGADOR 2
+
+        printf("\n ---------------");
+        printf("\n Turno jugador 2");
+        printf("\n ---------------");
+
+        do{
+            printf("\n Elige una fila: ");
+            // Pedir Fila y control de nº fila correcto
+            do{
+                scanf("%d", &fila);
+                if(fila<0||fila>2){
+                    printf("\nSolo hay filas del 0 al 2.");
+                    printf("\nVuelve a intentarlo: ");
+                }
+            }while (fila<-1||fila>2);
+
+
+            printf(" Elige una columna: ");
+
+            // Pedir Columna y control de nº columna correcto
+            do{
+                scanf("%d", &columna);
+                if(columna<0||columna>2){
+                    printf("\nSolo hay columnas del 0 al 3.");
+                    printf("\nVuelve a intentarlo: ");
+                }
+            }while (columna<-1||columna>2);
+
+            // Control si la posición está ocupada (error) o es una posición correcta
+            if(tablero[fila][columna]!=0){ 
+                printf("\nCasilla ocupada.");
+                printf("\nVuelve a intentarlo:\n");
+            }else{
+                tablero[fila][columna]=5;
+                tirada=1;
+            }
+
+        }while(tirada!=1);
+
+        tirada=0;
+        
+
+        
+
+        //Comprobar si hay ganador o empate
+        if(ganador1==tablero[0][0]+tablero[0][1]+tablero[0][2]||
+            ganador1==tablero[1][0]+tablero[1][1]+tablero[1][2]||
+            ganador1==tablero[2][0]+tablero[2][1]+tablero[2][2]||
+            ganador1==tablero[0][0]+tablero[1][0]+tablero[2][0]||
+            ganador1==tablero[0][1]+tablero[1][1]+tablero[2][1]||
+            ganador1==tablero[0][2]+tablero[1][2]+tablero[2][2]||
+            ganador1==tablero[0][0]+tablero[1][1]+tablero[2][2]||
+            ganador1==tablero[0][2]+tablero[1][1]+tablero[2][0]){
+            printf("\n#########################");
+            printf("\n#   GANADOR JUGADOR 1   #");
+            printf("\n#########################\n");
+            final=1;
+        }
+        
+        if(ganador2==tablero[0][0]+tablero[0][1]+tablero[0][2]||
+            ganador2==tablero[1][0]+tablero[1][1]+tablero[1][2]||
+            ganador2==tablero[2][0]+tablero[2][1]+tablero[2][2]||
+            ganador2==tablero[0][0]+tablero[1][0]+tablero[2][0]||
+            ganador2==tablero[0][1]+tablero[1][1]+tablero[2][1]||
+            ganador2==tablero[0][2]+tablero[1][2]+tablero[2][2]||
+            ganador2==tablero[0][0]+tablero[1][1]+tablero[2][2]||
+            ganador2==tablero[0][2]+tablero[1][1]+tablero[2][0]){
+            printf("\n#########################");
+            printf("\n#   GANADOR JUGADOR 2   #");
+            printf("\n#########################\n");
+            final=1;
+        }
+        
+        if(tablero[0][0]!=0&&tablero[1][0]!=0&&tablero[2][0]!=0&&
+                tablero[0][1]!=0&&tablero[1][1]!=0&&tablero[2][1]!=0&&
+                tablero[0][2]!=0&&tablero[1][2]!=0&&tablero[2][2]!=0){
+            printf("\n##############");
+            printf("\n#   EMPATE   #");
+            printf("\n##############\n");
+            final=1;
+        }
+
+
+
+
+    }while(final!=1);
+
+    return 0;
+}

Ejercicios/0702tresEnRaya.c

@@ -0,0 +1,246 @@
+#include<stdio.h>
+#include<stdlib.h> 
+
+/*
+    TRES EN RAYA
+*/
+
+#define TAM 3
+
+int main(){
+    // Variables
+    int tablero[TAM][TAM]={0};
+    int i,j,final, fila, columna, tirada=0;
+    char estado[1]="-";
+
+    // Variables de comprobación
+    int ganador1=3;
+    int ganador2=15;
+
+
+
+    do{
+        
+        //Muestra el estado del tablero
+        printf("\n     |\t0\t1\t2\t<< Columna\n");
+        printf("_____|____________________________________\n");
+        printf("     |\n");
+        for(i=0; i<TAM; i++){
+            printf("  %d  |\t",i);
+            for(j=0; j<TAM; j++){
+                if(tablero[i][j]==0){
+                    fflush(stdin);
+                    estado[0] = '-';
+                }else if(tablero[i][j]==1){
+                    fflush(stdin);
+                    estado[0] = 'X';
+                }else{
+                    fflush(stdin);
+                    estado[0] = 'O';
+                }
+
+
+                printf("%s\t", estado);
+            }
+            printf("\n");
+        }
+        printf("     |\n  ^  |\nFila |\n\n");        
+
+
+        // TURNO JUGADOR 1
+
+        printf("\n ---------------");
+        printf("\n Turno jugador 1");
+        printf("\n ---------------");
+
+        do{
+            printf("\n Elige una fila: ");
+            // Pedir Fila y control de nº fila correcto
+            do{
+                scanf("%d", &fila);
+                if(fila<0||fila>2){
+                    printf("\nSolo hay filas del 0 al 2.");
+                    printf("\nVuelve a intentarlo: ");
+                }
+            }while (fila<-1||fila>2);
+
+
+            printf(" Elige una columna: ");
+
+            // Pedir Columna y control de nº columna correcto
+            do{
+                scanf("%d", &columna);
+                if(columna<0||columna>2){
+                    printf("\nSolo hay columnas del 0 al 3.");
+                    printf("\nVuelve a intentarlo: ");
+                }
+            }while (columna<-1||columna>2);
+
+            // Control si la posición está ocupada (error) o es una posición correcta
+            if(tablero[fila][columna]!=0){ 
+                printf("\nCasilla ocupada.");
+                printf("\nVuelve a intentarlo:\n");
+            }else{
+                tablero[fila][columna]=1;
+                tirada=1;
+            }
+
+        }while(tirada!=1);
+
+        tirada=0;
+
+        //Comprobar si hay ganador o empate
+        if(ganador1==tablero[0][0]+tablero[0][1]+tablero[0][2]||
+            ganador1==tablero[1][0]+tablero[1][1]+tablero[1][2]||
+            ganador1==tablero[2][0]+tablero[2][1]+tablero[2][2]||
+            ganador1==tablero[0][0]+tablero[1][0]+tablero[2][0]||
+            ganador1==tablero[0][1]+tablero[1][1]+tablero[2][1]||
+            ganador1==tablero[0][2]+tablero[1][2]+tablero[2][2]||
+            ganador1==tablero[0][0]+tablero[1][1]+tablero[2][2]||
+            ganador1==tablero[0][2]+tablero[1][1]+tablero[2][0]){
+            printf("\n#########################");
+            printf("\n#   GANADOR JUGADOR 1   #");
+            printf("\n#########################\n");
+            final=1;
+        }
+        
+        if(ganador2==tablero[0][0]+tablero[0][1]+tablero[0][2]||
+            ganador2==tablero[1][0]+tablero[1][1]+tablero[1][2]||
+            ganador2==tablero[2][0]+tablero[2][1]+tablero[2][2]||
+            ganador2==tablero[0][0]+tablero[1][0]+tablero[2][0]||
+            ganador2==tablero[0][1]+tablero[1][1]+tablero[2][1]||
+            ganador2==tablero[0][2]+tablero[1][2]+tablero[2][2]||
+            ganador2==tablero[0][0]+tablero[1][1]+tablero[2][2]||
+            ganador2==tablero[0][2]+tablero[1][1]+tablero[2][0]){
+            printf("\n#########################");
+            printf("\n#   GANADOR JUGADOR 2   #");
+            printf("\n#########################\n");
+            final=1;
+        }
+        
+        if(tablero[0][0]!=0&&tablero[1][0]!=0&&tablero[2][0]!=0&&
+                tablero[0][1]!=0&&tablero[1][1]!=0&&tablero[2][1]!=0&&
+                tablero[0][2]!=0&&tablero[1][2]!=0&&tablero[2][2]!=0){
+            printf("\n##############");
+            printf("\n#   EMPATE   #");
+            printf("\n##############\n");
+            final=1;
+        }
+
+
+        //Muestra el estado del tablero
+        printf("\n     |\t0\t1\t2\t<< Columna\n");
+        printf("_____|____________________________________\n");
+        printf("     |\n");
+        for(i=0; i<TAM; i++){
+            printf("  %d  |\t",i);
+            for(j=0; j<TAM; j++){
+                if(tablero[i][j]==0){
+                    fflush(stdin);
+                    estado[0] = '-';
+                }else if(tablero[i][j]==1){
+                    fflush(stdin);
+                    estado[0] = 'X';
+                }else{
+                    fflush(stdin);
+                    estado[0] = 'O';
+                }
+
+
+                printf("%s\t", estado);
+            }
+            printf("\n");
+        }
+        printf("     |\n  ^  |\nFila |\n\n");  
+
+
+        // TURNO JUGADOR 2
+
+        printf("\n ---------------");
+        printf("\n Turno jugador 2");
+        printf("\n ---------------");
+
+        do{
+            printf("\n Elige una fila: ");
+            // Pedir Fila y control de nº fila correcto
+            do{
+                scanf("%d", &fila);
+                if(fila<0||fila>2){
+                    printf("\nSolo hay filas del 0 al 2.");
+                    printf("\nVuelve a intentarlo: ");
+                }
+            }while (fila<-1||fila>2);
+
+
+            printf(" Elige una columna: ");
+
+            // Pedir Columna y control de nº columna correcto
+            do{
+                scanf("%d", &columna);
+                if(columna<0||columna>2){
+                    printf("\nSolo hay columnas del 0 al 3.");
+                    printf("\nVuelve a intentarlo: ");
+                }
+            }while (columna<-1||columna>2);
+
+            // Control si la posición está ocupada (error) o es una posición correcta
+            if(tablero[fila][columna]!=0){ 
+                printf("\nCasilla ocupada.");
+                printf("\nVuelve a intentarlo:\n");
+            }else{
+                tablero[fila][columna]=5;
+                tirada=1;
+            }
+
+        }while(tirada!=1);
+
+        tirada=0;
+        
+
+        
+
+        //Comprobar si hay ganador o empate
+        if(ganador1==tablero[0][0]+tablero[0][1]+tablero[0][2]||
+            ganador1==tablero[1][0]+tablero[1][1]+tablero[1][2]||
+            ganador1==tablero[2][0]+tablero[2][1]+tablero[2][2]||
+            ganador1==tablero[0][0]+tablero[1][0]+tablero[2][0]||
+            ganador1==tablero[0][1]+tablero[1][1]+tablero[2][1]||
+            ganador1==tablero[0][2]+tablero[1][2]+tablero[2][2]||
+            ganador1==tablero[0][0]+tablero[1][1]+tablero[2][2]||
+            ganador1==tablero[0][2]+tablero[1][1]+tablero[2][0]){
+            printf("\n#########################");
+            printf("\n#   GANADOR JUGADOR 1   #");
+            printf("\n#########################\n");
+            final=1;
+        }
+        
+        if(ganador2==tablero[0][0]+tablero[0][1]+tablero[0][2]||
+            ganador2==tablero[1][0]+tablero[1][1]+tablero[1][2]||
+            ganador2==tablero[2][0]+tablero[2][1]+tablero[2][2]||
+            ganador2==tablero[0][0]+tablero[1][0]+tablero[2][0]||
+            ganador2==tablero[0][1]+tablero[1][1]+tablero[2][1]||
+            ganador2==tablero[0][2]+tablero[1][2]+tablero[2][2]||
+            ganador2==tablero[0][0]+tablero[1][1]+tablero[2][2]||
+            ganador2==tablero[0][2]+tablero[1][1]+tablero[2][0]){
+            printf("\n#########################");
+            printf("\n#   GANADOR JUGADOR 2   #");
+            printf("\n#########################\n");
+            final=1;
+        }
+        
+        if(tablero[0][0]!=0&&tablero[1][0]!=0&&tablero[2][0]!=0&&
+                tablero[0][1]!=0&&tablero[1][1]!=0&&tablero[2][1]!=0&&
+                tablero[0][2]!=0&&tablero[1][2]!=0&&tablero[2][2]!=0){
+            printf("\n##############");
+            printf("\n#   EMPATE   #");
+            printf("\n##############\n");
+            final=1;
+        }
+
+
+
+
+    }while(final!=1);
+
+    return 0;
+}

Ejercicios/0703hundirLaFlota (Sin corregir).c

@@ -0,0 +1,13 @@
+#include<stdio.h>
+#include<stdlib.h> 
+
+
+
+int main(){
+
+
+
+
+
+
+}

Ejercicios/0703hundirLaFlota.c

@@ -0,0 +1,13 @@
+#include<stdio.h>
+#include<stdlib.h> 
+
+
+
+int main(){
+
+
+
+
+
+
+}

Ejercicios/0801Caracteres.c

@@ -0,0 +1,31 @@
+#include<stdio.h>
+#include<stdlib.h> 
+#include<string.h>
+
+int main(){
+
+    char cadena1[50];
+    char cadena2[50];
+    char cadena3[50];
+
+    printf("\nIntroduce la primera cadena: ");
+    fflush(stdin);
+    scanf("%s", cadena1);
+
+    printf("\nIntroduce la segunda cadena: ");
+    fflush(stdin);
+    gets(cadena2);
+
+    printf("\nintroduce la tercera cadena: ");
+    fflush(stdin);
+    scanf("%[^\n]", cadena3);
+
+    printf("\n-----------");
+    printf("\nCadena 1: %s", cadena1);
+    printf("\nCadena 2: %s", cadena2);
+    printf("\nCadena 3: %s", cadena3);
+
+    printf("\n");
+
+
+}

Ejercicios/0802gestionarCadenasCaracteres.c

@@ -0,0 +1,88 @@
+#include<stdio.h>
+#include<stdlib.h> 
+#include<string.h>
+
+/*
+Ejercicio:
+Programa en C que pida al usuario 2 cadenas de 100 caracteres 
+y les cargue información. 
+
+Después
+- las muestra
+- indicará la longitud de cada una
+- indicará si son iguales entre ellas o no
+- copia el contenido de la primera en la segunda y mostrar de nuevo ambás.
+
+*/
+
+int main(){
+
+    /* Variables */
+    char cadena1[100];
+    char cadena2[100];
+    int longitud;
+
+    printf("\nIntroduce la primera cadena: ");
+    fflush(stdin);
+    scanf("%s", cadena1);
+
+
+fflush(stdin);
+
+    printf("\nIntroduce la segunda cadena: ");
+    fflush(stdin);
+    scanf("%s", cadena2);
+
+    printf("\n");
+
+
+    /* Mostrar */
+    printf("\n###################\nMostrar las cadenas\n###################");
+    printf("\nCadena 1: %s", cadena1);
+    printf("\nCadena 2: %s", cadena2);
+
+    printf("\n");
+
+
+    /* indicará la longitud de cada una*/
+    printf("\n#######################\nLongitud de las cadenas\n#######################");
+
+    longitud=strlen(cadena1);
+    printf("\nLa Cadena 1 mide: %d", longitud);
+    
+    longitud=strlen(cadena2);
+    printf("\nLa Cadena 2 mide: %d", longitud);
+
+    printf("\n");
+
+    /* indicará si son iguales entre ellas o no*/
+    printf("\n####################\nComparar las cadenas\n####################");
+
+    if (strcmp(cadena1,cadena2)==0){
+	    printf("\n Las cadenas son iguales");
+    }else{
+	    printf("\n Las cadenas no son iguales. ");
+
+        if(strcmp(cadena1, cadena2)<0){
+            printf("La Cadena 1 \"%s\" es alfabeticamente anterior a cadena2 \"%s\"",cadena1,cadena2);
+        }else{
+            printf("La Cadena 2 \"%s\" es alfabeticamente anterior a cadena 1 \"%s\"",cadena2,cadena1);
+        }
+    }
+
+    printf("\n");
+
+    
+    /* copia el contenido de la primera en la segunda y mostrar de nuevo ambás.*/
+
+    printf("\n##########################################\nCopio la cadena 1 en la cadena 2 y muestro\n##########################################");
+
+    strcpy(cadena2,cadena1);
+
+
+    printf("\nCadena 1: %s", cadena1);
+    printf("\nCadena 2: %s", cadena2);
+    printf("\n\n");
+
+
+}

Ejercicios/0901estructura.c

@@ -0,0 +1,143 @@
+#include<stdio.h>
+#include<stdlib.h>
+
+//definimos la estructura (el tipo)
+
+struct fecha{
+    int dia;
+    int mes;
+    int anio;
+};
+
+struct persona{
+    char nombre[50];
+    int edad;
+    char email[50];
+    float altura;
+    struct fecha fregistro;
+};
+
+int main(){
+
+    //declarar variables de ese tipo de estructura y darles valores
+    struct persona p1;
+    struct persona p2;
+    struct persona p3;
+    int numero;
+
+    //para darle valor a cada uno de sus campos, lo tenemos que hacer campo a campo
+    //para acceder a un campo utilizamos el operador .
+    // el operador . se conoce como acceso a miembro de una estructura 
+
+
+/* Datos persona 1*/
+
+    printf("\nIntroduce el nombre de la persona 1: ");
+    fflush(stdin);
+    scanf("%s", p1.nombre);
+
+    printf("\nIntroduce ahora la edad: ");
+    scanf("%d", &p1.edad);
+
+    printf("\nIntroduce el mail: ");
+    fflush(stdin);
+    scanf("%s", p1.email);
+
+    printf("\nIntroduce la altura: ");
+    scanf("%f", &p1.altura);
+
+    printf("\nIntroduce el día de registro: ");
+    scanf("%d", &p1.fregistro.dia);
+
+    printf("\nIntroduce el día de registro: ");
+    scanf("%d", &p1.fregistro.mes);
+
+    printf("\nIntroduce el día de registro: ");
+    scanf("%d", &p1.fregistro.anio);
+
+    printf("\nLa persona registrada es %s con %d años, con email %s y una altura de %.2f",  p1.nombre,
+                                                                                            p1.edad,
+                                                                                            p1.email,
+                                                                                            p1.altura);
+
+    printf("\nFecha de registro: %d/%d/%d", p1.fregistro.dia, p1.fregistro.mes, p1.fregistro.anio);
+
+    printf("\n");
+
+
+
+/* Datos persona 2*/
+
+    printf("\nIntroduce el nombre de la persona 2: ");
+    fflush(stdin);
+    scanf("%s", p2.nombre);
+
+    printf("\nIntroduce ahora la edad: ");
+    scanf("%d", &p2.edad);
+
+    printf("\nIntroduce el mail: ");
+    fflush(stdin);
+    scanf("%s", p2.email);
+
+    printf("\nIntroduce la altura: ");
+    scanf("%f", &p2.altura);
+
+
+    printf("\nIntroduce el día de registro: ");
+    scanf("%d", &p2.fregistro.dia);
+
+    printf("\nIntroduce el día de registro: ");
+    scanf("%d", &p2.fregistro.mes);
+
+    printf("\nIntroduce el día de registro: ");
+    scanf("%d", &p2.fregistro.anio);
+
+    printf("\nLa persona registrada es %s con %d años, con email %s y una altura de %.2f",  p2.nombre,
+                                                                                            p2.edad,
+                                                                                            p2.email,
+                                                                                            p2.altura);
+
+    printf("\nFecha de registro: %d/%d/%d", p2.fregistro.dia, p2.fregistro.mes, p2.fregistro.anio);
+
+    printf("\n");
+
+
+/* Datos persona 3*/
+
+
+    printf("\nIntroduce el nombre de la persona 3: ");
+    fflush(stdin);
+    scanf("%s", p3.nombre);
+
+    printf("\nIntroduce ahora la edad: ");
+    scanf("%d", &p3.edad);
+
+    printf("\nIntroduce el mail: ");
+    fflush(stdin);
+    scanf("%s", p3.email);
+
+    printf("\nIntroduce la altura: ");
+    scanf("%f", &p3.altura);
+
+    printf("\nIntroduce el día de registro: ");
+    scanf("%d", &p3.fregistro.dia);
+
+    printf("\nIntroduce el día de registro: ");
+    scanf("%d", &p3.fregistro.mes);
+
+    printf("\nIntroduce el día de registro: ");
+    scanf("%d", &p3.fregistro.anio);
+    
+    printf("\nLa persona registrada es %s con %d años, con email %s y una altura de %.2f",  p3.nombre,
+                                                                                            p3.edad,
+                                                                                            p3.email,
+                                                                                            p3.altura);
+
+    printf("\nFecha de registro: %d/%d/%d", p1.fregistro.dia, p1.fregistro.mes, p1.fregistro.anio);
+
+    printf("\n");
+
+
+
+}
+

Ejercicios/1101EjemploMatrices.c

@@ -0,0 +1,39 @@
+#include<stdio.h>
+
+#define FILAS 4
+#define COLUMNAS 3
+
+void cargar (int m[][COLUMNAS]);
+void mostrar(int m[][COLUMNAS]);
+
+int main(){
+
+int matriz[FILAS][COLUMNAS];
+
+cargar(matriz);
+mostrar(matriz);
+
+
+}
+
+void cargar(int m[][COLUMNAS]){
+    int i, j;
+
+    for(i=0; i<FILAS; i++){
+        for(j=0; j<COLUMNAS; j++){
+            printf("\nIntroduce el elemento fila %d y columnas %d", i, j);
+            scanf("%d", &m[i][j]);
+        }
+    }
+}
+
+void mostrar(int m[][COLUMNAS]){
+    int i,j;
+
+    for(i=0; i<FILAS; i++){
+        for(j=0; j<COLUMNAS; j++){
+            printf("%d\t", m[i][j]);
+        }
+        printf("\n");
+    }
+}

Ejercicios/1201ArrayEstructura.c

@@ -0,0 +1,83 @@
+#include<stdio.h>
+#include<stdlib.h> 
+
+#define MAX 3
+
+
+struct contacto {
+		char nombre[60];
+		char telefono[15];
+		int edad;
+};
+
+int main (){
+	
+    // Defino variables
+    int menu;
+    int i;
+
+	// tipo nombre [Tamaño]
+	struct contacto agenda [MAX];
+
+    //elabora un menú con estas opciones: 1. cargar 2. mostrar 0 . salir
+
+
+    do{
+
+        printf("\nMenú");
+        printf("\n1 Cargar agenda");
+        printf("\n2 Mostrar agenda");
+        printf("\n0 Salir\n");
+
+        printf("\nIntroduce una opción reseñada: ");
+        fflush(stdin);
+        scanf("%d", &menu);
+
+        switch(menu){
+            case 1:
+
+            for(i=0; i<MAX; i++){
+                printf("\nIntroduce el nombre del contacto %d",i);
+                fflush(stdin);
+                scanf("%s", agenda[i].nombre);
+
+                printf("\nIntroduce teléfono del contacto %d",i);
+                fflush(stdin);
+                scanf("%s", agenda[i].telefono);
+                
+                printf("\nIntroduce la edad del contacto %d",i);
+                fflush(stdin);
+                scanf("%d", &agenda[i].edad);
+
+            }
+
+                break;
+            case 2:
+
+                for(i=0; i<MAX; i++){
+
+                    printf("\nEl contacto %d se llama %s, su numero de teléfono es %s y tiene %d años", i, agenda[i].nombre,agenda[i].telefono, agenda[i].edad);
+
+
+
+                }
+                
+
+                break;
+            case 0:
+
+                
+                break;
+
+            // ERROR EN EL MENÚ 
+            default:
+                printf("\nNo es un valor correcto para este menu.\nVuelva a intentarlo\n\n");
+        }
+
+    }while ( menu != 0 );
+
+    return 0;
+
+
+
+}

Ejercicios/1202Garaje.c

@@ -0,0 +1,243 @@
+#include<stdio.h>
+#include<stdlib.h> 
+
+
+/*
+Programa que permita gestionar los coches de un garaje. 
+Cada plaza tiene un número del 0 al 44. 
+Para cada coche que se guarda en el garaje almacena:
+ - Matrícula cadena 10
+ - Modelo cadena 30
+ - Nombre conductor – cadena 60
+ - Fecha de entrada en el garaje  día mes y año. Todo números enteros.
+
+El programa mostrará el menú
+ 1 Meter coche. Comprobando que el garaje no está lleno.
+ 2 Mostrar la información del garaje
+ 3 Pedir una matrícula al usuario e indicar si ese coche está o no en el garaje.
+ 0 Salir
+
+*/
+
+#define TAM 45
+
+// estructura de la fecha de entrada
+struct fecha {
+    int dia;
+    int mes;
+    int year;
+};
+
+//estructura de la plaza de garaje
+struct plaza {
+        int estado;  // 0 cuando la plaza está vacía y 1 cuando está ocupada
+        char matricula[10];
+        char modelo[30];
+		char nomConductor[60];
+		struct fecha fechaEntrada;
+};
+
+int main (){
+	
+    // Defino variables
+    int menu;
+    int numPlaza;
+    int i;
+    int ocupado=0;
+    int libre=0;
+    char buscarMatr[10];
+    int encontrado;
+
+
+	// tipo nombre [Tamaño]
+	struct plaza garaje [TAM];
+
+
+    // Dejo el estado de las plazas de garaje a 0 (Vacías)
+    for(i=0; i<TAM; i++){
+        garaje[i].estado=0;
+    }
+
+    //elabora un menú con estas opciones: 1. cargar 2. mostrar 0 . salir
+
+
+    do{
+
+        printf("\nMenú");
+        printf("\n1 Introducir un coche."); // Comprobar que el garaje no está lleno
+        printf("\n2 Mostrar información de las plazas.");
+        printf("\n3 Introduce una matrícula para saber si está el coche en el garaje.");
+        printf("\n0 Salir\n");
+
+        printf("\nIntroduce una opción reseñada: ");
+        fflush(stdin);
+        scanf("%d", &menu);
+
+        switch(menu){
+            case 1:
+
+                /*        
+                // Cuento las plazas libres y ocupadas.
+                for(i=0; i<TAM; i++){
+                    if(garaje[i].estado==0){
+                        libre=libre+1;
+                    }else{
+                        ocupado=ocupado+1;
+                    }
+                }
+
+                if(libre==0){
+                    printf("\nEL GARAJE ESTA COMPLETO.");
+                    printf("\nVuelva más tarde.");
+
+                }else{
+                      
+                    printf("\nTenemos libres las siguientes plazas: \n");
+                    
+                    for(i=0; i<TAM; i++){
+
+                        if(garaje[i].estado==0){
+                            printf("%d \t", i);
+                        }
+                        if(i==14||i==29||i==44){
+                            printf("\n");
+                        }
+
+                    }  
+
+                    printf("\n¿Qué plaza desea reservar?: \n");
+                    // //////////////////////////////// ME HE QUEDADO AQUí
+                    // scanf .....
+
+
+                }*/
+
+            /*Solucion sencilla*/
+            ocupado=0;
+            for(i=0;i<TAM;i++){
+                if(garaje[i].estado==1){
+                    ocupado++;
+                }
+            }
+
+            if(ocupado==TAM){
+                printf("\nEste garaje estA completo");
+            }else{
+                libre=0;
+                while(garaje[libre].estado==1){
+                    libre++;
+                }
+                printf("\n Introduce la matricula del coche:  ");
+                fflush(stdin);
+                scanf("%s", garaje[libre].matricula);
+
+                garaje[libre].estado=1;
+
+                //y así, con el resto de los datos
+            }
+
+
+                break;
+            case 2: // Mostrar las plazas vacías y las plazas ocupadas
+
+                printf("\n####################");
+                printf("\nOCUPACIÓN DEL GARAJE");
+                printf("\n####################\n");
+
+                // Cuento las plazas libres y ocupadas.
+                /*
+                for(i=0; i<TAM; i++){
+                    if(garaje[i].estado==0){
+                        libre=libre+1;
+                    }else{
+                        ocupado=ocupado+1;
+                    }
+                }
+                printf("\nEn estos momentos de las %d plazas que disponemos en nuestro garaje tenemos: ", TAM);
+                printf("\n %d plazas libre y %d plazas ocupadas.\n", libre, ocupado);
+
+                // Indico las plazas concretas y su estado.
+
+                printf("\n_____________________________________ \n");
+                printf("\nTenemos libres las siguientes plazas: \n");
+                
+                for(i=0; i<TAM; i++){
+
+                    if(garaje[i].estado==0){
+                        printf("%d \t", i);
+                    }
+                    if(i==14||i==29||i==44){
+                        printf("\n");
+                    }
+
+                }
+
+                printf("\n_____________________________________ \n");
+                */
+
+                /*Mostrar la información de las plazas*/
+                libre=0;
+                ocupado=0;
+                for(i=0; i<TAM; i++){
+                    if(garaje[i].estado==0){
+                        printf("\nPlaza %d -> libre", i);
+                        libre++;
+                    }else{
+                        printf("\nPlaza %d -< ocupada matricula: %s, modelo: %s", i, garaje[i].matricula, garaje[i].modelo);
+                        ocupado++;
+                    }
+                }
+                printf("\nLibres: %d Ocupadas: %d", libre, ocupado);
+
+                break;
+            case 3:
+                //primero, pide la matrícula que la guardarás en una variable cualquiera (una cadena)
+
+                printf("\nDame la matrícula a buscar: ");
+                fflush(stdin);
+                scanf("%s", buscarMatr);
+
+                //recorre todo el garaje, comprueba que el estado es 1 y si el estado es 1, compara las matriculas
+                //recuerda que las cadenas se comparan con strcmp
+
+                //puedes valerte de un flag para indicar si has encontrado o no el coche.
+                
+                encontrado=0;
+                for(i=0; i<TAM; i++){
+                    
+                    if(garaje[i].estado==1){
+                        if(strcmp(buscarMatr, garaje[i].matricula)==0){
+                            printf("\nLo encontre!! es un %s", garaje[i].modelo);
+                            encontrado=1;
+                        }
+
+                                           
+                    }
+
+                }
+
+                if(encontrado==0){
+                    printf("\nEse coche con esa matricula no esta en el garaje");
+                }
+
+
+                break;
+            case 0:
+
+                
+                break;
+
+            // ERROR EN EL MENÚ 
+            default:
+                printf("\nNo es un valor correcto para este menu.\nVuelva a intentarlo\n\n");
+        }
+
+    }while ( menu != 0 );
+
+    return 0;
+
+    printf("Hasta pronto!");
+
+
+
+}