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])
}
Introducción
¿Qué es un dato?
Tipos de datos
Tipos de datos: texto
Tipos de datos: numéricos
Tipos de datos: booleanos
Tipos de datos: arrays
Reto 4: algoritmo de un reloj
Estructuras de control
¿Qué son las estructuras de control?
Condicionales
Reto 5: algoritmos con variables y condicionales
Ciclos
Reto 6: algoritmos con ciclos
Try Catch
Reto 7: algoritmos con manejo de errores
Quiz: Estructuras de control
Funciones
¿Qué es una función en programación?
Scope o alcance en funciones
Reto 8: algoritmos con funciones
Próximos pasos
Toma el Curso de Pensamiento Lógico: Lenguajes de Programación
No tienes acceso a esta clase
¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera
Para entender un poco más el uso de funciones, resolvamos los siguientes problemas, de esta manera identificarás cómo utilizarlos.
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)
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 84
Preguntas 8
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])
}
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.
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
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…
Así lo hice yo en JS. Agradezco todo feedback que me den
seria mas facil el aprendizaje si las explicaciones fueran mas practicas :’)
if (H<=23){
M=0 M++
}
siganle…
de nada.
😗
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]);
}
Asi quedo mi practica de reloj digital.
https://github.com/IVAN-DALI-GARCIA/RELOJ_DIGITAL_12_HRS.git
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]++;
}
}
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);
}
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();
¿QUE OPINAN DE ESTA FUNCION?
¿ES VALIDO Y FUNCIONAL ESTE RELOJ?
En mi aporte realice funciones que luego llame en el ciclo, que pueden ser reutilizadas. A la orden cualquier pregunta
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]);
}
Mi reto 8, saludos a todos.
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 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 }
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.
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;
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)
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.
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 compañeros, buen día!!
Así desarrollé yo el algoritmo. Me cuentan cómo les parece que quedó:
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}}}}
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
}
/* Funciones con parametros */
let tipo = [horas, minutos, segundos];
let limites = [24, 60, 60];
function validar(tipo, limite) {
if (tipo == limite) {
tipo = 0;
}
}
for (let i = 0; i < tipo.length; i++) {
validar(tipo[i], limites[i]);
}
Acá mi aporte al desafío usando ciclos.
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)
public class ValidarTiempo {
public static void validar(int tipo, int limite) {
if (tipo == limite) {
tipo = 0;
}
}
public static void main(String[] args) {
int[] tipos = {h, m, s};
int[] limite = {60, 60, 24};
for(int i = 0; i < tipos.length; i++) {
validar(tipos[i], limite[i]);
}
}
}
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);
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
Tengo una duda sobre el diagrama en el minuto 2:14, ¿la hora final no seria 24? Algo tal que así:
Si H = 24 --> H = 0
//Seria 24, ya que dijimos que la hora final seria a las 23:59:59,
//Por lo cual la siguiente hora sería 24
Que opinan 🤔
Explicación básica interesante
Codigo en TS
let Hours = 0;
let Minutes = 0;
let Seconds = 0;
function ValidateTime(tipo: number, limite: number) {
if (tipo === limite) {
tipo = 0;
return tipo;
}
++tipo;
return tipo;
}
function transformString(time: number) {
const transform = String(time);
if (transform.length < 2) {
return `0${transform}`;
}
return transform;
}
setInterval(() => {
const limitSeconds = 59;
const limitMinutes = 59;
const limitHours = 24;
Seconds = ValidateTime(Seconds, limitSeconds);
if (Seconds === limitSeconds) {
Minutes = ValidateTime(Minutes, limitMinutes);
}
if (Minutes === limitMinutes) {
Hours = ValidateTime(Hours, limitHours);
}
const transformedHour = transformString(Hours);
const transformedMinutes = transformString(Minutes);
const transformedSeconds = transformString(Seconds);
console.log(
`${transformedHour}:${transformedMinutes}:${transformedSeconds}`
);
}, 1000);
Output 00:01:00
Que bueno ir viendo como avanza el proceso ahora unificando en una funcion el ejercicio de la hora.
Mi codigo lo haría asi:
Definir variables:
h= m= s= 0
Definir funcion:
Entrada --> Tipo = [h, m, s]
Limite = [60, 60,24]
Funcion Validar (Tipo, Limite)
if Tipo == Limite
Tipo=0
end if
End Funcion
While h < 24
s=s+1
if s == 60
m=m+1
end if
if m == 60
h=h+1
end if
For (i=1:1:3)
(Llamar la funcion validar)
Funcion Validad (Tipo(i), Limite(i))
End for
Mostrar h : m : s
end while.
Que les parece?
Hola!
Vi a muchos compañeros compartiendo sus implementaciones, aquí les dejo la mía por si les es de utilidad.
let times = [55, 59, 23] // Initialize here s,m,h
let limits = [60, 60, 24]
function time() {
times[0] += 1 // Seconds increment
for(let i = 0; i < times.length; ++i) {
let step = validate(times[i], limits[i])
times[i] = step ? 0 : times[i]
if(step && i<2) {
times[i+1] += 1
}
}
// Printing result to console
console.log(`El reloj marca: ${(times[2]<=9) ? "0"+times[2] : times[2]}:${(times[1]<=9) ? "0"+times[1] : times[1]}:${(times[0]<=9) ? "0"+times[0] : times[0]}`);
}
function validate(currentValue, limit) {
return currentValue === limit;
}
//dos funciones mi aporte
import java.io.IOException;
public class Febrero01_DosReloj {
public static void main(String[] args) throws IOException, InterruptedException {
int horas = 0, minutos = 0, segundos = 0;
while(true) {
//mostrar
horaMinuto(horas);
horaMinuto(minutos);
second(segundos);
//aumentar el tiempo
segundos++;
//comprobar el tiempo
if (segundos == 60) {
segundos = 0;
minutos++;
if (minutos == 60) {
minutos = 0;
horas++;
if (horas == 24) {
horas = 0;
}
}
}
Thread.sleep(1000);
}
}
public static void horaMinuto(int valor){
if(valor<10){
System.out.print("0");
}
System.out.print(valor+":");
}
public static void second(int valor2){
if(valor2<10){
System.out.print("0");
}
System.out.println(valor2);
}
}
empieza de la 0:0:0 horas y termina en 24:0:0 horas díganme si lo puede optimizar mas acepto feedback
hora=0;
minuto=0;
segundo=0;
function tiempo(){
if(segundo==60){
segundo=0;
minuto++
}
if(minuto==60){
minuto=0;
hora++;
}
document.write(hora +" " + minuto + " " + segundo + "<br>");
segundo++;
}
while(segundo<=60 && minuto <60 && hora<24){
tiempo();
}
Ejemplo del reloj en python.
similar al de compañero de abajo
// Code in TypeScript: Create clock
// ----------------------------------------------
let tipos: string[] = ["Hora", "Minuto", "Segundo"];
let limites: number[] = [24, 60, 60];
let reloj: number[] = [0, 0, 0];
let relojString: string[] = ["00", "00", "00"];
let relojStringFinal: string = "";
let relojInterval: any;
function actualizarReloj() {
relojString = reloj.map((item) => {
return item < 10 ? "0" + item : item.toString();
});
relojStringFinal = relojString.join(":");
console.log(relojStringFinal);
}
function iniciarReloj() {
relojInterval = setInterval(() => {
reloj[2]++;
for (let i = 2; i >= 0; i--) {
if (reloj[i] >= limites[i]) {
reloj[i] = 0;
reloj[i - 1]++;
}
}
actualizarReloj();
}, 1000);
}
function detenerReloj() {
clearInterval(relojInterval);
}
iniciarReloj();
// ----------------------------------------------
def start_clock():
hours = 0
minutes = 0
seconds = 0
while True:
# Los segundos siempre se incrementan
seconds += 1
# Si los segundos llegan a 60, se incrementan los minutos, lo mismo pasa con las horas.
# Ejemplo: (5 // 60 = 0) (60 // 60 = 1)
minutes += seconds // 60
hours += minutes // 60
# Los segundos y minutos se resetean a 0 cuando llegan a 60, y las horas a llegan a 24.
# Ejemplo: (5 % 60 = 5) (60 % 60 = 0)
seconds %= 60
minutes %= 60
hours %= 24
print(f"{hours:02d}:{minutes:02d}:{seconds:02d}")
start_clock()
tipos( H,M,S)
limite (24,60,60)
function validar (tipo, limite)
if (tipo = limite)
return tipo 0;
else
return tipo;
for (i=0, i <= limite, i++)
return i;
Intenté Crear un reloj pero no pude hacer que el contador avanzara en el mismo <p> 😒
Tuve que dejar que se hiciera una lista . Es decir no es dinámico. Pero bueno ya aprenderé a hacerlo.
let h = 0;
let m = 0;
let s = 0;
let limite = [23, 60, 60];
function mostrar(){
document.getElementById("reloj").innerHTML = h+":"+m+":"+s;
document.write(h+":"+m+":"+s+"<br>");
}
function validar (tipo, limit){
if (tipo==limit){
tipo=0;
}
}
for (h=0;h<24;h++){
validar(h,limite[0]);
mostrar()
for(m=0;m<60;m++){
validar(m,limite[1]);
mostrar()
for(s=0; s<60; s++){
validar(s,limite[2]);
mostrar()
}
}
}
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);
const type = [“S”, “M”, “H”];
const deadline = [60, 60, 24];
function timeHandler(type, deadline){
if(type == deadline){
type = 0;
}
} // Also, this function could be like this:
const timeHandler = (parameters) => {
instruction
}
for (i = 0; i < type.length; i++) {
timeHandler(type[i], deadline[i]);
console.log(type[i], deadline[i]); // To verify the result of this for bucle
}
si, pienso igual que otros compañeros, no se puede comparar tipo = limite, ya que tipo es S, M u H y limite es 60, 60 o 24.
La comparación correcta es el numero de tiempo (S, M u H, vs el limite).
Se establece el ciclo FOR inicializando i = 0, luego cuando el ciclo sea menor que tres (tres por cada ciclo el de segundos, minutos y horas), debe hacer una iteración, hasta que entrada sea igual a límite
<code>
int entrada = 0;
int limite=0;
if (limite == 60){
for (int i = 0; i < limite; i++){
if (entrada == limite){
entrada = 0;
}
}
}
if (limite == 24){
for (int i = 0; i < limite; i++){
if (entrada == limite){
entrada = 0;
}
}
}
h = 0
m = 0
s = 0
formato = [h, m, s]
limite = [24, 60, 60]
function validar(formato,limite){
if (formato == limite) {
return formato = [h=0, m=0, s=0,]
}
}
function contador (formato, limite){
while (formato.length[0] > limite.length[0]){
if (formato.length[0] > limite.length[0]) {
validar(formato,limite)
}else if (formato.length[1] == limite.length[1]) {
formato.length[0]++
formato.length[1] = 0
}else if (formato.length[2] == limite.length[2]) {
formato.length[1]++
formato.length[2] = 0
}else
formato.length[2]++
}
}
<code>
// inicializamos las variables
let segundos=60;
let minutos=60;
let hora=4;
// creamos una funcion para cada uno de los tiempos
// Creamos una funcion para segundos
function incrementarSegundos(parametroSegundo){
if(parametroSegundo==60){
parametroSegundo=0
}
else{
parametroSegundo=parametroSegundo+1
}
}
// Creamos una funcion para minutos
function incrementarMinutos(parametroMinuto){
if(parametroMinuto==60){
parametroMinuto=0
}
else{
parametroMinuto=parametroMinuto+1
}
}
// Creamos una funcion para Hora
function incrementarHoras(parametroHora){
if(parametroHora==24){
parametroHora=0
}
else{
parametroHora+1
}
}
incrementarSegundos(segundos);
incrementarMinutos(minutos);
incrementarHoras(hora);
let tipos = [{hora: 0, limite: 24}, {minuto: 0, limite: 60}, {segundo: 0, limite: 60}];
let validar = (tipo, limite) => {
if (tipo == limite) {
tipo[0] = 0;
}
};
for (let tipo of tipos) {
validar(tipo[0], tipo.limite)
};
while tipo = limite;
tipo = 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");
}
}
}
}
var s = 0, m = 0, h = 0
while(h <= 23){
while(m <= 59){
while(s <= 59){
//Mostrar tiempo
console.log("Hora: ", h, "Minuto: ", m, "Segundo: ", s)
s=s+1
}
s=0
m=m+1
}
m=0
h=h+1
}
h=0
console.log("Hora: ", h, "Minuto: ", m, "Segundo: ", s)
{
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()
def inicio():
h = 0
m = 0
s = 0
return h, m, s
def validar():
h,m,s = inicio()
limites = 59
limitem = 60
limiteh = 24
while h < limiteh:
if s == limites:
s = 0
m = m + 1
if m == limitem:
m = 0
h = h + 1
s = s + 1
if h < limiteh:
print(f'la hora es: {h}:{m}:{s}')
if __name__ == '__main__':
validar()
ACEPTO CORRECIONES UU
aqui esta mi reloj con un siclo while 😄
let s = 0
let m = 0
let h = 0
let limite = 60
let limiteh = 24
relog()
function relog(){
while(s<limite){
s++
if(s==limite){
s = 0
m = m + 1
if(m==limite){
m = 0
h = h + 1
if(h==limiteh){
h = 0
}
}
}
console.log("segundos", s)
console.log("minutos", m)
console.log("horas",h)
}
}
⚡🧠¡Intentando resolver el reto!
Aplicando condicionales, ciclos y funciones =D
let h = 0;
let m = 0;
let s = 0;
function tiempo(h_inicial, m_inicial, s_inicial) {
h = h_inicial
m = m_inicial
s = s_inicial
segundo()
}
function segundo() {
while (s <= 59) {
console.log(`${h <= 9 ? '0' + h : h}:${m <= 9 ? '0' + m : m}:${s <= 9 ? '0' + s : s}`)
s += 1
}
minuto()
}
function minuto() {
s = 0
if (m < 59) {
m += 1
segundo()
} else {
hora()
}
}
function hora() {
s = 0
m = 0
if (h < 23) {
h += 1
segundo()
} else {
h = 0
segundo()
}
}
tiempo(0, 0, 0);
y ahora si terminé el curso…
¿Quieres ver más aportes, preguntas y respuestas de la comunidad?
o inicia sesión.