Mensajes

Saca el disco duro y déjalo unas 3 horas o toda la noche en un congelador... luego instala y recupera tu información...

Parece algo extraño o extremo, pero con frecuencia funciona...

Suerte.

Cierto, yo usé este método y me ayudó a recuperar datos de un disco medio muerto. Lo dicho ese disco ya sólo queda recuperar lo que se pueda y comprar otro. Un saludo.

Los últimos Total War en ocasiones presentan un problema de que puede llegar a sobrecalentar la gráfica (a mi me ocurría). En mi caso, también se notaba que el ventilador de la gráfica se ponía a toda potencia, cosa que no era normal.

La solución que encontré fue limitar los FPS a 30 con el Rivatuner Statistics Server. Esto unido a una buena configuración del ventilador con el MSI Afterburner consiguió que se solucionara. También es buena idea el activar el Vsync en los juegos.

Un saludo.

[palo selfie]

Y ojo, no nos olvidemos tampoco del invento ese del "palo selfie", es un invento digno de mencionar en la evolución del ser humano.

Lo del palo selfie merece un estudio aparte jajaja, al principio me acuerdo que lo usaban los japos, pero ahora empiezas a verlos bastante... yo paso de ir cargando con un palo de esos.

Respecto a las redes sociales, pienso como tú, es ridículo ver el uso que le da la mayoría y el cómo la gente va medio zombie por la vida, no puedes en ocasiones manterner conversaciones medio normales con gente que sólo habla de fulanito en facebook esto y pendientes continuamente de WhatsApp también, además normalmente chorradas de grupos.

Un saludo.

Hola a todos!!

Soy nuevo en estos lares escribiendo, aunque la verdad es que aprendí mucho leyendo otros post y demás.
Tengo un problema, no soy capaz de solventar una función de una práctica de Programación y Estructuras de Datos.

La función debe añadirse a la parte pública de TAVLCalendario y es:

TVectorCalendario* VectorLista(const TListaCalendario &)

La función en particular debe devolver un vector de TVectorCalendario del mismo tamaño que una lista que se le pasa como parámetro. La lista es recorrida de izquierda a derecha, siendo el primer elemento i=0, luego i=1...

Para cada TCalendario de la lista de entrada, se busca en el AVL y se escribe en la posición correspondiente del vector v, el TVectorCalendario que contiene el camino desde la raíz hasta dicho TCalendario (de no existir el TCalendario en el AVL se devolverá un TVectorCalendario vacío).

Adicional: Si el árbol está vacío se devuelve un vector del mismo tamaño que la lista con todos sus TVectorCalendarios vacíos. Si la lista está vacía se devolverá un vector apuntando a NULL.

Adjunto una imagen de lo que se pide:



Voy a ver si puedo agregar las funciones que tengo de las distintas partes. Sobretodo me hago un lío porque el tipo de la función es puntero de TVectorCalendario, y eso me dificulta mucho o algo se me escapa... Llevo mucho trabajando en esto y sólo me queda esta función para terminar, así que una ayuda me vendría genial. Muchas gracias de antemano ^^!!!

tavlcalendario.h
======================================

Código [Seleccionar] Expandir

#ifndef __TAVLCALENDARIO__
#define __TAVLCALENDARIO__

#include "tcalendario.h"
#include "tvectorcalendario.h"
#include "tlistacalendario.h"

class TAVLCalendario;
class TNodoAVL;

