Mensajes

Todo depende de cómo estructures el ejercicio ya que dependerá de las clases que estés usando y las restricciones que tenga que haber entre ellas. No es lo mismo tener por ejemplo usuarios y que cada uno almacene su número de asiento que tener únicamente los asientos.
En el segundo caso que es más sencillo, como te ha dicho @ryhuso, puedes tener un array de tipo boolean y longitud 21. La longitud tiene que ser 21 porque es el número de asientos que hay entre el 0 y el 20. Entonces a la hora de reservar un asiento, si ese índice del array vale true es que ya está ocupado, y si vale false es que está disponible y tendrás que ponerlo a true.

Pero como te digo, lo más importante es cómo tengas estructurado tu programa ya que cada implementación conllevará una solución diferente. Si quieres ayuda más concreta tendrás que dejar algo de tu código para que podamos verlo.

Al menos has intentado poner el código entre etiquetas (se valora) pero no te ha salido bien... Debes poner la parte de tu código entre las dos parejas de corchetes con la palabra code.
Además tienes un montón de cosas duplicadas que dificultan mucho la lectura del problema.

Corrige esos problemas para que podamos ayudarte...

Bueno, lo primero informarte de que lo pides en C++ pero tu programa tiene una pinta de C que no puede con ello...
Y lo segundo que para futuras consultas coloca tu código entre etiquetas de Código GeSHi porque sino se dificulta mucha la lectura de éste... Gracias.

Tu código digamos que hace lo siguiente:

Código (cpp) [Seleccionar] Expandir


#include <stdio.h>
#include <stdlib.h>

main(){
    int numero[10],size,contador=0,i=0; // Declaras el array de 10 elementos y un par de variables mas... De momento no va mal aunque... La funcion es: int main() ya que devuelve un int
    printf("Introduzca la cantidad de numeros(hasta un maximo de 10): "); // Pides el numero de elementos a guardar
    scanf("%i",&size); // Y lo guardas en size... Bien
    for (i=0;i<size;i++){ // Recorres el array hasta size y pides un valor para cada posicion
        printf("Numero %i: ",i+1);
        scanf("%i",&numero[i]); // AQUI SUPONGO QUE USAS EL INDICE i AUNQUE COMO PUEDES VER EN TU MENSAJE NO SE VE POR NO USAR ETIQUETAS DE CODIGO GESHI
    }
    // A partir de aqui es cuando ya tu programa pierde el sentido...
    for (i=0;i<size;i++){
        if (numero==size){
           contador++;
        }
        printf("%i  %i\n",numero,contador);
    }
    // No te recomiendo usar system("pause")... Es una mala practica.
    // Para C++ (el de verdad...) lo recomendable es usar cin.get() que pertenece al archivo de cabecera <iostream>
    // Para tu C++ (que es practicamente C) lo recomendable es usar getchar() que pertenece a <stdio.h>
    system("Pause");
    return 0;
}

Bueno pues te voy a dar una solución intentando que sea fácil de entender (ya habrá tiempo de hacerla más eficiente una vez entendido el procedimiento). Imagina que tienes un array con valores y te piden saber cuántas veces se repite un número concreto x... Fácil:

Código (cpp) [Seleccionar] Expandir


int contador = 0;
for(int i = 0; i < size; ++i)
    if(numeros[i] == x)
        ++contador;
Y ya estaría. El problema en tu caso es que no sabes cuántos valores tienes que buscar de antemano por lo que una posible solución es crear un par de arrays auxiliares:
En uno de ellos guardarás cada uno de los valores introducidos pero sólo una vez. Es decir si se introduce {1,2,3,2,3,1,3,2,4,1,2,4,1} tu array auxiliar guardará {1,2,3,4} y así puedes saber qué valores tienes que buscar.
El otro guardará cuántas veces está cada uno. Para el ejemplo anterior quedaría {4,4,3,2}, es decir, 4 veces el 1, 4 veces el 2, 3 veces el 3 y 2 veces el 4.

Creo que una buena forma de hacerlo (simple pero sin tener que recorrer todos los arrays 50 veces sería):

Código [Seleccionar] Expandir


numeros : array de longitud 10
valoresUnicos : array de longitud 10 // ya que en el peor de los casos habra 10 elementos diferentes
sizeValoresUnicos := 0 // Numero de elementos introducidos en valoresUnicos
indiceValoresUnicos := 0 // indice para recorrer el array de valoresUnicos y a veces utilizado para el array contadores. Lo puedes ver mas abajo
contadores : array de longitud 10 // igual que antes para el peor de los casos en el cual quedaria {1,1,1,1,1,1,1,1,1,1}. IMPORTANTE: debe estar inicializado a 0

