Mensajes

Hay muchas formas de resolver esto, yo te voy a comentar una posible solución.
Te recomiendo leer el número en una variable de tipo <long long> porque en un <int> no cabe un número de 16 dígitos y después ir guardando cada dígito en un array ya que tal como lo haces en esa cadena podrías escribir cualquier cosa y tener problemas en la ejecución.
Además separar un número en dígitos es un problema muy común cuando empiezas en programación y que viene bien que lo practiques ya que es muy útil.
Una vez guardado el número, si creas un array de memoria estática de tamaño 16 siempre (quiero decir, que no usas memoria dinámica) empieza a guardar los dígitos por el final y así podrás localizar siempre la penúltima posición ya que los 0 estarán al principio, no al final.

Suerte

Si especificas un poco más tu problema, será más fácil ayudarte...
Creo que nadie se va a leer todo ese mensaje para explicártelo entero.

Dejo por aquí otra función que permite validar una fecha

Código (c) [Seleccionar] Expandir


bool validarFecha(int day, int month, int year){
    int dias_mes[12] = {31,28,31,30,31,30,31,31,30,31,30,31};
    if(month < 1 or month > 12)
        return false;
    if(month == 2 and esBisiesto(year))
        dias_mes[1] = 29;
    return day <= dias_mes[month-1];
}

bool esBisiesto(int year){
    return (year % 4 == 0 && (!(year % 100 == 0) || (year % 400 == 0)))
}

Otra opción sería esta:

Código (cpp) [Seleccionar] Expandir


char *pm = claveHabitacion[9];

Muy bien, vamos por partes.

• ¿Por qué es más fácil si "Nombre_alumno_n" va todo junto?
  Muy simple. Porque es "una sola palabra". Entiéndase como una sola palabra que no va separado por espacios lo cual permite leerlo de otra forma, en vez de usando <getline()> podemos usar el operador >> como hacemos cuando ponemos < cin >> variable >.
  En este caso lo que te propuse para evitar darle tantas vueltas a esto fue lo siguiente, si recuerdas:
  

  
  Igual que antes copias las líneas pares pero antes intercalas esto:
  

  Código (cpp) [Seleccionar] Expandir

  
file << "Nombre alumno " << contador << "  Alumno " << contador++ << endl;
  Inicializando contador en 1 para que vaya incrementándose en cada iteración.

  Como conocíamos el formato de la línea podíamos escribirla nosotros sin necesidad de usar lo que habíamos leído. Pero imagina que desconocemos el formato, o que en algún momento cambiaremos el formato del fichero de entrada y cambiamos "Nombre alumno n" por "Nombre". Entonces tendríamos que cambiarlo en nuestro código si queremos que siga quedando igual.
  En cambio si lo tenemos en una sola palabra (usando _) podemos leer esa primera palabra, copiarla en el fichero de salida y reemplazar el nombre únicamente. Para ello podemos leer palabra a palabra de la siguiente manera:
  
  Código (cpp) [Seleccionar] Expandir
  
string palabra;
while(!fichero.eof())
    fichero >> palabra;
  No sé si lo ves. Si leyésemos la línea entera tendríamos que ver dónde empieza el nombre para ver dónde empezar a reemplazar. De esta forma leemos la primera palabra, la copiamos, leemos la segunda (para poder avanzar en el fichero) pero la obviamos y reemplazamos por lo que nosotros queramos poner. También podemos leer el nombre si fuera una sola palabra y modificar el <string> que almacena el nombre y volver a guardarlo. Por hacerlo menos manual.
  
  Esto que te comento se ve mucho mejor en la otra línea, en la que se encuentran las notas. Si leemos la línea entera pues luego tendríamos que calcular nosotros dónde empieza la nota para separarla y convertirla en un <double> por ejemplo y luego guardarla en otra variable para poder trabajar con ella... En definitiva, un rollo
  Al poder leer por palabras podemos guardar la primera en un <string> que sea siempre el mismo ya que no lo necesitamos y la segunda palabra (la nota en este caso) en otra variable.
  Para ello cómo te he comentado antes debemos usar el operador >> en lugar de <getline()>. Te pongo un ejemplo de cómo quedaría:
  
  Código (cpp) [Seleccionar] Expandir
  
