You don't have access to this class

Keep learning! Join and start boosting your career

Aprovecha el precio especial y haz tu profesión a prueba de IA

Antes: $249

Currency
$209
Suscríbete

Termina en:

0 Días
1 Hrs
21 Min
29 Seg

Reto 8: algoritmos con funciones

16/17
Resources

To understand a little more about the use of functions, let's solve the following problems, this way you will identify how to use them.

Algorithm of a clock using functions

You will remember the algorithm of a clock that you made, there were steps in the flowchart that were repeated. Let's use functions to encapsulate that logic and reuse it as appropriate.

First, we set the initial variables for hours, minutes, and seconds to a value equal to zero. These variables followed a set format to display as time.

H = 0M = 0S = 0Format = 00:00:00

Next, we validated when the variable hours and minutes was equal to 60; and the variable hours was equal to 24.

If S == 60 then S = 0If M == 60 then M = 0If H == 24 then H = 0

This behavior follows a pattern, we validate that a variable type is below a limit. Then, let's encapsulate this logic in a function to only invoke it when necessary.

Let's represent as parameters the variables with the type name and the maximum value as limit. Inside the function we will use a conditional to check if type is equal to limit, if this is true, then we return a value of zero, otherwise, we return the same value of type.

function validate (type, limit) if (type == limit) return 0 else return type

In this way, we can now use it in our algorithm:

S = validate(S, 60) M = validate(M, 60) H = validate(H, 24).

Challenge using cycles

Using cycles, represent the statements that are necessary to be repeated in order to increase by one unit the variables according to the flowchart. Share your work in the contributions section!

Contribution created by Andrés Guano (Platzi Contributor).

Contributions 175

Questions 13

Sort by:

Want to see more contributions, questions and answers from the community?

tipos = [h, m, s];
limite = [60, 60, 24];

function validar(tipo, limite) {
	If(tipo == limite) {
		tipo = 0;
	}
}

for(i = 0; i < tipos.length; i++) {
	validar(tipos[i], limite[i])
}

Bueno estando finalizando el curso me di cuenta que muchos temas no me quedaron claros me toca buscar apoyo por otro lado y volver a mirar el curso para ver si logro despejar muchas dudas. Para muchos pueda que esto sea algo elemental pero para mí que estoy iniciando en este tema es un poco complejo entender muchos términos que no son aclarados desde el principio

seria mas facil el aprendizaje si las explicaciones fueran mas practicas :’)

Así lo hice yo en JS. Agradezco todo feedback que me den

const type = [h, m, s];
const limit = [60, 60, 24];

function inicializarContador(type, limit){
	If(type == limit) {
		type = 0;
	}
}

for(i = 0; i < type.length; i++) {
	//llamada a la función
	inicializarContador(type[i], limit[i]);
}

Esta clase me ayudo a mejorar mi cronometro. Siempre me impresiona como se pueden usar las funciones y lo complejo que es realmente entenderlas y usarlas bien. A veces siento que requieren una creatividad que simplemente no tengo pero espero que con el tiempo y con la experiencia vaya saliendo. Espero les sirva!

const limite = [60, 60, 24];
let tipo = [0, 0, 0], // segundos, minutos, horas
  txt0 = document.getElementById("txt");
setInterval(function () {
  tipo[0]++;
  validar(0);
  validar(1);
  validar(2);
  txt0.innerHTML = "La hora es: " + tipo[2] + ":" + tipo[1] + ":" + tipo[0];
}, 1000);
function validar(a) {
  if (tipo[a] == limite[a]) {
    tipo[a] = 0;
    tipo[a + 1]++;
  }
}

Cuidado al ejecutarlo, es un ciclo infinito y no tiene limpieza de memoria. También le hace falta que un segundo sea igual a un segundo, actualmente un segundo es igual a un calculo del procesador(super rapido).

var tipos = [0, 0, 0];
var limites = [59, 59, 23];

function reloj(){
    while(true){
        if(tipos[0] = limites[0]){
            tipos[0] = 0;
            if(tipos[0] < limites[0]){
                tipos[0]++;
            }
        };

        if(tipos[1] = limites[1]){
            tipos[1] = 0;
            if(tipos[0] = limites[0]){
                tipos[1]++;
            }
        };

        if(tipos[2] = limites[2]){
            tipos[2] = 0;
            if(tipos[1] = limites[0]){
                tipos[0]++;
            }
        };

        console.log(tipos[2]+":"+ tipos[1]+":"+tipos[0]);   
    };
};

reloj();

if (H<=23){
M=0 M++
}

siganle…
de nada.
😗

#teamplatzi por favor actualizar este curso a uno más practico

cuando inicié en Platzi fue con el curso de programación Basica, el reto era crear un juego que se pudiera jugar en diferentes dispositivos, era mi primer vista hacia la programación, sinceramente terminé y hubo muchisimas cosas que no comprendía del todo, pero seguí adelante y al tomar estos cursos, he comprendido mucho de lo que ya vi, algo que es importante es practicar, para hacer código se requiere practicar y se requiere cometer errores para comprender. así que si hay cosas que aun no se comprenden a estas alturas, no se preocupe, repita, busque por otros medios, lea los aportes y preguntas y poco a poco irá aprendiendo.
Por ahí dicen que nunca hay que parar de aprender.

Con el debido respeto, la teacher no deja claro con el algoritmo sobre la condicional o los tipos en esta clase, no logro comprender.

Hola, con respeto quiero dar una opinión, por si de pronto Platzi lee estos aportes: Me gustaría que platzi dejara las respuestas o soluciones a los ejercicios o retos que propone, para contar con un referente y saber si estamos comprendiendo lo que quieren con el ejercicio y sobre todo aprendiendo el tema.
Mi solución no va a funcionar como un reloj, pero aplico un ciclo e invoco la función para cada variable, que hasta ahora es lo que entiendo y no sé si del todo bien.
Gracias,

Variable s=0
              m=0
               h=0
function validar (tipo, limite) {
    if (tipo == limite) {
        return 0
    } else {
        return tipo
    }
}