PEDIR size
PARA i := 0 HASTA size-1 HACER
    PEDIR numeros[i]
    // Buscamos si ese valor ya esta en valoresUnicos y sino lo metemos
    indiceValoresUnicos := 0
    MIENTRAS indiceValoresUnicos < sizeValoresUnicos && valoresUnicos[indiceValoresUnicos] != numeros[i] HACER // IMPORTANTE: las condiciones en ese orden o te dara problemas
        indiceValoresUnicos := indiceValoresUnicos + 1
    FIN MIENTRAS
    // Cuando salimos de ese bucle tenemos que comprobar cual ha sido la condicion que ha hecho salir
    SI indiceValoresUnicos == sizeValoresUnicos ENTONCES // Si hemos llegado hasta el final significa que no lo hemos encontrado
        valoresUnicos[indiceValoresUnicos] := numeros[i] // Entonces lo metemos
        contadores[indiceValoresUnicos] = 1; // y guardamos que ya tenemos una vez ese valor
        sizeValoresUnicos := sizeValoresUnicos + 1 // y este array ya tiene 1 elemento mas
    SINO // En cambio si no hemos llegado hasta el final significa que si lo hemos encontrado. Entonces incrementamos en 1 el numero de veces que ha salido ese valor
        contadores[indiceValoresUnicos] := contadores[indiceValoresUnicos] + 1
    FIN SI
FIN PARA

Ahora tienes que entender el algoritmo y una vez lo hayas entendido tienes que pasarlo a C/C++ ya que como puedes ver no he usado la sintaxis de estos lenguajes. Si entiendes cómo funciona, traducirlo resulta muy sencillo.
Si tienes alguna duda o algo no te funciona, siempre puedes preguntar pero recuerda utilizar las etiquetas para facilitarnos la lectura de tu código.

[Coloca el código entre etiquetas de Código GeSHi...]

Coloca el código entre etiquetas de Código GeSHi...

Los arrays también puedes pasarlos como parámetros (exactamente lo que pasas es un puntero al array) y modificarlos en la función. Además no viene mal recalcar que no es necesario pasarlos por referencia a no ser que vayas a reservar/liberar memoria.

Código (c) [Seleccionar] Expandir


void f(int *numeros, int size){
  for(int i = 0; i < size; ++i)
    numeros[i] = i;
}

int main(){
  int numeros[10];
  f(numeros, 10);
  // Mostrar array numeros. Salida: 0 1 2 3 4 5 6 7 8 9
}

Como te han dicho, si lo que quieres es obtener una equivalencia entre las letras y sus respectivos códigos ASCII, puedes hacer un casting entre int y char para obtener los códigos ASCII a partir de las letras o viceversa.
Si lo que quieres es asignar unos valores numéricos diferentes a cada letra, te recomiendo usar el contenedor Map de la STL: http://www.cplusplus.com/reference/map/map/
Puedes buscar ejemplos de uso en internet, seguro que encuentras códigos que te pueden servir de ayuda.

Supongo que cuando dices crear es inicializar no?

Si no sé a qué hace referencia cada parámetro de la función pues la cosa está un poco complicada. Aunque por lo que dices supongo que uno es la matriz, otro el orden y otro es la variación para la recursividad. Con esa idea, la función quedaría prácticamente igual a la que puse anteriormente:

Código (cpp) [Seleccionar] Expandir


void f(float matriz[][SIZE], int orden, int fila){
  if(fila < orden){
    f(matriz, orden, fila+1);
    for(int i = 0; i < orden; ++i)
      matriz[fila][i] = fila; // el valor lo he puesto como ejemplo
  }
}

La función tendrías que llamarla inicialmente como:

Código (cpp) [Seleccionar] Expandir


f(matriz, orden, 0);

Creo que dejas varias dudas en tu mensaje.
Normalmente una matriz es bidimensional (con n filas y m columnas) pero cuando la matriz es cuadrada, en vez de decir que tiene n filas y n columnas (o como se denota normalmente: nxn), se dice que es de orden n.
Ahora bien, en tu caso no estoy seguro de que el parámetro n se refiera a la dimensión o al orden.

Es mejor que pongas un ejemplo concreto, como por ejemplo (predicando con el ejemplo ):
"Necesito implementar una función que reciba como parámetro el orden de la matriz <crearMatrizRecursiva(int orden)> y genere una matriz de 2 dimensiones y de tamaño (orden x orden)"

Para ese supuesto que he puesto primero imagina cómo lo harías de manera iterativa:
(No sé en que lenguaje lo necesitas así que haré el ejemplo en C++... Hay que procurar ser lo más concreto posible cuando se solicita ayuda)

Código (cpp) [Seleccionar] Expandir