class TAVLCalendario {

friend class TNodoAVL;
friend ostream & operator<<(ostream &, const TAVLCalendario &);

public:
TAVLCalendario ();
TAVLCalendario (const TAVLCalendario &);
~TAVLCalendario ();
TAVLCalendario & operator=(const TAVLCalendario &);

bool operator==(const TAVLCalendario &);
bool operator!=(const TAVLCalendario &);
bool EsVacio();
bool Insertar(const TCalendario &);
bool Buscar(const TCalendario &);
int Altura();
int Nodos();
int NodosHoja();
TVectorCalendario Inorden();
TVectorCalendario Preorden();
TVectorCalendario Postorden();
bool Borrar(const TCalendario &);
TVectorCalendario Niveles();
TCalendario Raiz();
int ActualizarFe();
void EscogerRotacionIns();
void EscogerRotacionBor();
void RotacionII();
void RotacionDD();
void RotacionID();
void RotacionDI();
TVectorCalendario* VectorLista(const TListaCalendario &);

private:
TNodoAVL *raiz;
void InordenAux(TVectorCalendario &, int &);
void PreordenAux(TVectorCalendario &, int &);
void PostordenAux(TVectorCalendario &, int &);
};

class TNodoAVL {

friend class TAVLCalendario;

public:
TNodoAVL ();
TNodoAVL (const TNodoAVL &);
~TNodoAVL ();
TNodoAVL & operator=(const TNodoAVL &);

private:
TCalendario item;
TAVLCalendario iz, de;
int fe;
};


tcalendario.h
======================

Código [Seleccionar] Expandir

#ifndef __TCALENDARIO__
#define __TCALENDARIO__

#include <iostream>
#include <string.h>

using namespace std;

/*! \brief Clase TCalendario.
*
* Clase que incluye todos los metodos y atributos de TCalendario utilizados para crear un calendario
* y así poder trabajar con él.
*/
class TCalendario
{
//!FUNCIONES AMIGAS
/*! Sobrecarga del operador salida y declaracion de amistas de esta.
  * \param os salida del calendario.
  * \param calen calendario a mostrar
  * \return devuelve la salida.
  */
friend ostream& operator<<(ostream &,const TCalendario &);

//! FORMA CANÓNICA
public:
//!Constructor por defecto de TCalendario
TCalendario ();
/*! Constructor que inicializa un calendario con parametros pasados
* \param dia dia de la fecha
* \param mes mes de la fecha
* \param anyo año de la fecha
* \param mens cadena con el texto de la fecha
*/
TCalendario (int dia,int mes,int anyo,char *mens);
/*! Constructor copia de TCalendario
* \param calen calendario a copiar
*/
TCalendario (const TCalendario &);
//! Destructor de TCalendario
~TCalendario ();
/*! Sobrecarga del operador asignacion
* \param calen calendario a copiar
* \return calendario copiado
*/
TCalendario& operator= (const TCalendario &);

//!MÉTODOS
/*! Sobrecarga del operador suma.
* \param dia el dia de la fecha que sumamos al dia actual.
* \return devolvemos un calendario válido con la fecha nueva.
*/
TCalendario operator+ (const int);
/*! Sobrecarga del operador resta.
* \param dia el dia de la fecha que restamos al dia actual.
* \return devolvemos un calendario válido con la fecha nueva.
*/
TCalendario operator- (const int);
/*! Sobrecarga del operador incremento (postincremento)
* \param a entero para diferenciar postincremento de preincremento
  * \return devolvemos un calendario válido con la fecha nueva
*/
TCalendario operator++ (int);
/*! Sobrecarga del operador incremento (preincremento)
* \return devolvemos un calendario válido con la fecha nueva
*/
TCalendario& operator++ ();
/*! Sobrecarga del operador decremento (posdecremento)
* \param a entero para diferenciar posdecremento de predecremento
  * \return devolvemos un calendario válido con la fecha nueva
*/
TCalendario operator-- (int);
/*! Sobrecarga del operador decremento (predecremento)
* \return devolvemos un calendario válido con la fecha nueva
*/
TCalendario& operator-- ();
/*! Método que modifica el mensaje de la fecha actual.
* \param dia el nuevo dia de la fecha.
* \param mes el nuevo mes de la fecha.
* \param anyo el el nuevo año de la fecha.
* \return devolvemos TRUE si no modificamos la fecha, y FALSE en caso contrario.
*/
bool ModFecha (int,int,int);
/*! Método que modifica el mensaje del calendario actual.
* \param char mensaje nuevo.
*/
void ModMensaje (char *);
/*! Sobrecarga del operador igualdad.
* \param calen el calendario que comparamos con el actual.
* \return devuelve TRUE si son calendarios idénticos, y FALSE en caso contrario.
*/
bool operator== (const TCalendario &);
/*! Sobrecarga del operador desigualdad.
* \param calen el calendario que comparamos con el actual.
* \return devuelve TRUE si son calendarios distintos, y FALSE en caso contrario.
*/
bool operator!= (const TCalendario &);
/*! Sobrecarga del operador mayor.
* \param calen el calendario que comparamos con el actual.
* \return devuelve TRUE si el calendario actual es mayor que el que le pasas, y FALSE en caso contrario.
*/
bool operator> (const TCalendario &);
/*! Sobrecarga del operador menos.
* \param calen el calendario que comparamos con el actual.
* \return devuelve TRUE si el calendario actual es menor que el que le pasas, y FALSE en caso contrario.
*/
bool operator< (const TCalendario &);
/*! Método que devuelve TRUE si el calendario esta vacío, y FALSE en caso contrario.
* \return vacio según el contenido del calendario
*/
bool EsVacio ();
/*! Método que devuelve el dia del calendario.
* \return dia
*/
int Dia () const;
/*! Método que devuelve el mes del calendario
* \return mes
*/
int Mes () const;
/*! Método que devuelve el año del calendario
* \return anyo
*/
int Anyo () const;
/*! Método que devuelve el mensaje del calendario
* \return mens
*/
char * Mensaje ();
/*! Método que devuelve TRUE si el año es bisiesto, y FALSE en caso contrario.
* \param calen el calen del que queremos saber si es bisiesto o no
* \return bool según sea bisiesto o no
*/
bool Bisiesto(TCalendario);
/*! Metodo que devuelve TRUE si la fecha es correcta (incluyendo que sea mayor a 1/1/1900), y FALSE en caso contrario.
* \param calen el calen del que queremos conocer su validez
* \return novalido si el calendario cumple los requisitos o no
*/
bool ValidarFecha(const TCalendario);


//!PARTE PRIVADA
private:
//! Atributo de tipo entero que contiene el dia de una fecha.
int dia;
//! Atributo de tipo entero que contiene el mes de una fecha.
int mes;
//! Atributo de tipo entero que contiene el año de una fecha.
int anyo;
//! Atributo de tipo puntero char que apunta al mensaje del calendario.
char *mens;
};