for (var s = 0; s<=60; s= s+1) {
    var rta = validar(s, 60)

Mostrar conteo segundos;

for (var m = 0; m<=60; m=m+1) {
    var rta = validar(m, 60)

Mostrar conteo minutos;

for (var h = 0; h<=24; h=h+1) {
    var rta = validar(h, 24)

Mostrar conteo horas;

si encuentran algun error se los agradesco

h=0;
m=0;
s=0;

for(s;s<60;s++){
 if(s==60){
   m=m+1;
   s=0;
   if(m==60){
     h=h+1;
     m=0;
     if(h==24){
       h=0
     }
   }
 }
  console.log(s,m,h)
}
while(s<60){
  if(s==60){
    m=m+1;
    s=0;
    if(m==60){
      h=h+1;
      m=0;
      if(h==24){
        h=0;
      }
    }
  }
  s++
  console.log(s,m,h);
}

En mi aporte realice funciones que luego llame en el ciclo, que pueden ser reutilizadas. A la orden cualquier pregunta

¿QUE OPINAN DE ESTA FUNCION?

¿ES VALIDO Y FUNCIONAL ESTE RELOJ?

Mi pequeño aporte ¡Quizá te sirva de inspiración! 🙂


Aquí les dejo el código, como corresponde:


HTML

‎‎<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Clock</title>
    <link rel="stylesheet" href="styles.css">
</head>
<body>

    <div class="clock">
		<span id="hours">00</span> :
		<span id="minutes">00</span> :
		<span id="seconds">00</span>
	</div>

	<script src="script.js"></script>
</body>
</html>


CSS

body {
    background-color: #000000;;
}

.clock {
    font-family: 'Montserrat', sans-serif;
    font-size: 60px;
    text-align: center;
    color: #ffffff;
    background-color: #000000;
    padding: 50px;
    margin-top: 20%;
  }
  
  #hours, #minutes, #seconds {
    display: inline-block;
    width: 100px;
    height: 100px;
    border-radius: 50%;
    background-color: #00bfff;
    line-height: 100px;
    margin: 20px;
    text-shadow: 0 0 10px #fff;
    box-shadow: 0 0 20px rgba(0, 191, 255, 0.5);
  }
  
  #hours {
    background-color: #ff1493;
    box-shadow: 0 0 20px rgba(255, 20, 147, 0.5);
  }
  
  #minutes {
    background-color: #00ff7f;
    box-shadow: 0 0 20px rgba(0, 255, 127, 0.5);
  }
  
  #seconds {
    background-color: #ffd700;
    box-shadow: 0 0 20px rgba(255, 215, 0, 0.5);
  }
 

JavaScript

//Tempus fugit...

const h = document.getElementById("hours");
const m = document.getElementById("minutes");
const s = document.getElementById("seconds");

function update_display(value, element) {
    element.innerText = (value < 10 ? "0" : "") + value;
}

function increase_seconds() {
    let seconds = parseInt(s.innerText);
    switch (seconds) {
        case 59:
            update_display(0, s);
            increase_minutes();
            break;
        default:
            seconds++;
            update_display(seconds, s);
            break;
    }
}

function increase_minutes() {
    let minutes = parseInt(m.innerText);
    switch (minutes) {
        case 59:
            update_display(0, m);
            increase_hours();
            break;
        default:
            minutes++;
            update_display(minutes, m);
            break;
    }
}

function increase_hours() {
    let hours = parseInt(h.innerText);
    switch (hours) {
        case 23:
            update_display(0, h);
            break;
        default:
            hours++;
            update_display(hours, h);
            break;
    }
}

setInterval(increase_seconds, 1000);

//A script made by Nise and GPT-3.5
//2023 A.D
import time


seconds = 0
minutes = 0
hours = 0

    
def validate(type, limit):
    if type == limit - 1:
        type = 0
    else:
        type += 1
    return type
        

while True:
    seconds = validate(seconds, 60)
    if seconds == 0:
        minutes = validate(minutes, 60)
        if minutes == 0:
            hours = validate(hours, 24)
    print(f'{hours}:{minutes}:{seconds}')
    time.sleep(1)

Solo sé que nada sè -------------------------------

a veces siento que el lenguaje de la profe es muy complejo y me toca pausar la clase para procesar lo que dijo porq hay palabras que uno no está acostumbrado a escucharlas en el dia a dia y le cuesta comprender frases largas con ese tipo de palabras

Soy uno más que inicio el curso sin conocimientos en ningún lenguaje. Después de muchas horas mirando mensajes de compañeros, los recursos, repasando los ciclos (que fueron ejemplos muy pobres), revisando como incluir una función en un diagrama, o los ciclos…en fin varios huecos. Pero gracias a Dios me quedo más claro, aquí comparto el Reto8:

Buen dia

terrible esta explicacion, habla de muchass cosas a la vez, y deja en el aire los topicos, me estoy decepcionando
tipos = [h, m, s]
limite = [24, 60, 60]

def validar(tipos, limite):
	if tipos == limite:
		tipos = 0

for i in tipos:
	validar(tipos, limite)	
function validar(tipo,limite){
	if tipo==limite{
		return True
		} else return False
} // modificacion a validar para que el resultado sea bool
while(s<60){
	if validar(s,60){
		s=0
		m=m+1
		if validar(m,60){
			m=0
			h=h+1
			if validar(h,24){
				h=0,m=0,s=0}}}}

Aquí está un ejemplo de un algoritmo en pseudocódigo para simular un reloj utilizando funciones y ciclos:

Declare una función llamada "incrementarTiempo" que tome 3 valores: horas, minutos y segundos
  Si segundos < 59
    Incrementar segundos en 1
  De lo contrario
    Poner segundos a 0
    Si minutos < 59
      Incrementar minutos en 1
    De lo contrario
      Poner minutos a 0
      Si horas < 23
        Incrementar horas en 1
      De lo contrario
        Poner horas a 0
    Fin si
  Fin si
Fin de la función

Declare variables horas, minutos y segundos con valor 0

Hacer
  Escribir horas, ":", minutos, ":", segundos
  Llamar a la función incrementarTiempo con horas, minutos y segundos como argumentos
  Esperar 1 segundo
Hasta que el usuario interrumpa el programa

