No tienes acceso a esta clase

隆Contin煤a aprendiendo! 脷nete y comienza a potenciar tu carrera

Reto 8: algoritmos con funciones

16/17
Recursos

Para entender un poco m谩s el uso de funciones, resolvamos los siguientes problemas, de esta manera identificar谩s c贸mo utilizarlos.

Algoritmo de un reloj utilizando funciones

Recordar谩s el algoritmo de un reloj que realizaste, exist铆an pasos en el diagrama de flujo que se repet铆an. Utilicemos funciones para encapsular esa l贸gica y reutilizarla seg煤n corresponda.

Primeramente, definimos las variables iniciales de horas, minutos y segundos en un valor igual a cero. Estas variables segu铆an un formato establecido para mostrarlo como tiempo.

H = 0
M = 0
S = 0

Formato = 00:00:00

Despu茅s, valid谩bamos cuando la variable horas y minutos era igual a 60; y la variable horas era igual a 24.

Si S == 60 entonces S = 0
Si M == 60 entonces M = 0
Si H == 24 entonces H = 0

Este comportamiento sigue un patr贸n, validamos que un tipo de variable est茅 por debajo de un l铆mite. Entonces, encapsulemos esta l贸gica en una funci贸n para solamente invocarla cuando sea necesario.

Representemos como par谩metros a las variables con el nombre de tipo y el valor m谩ximo como limite. Dentro de la funci贸n utilizaremos un condicional para comprobar si tipo es igual a limite, si esto es verdadero, entonces regresamos un valor de cero, caso contrario, regresamos el mismo valor de tipo.

function validar (tipo, limite)
    if (tipo == limite)
        return 0
    else
        return tipo

De esta manera, ya podemos utilizarlo en nuestro algoritmo:

S = validar(S, 60)
M = validar(M, 60)
H = validar(H, 24)

Desaf铆o utilizando ciclos

Utilizando ciclos, representa las sentencias que son necesarias que se repitan para que aumente una unidad las variables seg煤n el diagrama de flujo. 隆Comparte tu trabajo en la secci贸n de aportes!

Contribuci贸n creada por Andr茅s Guano (Platzi Contributor).

Aportes 163

Preguntas 13

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad?

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

Comparto mi diagrama usando el ciclo while. Realmente no se si este correcto , agradecer铆a su feedback.

Para realizar este reto me apoye en el siguiente video https://www.youtube.com/watch?v=LLeiVHsU1gs, tambi茅n encontrar谩n con los ciclos for y do while.

No s茅 uds. a mi me qued贸 medio agarrado de un hilo todo鈥 la ejecuci贸n del reto que hicieron muchos es porque saben mas de programaci贸n que lo explicado hasta ahora. Creo que toca buscar por fuera de platzi calculo鈥

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

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

Asi quedo mi practica de reloj digital.

https://github.com/IVAN-DALI-GARCIA/RELOJ_DIGITAL_12_HRS.git

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]);
}

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

siganle鈥
de nada.
馃槜

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();

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

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);
}

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.

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?

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;

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

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

Para todos aquellos que les quedaron muchas dudas al finalizar el curso, no se desanimen, veo que muchos estamos empezando y quiero compartirles un libro que me ha ayudado bastante a m铆, reci茅n estoy aprendiendo a programar y este libro te da las bases de manera muy sencilla鈥 aunque es una introducci贸n al lenguaje C, resulta m谩s f谩cil entender conceptos como estructuras de control, arrays, funciones, etc., al verlas aplicadas de manera pr谩ctica; es un libro de hace algunos a帽os, pero la verdad gracias a 茅l he entendido muchas cosas, espero les sirva!

https://drive.google.com/file/d/1up3SQgEPp4sEPvoRDRRKA16EDHqTGQ3n/view?usp=sharing

terrible esta explicacion, habla de muchass cosas a la vez, y deja en el aire los topicos, me estoy decepcionando
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)

Buen dia

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]);
}


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

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鈥n fin varios huecos. Pero gracias a Dios me quedo m谩s claro, aqu铆 comparto el Reto8:

Hola a todos. Agradezco sus observaciones. Saludos.![](https://static.platzi.com/media/user_upload/IMG_20240221_221126-f2327c99-8318-4ce7-bbf3-41bfcc120270.jpg)
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
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()
 }
}

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

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

      S铆

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 |
卤鈥揊in----------------+


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()