#endif


tlistacalendario.h
=========================

Código [Seleccionar] Expandir

#include "tcalendario.h"

#ifndef __TLISTACALENDARIO__
#define __TLISTACALENDARIO__

class TListaCalendario;
class TListaPos;

/*! \brief Clase TNodoCalendario.
*
* Clase que incluye todos los metodos y atributos de TNodoCalendario utilizados para crear un nodo con un calendario
* y así trabajar con él.
*/

class TNodoCalendario
{
//! FUNCIONES AMIGAS
/*! Sobrecarga del operador salida y declaracion de amistas de esta.
  * \param los salida de la lista.
  * \param lista lista a mostrar
  * \return devuelve la salida.
  */
friend ostream& operator<<(ostream &, const TListaCalendario &);
//! Declaración de funcion amiga TListaCalendario
friend class TListaCalendario;
//! Declaración de funcion amiga TListaPos
friend class TListaPos;

//! FORMA CANÓNICA
public:
//! Constructor por defecto de TNodoCalendario.
TNodoCalendario();
/*! Constructor de copia de TNodoCalendario.
* \param nodo nodo a copiar
*/
TNodoCalendario(const TNodoCalendario &);
//! Destructor de TNodoCalendario.
~TNodoCalendario();
/*! Sobrecarga del operador asignación.
* \param nodo nodo a copiar
* \return nodo copiado
*/
TNodoCalendario & operator=(const TNodoCalendario &);

//! PARTE PRIVADA
private:
//! Atributo de TCalendario que almacena la información del nodo.
TCalendario c;
//! Atributo de tipo puntero a TNodoCalendario que apunta al siguiente nodo.
TNodoCalendario *siguiente;
};