string palabra, linea; // linea es innecesaria, podemos usar la misma variable para todo pero es para verlo mejor
double notas[SIZE]; // si no trabajamos con memoria dinamica ponemos un SIZE suficientemente grande
int num_notas = 0;
while(!fichero.eof()){
    getline(fichero, linea);
    fichero >> palabra >> notas[num_notas++];
}
  Con ese código vamos almacenando las líneas impares en línea (que son las que menos nos interesan ahora) y luego de las líneas pares guardamos la primera palabra (notas_alumno_n) en <palabra> y la nota en <notas>. Repito, como no estamos utilizando ni <linea> ni <palabra> para trabajar podemos usar la misma variable para ambas cosas, pero lo he puesto así para que fuera más visual.
  Hecho esto tenemos en el array <notas> todas las notas almacenadas para trabajar con ellas y en la variable <num_notas> el número de notas que hemos almacenado para no recorrer el array entero en caso de que nos sobren posiciones.
  
  Respecto a lo que has mencionado de la función <seekg()>, eso son funciones para acceso aleatorio de un fichero pero si estás empezando te recomiendo trabajar con acceso secuencial hasta que hayas cogido práctica al menos. Casi siempre tendrás que usar alguna variable "vertedero" donde ir dejando lo que no te interesa pero se como has visto, se puede hacer.
  
  Espero que te sirva para completar tu programa. Suerte
  

Si quieres comprobar si un valor ya existe en un array, tienes que comparar ese elemento con cada uno de los elementos del array. Para mejorar la eficiencia puedes crear una variable de tipo <bool> para dejar de recorrer el array cuando ya lo has encontrado. Por ejemplo:

Código (c) [Seleccionar] Expandir


for(size_t i = 0; i < size and !encontrado; ++i)
    if(v[i] == elemento_buscado)
        encontrado = true;

La forma más sencilla es que recorras toda la matriz y compares cada casilla que rodea a la que estás situado con el valor contrario al de esa casilla.

Claro a ver, todo depende de cuál quieras que sea el resultado. Pongamos el supuesto de ejemplo que has comentado tú:

Código [Seleccionar] Expandir


Nombre alumno 1   Pepito Pérez
nota_alumno_1      5.8
Nombre alumno 2   Juan Gómez
nota_alumno_2      3.3
...               ...
Nombre alumno n   Mauricio Colmenero
nota_alumno_n      8.2
Supongo que "Nombre alumno n" no va con _ (lo cuál sería más fácil de leer todo el bloque junto).

• OPCION 1: Como tú dices copiar sólo las líneas pares.
  
  Código [Seleccionar] Expandir
  
nota_alumno_1   5.8
nota_alumno_2   3.3
...                         ...
nota_alumno_n   8.2
  Para conseguir esto debes ir leyendo línea a línea y escribir en el fichero de salida sólo las pares. Para leer una línea usa la función <getline()>
  
  Código (cpp) [Seleccionar] Expandir
  
istream& getline(istream&, string&, char delimitador) // esta es la funcion para que veas los parametros
// el char es opcional y es para que lea solo hasta un caracter delimitador

// Te pongo un ejemplo de uso
string linea;
while(!file.eof()){
    getline(file, linea);
    cout << linea << endl;
}
  
  
• OPCION 2: Sustituir el nombre del alumno por "Alumno 1", "Alumno 2", ... , "Alumno n". Para esto sabiendo el formato de la línea que es "Nombre alumno n" no hace falta copiar esa línea sino simplemente sustituirla y hacer algo así:
  
  Código [Seleccionar] Expandir
  
Nombre alumno 1   Alumno 1
nota_alumno_1      5.8
Nombre alumno 2   Alumno 2
nota_alumno_2      3.3
...               ...
Nombre alumno n   Alumno n
nota_alumno_n      8.2
  Igual que antes copias las líneas pares pero antes intercalas esto:
  
  Código (cpp) [Seleccionar] Expandir
  
