Esta sección te permite ver todos los mensajes escritos por este usuario. Ten en cuenta que sólo puedes ver los mensajes escritos en zonas a las que tienes acceso en este momento.
#include "tiempo.h"
#include <iostream>
using namespace std;
Tiempo definir(int seg){
int h=seg/3600;
int minutos=seg%3600;
int segundos=(seg%3600)%60;
Tiempo t={h,minutos,segundos};
return t;
}
/*
* Pre: seg >= 0, mil_seg >= 0 y mil_seg <= 999
* Post: Devuelve una medida de tiempo de seg segundos y mil_seg milesimas
* de segundo
*/
Tiempo definir(int seg, int mil_seg){
int h=seg/3600;
int min=seg%3600;
int segundos=(seg%3600)%60;
int milesimas= mil_seg;
Tiempo t={h,min,segundos,milesimas};
return t;
}
/****************************************************************************
* Funciones para conocer la descomposición de un dato de tipo Tiempo
* en horas, minutos, segundos y milésimas de segundo
****************************************************************************/
/*
* Pre: t define una medida de tiempo no negativa con precisión de una milésima
* de segundo.
* Podemos imaginar a t equivalente a <h:m:s:mil>, donde h son horas (igual
* o mayor que 0), m son minutos (entre 0 y 59), s son segundos (entre 0 y
* 59) y mil son milésimas de segundo (entre 0 y 999)
* Post: Devuelve el número de horas h de la medida de tiempo t
*/
int hora (Tiempo t){
return t.horas;
}
/*
* Pre: t define una medida de tiempo no negativa con precisión de una milésima
* de segundo.
* Podemos imaginar a t equivalente a <h:m:s:mil>, donde h son horas (igual
* o mayor que 0), m son minutos (entre 0 y 59), s son segundos (entre 0 y
* 59) y mil son milésimas de segundo (entre 0 y 999)
* Post: Devuelve el número de minutos m de la medida de tiempo t
*/
int minuto (Tiempo t){
return t.minutos;
}
/*
* Pre: t define una medida de tiempo no negativa con precisión de una milésima
* de segundo.
* Podemos imaginar a t equivalente a <h:m:s:mil>, donde h son horas (igual
* o mayor que 0), m son minutos (entre 0 y 59), s son segundos (entre 0 y
* 59) y mil son milésimas de segundo (entre 0 y 999)
* Post: Devuelve el número de segundos s de la medida de tiempo t
*/
int segundo (Tiempo t){
return t.seg;
}
/*
* Pre: t define una medida de tiempo no negativa con precisión de una milésima
* de segundo.
* Podemos imaginar a t equivalente a <h:m:s:mil>, donde h son horas (igual
* o mayor que 0), m son minutos (entre 0 y 59), s son segundos (entre 0 y
* 59) y mil son milésimas de segundo (entre 0 y 999)
* Post: Devuelve el número de milésimas de segundos mil de la medida de tiempo t
*/
int milesima (Tiempo t){
return t.mil_seg;
}
/****************************************************************************
* Funciones para comparar dos datos de tipo Tiempo
****************************************************************************/
/*
* Pre: t1 y t2 definen dos medidas de tiempo con precisión de una milésima
* de segundo, iguales o superiores a 0 milésimas de segundo
* Post: Devuelve true si y sólo si el tiempo t1 es más corto que el tiempo t2
*/
bool esMenor (Tiempo t1, Tiempo t2){
if(t1.horas<t2.horas){
return t1.horas<t2.horas;
}
else if(t1.horas==t2.horas && t1.minutos<t2.minutos){
return t1.minutos<t2.minutos;
}
else if(t1.minutos<t2.minutos && t1.seg<t2.seg){
return t1.seg<t2.seg;
}
else if(t1.segundos==t2.segundos && t1.mil_seg<t2.mil_seg){
return t1.mil_seg<t2.mil_seg;
}
else{
return false;
}
}
/*
* Pre: t1 y t2 definen dos medidas de tiempo con precisión de una milésima
* de segundo, iguales o superiores a 0 milésimas de segundo
* Post: Devuelve true si y sólo si el tiempo t1 es más largo que el tiempo t2
*/
bool esMayor (Tiempo t1, Tiempo t2){
if(t1.horas>t2.horas){
return t1.horas>t2.horas;
}
else if(t1.horas==t2.horas && t1.minutos>t2.minutos){
return t1.minutos>t2.minutos;
}
else if(t1.minutos>t2.minutos && t1.seg>t2.seg){
return t1.seg>t2.seg;
}
else if(t1.segundos==t2.segundos && t1.mil_seg>t2.mil_seg){
return t1.mil_seg>t2.mil_seg;
}
else{
return false;
}
}
/*
* Pre: t1 y t2 definen dos medidas de tiempo con precisión de una milésima
* de segundo, iguales o superiores a 0 milésimas de segundo
* Post: Devuelve true si y sólo el valor del tiempo t1 es igual al del
* tiempo t2
*/
bool sonIguales (Tiempo t1, Tiempo t2){
if(t1.horas==t2.horas && t1.minutos==t2.minutos && t1.seg==t2.seg && t1.mil_seg==t2.mil_seg){
return t1.horas==t2.horas;
}
else{
return false;
}
}
/****************************************************************************
* Funciones para operar aritméticamente con un par de datos de tipo Tiempo
****************************************************************************/
/*
* Pre: t1 y t2 definen dos medidas de tiempo con precisión de una milésima
* de segundo, iguales o superiores a 0 milésimas de segundo.
* Post: Devuelve un tiempo igual a la suma de los tiempos t1 y t2
*/
Tiempo sumar (Tiempo t1, Tiempo t2){
t1=t1.horas*3600+t1.minutos*60+t1.seg+(double)t1.mil_seg/1000;
t2=t2.horas*3600+t2.minutos*60+t2.seg+(double)t2.mil_seg/1000;
return t1+t2;
}
/*
* Pre: t1 y t2 definen dos medidas de tiempo con precisión de una milésima
* de segundo, iguales o superiores a 0 milésimas de segundo. El valor
* de t1 es igual o superior al de t2.
* Post: Devuelve un tiempo igual a la diferencia del tiempo t1 menos el
* tiempo t2
*/
Tiempo restar (Tiempo t1, Tiempo t2){
t1=t1.horas*3600+t1.minutos*60+t1.seg+(double)t1.mil_seg/1000;
t2=t2.horas*3600+t2.minutos*60+t2.seg+(double)t2.mil_seg/1000;
return t1-t2;
}
#include <iostream>
#include <iomanip>
#include "../ModTiempo/tiempo.h"
using namespace std;
/*
* Pre: n >= 0 y T[0,n-1] almacena los valores de n medidas de tiempo.
* Post: Los valores de T[0,n-1] han sido permutados de forma que ahora
* se encuentran ordenados según medidas de tiempo de duración
* igual o creciente. Es decir, el tiempo T[0] es igual o menor
* que el tiempo T[1], ..., y el tiempo T[n-2] es menor o igual
* que el tiempo T[n-1]
*/
void ordenar(Tiempo T[], const int n){
for(int i=0;i<n;i++){
int menor=i;
for(int j=i+1;j<n;j++){
if(esMenor(T[j],T[menor])){
menor=j;
}
}
Tiempo aux=T[i];
T[i]=T[menor];T[menor]=aux;
}
}
/*
* Pre: El tiempo t es inferior a 100 horas
* Post: Escribe por pantalla una secuencia de 12 caracteres (y sin
* acabar la línea) en la que presenta el tiempo definido por t
* con el siguiente formato:
* hh:mm:ss,mmm
* Un ejemplo:
* 07:30:00,055
*/
void mostrar (const Tiempo t){
if(hora(t)>=0 && hora(t)<=100){
cout<<setw(2)<<hora(t)<< ':'<<setw(2)<<setfill('0')<<minuto(t)<<':'<<setw(2)<<setfill('0')<<segundo(t)<<','<<setw(3)<<setfill('0')<<milesima(t);
}
}
/*
* Pre: Los tiempos almacenados en T[0,n-1] son inferiores a 100 horas
* Post: Escribe por pantalla n líneas en las que presenta los valores de
* los tiempos almacenados en T[0,n-1] con el siguiente formato
* (cadauno de los tiempos ocupa 12 caracteres):
* 01. 03:12:00,500
* 02. 12:45;30,000
* 03. 00:01:00,450
* ....
*/
void mostrar (const Tiempo T[], const int n){
{
if(hora(t)>=0 && hora(t)<=100){
for(int i=0;i<n;i++){
cout<<setw(2)<<hora(t)<< ':'<<setw(2)<<setfill('0')<<minuto(t)<<':'<<setw(2)<<setfill('0')<<segundo(t)<<','<<setw(3)<<setfill('0')<<milesima(t);
}
}
}