int** generarMatriz(int orden){
    int **matriz = new int* [orden];
    for(size_t i = 0; i < orden; ++i)
        matriz[i] = new int [orden];
    return matriz;
}

La recursividad normalmente lo que hace es eliminar un bloque iterativo y convertirlo en una sentencia condicional. Además alguno de los parámetros tiene que ir cambiando para en algún momento llegar al caso base que es el que termina con las llamadas recursivas.
Como en la función anterior sólo tenemos un bloque iterativo, será la parte que implementaremos de manera recursiva. Existen diferentes formas de hacerlo, una de ellas es esta:

Código (cpp) [Seleccionar] Expandir


int** generarMatriz(int orden){
    int **matriz = new int* [orden];
    generarMatrizRecursiva(matriz, orden-1, orden);
    return matriz;
}

void generarMatrizRecursiva(int **matriz, int filaActual, int orden){
    if(filaActual >= 0){
        matriz[filaActual] = new int [orden];
        generarMatrizRecursiva(matriz, filaActual-1, orden);
    }
}

Esta versión es muy simple pero creo que es la mejor para que entiendas cómo funciona la recursividad. Si quieres añadirle un poco más de gracia, te recomiendo cambiar el orden de las instrucciones y comprobar si puedes explicar su funcionamiento ahora. Pero eso ya es cosa tuya...

Código (cpp) [Seleccionar] Expandir


void generarMatrizRecursiva(int **matriz, int filaActual, int orden){
    if(filaActual >= 0){
        generarMatrizRecursiva(matriz, filaActual-1, orden);
        matriz[filaActual] = new int [orden];
    }
}

Y no olvides liberar toda esa memoria antes de terminar el programa...

PD: No te acostumbres a recibir los ejercicios hechos. Esta ha sido una excepción por la Navidad   

Eso es porque primero tienes la llamada recursiva y después la instrucción de mostrar.

Lo que hace tu programa es:

Código [Seleccionar] Expandir


Llamar a mostrar desde la posicion 0
  Llamar a mostrar desde la posicion 1
    Llamar a mostrar desde la posicion 2
      Llamar a mostrar desde la posicion 3
        //...
          Llamar a mostrar desde la posicion SIZE-1
          // AQUI ACABA LA RECURSIVIDAD Y AHORA EMPIEZA A MOSTRAR DESDE DENTRO HACIA FUERA
          Mostrar la posicion SIZE-1
        //...
      Mostrar la posicion 3
    Mostrar la posicion 2
  Mostrar la posicion 1
Mostrar la posicion 0

Lo único que tienes que hacer es cambiar el orden de las dos instrucciones haciendo que primero muestre y después se llame de nuevo. Así el esquema sería:

Código [Seleccionar] Expandir


Llamar a mostrar desde la posicion 0
  Mostrar la posicion 0
  Llamar a mostrar desde la posicion 1
    Mostrar la posicion 1
    Llamar a mostrar desde la posicion 2
    //...
      Mostrar la posicion SIZE-2
      Llamar a mostrar desde la posicion SIZE-1
        Mostrar la posicion SIZE-1
        FIN // Si hubiese mas instrucciones despues de la llamada recursiva se harian aqui
      FIN // Si hubiese mas instrucciones despues de la llamada recursiva se harian aqui
    //...
  FIN // Si hubiese mas instrucciones despues de la llamada recursiva se harian aqui
FIN // Si hubiese mas instrucciones despues de la llamada recursiva se harian aqui

Al final lo importante en esto es entender cómo funciona la recursividad, más que conseguir el resultado esperado a prueba y error.

Buenas.

Me alegra que hayas podido hallar con la solución a tu problema.
Entonces es del disco duro? Perdón por insistir, pero me gustaría saber el porqué. Si alguien tiene claro el porqué estaría bien saberlo, me ha dejado un poco descolocado jaja.

Puede ser que sea el tipo de formato del disco duro?

Un saludo.

Ambos discos son FUSE. La verdad es que no sé cuál puede ser el motivo.
Me dio por hacer la prueba porque vi que el disco de 4TB no lo reconocía mi otro tv, mientras que el de 1TB sí; pero como digo, no puedo explicar el porqué.

Ya he conseguido solucionar el problema.
Como ya lo había probado todo y nada funcionaba, probé y conectar el disco duro a otra tv y vi que está ni siquiera reconocía el disco duro por lo que pasé los vídeos de ese disco duro (de 4 TB) a otro (de 1 TB) y ahora ya puedo ver todos los vídeos sin problemas.
Al final resulta que no era problema de los códecs ni las tasas ni nada de eso pero bueno, me ha servido para aprender un poco sobre el tema.

Muchas gracias a los que habéis colaborado.