/*! \brief Clase TListaCalendario.
*
* Clase que incluye todos los metodos y atributos de TListaCalendario utilizados para crear una lista formada por
* calendarios y así poder trabajar con ella.
*/

class TListaCalendario
{
//! FUNCIONES AMIGAS
/*! Sobrecarga del operador salida y declaracion de amistas de esta.
  * \param los salida de la lista.
  * \param lista lista a mostrar
  * \return devuelve la salida.
  */
friend ostream& operator<<(ostream &, const TListaCalendario &);
//! Declaración de funcion amiga TListaPos
friend class TListaPos;
//! Declaración de funcion amiga TNodoCalendario
friend class TNodoCalendario;

//! FORMA CANÓNICA
public:
//! Constructor por defecto de TListaCalendario.
TListaCalendario();
/*! Constructor de copia de TListaCalendario.
* \param lista lista a copiar
*/
TListaCalendario(const TListaCalendario &);
//! Destructor de TListaCalendario.
~TListaCalendario();
/*! Sobrecarga del operador asignación.
* \param lista lista a copiar
* \return lista copiada
*/
TListaCalendario & operator=(const TListaCalendario &);

//! -Métodos-

/*! Sobrecarga del operador igualdad.
* \param lista la lista que comparamos con la actual.
* \return devuelve TRUE si son listas identicas, y FALSE si no.
*/
bool operator==(const TListaCalendario &);
/*! Sobrecarga del operador suma, une los elementos únicos de la segunda lista en la primera.
*  \param lista la lista que queremos sumar a la actual.
*  \return la lista resultante de la unión de los elementos de la lista actual y la pasada por parámetro.
*/
TListaCalendario operator+(const TListaCalendario &);
/*! Sobrecarga del operador resta, excluye de la primera lista los elementos de la segunda.
* \param lista la lista que queremos restar a la actual.
* \return la lista resultante de la exclusión de los elementos de la lista pasada por parámetro en la actual.
*/
TListaCalendario operator-(const TListaCalendario &);
/*! Método que inserta de forma ordenada un calendario en la posición que le corresponde en la lista.
* \param calen el calendario que se pretende incluir en la lista.
* \return devuelve TRUE si se inserta el calendario, y FALSE en caso contrario.
*/
bool Insertar(const TCalendario &);
/*! Método que busca y borra un calendario que le pasas por parámetro.
* \param calen calendario que pretendemos buscar y borrar.
* \return devuelve TRUE si se ha borrado el calendario, y FALSE en caso contrario.
*/
bool Borrar(const TCalendario &);
/*! Método que borra un calendario desde una posición pasada por parámetro.
* \param ptE posición que queremos borrar de la lista.
* \return devuelve TRUE si se ha borrado el calendario, y FALSE en caso contrario.
*/
bool Borrar(const TListaPos &);
/*! Método que borra todos los calendarios anteriores a la fecha dada por parámetro.
* \param dia el dia de la fecha hasta la que queremos borrar.
* \param mes el mes de la fecha hasta la que queremos borrar.
* \param anyo el año de la fecha hasta la que queremos borrar.
* \return devuelve  TRUE si se ha borrado algún calendario de la lista, y FALSE en caso contrario.
*/
bool Borrar(int, int, int);
/*! Método que devuelve TRUE si la lista está vTNodoCalendarioacia, y FALSE en caso contrario.
* \return indica si hay contenido o no
*/
bool EsVacia();
/*! Método que devuelve el calendario de una posición dada.
* \param ptE posición de la que queremos obtener un calendario.
* \return devuelve el calendario que ocupa la posición pasada por parámetro.
*/
TCalendario Obtener(const TListaPos &);
/*! Método que indica si un calendario está en la lista.
* \param calen calendario que queremos buscar en la lista.
* \return devuelve TRUE si el calendario está en la lista, y FALSE en caso contrario.
*/
bool Buscar(const TCalendario &);
/*! Método que devuelve la longitud de la lista.
* \return entero con la longitud.
*/
int Longitud();
/*! Método que devuelve la primera posición de la lista.
* \return devuelve la primera posicion.
*/
TListaPos Primera();
/*! Método que devuelve la última posición de la lista.
* \return devuelve la ultima posicion.
*/
TListaPos Ultima();
/*! Método que suma los elementos de dos listas indicados en un rango determinado para cada una de ellas.
* \param I_L1 entero que indica desde que posición de la lista actual sumar (incluido).
* \param F_L1 entero que indica hasta que posición de la lista actual sumar (incluido).
* \param L2 la lista pasada por parametro que sumamos a la actual.
* \param I_L2 entero que indica desde que posición de la lista pasada por parámetro sumar (incluido).
* \param F_L2 entero que indica hasta que posición de la lista pasada por parámetro sumar (incluido).
* \return devuelve una tercera lista formada por los rangos de las listas anteriores.
*/
TListaCalendario SumarSubl(int, int, const TListaCalendario &, int, int);
/*! Método que extrae de la lista los elementos contenidos en un rango, con los que crear una nueva lista.
* \param n1 entero que indica desde que posición de la lista extraer los calendarios (incluido).
* \param n2 entero que indica hasta que posición de la lista extraer los calendarios (incluido).
* \return devuelve una nueva lista con los elementos extraidos de la lista actual.
*/
TListaCalendario ExtraerRango (int, int);

private:
//! Atributo de tipo puntero de TNodoCalendario, que apunta al primer nodo de la lista.
TNodoCalendario *primero;
};

