Tag Archives: operadores

Convertir segundos a horas, minutos y segundos

Como les prometí en el post anterior, en este post vamos a hablar sobre un programa que usa los operadores compuestos de manera muy útil: convierte los segundos en horas minutos y segundos.

El programa es este:

#include 
using namespace std;

int main()
{
    int sec, hr, min;
    cout <> sec;
    cout << sec << " segundos son ";
    hr = sec / (60*60);
    sec %= 60*60;
    min = sec / 60;
    sec %= 60;
    cout << hr << " horas " << min << " minutos y " << sec << " segundos" << endl;
}

Primero dividimos los segundos sec entre 60*60 (3600) para obtener los horas y lo guardamos en hr. Noten que la variable sec no cambia.

Luego obtenemos el residuo de dividir sec / 60*60 (es lo que el operador % hace) y lo guardamos en la misma variable. En este paso sí modificamos la variable sec, ahora contiene los segundos iniciales menos las horas que ya obtuvimos en el paso anterior.

Ahora dividimos nuevamente la variable sec / 60 para obtener los minutos y lo guardamos en hr. La variable sec no cambia.

Luego obtenemos el residuo de dividir sec / 60 (es lo que el operador % hace) y lo guardamos en la misma variable. En este paso sí modificamos la variable sec, ahora contiene los segundos iniciales menos las horas menos los minutos.

Ya sólo mostramos las tres variable y listo.

Ahora, si somos de los que nos preocupamos por el lenguaje, veremos que a veces hay errores de ortografía como “1 minutos”. Para solucionar eso sólo necesitamos unos cuantos ifs:

#include 
using namespace std;

int main()
{
    int sec, hr, min;
    cout <> sec;
    cout << sec << " segundos son ";
    hr = sec / (60*60);
    sec %= 60*60;
    min = sec / 60;
    sec %= 60;
    cout << hr << " hora";
    if(hr != 1) cout << "s";
    cout << " " << min << " minuto";
    if(min != 1) cout << "s";
    cout << " y " << sec << " segundo";
    if(sec != 1) cout << "s";
}
Advertisements

Operadores compuestos en C++

Los operadores (en cualquier lenguaje de programación) son los símbolos que permiten hacerle una operación a una o más variables. Los más conocidos son los operadores aritméticos:

  • + Suma
  • Resta
  • * Multiplicación
  • / División
  • % Módulo (residuo de la división)

Otros son los lógicos (&&, ||), los relacionales (<, >, !=, ==), etc. Pero en este post, como dice el título, vamos a ver los operadores compuestos en c++.

¿Cómo haríamos para sumarle a una variable int, por ejemplo, 3 unidades? Alguien que nunca hubiera programado escribiría algo así:
mivar + 3;
Sabemos que eso no es válido porque una suma retorna un valor (el resultado) y ese valor tiene que ser almacenado en una variable. En el código anterior ese valor no se almacena en ninguna variable, por lo tanto ERROR. Sabiendo esto último podemos escribir esto:
mivar = mivar + 3;
En la variable mivar, guardamos el contenido de esa misma variable más tres. Todo bien ¿no? eso es perfectamente válido y normal, sin embargo los operadores compuestos nos permiten hacer lo mismo con menos código:
mivar += 3;
Como ven está inspirado en hacer que ‘lo-primero-que-se-nos-ocurre’ sea posible.

Así tenemos que:

mivar = mivar + 3; es lo mismo que mivar += 3;
mivar = mivar - 3; es lo mismo que mivar -= 3;
mivar = mivar * 3; es lo mismo que mivar *= 3;
mivar = mivar / 3; es lo mismo que mivar /= 3;

Bueno, para ver un poco de la utilidad de estos operadores y haciéndole un favor a un tal Victor, vamos a ver un programa que imprima los múltiplos de un cierto número (introducido por el usuario) que haya desde 1 hasta otro cierto número (introducido por el usuario):

#include
using namespace std;
int main()
{
    int num, lims, m=0;
    cout <> num;
    cout <> lims;
    while(lims >= (m+=num))
    {
        cout << m << ", ";
    }
}

Primero pedimos el número del cual queremos obtener múltiplos (num), luego el límite superior (lims). m obtendrá el valor de los múltiplos y lo tenemos que igualar a 0 al inicio.

Luego tenemos un ciclo while. En español dice: “Me mantendré ejecutando mientras el lims sea mayor o igual a m más num“. Dentro del ciclo mostramos la variable m.

Si, por ejemplo, num = 3, entonces la instrucción n+=num se desarrolla así:
m = 0;
m+=num; -----> m= m + num; -----> m = 0 + 3; -----> m = 3;
m+=num; -----> m= m + num; -----> m = 3 + 3; -----> m = 6;
m+=num; -----> m= m + num; -----> m = 6 + 3; -----> m = 9;
etc, etc.

Aquí podría poner un otro programa aún más útil para usar los operadores compuestos, pero mejor lo dejo para el siguiente post. Ah y si tú eres Victor, entonces tal vez te interese este post: Cómo contar el número de veces que sucede algo.

Operadores lógicos en C++

Con operadores de relación nos referimos a los ya conocidos:

  • < (menor que)
  • <= (menor o igual que)
  • > (mayor que)
  • >= (mayor o igual que)
  • == (igual)
  • != (diferente)

Bueno, talvéz los operadores de igual (==) y diferente (!=) no los hayan visto escritos así, pero en C++ así se representan.

Una expresión con operadores de relación (por ejemplo: a<b, a!=b) únicamente nos dice si la evaluación es verdadera (true) o falsa (false).

También están estos otros:

  • and, que significa ‘y’ y se representa con &&
  • or, que significa ‘o’ y se representa con || (alt+124 dos veces)

Sirven para relacionar dos o más operaciones lógicas. Al usar && (y), las dos operaciones tienen que ser verdaderas para que arroje un resultado verdadero, si no, es falso. Al usar || (o), las dos operaciones tienen que ser falsas para que arroje un resultado falso, si no, es verdadero.

Ejemplos

Si a=4 y b=5 entonces,

  • a==b es false
  • a>b es false
  • a!=b es true
  • a==b && a<b es false
  • a==b || a<b es true

Operaciones en C++

Bien, ya sabemos declarar y mostrar variables, ahora solo falta saber cómo hacer operaciones matemáticas con ellas. Una suma sería así:

#include
#include
int main()
{
  int num1=5, num2=10, resultado=0;
  resultado=num1+num2;
  printf("El resultado es: %i", resultado);
  //Esto mostrará en pantalla: El resultado es: 15
  getch();
}

Como ven, siempre hay que tener una variable para guardar el resultado de cualquier operación. En algunos casos se puede usar la misma variable:

#include
#include
int main()
{
  int num1=5;
  num1=num1+6;
  printf("El resultado es: %i", num1);
  //Esto mostrará en pantalla: El resultado es: 11
  getch();
}

Entonces, los signos de operación en C++ y la mayoría de los lenguajes de programación son:

  • + para suma
  • – para resta
  • * para multiplicación
  • / para división
  • () también indican multiplicación