Este algoritmo declara una función llamada incrementarTiempo que recibe 3 valores: horas, minutos y segundos. La función incrementa el tiempo en un segundo. Si los segundos son menores que 59, simplemente los incrementa en 1. Si los segundos son 59 o más, los pone a 0 y procede de la misma manera con los minutos. Si los minutos son 59 o más, los pone a 0 y procede de la misma manera con las horas. Si las horas son 23 o más, las pone a 0.

Después de declarar la función, el algoritmo declara las variables horas, minutos y segundos con valor 0. Luego, utiliza un ciclo hacer… hasta para simular el funcionamiento de un reloj. Dentro del ciclo, imprime el tiempo actual y luego llama a la función incrementar Tiempo para actualizar el tiempo. Finalmente, el programa espera 1 segundo antes de repetir el proceso. Este ciclo se repetirá hasta que el usuario interrumpa el programa.

Hola compañeros, buen día!!

Así desarrollé yo el algoritmo. Me cuentan cómo les parece que quedó:

Yo lo haría así, hay que inicializar las variables.

var hora = 0;
var mins = 0;
var segs = 0;

var limites = [60,60,24];
var tipos =[segs,mins,hora];

function validar(tipo, limite){
	if(tipo == limite){
		tipo=0;
		console.log("Si es igual al limite");
	}
}

for(var i=0; tipos.length > i; i++){
	validar(tipos[i],limites[i]);
}


La muñeca del final me pegó un susto que hasta me hizo brincar!! jajaja
1\. Definir una función llamada mostrar Hora * Recibe tres parámetros: hora, minuto y segundo * Muestra la hora en formato HH: MM: SS 2\. Inicializar las variables * hora = 0, minuto = 0, segundo = 0 3\. Iniciar un ciclo de repetición mientras hora < 24 * Llamar a la función mostrar Hora (hora, minuto, segundo) * Esperar 1 segundo. * Actualizar los valores del reloj: * Si segundo es menor que 59, incrementarlo * Si segundo llega a 60, reiniciarlo a 0 y aumentar un minuto * Si minuto llega a 60, reiniciarlo a 0 y aumentar una hora * Si hora = 24, salir del ciclo Fin del programa

De la forma en entendi las condicionales y bucles espero estar bien si no! Por favor agradeceria sus correcciones.