file << "Nombre alumno " << contador << "  Alumno " << contador++ << endl;
  Inicializando contador en 1 para que vaya incrementándose en cada iteración.
  
  Espero que te sirva y suerte

Los ficheros son de lectura/escritura por lo que para trabajar con los datos debes guardar esos datos en variables. Para ello debes conoces la estructura que tiene el fichero.
Imagina que el fichero tiene la siguiente estructura:

Código [Seleccionar] Expandir


Nombre Nota
Vamos a dividir el problema en dos partes:

• PARTE 1: Modificar los nombres
  Como no puedes usar estructuras de datos (arrays) necesitarás una variable para el nombre <string> o <char*> y otra para la nota <double> o <float>. Entonces deberás seguir la siguiente estructura:
  
  Código [Seleccionar] Expandir
  
mientras !fin_fichero_entrada
    nombre <-- leer(fichero_entrada)
    edad <-- leer(fichero_entrada)
    nombre := nuevo_nombre
    escribir(nombre, fichero_salida)
    escribir(edad, fichero_salida)
fin mientras
  
  
• PARTE 2: Calcular la media
  Para esto necesitas otras dos variables <suma_notas> y <num_alumnos>. Entonces la estructura es la siguiente:
  
  Código [Seleccionar] Expandir
  
suma_notas := 0
num_alumnos := 0
mientras !fin_fichero_entrada
    nombre <-- leer(fichero_entrada) // aunque no lo usamos debemos recorrer todo el fichero
    edad <-- leer(fichero_entrada)
    suma_notas := suma_notas + edad
    num_alumnos := num_alumnos + 1
fin mientras

media := suma_notas / num_alumnos
  
  Espero que te sirva para resolver el problema. Si tienes algún problema más puedes dejar tus avances para poder ayudarte mejor. Tampoco sé si estás programando en C o C++...
  Suerte

Como estás empezando y parece que quieres aprender te comento un par de cosas más:

• La librería <iostream> es sin la h.
  
• Las librerías que terminan en ".h" son características de C, aunque se pueden usar en C++, las de C++ pierden el ".h" y se añade una "c" al principio. (<math.h> -> <cmath>).
  
• La librería <conio.h> no es recomendable usarla ya que no es estándar. Es decir, que no está disponible en todos los compiladores por lo que puede dar errores. Además no es necesaria. En tu caso la incluyes para usar la función <getch>. Esta función se puede sustituir en C++ por <cin.get()> (incluida en <iostream>).
  También usas la función <clrsrc()> para limpiar la pantalla. Primero te recomendaría, como estás empezando, no usar funciones fanzy (funciones de adorno) y centrarte en resolver el problema que se propone.
  
• En caso de querer limpiar la pantalla tienes <system("cls")> (Windows) y <system("clear")> (Linux) para las cuales solo es necesaria la librería <cstdlib>.
  
  Ahora vamos al problema. Para comprobar si un elemento existe en un array/arreglo/vector hay que recorrer dicho array elemento por elemento. La idea sería la siguiente:
  
  Código [Seleccionar] Expandir
  
i := 0
encontrado = false
mientras !encontrado and i < n
    si v[i] == elemento_buscado
        encontrado = true
    fin si
fin mientras

si encontrado
    "El elemento esta en el array"
sino
    "El elemento no esta en el array"
fin si
  
  Usamos una variable de tipo booleana <bool> para determinar si ya hemos encontrado el elemento que buscamos. Recorremos el array y comparamos cada elemento con el elemento buscado, si coinciden, actualizamos el valor de <encontrado> para que termine el bucle. Así una vez encuentra el elemento, no sigue recorriendo el array.
  El bucle puede terminar por dos razones: por haber llegado al final del arreglo, lo que podemos traducir como (i == n) siendo <n> el tamaño del array o porque la variable <encontrado> vale <true>. Entonces cuando termina el bucle, comprobamos si la variable <encontrado> vale <true>, si es así es que el elemento existe, sino es que ha terminado el bucle por la otra condición y entonces no existe el elemento.
  
  Te dejo que conviertas ese pseudocódigo a C++ para que practiques y cualquier duda, puedes comentarla aquí.
  Suerte