class TListaPos
{
//! FUNCIONES AMIGAS
/*! Sobrecarga del operador salida y declaracion de amistas de esta.
  * \param los salida de la lista.
  * \param lista lista a mostrar
  * \return devuelve la salida.
  */
friend ostream& operator<<(ostream &, const TListaCalendario &);
//! Declaración de funcion amiga TNodoCalendario
friend class TNodoCalendario;
//! Declaración de funcion amiga TListaCalendario
friend class TListaCalendario;

//! FORMA CANÓNICA
public:
//! Constructor por defecto de TListaPos.
TListaPos();
/*! Constructor de copia de TListaPos.
* \param ptE posicion a copiar
*/
TListaPos(const TListaPos &);
//! Destructor de TListaPos.
~TListaPos();
/*! Sobrecarga del operador asignación.
* \param ptE posicion a copiar
* \return posicion copiada
*/
TListaPos & operator=(const TListaPos &);

//! -Métodos-

/*! Sobrecarga del operador igualdad.
* \param ptE posición que comparamos con la actual.
* \return devuelve TRUE si son identicas, y FALSE en caso contrario.
*/
bool operator==(const TListaPos &);
/*! Sobrecarga del operador desigualdad.
* \param ptE posición que compraramos con la actual.
* \return devuelve TRUE si son diferentes, y FALSE en caso contrario.
*/
bool operator!=(const TListaPos &);
/*! Método que devuelve la posición siguiente a la actual.
* \return posicion siguiente.
*/
TListaPos Siguiente();
/*! Método que devuelve TRUE si la posición no apunta a un elemento de la lista, y FALSE en caso contrario.
* \return vacio según el contenido.
*/
bool EsVacia();

private:
//! Atributo de tipo puntero de TNodoCalendario, que apunta al primer nodo de la lista.
TNodoCalendario *pos;
};

#endif


tvectorcalendario.h
==============================