Solo s茅 que nada s猫 -------------------------------

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 鈥渟imple鈥 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
}
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)
La mu帽eca del final me peg贸 un susto que hasta me hizo brincar!! jajaja
```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)
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)
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)
![](https://static.platzi.com/media/user_upload/image-66dcb72f-6cd3-4dfe-a3fc-11d79e0dc002.jpg)
```js H=00 M=00 S=00 Tipo 1 = h Tipo 2 = m Tipo 3 = s limite H = 24 limite M = 60 limite S = 60 function validar(tipo, limite) { If(tipo == limite) { tipo = 0; } } for(i = 0; i < tipos.length; i++) { validar(tipos[i], limite[i]) } ```H=00M=00S=00 Tipo 1 = hTipo 2 = mTipo 3 = s limite H = 24limite M = 60limite S = 60 function validar(tipo, limite) {聽 聽 If(tipo == limite) {聽 聽 聽 聽 tipo = 0;聽 聽 }} for(i = 0; i < tipos.length; i++) {聽 聽 validar(tipos\[i], limite\[i])}
`funci贸n incrementarReloj(H, M, S) {` ` S++` ` S = validar(S, 60)` ` if (S == 0) {` ` M++` ` M = validar(M, 60)` ` if (M == 0) {` ` H++` ` H = validar(H, 24)` ` }` ` }` `}` `funci贸n validar(tipo, limite) {` ` if (tipo == limite) {` ` tipo = 0` ` }` ` return tipo` `}`
Escrib铆 mi algoritmo del funcionamiento del reloj en Python: `horas = 00 ` `minutos = 00` `segundos = 00` `while horas < 24:` ` while minutos <= 59:` ` while segundos <=59:` ` print (f"la hora es {horas}:{minutos}:{segundos}")` ` segundos += 1` ` ` ` ` ` minutos +=1` ` segundos = 0` ` ` ` horas +=1` ` minutos = 0` ` segundos = 0`
Mi aporte en python: ```js h = 0 m = 0 s = 0 tipos = [h,m,s] limite = [24,60,60] def validar(tipo, limite): if (tipo == limite): tipo = 0 tipo+=1 return tipo for i in range(limite[0]): i = validar(i, limite) for j in range(limite[1]): j = validar(j, limite) for k in range(limite[2]): k = validar(k, limite) print(f"{i}:{j}:{k}") ```
Hola, aqui le dejo mi codigo en Python ```python import time # Definir tipos de unidades de tiempo y sus l铆mites tipos = ["horas", "minutos", "segundos"] limite = [24, 60, 60] # Funci贸n para validar el valor de una unidad de tiempo def validar(valor, tipo): if 0 <= valor < limite[tipo]: return True # Valor v谩lido else: raise ValueError("Valor de {} no v谩lido".format(tipos[tipo])) # Inicializar valores del reloj hora = 0 minuto = 0 segundo = 0 while True: try: # Incrementar segundo segundo += 1 # Validar segundo y ajustar si es necesario if validar(segundo, 2): pass # No es necesario ajustar else: segundo = 0 # Reiniciar a 0 si se excede el l铆mite # Incrementar minuto minuto += 1 # Validar minuto y ajustar si es necesario if validar(minuto, 1): pass # No es necesario ajustar else: minuto = 0 # Reiniciar a 0 si se excede el l铆mite # Incrementar hora hora += 1 # Validar hora y ajustar si es necesario if not validar(hora, 0): hora = 0 # Reiniciar a 0 si se excede el l铆mite # Mostrar el tiempo actual print("Hora actual: {}h {}m {}s".format(hora, minuto, segundo)) # Dormir durante 1 segundo (simulando el paso del tiempo) time.sleep(1) except ValueError as e: # Manejar la excepci贸n mostrando un mensaje de error print("Error:", str(e)) ```
`public class Reloj {` ` public static void main(String[] args) {` ` int[][] x;` ` x = new int[1][4];` ` x[0][0] = 0;` ` x[0][1] = 0;` ` x[0][2] = 0;` ` x[0][3] = 0;` ` while (x[0][0]<60 ){` ` x[0][0] = x[0][0] + 1;` ` System.out.println("Segundos: " + x[0][0]);` ` while (x[0][0]==60 && x[0][1]<60){` ` x[0][0] = 0;` ` x[0][1] = x[0][1] + 1;` ` System.out.println("Minutos: " + x[0][1]);` ` while (x[0][1]==60 && x[0][2]<24) {` ` x[0][1] = 0;` ` x[0][2] = x[0][2] + 1;` ` System.out.println("Horas: " + x[0][2]);` ` while (x[0][2]==24 && x[0][3]<3){` ` x[0][2] = 0;` ` x[0][3] = x[0][3] + 1;` ` System.out.println("Dias: " + x[0][3]);` ` }` ` }` ` }` ` }` ` System.out.println("Es el d铆a: " + x[0][3] + " /Hora: " + x[0][2] + " Minutos: "+ x[0][1] +" Segundos: " + x[0][0]);` }}
No s茅 si esta bueno todo esto que escrib铆 pero es lo que he entendido Tipos (h,m;s) Limite (60,60,23) h=0 m=0 s=0 formato 00:00:00 Function validar segundo ( S;60) If ( tipo==limite) Tipo=0 Else For (segundo=1; segundo <=60; segundo +1) Function validar minutos (M;60) If ( tipo == limite) Tipo =0 Else For ( minuto =1; minuto <=60; minuto +1) Function validar hora (H;23) If ( tipo == limite ) Tipo =0 Else For (hora=1; hora <=23; hora +1)
Imprimiendo el reloj con C++ utilizando bucles, soy principiante, recibo feedback, por favor. Ciclo for: ![](https://static.platzi.com/media/user_upload/image-6fb2beed-bbb5-41ed-8383-cedb931692b9.jpg) Ciclo while: ![](https://static.platzi.com/media/user_upload/image-07701711-2ad4-49f0-89be-28262b39ac77.jpg) Ciclo do-while: ![](https://static.platzi.com/media/user_upload/image-e43313f6-e37c-4732-810b-dca573d89100.jpg)
Funcion validar(tipo,limite) While: tipo=limite Do: Tipo=0
Contador tipo reloj ! con Go![](https://static.platzi.com/media/user_upload/image-d7820e08-e576-4225-bf2f-e1e32f7815c0.jpg)