Comparto el algoritmo del reloj con funciones en Python: ![](https://static.platzi.com/media/user_upload/image-56371680-4520-4c3d-85ea-e204eb31e455.jpg)
Está bien que se de a entender que aprender en platzi es ser autodidacta en un 80%-90% y que la comunidad se ayúde entré si, deberían dar un ejemplo guía un poco más claro
Hola a todos. Agradezco sus observaciones. Saludos.![](https://static.platzi.com/media/user_upload/IMG_20240221_221126-f2327c99-8318-4ce7-bbf3-41bfcc120270.jpg)
Hola, adjunto mi solución al reto de la clase (funcionamiento de un reloj), utilizando diagrama de flujo, junto con funciones y el ciclo while. Me gustaría retroalimentación por parte de todos (soy novato), muchas gracias. ![](https://static.platzi.com/media/user_upload/imagen-71313cfc-8df4-4baa-a2e2-028be9ec7377.jpg)
![](https://static.platzi.com/media/user_upload/image-ecefc01b-35f7-49d8-a143-c0327db2d7a6.jpg) Seguro es muy ineficiente mi pseudocódigo. Utilicé ciclos y preguntas para el reloj, no utilicé funciones y los horarios se pueden inicializar en cualquier número, con fines prácticos empecé en el número 23..

Lo escribí en otra clase, pero lo vuelvo a poner

let S = 0
let M = 0
let H = 0

pasarSegundos() {
 for (S = 0; S == 60; S = S + 1) {
  S = 0
  M = M + 1
  pasarMinutos()
 }
}

pasarMinutos() {
 If(M == 60) {
  M = 0
  H = H + 1
  pasarHoras()
 }
 Else {
  pasarSegundos()
 }
}

pasarHoras() {
 If(H == 24) {
  H = 0
  pasarSegundos()
 }
 else {
  pasarSegundos()
 }
}

se me hizo mas facil asi si ven algun error m escriben porfa 😄

function timer(h,m,s){
	while (h == 24 && m == 60 && s == 60){
		s = s + 1;
		if (s == 60){
			m = m + 1
			}
		if(m == 60){
				h = h + 1
			}
			console.log(h + ":" + m + ":" + s)
		}
}
timer(0,0,0)

Hice un for anidado para el reloj y agregue el validar para convertir en 0 cada que termine un for.

Pero no es necesario, el for de cada varible : h,m,s deja de ejecutarse una ves se alcanze su limite de iteraciones.

#include <iostream>
#include <conio.h>
#include <Windows.h>
using namespace std; 

void validar(int tipo, int limite ){
    if(tipo=limite){
        tipo=0;
    }
}

int main(){
    int segundos=0;
    int minutos=0;
    int horas=0;
    int limite[4]={60,60,24};
    cout<<"Prueba reloj "<<endl;

    for (int h = horas; h < 25; h++){
        validar(h,limite[2]);
        for (int m = minutos; m < 61; m++){
            validar(m,limite[1]);
            for (int s = segundos; s < 61; s++){
                    validar(s,limite[0]);
                    cout<<h<<" : "<<m<<" : "<<s<<endl;
                    system("cls");
               		 }
    		}
	}   
}

Hola Platzinautas 😄
Les comparto mi codigo, espero les guste.

let horas = 0
let minutos = 0
let segundos = 0

let limiteHoras = 24
let limiteMinutos = 60
let limiteSegundos = 60


function contadorSegundos(){

		setInterval(function () {
			if(segundos < limiteSegundos){
				console.log( `${horas}:${minutos}:${segundos++}`)
			}
			else {
					segundos = 0
					contadorMinutos()
			}
		}, 1000);
}

function contadorMinutos(){
	minutos++
	if(minutos < limiteMinutos){
		contadorSegundos()
	} else {
		contadorHoras()
	}
}

function contadorHoras(){
	horas++
	minutos = 0
	if(horas < limiteHoras){
		contadorSegundos()
	} else {
		contadorSegundos()
		horas = 0
	}
}

contadorSegundos()

Es interesante todo el contenido que se aprendio y como ahora se aplica para tener los resultados deseados como las funciones de if-else y ahora las function. Aqui esta el reto:

//Valores del tiempo
let h = 0
let m = 0
let s = 0

//Valores de tipo y limites
let tipo = [h, m, s]
let limite = [23, 60, 60]

//Funcion del Algoritmo del Reloj
function validar(tipo, limite) {
    if (tipo == limite) {
        tipo = 0
    }
}

//Ciclo para la validadcion
for (let i = 0; i < tipo.length; i++) {
    validar(tipo[i], limite[i])
}

Aquí mi aporte, lo único que hice en comparación al ejercicio anterior, fue quitar el último condicional y abajo de los primeros valores en cero, poner el ciclo preguntando si ha llegado a la estructura que se muestra, entonces volver a empezar

<let Hora = 0;
let Minuto = 0;
let segundo = 0;
function reloj (){
  console.log(Hora+":"+ Minuto + ":"+segundo); // aqui va a mostar en pantalla
  segundo = segundo +1;
  if (segundo > 59){
    segundo = 0;
    Minuto = Minuto + 1;
  }
  if (Minuto > 59){
    Minuto = 0;
    Hora = Hora + 1;
  }
  if (Hora > 23 ) {
     Hora = 0;
     Minuto = 0;
    segundo = 0;
  }
  setTimeout(reloj, 1000);
}
reloj ();> 

En python me funciono hacerlo así:

import time 
tipo = [0, 0, 0]
limite = [24, 60, 60]

def reloj(tipo, limite):
  while tipo[0]<limite[0]:
    while tipo[1]<limite[1]:
      while tipo[2]<limite[2]:
        print("{:02d}:{:02d}:{:02d}".format(tipo[0], tipo[1], tipo[2]))
        tipo[2]=tipo[2]+1
        time.sleep(1)
      tipo[1]=tipo[1]+1
      tipo[2]=0
    tipo[0]=tipo[0]+1
    tipo[1]=0
    
reloj(tipo, limite)

Inicio
H = 0, M = 0, S = 0

Tipo = (S, M, H)
Limite = (60, 60, 24)

Incrementar el segundo (S)
Función validar (tipo, límite)
If (S == 60)
Tipo = 0

Incrementar el minuto (M)
Función validar (M, 60)
If (M == 60)
Tipo = 0

                           No
                 │ Volver al ciclo de │
                  │ incremento de S │

    Sí 

Incrementar la hora (H)
Función validar (H, 24)
If (H == 24)
Tipo = 0

                             No 
                 │ Volver al ciclo de │
                 │ incremento de M │

      Sí

│ Reiniciar el ciclo │

Inicio
|
V
±-------------------------+
| Ingresar la hora (0-23) |
±-------------------------+
|
V
|
|----¿Hora válida?-----Sí
| | |
| | No
| V V
| Mostrar mensaje ±----------------+
| de error | Ingresar la |
| y volver a | hora nuevamente |
| ingresar hora ±----------------+
| | |
| V |
|----¿Minutos |
| válidos?-----Sí
| | |
| | No
| V V
| Mostrar mensaje ±----------------+
| de error | Ingresar los |
| y volver a | minutos |
| ingresar minutos ±----------------+
| | |
| V |
| Mostrar hora y |
| minutos ingresados |
| | |
| V |
±–Fin----------------+


tipo = [H,M,S]
limite = [24,60,60]

mostrar_hora(tipo, limite) {
   if tipo == limite:
     tipo = 0
  else:
    tipo = tipo + 1
}


Para los que estudian Python acá dejo un aporte de lo que hice con el algoritmo del reloj.

def main():
    limite = [59, 59, 23, 1]
    segundos = 0
    minutos = 0
    horas = 0
    dias = 0
    while dias < 1:
        segundos += 1
        if segundos == limite[0] and minutos == limite[1] and horas == limite[2]:
            print(f'Ha pasado {horas}:{minutos}:{segundos}')
            dias += 1
        elif segundos == limite[0]:
            segundos = 0
            minutos += 1
            if minutos == limite[1] + 1:
                horas += 1
                minutos = 0
                segundos = 0


if __name__ == '__main__':
    main()

Creo que podría ser así…
Lo ideal es saber cuál dato varía.




s=0;
m=0;
h=0;

function validar(tipo, limite){
	if(tipo=="s") {
		if(s==limite){
			s=0;
			m++;	
		}
	} else if(tipo=="m"){
				if(m==limite) {
					m=0;
					h++;
				}
			} else if(tipo=="h"){
						if(h==limite) {
							h=0;
						}
					}
	}

do{
	for(i=0; i<=60; i++){
		s++;
		validar("s",60);
		validar("m",60);
		validar("h",24);
	}

}while(h<24);
	
	
		
	

Que bueno ir viendo como avanza el proceso ahora unificando en una funcion el ejercicio de la hora.

se aceptan sugerencias 😃

tipo = [H,M,S];
limite [60, 60, 24];

function validar (tipo, limite)
if (tipo == limite)
return 0
else{
while (tipo <= 60){
try validar tipo [H , M , S]
catch
"Se produjo un error en el programa"
}
}
return tipo

Hola, he logrado resolver el codigo:
limite = [60, 60, 24];
tipos= [0, 0, 0];

function validar(tipos, limite) {
setTimeout(() => {
validar(tipos, limite);
}, 1000);
if (tipos[0] == limite[0]) {
tipos[0] = 0;
tipos[1] = tipos[1] + 1;
if (tipos[1] == limite[1]) {
tipos[1] = 0;
tipos[2] = tipos[2] + 1;
if (tipos[2] == limite[2]) {
tipos[2] = 0;
}
}
} else {
console.log(tipos[0],tipos[1],tipos[2])
tipos[0] = tipos[0]+1;
}
}
validar(tipos, limite);

me tomó algo de tiempo, pero lo logré, mi codigo en python.
realmente me funcionó muy bien para terminar de entender algunas cosas.
para las personas que sienten que no entienden les digo que continúen intentándolo poco a poco se va haciendo menos complejo.

s = 0
m = 0
h = 0
time = [s,m,h]
limit = [60,60,23]

def valid(time,limit):
    i = 0
    while True:
        if time[i] == limit[i]:
            time[i] = 0
            time[i+1] += 1 
            if time[i+1] == limit[i+1]:
                time[i+1] = 0
                time[i+2] += 1
                if time[i+2] ==limit[i+2]+1:
                    break   
        for j in range(1,limit[i]+1,1):
            time[i] = j
            print(f'hora:Minutos:Segundos')  
            print(f'{time[2]}:{time[1]}:{time[0]}')      
valid(time,limit)

Mi reto 8, saludos a todos.

para entenderlo mejor, en la logica del reloj dice;

tipo = al recorrido que hace, vease, segundos, min,horas
limite = al punto final de ese recorrido

si el tipo es igual al limite, if ( tipo == limite )
entonces, {
hacer que tipo vuelva a 0 tipo = 0 }

while tipo <> limite
limite + 1

For limite + 1
if (tipo <> limite)
else
tipo = 0

¡Hola compañeros, les comparto mi código en JavaScript, donde definí tres funciones, una para validar, otra para el flujo de trabajo, y otra para mostrar el avance del tiempo mediante la consola, quiero cronometrarlo, pero no encuentre aún el método para hacerlo, si lo sabes cuéntamelo, saludos!

En la función conteo puedes añadir el número de días que quieres medir, y el límite lo deje en dos horas por día, para no hacer muy lago el resultado del console.log

// alert("Viva platzi");
let hours = 0;
let minutes = 0;
let seconds = 0;
let days = 1;
let cycle = 0;

function validar (tipo,maximo)
{
    if (tipo == maximo)
    {
        cycle = 1;
    }
    
}
function mensaje()
{
    console.log("Son las "+hours+":"+minutes+":"+seconds+" del día "+days);
}

function conteo(daysWhile)
{
    while (days <= daysWhile)
    {
        seconds += 1;
        cycle = 0;
        validar(seconds,60);
        if(cycle)
        {
            minutes +=1;
            seconds = 0;
            cycle = 0;
            validar(minutes,60);
            if(cycle)
            {
                hours += 1;
                minutes = 0;
                cycle = 0;
                validar(hours,2);
                if(cycle)
                {
                    hours = 0;
                    minutes = 0;
                    seconds = 0;
                    days += 1;
                }   
            }
        }
        mensaje();
    }    
}

conteo(3);

funcion( segundo, 60)
if (segundos == 60)l
= 0
else if (minutos == 60)
= 60
else ( 24)

Algoritmo funcional de reloj, da 2 vueltas (2 dias) y se detiene. Es lo más “simple” que logre hacer.

Comparto mi tarea de algoritmos y estructuras de datos donde me pidieron un menú de funciones con python:

let H = 0
let M = 0
let S = 0

function clock(){
    console.log(H+':'+M+':'+S);
    S = S + 1
    if (S > 59){
        S = 0
        M = M + 1
    }
    if (M > 59){
        M = 0
        H = H + 1
    }
    if (H > 23){
        H = 0
        M = 0
        S = 0
    }
    setTimeout(()=>{
        clock()
    }, 1000)
}
clock();

Creé un tipo de contador que empieza desde 0:0:0 y termina en 24:60:60.

let hours= 0
let minutes= 0
let seconds= 0

inicio()
procesosegundos()
procesomins()
procesohoras()
fin()


function inicio(){
    console.log(hours,":",minutes,":",seconds)
}

function procesosegundos(){
   do{
    seconds=seconds+1
    console.log(hours,":",minutes,":",seconds)
   }while(seconds<=59)
}

function procesomins(){
    do{
        seconds=0
        procesosegundos()
        minutes=minutes+1
        console.log(hours,":",minutes,":",seconds)
    }while(minutes<=59)
}

function procesohoras(){

    do{
        seconds=0
        minutes=0
        procesosegundos()
        procesomins()
        hours=hours+1
        console.log(hours,":",minutes,":",seconds)
    }while(hours<=23)
}

function fin(){
    if (hours==24 && minutes==60 && seconds==60){
        console.log(0,":",0,":",0)
        console.log("EL contador ha llegado a su fin debido a que ha llegado a las 24 horas.")
    }
}

Todavía no sé como programar, pero creo que es algo así.

<Variables: h, m, s

Función validar (tipo, limite)
	if (tipo = limite)
	tipo = 0

for i = 0; i, i++
> 

//quisiera haber entendido mejor a la profe, pero bueno, alguien compartió un algoritmo de reloj en js y se los comparto. Honor a quien honor merece.

let h = 0;
let m = 0;
let s = 0;

function reloj(){

  console.log(h +':' + m + ':' + s); //mostrar en pantalla
  s = s+1;
  if(s>59){
    s=0;
    m = m+1;
  }
  if(m>59){
    m=0;
    h = h+1;
  }
  if(h>23){
    h=0;
    m=0;
    s=0;
  }
  setTimeout(() => {
    reloj();
  }, 1000);
}
reloj();
tipo = [h, m, s];
limite = [60, 60, 24];

function Reloj(tipo, limite){
	If(tipo == limite) {
		tipo = 0;
	}
}

for(i = 0; i < tipo.length; i++) {
	Reloj(tipo[i], limite[i]);
}

desde que haces un algoritmo ya cuentas con una función que es la función main que se ejecuta en tu flujo, o sea lo primero que ves. La función main va ser ayudada por diferentes funciones que van a realizar tareas especificas para que la función main no hago todo el trabajo.
puedes hacer un algoritmo en el cual se ingrese la base y la altura de un rectangulo, y una función área se encargue del proceso.

s=0
m=0
h=0

t1 = [s,m,h];
t2=[60,60,24];

function reloj(a,b){
  if(a==b){
    a=0;
  }
  console.log(a)
}

reloj(t1,t2);

for(i=0;i<t1.length;i++){
  reloj(t1[i],t2[i]);
  console.log(t1[i],t2[i])
}

Mi algoritmo utilizando funciones , lo hice con Pseint. Lo probé llegando a una hora y funcionó bien.

Algoritmo relojConFunciones
	hr=0
	min=0
	seg=0
	
	Repetir 
		
		seg=incrementar1(seg,60)
		min=incrementar1Si(seg,60,min)
		seg=reiniciaraCero(seg,60)
		hr=incrementar1Si(min,60,hr)
		min=reiniciaraCero(min,60)
		
		Esperar 1 segundo
		Imprimir "Son las  " hr ":" min ":" seg
		
	Hasta Que hr==23
	
FinAlgoritmo

Funcion tipo <- reiniciaraCero (tipo,limite) //Funcion para reiniciar a cero los segundos, minutos y horas y retorna su valor
	si tipo==limite Entonces
		tipo=0
		
	FinSi
	
FinFuncion

Funcion tipo <- incrementar1(tipo,limite) //Funcion para incrementar en uno los segundos y retorna su valor 
	si tipo<=limite
		tipo=tipo+1
	FinSi
FinFuncion

Funcion tipo2 <- incrementar1Si(tipo,limite,tipo2)//Funcion para incrementar en uno los minutos si los segundos llegan a su limite, e incrementar en uno las horas si los minutos llegan a su limite y retorna su valor
	si tipo==limite
		tipo2=tipo2+1
	FinSi
FinFuncion

s=0
m=0
h=0

t1 = [s,m,h];
t2=[60,60,24];

function reloj(a,b){
  if(a==b){
    a=0;
  }
  console.log(a)
}

reloj(t1,t2);
for(i=0;i<t1.length;i++){
  reloj(t1[i],t2[i]);
  console.log(t1[i],t2[i]);
}

t=0
while(t < t1.length){
  reloj(t1[t],t2[t]);
  console.log(t1[t],t2[t]);
  t=t+1
}
```js let h = "00"; let m = "00"; let s = "00"; let limite = [24, 60, 60]; function validar(valor, limite) { if (parseInt(valor) >= limite) { return "00"; } return valor; } function actualizarReloj() { // Incrementar segundos s++; if (s >= limite[2]) { s = 0; // Incrementar minutos si los segundos llegan a 60 m++; if (m >= limite[1]) { m = 0; // Incrementar horas si los minutos llegan a 60 h++; if (h >= limite[0]) { h = 0; } } } // Validar y actualizar los valores en el arreglo tipo tipo = [validar(h.toString(), limite[0]), validar(m.toString(), limite[1]), validar(s.toString(), limite[2])]; // Mostrar el tiempo actualizado console.log(`${tipo[0]}:${tipo[1]}:${tipo[2]}`); // Llamar recursivamente a actualizarReloj cada segundo setTimeout(actualizarReloj, 1000); // Llamar la función nuevamente después de 1 segundo } // Iniciar el reloj actualizarReloj(); ```
El algoritmo para un reloj, como se menciona en el transcript, establece que cuando las horas llegan a 24, se reinician a 0. Esto es correcto; sin embargo, cuando se habla de la hora 23, se refiere a las 11 de la noche. En este contexto, el algoritmo está diseñado para reiniciar la cuenta a 0 después de alcanzar 23, representando así 24 horas en un ciclo diario correcto. Por lo tanto, no faltaría una hora al día, ya que el ciclo se repite adecuadamente cada 24 horas.
```python # Definir las listas tipo y limite tipo = ['H', 'M', 'S'] limite = [24, 60, 60] # Ciclo for para iterar sobre las listas tipo y limite for i in range(len(tipo)): # Validar si tipo es igual al limite if tipo[i] == limite[i]: tipo[i] = 0 # Mostrar el valor de tipo después de la validación print(f'{tipo[i]}: {limite[i]}') ```H: 24 M: 60 S: 60
```js let tipos = ["h", "m", "s"]; let limites = [23, 59, 59]; function validar(valor, limite) { return valor <= limite; } for (let i = 0; i < tipos.length; i++) { if (validar(i, limites[i])) { console.log(tipos[i], "está dentro de los límites."); } else { console.log(tipos[i], "excede el límite."); } } ```
Mi solución: Función validar(valor, limite):     Si valor == limite:         retornar 0     Retornar valor Inicializar H = 0, M = 0, S = 0 ```js Función validar(valor, limite): Si valor == limite: retornar 0 Retornar valor Inicializar H = 0, M = 0, S = 0 Mientras verdadero: # Bucle infinito para simular el reloj S = S + 1 Si S == 60: S = validar(S, 60) M = M + 1 Si M == 60: M = validar(M, 60) H = H + 1 Si H == 24: H = validar(H, 24) Mostrar H:M:S # Imprime el tiempo actual en formato reloj ```Función validar(valor, limite):     Si valor == limite:         retornar 0     Retornar valor Inicializar H = 0, M = 0, S = 0 Mientras verdadero:  # Bucle infinito para simular el reloj     S = S + 1     Si S == 60:         S = validar(S, 60)         M = M + 1         Si M == 60:             M = validar(M, 60)             H = H + 1             Si H == 24:                 H = validar(H, 24)     Mostrar H:M:S  # Imprime el tiempo actual en formato reloj
![](https://static.platzi.com/media/user_upload/image-c818135b-a70f-48a3-8e5a-8b1148b18e60.jpg)
este es mi ejemplo del reloj usando alguno de los ciclos vistos, por medio de un algoritmo. jamás me enteraré que tan cercano a bueno quedó este trabajo, si se acerca a lo requerido.👇 ![](https://static.platzi.com/media/user_upload/mandar-f7a41284-2a4f-4a70-b613-fe6e517b980a.jpg)
let hora = 0; let minutos = 0; let segundos = 0; const limites = \[60, 60, 24]; function validar(valor, limite) { if (valor >= limite) { return 0; } return valor; } function actualizarReloj() { segundos++; if (segundos >= limites\[0]) { segundos = validar(segundos, limites\[0]); minutos++; if(minutos >= limites\[1]){ minutos = validar(minutos, limites\[1]) hora++; hora = validar(hora, limites\[2]) } } const horaStr = String(hora).padStart(2, '0'); const minutosStr = String(minutos).padStart(2, '0'); const segundosStr = String(segundos).padStart(2, '0'); console.log(`${horaStr}:${minutosStr}:${segundosStr}`); } setInterval(actualizarReloj, 1000);
```js Funcion valorSalida <- validacion ( tipo, limite ) si tipo == limite Entonces valorSalida = 0 FinSi Fin Funcion Algoritmo reloj // definicion de la variables definir hora Como Entero definir min Como Entero Definir seg Como Entero //asignacion de valores limites de vaibles L_hora = 24 L_min = 60 L_seg = 60 // inicializacion de las variables hora = 0 min = 0 seg = 0 //impresion de los valores en el esquema de relij en pantalla Escribir "hora: ", hora, ":", min, ":", seg // inicio del ciclo while que ejecuta el fincionamiento del reloj Mientras hora<=23 y min<60 Hacer Escribir "hora: ", hora, ":", min, ":", seg seg = seg + 1 si seg == 60 Entonces seg = validacion(seg, L_seg) min = min + 1 FinSi si min == 60 Entonces min = validacion(min, L_min) hora = hora + 1 FinSi FinMientras // al salir del ciclo una vez lleguemos al valor de 24:0:0 //se ejecuta la ultima validacion con la funcion para inicializar el valor de hora a 0 si hora == L_hora Entonces hora = validacion(hora, L_hora) FinSi // obtenemos como final de nuestro algoritmo horas 0:0:0 Escribir "hora: ", hora, ":", min, ":", seg FinAlgoritmo ``` ![](https://static.platzi.com/media/user_upload/Screenshot%202024-12-26%20at%203.15.10AM-87681d60-186c-47c4-b0c3-fea8b69d1259.jpg)
Excelente
a = 40b = 60 def validar(tipo, limite):    while tipo < limite:        tipo += 1        print("Tipo:", tipo)  # Mostrar el valor de tipo en cada iteración                # Si `tipo` alcanza el `limite`, se establece a 0 y se detiene el bucle.        if tipo == limite:            tipo = 0            print("Tipo ha alcanzado el límite y ahora vale:", tipo)            break  # Detener el bucle \# Llamar a la funciónvalidar(a, b) esta función fue la que hice, tengan cuidado con la identacion, al menos en python esta es muy importante para hacer que los algoritmos se lleven como uno desea, las identaciones son como la ortografía, no es lo mismo decir "El se va a casar" a "El se va a cazar"
Les agradeceria si pudiesen darme feedback sobre mi diagrama de flujo :) ![](https://static.platzi.com/media/user_upload/Diagramas%20de%20flujo%20curso%20pensamiento%20l%C3%B3gico-6af01e68-d557-4704-97a5-3c393dccb0b1.jpg)
Esta es la forma en como lo realice, uniendo al final las tres funciones se unen para dar este resultado. ![](https://static.platzi.com/media/user_upload/image-55e2d7ac-5062-487d-b978-53984673c46c.jpg) ![](https://static.platzi.com/media/user_upload/image-67aa578e-e44f-4b52-aec1-8126f07513ff.jpg) ![](https://static.platzi.com/media/user_upload/image-2c7cc251-7664-4f09-af5e-1ca80fe45de3.jpg) 2.Esta función retorna a cero el valor de los datos una vez que los datos lleguen a su limite. ![](https://static.platzi.com/media/user_upload/image-f22a9ded-e51b-4c62-8e40-e92acee5d1ce.jpg) 3\. Esta función aumenta uno en uno el dato "s" (segundos) hasta su limite. ![](https://static.platzi.com/media/user_upload/image-ba3e136e-d25e-490b-b879-385706337baf.jpg) 1. Esta función verifica si "s" llego a su limite para que luego aumente en uno "m" y debajo la función anterior vuelve a generar uno en uno los segundos ![](https://static.platzi.com/media/user_upload/image-9d3eaa69-0d6d-4446-b97e-1e62ec1d88c9.jpg) 1. Esta función verifica que "m" este en su limite para que "h" aumente uno en uno hasta alcanzar su limite.![](https://static.platzi.com/media/user_upload/image-df21b96a-bc0e-4cf7-b91d-6ffa9ad04c80.jpg)
Mi código en versión Java para implementar el reloj:public class main { public static int incremento (int valor, int limite){ if (valor < limite) { valor++; }else{ valor =0; } return valor; } public static String horaCompleta(int h, int m, int s){ String cadena = String.*valueOf*(h)+" : "+String.*valueOf*(m)+" : "+String.*valueOf*(s); return cadena; } public static void main(String \[] Args){ int hora=0,minuto=0,segundo=0; int limHora=24, limMinuto=60, limSegundo =60; int contador = 0; for(int x=0;x\
Adjunto mi diagrama, de flujo de las dos funciones a crear en el proceso del reloj, lo acoté hasta dos horas, para que no sea muy largo. ![](https://static.platzi.com/media/user_upload/diagrama_flujo_time-65da76d6-60a0-45f1-bde9-8bfdba34118c.jpg) Estoy atento cualquier sugerencia o retroalimentación.
wow
Mi aporte ```js var ArrayTipo = [50, 30, 22]; var ArrayLimite = [60, 60, 24]; var posicionActual= 0; var iteracionesTiempo= 0; function validarTiempo(ArrayTipo, ArrayLimite){ if (ArrayTipo== ArrayLimite){ //console.log(ArrayTipo + 'Se reiniciara de nuevo') ArrayTipo = 0; } else { //console.log(ArrayTipo + 'sigue contando') ArrayTipo = ArrayTipo+1; } }; while(iteracionesTiempo<=2) { validarTiempo(ArrayTipo[iteracionesTiempo], ArrayLimite[iteracionesTiempo]); iteracionesTiempo = iteracionesTiempo+1; } ```
Aun no me acostrumbro a crear comentarios, perdon el spam. ```js var ArrayTipo = [50, 30, 22]; var ArrayLimite = [60, 60, 24]; var posicionActual= 0; var iteracionesTiempo= 0; function validarTiempo(ArrayTipo, ArrayLimite){ if (ArrayTipo== ArrayLimite){ console.log(ArrayTipo + 'Se reiniciara de nuevo') ArrayTipo = 0; } else { console.log(ArrayTipo + 'sigue contando') ArrayTipo = ArrayTipo+1; } console.log(ArrayTipo); }; while(iteracionesTiempo<=2) { validarTiempo(ArrayTipo[iteracionesTiempo], ArrayLimite[iteracionesTiempo]); iteracionesTiempo = iteracionesTiempo+1; } ```var ArrayTipo = \[50, 30, 22];var ArrayLimite = \[60, 60, 24];var posicionActual= 0;var iteracionesTiempo= 0; function validarTiempo(ArrayTipo, ArrayLimite){    if (ArrayTipo== ArrayLimite){        console.log(ArrayTipo + 'Se reiniciara de nuevo')        ArrayTipo = 0;    } else {        console.log(ArrayTipo + 'sigue contando')        ArrayTipo = ArrayTipo+1;    }        console.log(ArrayTipo);}; while(iteracionesTiempo<=2) {    validarTiempo(ArrayTipo\[iteracionesTiempo], ArrayLimite\[iteracionesTiempo]);    iteracionesTiempo = iteracionesTiempo+1;}
```js var ArrayTipo = [50, 30, 22]; var ArrayLimite = [60, 60, 24]; var posicionActual= 0; var iteracionesTiempo= 0; function validarTiempo(ArrayTipo, ArrayLimite){ if (ArrayTipo== ArrayLimite){ console.log(ArrayTipo + 'Se reiniciara de nuevo') ArrayTipo = 0; } else { console.log(ArrayTipo + 'sigue contando') ArrayTipo = ArrayTipo+1; } console.log(ArrayTipo); }; //ciclo while //3 iteraciones while(iteracionesTiempo<=2) { validarTiempo(ArrayTipo[iteracionesTiempo], ArrayLimite[iteracionesTiempo]); iteracionesTiempo = iteracionesTiempo+1; } ```var ArrayTipo = \[50, 30, 22];var ArrayLimite = \[60, 60, 24];var posicionActual= 0;var iteracionesTiempo= 0; function validarTiempo(ArrayTipo, ArrayLimite){    if (ArrayTipo== ArrayLimite){        console.log(ArrayTipo + 'Se reiniciara de nuevo')        ArrayTipo = 0;    } else {        console.log(ArrayTipo + 'sigue contando')        ArrayTipo = ArrayTipo+1;    }        console.log(ArrayTipo);}; //ciclo while //3 iteraciones while(iteracionesTiempo<=2) {    validarTiempo(ArrayTipo\[iteracionesTiempo], ArrayLimite\[iteracionesTiempo]);    iteracionesTiempo = iteracionesTiempo+1;}
Les comparto lo que hice en JS `<` var ArrayTipo = \[50, 30, 22];var ArrayLimite = \[60, 60, 24];var posicionActual= 0;var iteracionesTiempo= 0; function validarTiempo(ArrayTipo, ArrayLimite){    if (ArrayTipo== ArrayLimite){        console.log(ArrayTipo + 'Se reiniciara de nuevo')        ArrayTipo = 0;    } else {        console.log(ArrayTipo + 'sigue contando')        ArrayTipo = ArrayTipo+1;    }        console.log(ArrayTipo);}; //ciclo while //3 iteraciones while(iteracionesTiempo<=2) {    validarTiempo(ArrayTipo\[iteracionesTiempo], ArrayLimite\[iteracionesTiempo]);    iteracionesTiempo = iteracionesTiempo+1;} `>`
`unidadesdeMedida=[h,m,s];` `limites=[60,60,24];` `function chequeo(tiempo,limite){` `if(tiempo===limite){` `tiempo=0;` `}}` `for (i=0;i
![](https://static.platzi.com/media/user_upload/Algoritmo%20de%20reloj%20con%20funciones-24496648-34b8-477b-aed0-cb1536c522a7.jpg)
```python import time def incrementar_tiempo(horas, minutos, segundos): segundos += 1 if segundos == 60: segundos = 0 minutos += 1 if minutos == 60: minutos = 0 horas += 1 if horas == 24: horas = 0 return horas, minutos, segundos def mostrar_reloj(horas, minutos, segundos): # Usamos str.zfill() para asegurarnos de que los números sean siempre de dos dígitos return f"{str(horas).zfill(2)}:{str(minutos).zfill(2)}:{str(segundos).zfill(2)}" def simular_reloj(): horas, minutos, segundos = 0, 0, 0 # Iniciamos el reloj a medianoche while True: # Mostrar la hora actual print(mostrar_reloj(horas, minutos, segundos)) # Incrementar el tiempo horas, minutos, segundos = incrementar_tiempo(horas, minutos, segundos) # Esperar un segundo antes de continuar time.sleep(1) # Llamar a la función simular_reloj para iniciar el reloj simular_reloj() ```
```python def validar(tipo, limite): if tipo == limite: tipo == 0 ```
La profe tiene bonita letra
```java public class Reloj { static int horas = 0; static int minutos = 0; static int segundos = 0; public static void main(String[] args) { System.out.println("Hora Inicial: " + horas + ":" + minutos + ":" + segundos); iniciarReloj(); } public static void iniciarReloj() { while (horas < 2) { segundos += 1; System.out.println("Hora Actual: " + horas + ":" + minutos + ":" + segundos); if (segundos == 59) { minutos += 1; if (minutos == 60) { minutos = 0; horas += 1; } segundos = 0; System.out.println("Hora Actual: " + horas + ":" + minutos + ":" + segundos); } } } } ```
ahora el ejemplo de como se realizaría en una función, OJO, no está completa, con este vistazo se presume lo que vendría después, ahora, estará bien?😬👇 ![](https://static.platzi.com/media/user_upload/5-0fa1c5d1-da75-4a89-b6e0-ffbb8052d025.jpg)
No pude completar el algoritmo del reloj con la función propuesta pero lo hice de otra forma con un ciclo while y varios condicionales if, este es un ciclo infinito, se parece mucho al diagrama de flujo que hicimos en clases pasadas. Este es mi diagrama de flujo: ![](https://static.platzi.com/media/user_upload/_Diagrama%20de%20flujo%20%282%29-79a24ff7-1651-4ad3-9852-cb51dbfd75b6.jpg) Este es como un pseudocodigo que hice: h = 0 m = 0 s = 0 while(True){ limpiar pantalla imprimir en pantalla h:m:s parar un segundo s++ #s++ == s = s+1 if(s == 60) { s = 0 m++ } if(m == 60) { m = 0 h++ } if(h == 24) { h = 0 } }
![](https://static.platzi.com/media/user_upload/image-045df72d-2d2b-4638-a501-07560af3ba0b.jpg)