Código [Seleccionar] Expandir

#include "tcalendario.h"

#ifndef __TVECTORCALENDARIO__
#define __TVECTORCALENDARIO__

/*! \brief Clase TNodoCalendario.
*
* Clase que incluye todos los metodos y atributos de TVectorCalendario utilizados para crear un vector de
* calendarios y así poder trabajar con él.
*/

class TVectorCalendario
{
//! FUNCIONES AMIGAS
/*! Sobrecarga del operador salida y declaracion de amistas de esta.
  * \param vos salida del vector.
  * \param vcalen vector a mostrar
  * \return devuelve la salida.
  */
friend ostream& operator<<(ostream &, const TVectorCalendario &);

//! FORMA CANÓNICA
public:
//! Constructor por defecto de TVectorCalendario.
TVectorCalendario();
/*! Constructor de TVectorCalendario con el tamaño pasado por parámetro.
* \param dim entero del vector
*/
TVectorCalendario(int);
/*! Constructor de copia de TVectorCalendario.
* \param vector vector a copiar
*/
TVectorCalendario(const TVectorCalendario &);
//! Destructor de TVectorCalendario.
~TVectorCalendario();
/*! Sobrecarga del operador asignación.
* \param vector vector a copiar
* \return vector copiado
*/
TVectorCalendario & operator=(const TVectorCalendario &);

//! -Métodos-
/*! Sobrecarga del operador igualdad.
* \param vec vector que comparamos con la actual.
* \return devuelve TRUE si los vectores son identicos, y FALSE si no.
*/
bool operator==(const TVectorCalendario &);
/*! Sobrecarga del operador desigualdad.
* \param vec vector que comparamos con la actual.
* \return devuelve TRUE si los vectores son distintos, y FALSE en caso contrario.
*/
bool operator!=(const TVectorCalendario &);
/*! Sobrecarga del operador corchete (parte izquierda).
* \param pos identifica la parte izquierda de la derecha
* \return calendario de la posicion en el vector
*/
TCalendario & operator[](int);
/*! Sobrecarga del operador corchete (parte derecha).
* \param pos identifica la parte derecha de la izquierda
* \return calendario de la posicion en el vector
*/
TCalendario operator[](int) const;
/*! Método que devuelve el tamaño del vector.
* \return entero con el tamaño.
*/
int Tamano() const;
/*! Método que devuelve la cantidad de posiciones no vacias del vector
* \return entero con el numero de posiciones ocupadas.
*/
int Ocupadas() const;
/*! Método que devuelve TRUE si existe el calendario pasado por parametro.
* \param calen calendario que queremos buscar en el vector.
* \return devuelve TRUE si existe el calendario en el vector, y FALSE en caso contrario.
*/
bool ExisteCal(const TCalendario &);
/*!Método que muestra por pantalla los calendarios del vector, a partir de la fecha dada.
* \param dia el dia de la fecha que buscamos en el vector.
* \param mes el mes de la fecha que buscamos en el vector.
* \param anyo el año de la fecha que buscamos en el vector.
*/
void MostrarMensajes(int,int,int);
/*! Método que modifica el tamaño del vector al entero pasado por parámetro
* \param tam entero con el que indicamos que tamaño queremos que tenga en vector.
* \return devuelve TRUE si se ha cambiado el tamaño del vector, y FALSE en caso contrario.
*/
bool Redimensionar(int);

//PARTE PRIVADA
private:
//! Atributo de tipo puntero TCalendario, que apunta a un calendario del vector.
TCalendario *c;
//! Atriubuto de tipo TCalendario utilizado cuando hay que devolver algo en caso de error.
TCalendario error;
//! Atributo de tipo entero que indica el tamaño del vector.
int tamano;
};

#endif



Repito, muchísimas gtracias, quería poner el código en spoilers, pero no me deja con el clásico [spoiler][/spoiler], como se hace aquí?? Un saludo!!