Introducción

1

Desafíos para Entrenar tu Pensamiento Lógico

Desafío 1: Problema

2

Cajas de Frutas

Quiz: Desafío 1: Problema

Desafío 1: Solución

3

Solución al desafío de Cajas de Frutas

Desafío 2: Problema

4

Operación Matemática Oculta

Quiz: Desafío 2: Problema

Desafío 2: Solución

5

Solución al desafío de Operación Matemática Oculta

6

Playground: Operación Matemática Oculta

Desafío 3: Problema

7

Carrera de Automóviles

Quiz: Desafío 3: Problema

Desafío 3: Solución

8

Solución al desafío de Carrera de Automóviles

Desafío 4: Problema

9

Identifica la operación

Quiz: Desafío 4: Problema

Desafío 4: Solución

10

Solución al desafío de identifica la operación

11

Playground: Obtén el factor multiplicador

Desafío 5: Problema

12

Los signos matemáticos

Quiz: Desafío 5: Problema

Desafío 5: Solución

13

Solución al desafío de signos matemáticos

Desafío 6: Problema

14

Operaciones matemáticas

Quiz: Desafío 6: Problema

Desafío 6: Solución

15

Solución al desafío de operaciones matemáticas

Desafío 7: Problema

16

Figuras lógicas

Quiz: Desafío 7: Problema

Desafío 7: Solución

17

Solución al desafío de figuras lógicas

Desafío 8: Problema

18

Identifica la operación

Quiz: Desafío 8: Problema

Desafío 8: Solución

19

Solución al desafío de identifica la operación

Desafío 9: Problema

20

Secuencias de Dominos

Quiz: Desafío 9: Problema

Desafío 9: Solución

21

Solución al desafío de secuencia de dominos

Desafío 10: Problema

22

Une los puntos

Desafío 10: Solución

23

Solución al desafío de une los puntos

Desafío 11: Problema / Solución

24

Playground: Reduce el número a 1 en la menor cantidad de pasos

Desafío 12: Problema / Solución

25

Playground: Imprime los números primos

Desafío 13: Problema

26

Encuentra la lógica del mandato

Quiz: Desafío 13: Problema

Desafío 13: Solución

27

Identifica la lógica - Platzi

Desafío 14: Problema

28

Identifica los números

Quiz: Desafío 14: Problema

Desafío 14: Solución

29

Solución al desafío de identifica los números

No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Playground: Reduce el número a 1 en la menor cantidad de pasos

24/29

Aportes 119

Preguntas 12

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

creo que estas pruebas son para profesionales porque los que estamos empezando lo digo por mi caso en particular estoy es anotando las soluciones y tratando de entender de donde sale cada cosa porque la verdad esta dificil.

Mi solución.

export function solution(num) {
  let resp = 0;
  while (num > 1) {
    if (num % 2 === 0) {
      num = num / 2;
    } else if (num % 4 == 3) {
      num++;
    } else {
      num--;
    }
    resp++;
  }
  return resp;
}

hay contados casos en los que es mejor sumar que restar, según mis pruebas esos números fueron el 7, 15 y 23

No encontré patrones entre esos números mas que al sacar modulo 4 todos esos números devuelven 3.

La función tiene un bucle while que se ejecuta mientras num sea mayor que 1. En cada iteración del bucle, se incrementa un contador llamado count y se realizan varias operaciones condicionales basadas en el valor de num.
.

  • La primera condición es: if (num % 2 === 0). Aquí, se está utilizando el operador módulo (%) para obtener el resto de la división de num entre 2. Si este resto es igual a 0, significa que num es divisible entre 2. En este caso, se divide num entre 2 mediante num = Math.floor(num / 2); y se imprime un mensaje indicando el nuevo valor de num en la consola.
    .
  • La segunda condición es: else if (num % 4 === 1 || num === 3). Aquí, se está verificando dos cosas. Primero, si el resto de la división de num entre 4 es igual a 1. Segundo, si num es igual a 3. Si se cumple alguna de estas dos condiciones, se resta 1 a num mediante num -= 1; y se imprime un mensaje indicando el nuevo valor de num en la consola.
    .
  • Por último, si ninguna de las condiciones anteriores se cumplen, se sigue con el siguiente bloque else donde se suma 1 a num mediante num += 1; y se imprime un mensaje indicando el nuevo valor de num en la consola.
    .
  • Finalmente, después de salir del bucle while, la función devuelve el valor del contador, count.
    .

export function solution(num) {
  // Initialize a count variable to keep track of the number of steps
  let count = 0;
  // Loop while the number is greater than 1
  while (num > 1) {
    // Increment the count at the start of each iteration
    count++;
    // If the number is divisible by 2, divide it by 2
    if (num % 2 === 0) {
      num = Math.floor(num / 2);
      console.log("Mádulo 2 de n = 0; " + num)
    }
    // If the number is equal to 3 or the remainder of dividing it by 4 is 1, subtract 1
    else if (num % 4 === 1 || num === 3) {
      num -= 1;
      console.log("Mádulo 4 de n = 1 || n = 0; " + num)
    }
    // If none of the above conditions are met, add 1 to the number
    else {
      num += 1;
      console.log("n + 1; " + num)
    }
  }
  // return the count variable
  return count;
}

💚SOLUCIÓN CON EXPLICACIÓN 💚

🛡️MURO ANTI-SPOILERS🛡️


La dificultad de este ejercicio radica en saber si es mejor SUMAR o RESTAR cuando el número que se nos presenta es impar.
Lo ideal es hacer diferentes pruebas de escritorio para nosotros e ir viendo paso a paso el comportamiento. Podemos ayudarnos de una tabla en donde vayamos registrando cuantos pasos se necesitan para llegar a 1.

🎯TIP1:

Para hacer este proceso más sencillo en el momento de encontrar un número IMPAR, saltarselo y hacer la prueba con el número siguiente (que será PAR) de la siguiente manera:

De esta manera podremos fijarnos de manera más sencilla que acción es ideal ya que:

  • Si elegimos SUMAR serán los pasos del número siguiente + 1.
  • Si elegimos RESTAR serán los pasos del número anterior + 1.

En este caso con el número 3 conviene elegir RESTAR ya que sumaríamos 1 + 1 quedando de la siguiente manera:

🎯TIP2:

Cuando estemos calculando los números PARES muchas veces nos daremos cuenta que al dividir por primera vez en 2 nos da un número que muy posiblemente ya habíamos calculado sus pasos (Ejemplo: 6 / 2 = 3) por lo que bastaría sumarle 1 a los pasos del número resultado de la división:

Pasos de 6 = ( Pasos de 3 ) + 1 
Pasos de 6 =  2 + 1
Pasos de 6 = 3

👁️OBSERVACIÓN:

Si continuamos la tabla como a continuación:

Nos daremos cuenta de que en la mayoría de los casos es más factible RESTAR o simplemente NO IMPORTA por lo que el secreto aquí es encontrar un PATRÓN en los números en los que sí es mejor SUMAR.

🔑DEVELANDO EL SECRETO

En mi caso, decidí continuar mi tabla hasta el número 40 donde encontré que en los números [15, 23, 31, 39] es más factible SUMAR.

Como no encontré alguna operación matemática que pudiera relacionar estos números (al menos no tan directa como si fueran divisibles entre ellos o fueran múltiplos de algún otro número) decidí usar la operación MÓDULO (%) (recordemos que la operación módulo es el residuo de la división entre 2 números) con los números [15, 23, 31, 39] y los números del 2 al 7 de la siguiente manera:

15%2 = 1
23%2 = 1
31%2 = 1
39%2 = 1
15%3 = 0
Y así sucesivamente...

De modo que, al registrarlos en una tabla (o en mi caso con ayuda de Excel) ¡Encontramos nuestro famoso patrón!

Donde podemos observar que el módulo 4 de todos los números donde es más factible SUMAR da 3.
Es por ello que podemos ocupar este dato para integrarlo en nuestro código, donde cuando el número sea IMPAR además verifiquemos si el num % 4 == 3 entonces sumamos , de lo contrario restamos:

// Si el modulo 4 es == 3 SE SUMA
if (num % 4 == 3)
	num++;
else
	num--;
}

Puedes ver el código completo más abajo…

🎖️CONCLUSIÓN

Como te darás cuenta, la mayoría de estos ejercicios se trata de encontrar patrones por lo que te invito a no darte por vencido e intentar ocupar cualquier concepto que se te venga a la mente, ya sea matemático o puramente visual. Espero este aporte te haya ayudado a comprender el problema 💚

👾CÓDIGO

export function solution(num) {
  let pasos = 0;

  while (num > 1) {
    if (num % 2 == 0) { //PAR
      num = num / 2
    } 
    else { // IMPAR
      // Si el modulo 4 es == 3 SE SUMA
      if (num % 4 == 3)
        num++;
      else
        num--;
    }
    //AUMENTAMOS LOS PASOS
    pasos++;
  }

  return pasos
`

cada vez que pasa un reto entiendo menos. a alguien más le pasa?

Si que me costo!! Aqui mi solucion:

<export function solution(num) {
  let response = 0

  while (num > 1) {
    if (num % 2 === 0) {
      num = num / 2
    } else if (num % 2 != 0) {
      if ((((num + 1) / 2) % 2) != 0) {
        num--
      } else {
        num++
      }
     
    }
    response++
  }
  return response

}
> 

Hola compañeros, es un echo que el ejercicio está mal explicado respecto a que es lo que se requiere, al inicio yo pensaba que lo que se pedía era que la función recibiera un número y lo redujera a 1, pero no es esto lo que se requiere. Realmente el ejercicio lo que solicita es retornar el número de pasos con el que la función redujo a 1 el número inicial.

Aquí les comparto mi solución al ejercicio ya revisado y validado, me costo mucho lograrlo pero pude hacerlo

Ha manera de consejo para el ejercicio, lo más difícil está en saber en que momento sumar la unidad o restar la unidad.

No soy un supermatematico, pero dadas las condiciones jajaja esto también es una respuesta:

num=num/num

Mi solución abajo

Funciona haciendo los dos puntos iniciales de la guía. Y para reducir números más grandes más rápido, siempre se suma 1 hacia número múltiplos de 4, o si no se resta.
.
.
.
.

export function solution(num) {
  let pasos = 0;
  while ( num != 1 && num != 0 ) { 
    if ( num % 2 ) { 
      ((num + 1) % 4) ? --num : ++num ;
    } else {
      num /= 2;
    }
    ++pasos;
  }
  console.log(num)
  return pasos;
}

La instrucción es muy poco clara, no dice que el objetivo en mostrar los paso en lo que se redujo el numero

Dios mioooooo!!! Pase dos dias tratando de resolver el problema y no pude lograrlo sola. Si estas igual que yo, no te quedes aca!! avanza, mira los aportes, aprende de los demas. No hagan como yo, no se puede aprender en 1 dia como resolver problemas que se logra solo con la practica y experiencia. Tenia una idea de como lograrlo, hice borradores, corridas en frio, todo y aun asi me costo mucho. Aunque la logica que uso en mi codigo es muy diferente a los demas aportes, es la que puedo dominar hasta el momento. La verdad que los demas aportes se me hicieron dificiles de leer en cuanto a la logica que utilizaron xD, mis felicitaciones!! estan a otro nivel xD jejeje. Espero poder orientar a alguien con este aporte. Y tranquilo/a si aun no lo logras, no dejes que la frustracion te ciegue, todo toma un tiempo, no hay que sentirse mal. Yo tuve que acudir a mi esposo (developer) para que me orientara. Este es solo un paso mas para aprender. ```js export function solution(n) { let i = 0 do { if (n % 2 === 0) { n = n / 2 } else { let countSuma = dividirNumeroImparConSuma(n) let countResta = dividirNumeroImparConResta(n) if (countSuma < countResta) { n += 1 } else { n -= 1 } } i++ } while (n > 1); return i } function dividirNumeroImparConSuma(n) { let count = 0 do { if (n % 2 === 0) { n = n / 2 } else { n += 1 } count++ } while (n > 1); return count } function dividirNumeroImparConResta(n) { let count = 0 do { if (n % 2 === 0) { n = n / 2 } else { n -= 1 } count++ } while (n > 1); return count } ``` Entramos a la funcion `solution()` y mientras `n` sea mayor a 1 se correra el ciclo `dowhile()` . Que tengo que evaluar? si el numero es par `if (n % 2 === 0)`. Si no es par entonces debo considerar si sumo o resto `1`. Dependiendo cual de los dos metodos (`n+1` o `n-1`) sea el mas corto, decidire si se suma o se resta dentro del ciclo `dowhile()` en la funcion `solution()`. Para tomar esa decision, guardo en una variable (`countSuma` y `countResta`) las vueltas/iteraciones/ciclos que debo realizar para llevar el numero que se introduce hasta `1`. Aca entran las funciones `dividirNumeroImparConSuma()` y `dividirNumeroImparConResta()`. Cada una tiene un contador interno `count`, el cual es retornado al salir de su respectivo ciclo `dowhile()` y se alojan en las respectivas variables `countSuma` y `countResta`. Una vez se obtienen los `count` se compara cual tiene menos pasos. Si el de `sumar` es menor al de `restar` entonces sumo, sino resto `1` al `n`. El contador `i` es el que muestra cuantos pasos en total se realizan para reducir un numero a 1. `i` contabiliza como un paso la suma o resta de `1` para convertir el numero impar en par, y asi poder dividirlo entre 2 hasta que el cociente sea 1. Como dije es la logica que puedo comprender por el momento. Espero poder orientar a alguien :).

Hola, les comparto mi solución del ejercicio; puede ser difícil pero lo difícil es lo que más enseña. Soy ingeniero electrónico entonces tengo experiencia; Intenten entender la solución, pero no se preocupen, con el tiempo lograran solucionarlo por sí mismos. (^-^)/

  1. Hacemos la condición: Sí num es par (num % 2 == 0) entonces haga num/2

  2. En caso contrario pregunte Sí (num+1) / 2 da como resultado par, entonces haga num+1

  3. Sí no da resultado par entonces haga num-1

  4. durante cada ciclo del While se incremeta la variable steps + 1

  5. Limitamos toda la logica con el While para que se ejecute hasta que num sea igual a 1

export function solution(num) {

  let steps = 0

  while (num != 1) {
    if (num % 2 == 0) {
      num = num / 2
    } else if (((num + 1) / 2) % 2 == 0) {
      num = num + 1
    } else {
      num = num - 1
    }
    steps++
  }

  return steps
}

Uno que disque aprendiendo los fundamentos de programación y ya le ponen retos de estos, me parece que no tiene sentido.

PLATZIIII más pedagogia que es esto por favor, uds pueden hacer una mejor labor.

Si estamos acá es porque aún estamos construyendo las bases del codigo

La guia del ejercicio no se entiende por si mismos, toca hacer una prueba o leer en los comentarios para saber que el 5 de la salida (en el ejemplo de la guia) es lo que toca retornar.

El ejercicio se me complicó bastante y el código seguro me habrá quedado mal pero funciona y es lo importante 😅. La verdad me gustan estos retos porque me lleva tiempo llegar a la solución y entreno el pensamiento lógico y sobre todo la paciencia, además me encanta ver tantas formas de llegar a la misma solución con los aportes de los compañeros. Aquí mi solución:

export function solution(num) {
  let number = num;
  let results = [];

  do {
    if (number % 2 == 0) {
      number = number / 2;
      results.push(number);
    } else {
      number = number + 1;
      let checkNumber = number / 2;
      if (checkNumber % 2 > 0) {
        number = number - 2;
      }
      results.push(number);
    }
  } while (number > 1)

  if (number == 1) {
    let steps = results.length;
    return steps;
  } else {
    return 0;
  }
}

Mi solución:

export function solution(num) {
  var steps = 0
  while (num > 1) {
    if (num % 2 === 0) {
      num = num / 2
    } else if (((num - 1) / 2) % 2 == 0) {
      num --
    } else {
      num ++
    }
    console.log(num)
    steps ++
  }
  return steps
}
export function solution(num) {
  // Tu código aquí 👈
  let steps = 0
  while (num > 1) {
    steps = steps + 1
    if (num % 2 == 1) {
      if (((num + 1) / 2) % 2 == 1) {
        num--
      } else {
        num++
      }
    } else {
      num = num / 2
    }
    
  }
  return steps
}
solution()
  var steps = 0;
  while (num > 1) {
    if (num % 2 == 1) {
      if ((((num + 1) / 2) % 2) == 1) {
        num -= 1;
      } else {
        num += 1;
      }
      steps++;
    } else {
      num /= 2;
      steps++;
    }
  }
  return steps;

Mi respuesta con programcion dinamica * memoizacion

const rutas = {}

function solution (num) {
  return cumplirRegla(num)
}

function cumplirRegla (num) {
  if (num <= 1) return 0
  if (!!rutas[num]) {
    return rutas[num]
  }
  if (num % 2 !== 1) {
    const divisible = cumplirRegla(num / 2)
    if (!rutas[num]) {
      rutas[num] = divisible + 1
    }
    return divisible + 1
  } else {
    const mas1 = cumplirRegla(num + 1)
    const menos1 = cumplirRegla(num - 1)

    const result = mas1 > menos1 
	? menos1 + 1
 : mas1 + 1
    if (!rutas[num]) {
      rutas[num] = result
    }

    return result
  }

}
Buenas tardes: Aca la solución al problema entiendo que todos tenemos formas de resolver problemas de manera distinta! : export function solution(num) {   let auxCont = -1;   if (num == 0) {    return 0;  }   while (num >= 1) {    auxCont++;     if (num == 1) {        return 0;    }    if (num % 2 == 1) {      num = num - 1;     } else if (num % 2 == 0) {      num = num / 2;       if (num == 1) {        console.log(auxCont);        return auxCont;      }     }   }}
Aquí mi soluciónexport function solution(num) {  let out = 0;  if (num == 0 || num == 1) return 0;  while (num > 1) {    if (num % 2 == 0) {      num /= 2;      out++;    } else {      num -= 1;      out++;    }  }  return (out - 1) >= 0 ? out - 1 : 0;} ```js export function solution(num) { let out = 0; if (num == 0 || num == 1) return 0; while (num > 1) { if (num % 2 == 0) { num /= 2; out++; } else { num -= 1; out++; } } return (out - 1) >= 0 ? out - 1 : 0; } ```
```js export function solution(num) { let pasos = 0; while (num !== 1) { if (num % 2 === 0) { num = num / 2; } else { if (num === 3 || num % 4 === 1) { num--; } else { num++; } } pasos++; } return pasos; } ```
![](https://static.platzi.com/media/user_upload/Captura%20de%20pantalla%202024-03-18%20a%20la%28s%29%2016.40.04-ff2649e6-b613-4098-9404-e697fa160035.jpg)
Este vendría a ser mi código, falta explicar que lo que se desea es la cantidad de pasos, y que tanto la suma como la resta, cuentan como pasos y no solo las divisiones. Espero que el código pueda ser entendible, sino me escriben y les daré todo mi apoyo. Por cierto no estoy familiarizado con este tipo de lenguaje, así que me tomo todo el día. ```js export function solution(num) { // Tu código aquí 👈 let pasos = 0; if (num == 0 || num == 1) { pasos = pasos; } else { do { if (num % 2 == 0) { num = num / 2; pasos = pasos + 1; } else { if ((num + 1) % 16 == 0) { num = num + 1; pasos = pasos + 1; } else if ((num - 1) % 16 == 0) { num = num - 1; pasos = pasos + 1; } else if ((num + 1) % 8 == 0) { num = num + 1; pasos = pasos + 1; } else if ((num - 1) % 8 == 0) { num = num - 1; pasos = pasos + 1; } else if ((num + 1) % 4 == 0) { num = num + 1; pasos = pasos + 1; } else if ((num - 1) % 4 == 0) { num = num - 1; pasos = pasos + 1; } } } while (num !== 1); } return pasos; } ```Este vendría a ser mi código, falta explicar que lo que se desea es la cantidad de pasos, y que tanto la suma como la resta, cuentan como pasos y no solo las divisiones. Espero que el código pueda ser entendible, sino me escriben y les dare todo mi apoyo. Por cierto no estoy familiarizado con este tipo de lenguaje, así que me tomo todo el día.
Este vendría a ser mi código, falta explicar que lo que se desea es la cantidad de pasos, y que tanto la suma como la resta, cuentan como pasos y no solo las divisiones. Espero que el código pueda ser entendible, sino me escriben y les dare todo mi apoyo. Por cierto no estoy familiarizado con este tipo de lenguaje, así que me tomo todo el día. export function solution(num) {  // Tu código aquí 👈  let pasos = 0;  if (num == 0 || num == 1) {    pasos = pasos;  }   else {    do {      if (num % 2 == 0) {        num = num / 2;        pasos = pasos + 1;      }      else {        if ((num + 1) % 16 == 0) {          num = num + 1;          pasos = pasos + 1;        }        else if ((num - 1) % 16 == 0) {          num = num - 1;          pasos = pasos + 1;        }        else if ((num + 1) % 8 == 0) {          num = num + 1;          pasos = pasos + 1;        }        else if ((num - 1) % 8 == 0) {          num = num - 1;          pasos = pasos + 1;        }        else if ((num + 1) % 4 == 0) {          num = num + 1;          pasos = pasos + 1;        }        else if ((num - 1) % 4 == 0) {          num = num - 1;          pasos = pasos + 1;        }       }     } while (num !== 1);  }  return pasos;}```js export function solution(num) { // Tu código aquí 👈 let pasos = 0; if (num == 0 || num == 1) { pasos = pasos; } else { do { if (num % 2 == 0) { num = num / 2; pasos = pasos + 1; } else { if ((num + 1) % 16 == 0) { num = num + 1; pasos = pasos + 1; } else if ((num - 1) % 16 == 0) { num = num - 1; pasos = pasos + 1; } else if ((num + 1) % 8 == 0) { num = num + 1; pasos = pasos + 1; } else if ((num - 1) % 8 == 0) { num = num - 1; pasos = pasos + 1; } else if ((num + 1) % 4 == 0) { num = num + 1; pasos = pasos + 1; } else if ((num - 1) % 4 == 0) { num = num - 1; pasos = pasos + 1; } } } while (num !== 1); } return pasos; } ```
```js function solution(num) { var steps = 0; while (num>1) { if (num%2 == 0) { num = num/2; } else if (num % 4 == 3) { num++; } else { num--; } steps++; } return steps; } ```
Y si solo nos dejamos de cocinar el coco y lo hacemos simple: `export function solution(num) {` `let steps = -1;` `if (num <= 1) {` `return 0;` `} while (num != 1) {` `if (num % 2 == 0) {` `num = num / 2` `} else {` `num--` `} steps++` `} return steps` `}`

Aquí mi solución, después de romperme hasta el alma, pero que bien se sintió resolverlo, quien lo diría, las potencias de 2 como divisores predecibles, me permitieron elegir entre la suma o la resta, que interesante desafío, nunca lo olvidaré, porque al analizarlo en Excel paso por paso llegué a esta conclusión, a lo mejor hay otros métodos, pero éste es el mío 100% sacado de mi análisis perseverante y minucioso.

Se los comparto con mucha satisfacción.

![](```

Aquí el código:

export function solution(num) {
  // Tu código aquí 👈
  let numActual = num;
  let pasos = 0;
  while (numActual > 1) {
    pasos++;
    if (numActual % 2 == 0)
      numActual = numActual / 2;
    else {
      if (divisorMaximo(numActual + 1) > divisorMaximo(numActual - 1))
        numActual++;
      else
        numActual--;

    }
  }

  return pasos;
}

function divisorMaximo(number) {
  let divisor;
  let potencia = 0;
  do {
    potencia++;
    divisor = Math.pow(2, potencia);  //los divisores serán potencias de 2, es decir 2,4,8,16,32,64, etc.
  } while (number % divisor == 0)
  return divisor;
}
Soy estudiante de Ingenieria de sistemas y siempre me destaque en las matemáticas pero créanme que siempre me ha costado a hacer los otros ejercicios los que colocan la solución ahi o una de dos saben mucho y ya trabajan en google o van y miran la solución luego devuelven y la sapean con dibujo y todo y hacen que saben mucho. acá les traigo una solución mas simple que yo he visto aquí: cual fue lo que me ayudo pues saber que debo saber que en el futuro si es par puedo dividir mas veces ```js export function solution(num) { let count = 0; do { if (num == 0) { break; } if (num == 1) { break; } count = count + 1; if (num % 2 == 0) { num = num / 2 } else { if ((num + 1) / 2 % 2 == 0) { num = num + 1 } else { num = num - 1 } } } while (num != 1) return count } ```export function solution(num) { let count = 0; do { if (num == 0) { break; } if (num == 1) { break; } count = count + 1; if (num % 2 == 0) { num = num / 2 } else { if ((num + 1) / 2 % 2 == 0) { num = num + 1 } else { num = num - 1 } } } while (num != 1) return count}
```js export function solution(num) { let pasos = 0 let numNew = num if (num === 0 || num === 1) { return 0 } else { while (numNew !== 1) { if (numNew % 2 === 0) { numNew = numNew / 2; } else { numNew = (numNew - 1) % 4 == 0 ? numNew - 1: numNew + 1 } pasos++ } return pasos } } ```La división es entre 4 por que calcula dos paso hacia adelante, por ejemplo si tenemos 15 y le quitamos uno es 14, pero 14 entre 2 es 7 por lo que tendriamos que volver a validar, sin embargo si sumamos 1 al 15 entonces en 16 y 16 entre 2 es 8 y 8 entre 2 es 4, por lo tanto seguimos diviendo por pares
Los requerimientos o la parte de la guía tiende a ser muy ambiguo, si la finalidad es reducir un número a uno, se me ocurren mil formas, pero no se precisa que se deba ir dividiendo constantemente. Simplemente tal cual `n - n + 1` Resuelve la primicia tan simple del problema pero no se detalla que es lo que se realmente se busca.
Mi solución es el siguiente ```js export function solution(num) { // Tu código aquí 👈 let resp = 0; while (num != 1) { if (num == 0) { break; } else if (num % 2 == 0) { num = num / 2; } else if (num % 4 == 3) { num++; } else { num--; } resp++; } return resp; } ```export function solution(num) {  // Tu código aquí 👈  let resp = 0;  while (num != 1) {    if (num == 0) {      break;    }    else if (num % 2 == 0) {      num = num / 2;    }    else if (num % 4 == 3) {      num++;    }    else {       num--;    }    resp++;  }  return resp;}

Este es mi solucion:

export function solution(num) {
  // Tu código aquí 👈
  var c = 0;
  var n = num;
  while (n / 2 >= 1) {
    c++;
    if (n % 2 == 0) {
      n = n / 2;
    }
    else {
      if ((n + 1) % 4 == 0) {
        n++;
      }
      else {
        n--;
      }
    }
  }
  return c;
}
```js export function solution(num) { if (num === 0) return 0; let pasos = 0; while (num !== 1 && isFinite(num)&& (num % 2 === 0 ? num /= 2 : num = (num + 1) % 4 === 0 ? num + 1 : num - 1)) { pasos++; } return isFinite(num) ? pasos : -1; } ```![]()![]()![](https://areajugones.sport.es/wp-content/uploads/2021/05/ozarru.jpg.webp)
No sé JS, pero lo hice usando PSeINT jajajaja ![](https://static.platzi.com/media/user_upload/imagen-d6e8035b-f380-4fd6-b919-778525a92a17.jpg) ![](https://static.platzi.com/media/user_upload/imagen-fc6dd8b8-47dd-494c-8583-ba880a3461f2.jpg)
Resulta intrigante el planteamiento, ya que indica que el número debe reducirse a 1. En este contexto, la solución comienza restando 1 para lograr su divisibilidad por dos, continuando así con sucesivas restas y divisiones hasta alcanzar dicho objetivo. Por otro lado, el resultado final indica 5. En este escenario particular, la estrategia difiere, ya que no se resta uno inicialmente, sino que se comienza sumando 1. Posteriormente, se lleva a cabo la división por dos en cada iteración, siguiendo este proceso hasta llegar al valor final de 5.
```js function solution(num){ let pasos = 0; while (num > 1) { if (num % 2 === 0) { num = num / 2; } else { if (num % 4 === 1 || num === 3) { num = num - 1; } else { num = num + 1; } } pasos++; } return pasos; } ``` ```js ```

Animo chicos, después de que aprendan más de programación verán que ejercicios como este es fácil, solo es pensar en la lógica del ejercicio y aplicarlo en el código.

Esta es mi solución:

function solution(num) {
    let resultado = 0
    if (num % 2 === 0) {
        resultado = num / 2
    } else {
        resultado = num + 1
    }
    console.log(resultado)
}
![](https://static.platzi.com/media/user_upload/image-2485ec9e-2927-412d-a88a-70d2a0be63ac.jpg)
Mi solución: `export function solution(num) { ` ` let resultado = 0;` ` while (num > 1) {` ` resultado++;` ` if (num % 2 == 0) {` ` num = num / 2;` ` }` ` else if ((num + 1) % 4 == 0) {` ` num = num + 1;` ` }` ` else {` ` num = num - 1;` ` }` ` } return resultado;` `}`

Muy interesante las soluciones que incluyen el módulo de 4 = 3, no se me hubiera ocurrido

![](https://drive.google.com/file/d/1zqnm7AO3LEtPwxZJeQ0o8UXnjvlObZLF/view?usp=drive_link)vacilatela mi llave 🤠
```js export function solution(num) { // Tu código aquí 👈 // Declaro contador de pasos let cont = 0; // Usamos un ciclo while con un condicional que controla el caso en que el número ingresado pueda ser 0 para no inicializar el ciclo while (num > 1) { // Esta condición valida si el número es par if (num % 2 == 0) { num = num / 2; cont += 1; } // Estas 2 condiciones valida si el número es impar y decidimos con la condición si nos conviene sumar o restar 1, basándonos que el valor óptimo es el que nos permite que al restarle o sumarle nos permita dividirlo entre 4 else if ((num - 1) % 4 == 0) { num = (num - 1) / 4; cont += 3; } else { num = (num + 1) / 4; cont += 3; } } return cont; } ```
Asi quedo mi solución export function solution(num) {  while (num != 1) {    if (num % 2 === 0){      num = num / 2;    } else {      num++;    }  }  return num;}
```js export function solution(num) { // Tu código aquí 👈 if (num === 1) { return 0; // Ya hemos llegado a 1, no se necesita ningún paso. } else if (num % 2 === 0) { return 1 + solution(num / 2); // Si es par, dividir por 2 es una opción. } else { // Si es impar, tenemos dos opciones: sumar 1 o restar 1. const option1 = 1 + solution(num + 1); const option2 = 1 + solution(num - 1); // Retornar la opción con la menor cantidad de pasos. return Math.min(option1, option2); } } const resultado = solution(15); console.log(resultado); // 5 ```export function solution(num) {  // Tu código aquí 👈    if (num === 1) {    return 0; // Ya hemos llegado a 1, no se necesita ningún paso.  } else if (num % 2 === 0) {    return 1 + solution(num / 2); // Si es par, dividir por 2 es una opción.  } else {    // Si es impar, tenemos dos opciones: sumar 1 o restar 1.    const option1 = 1 + solution(num + 1);    const option2 = 1 + solution(num - 1);    // Retornar la opción con la menor cantidad de pasos.    return Math.min(option1, option2);  }} const resultado = solution(15);console.log(resultado); // 5
export function solution(num) {
  let counter = 0
  while (num > 1) {
    if ((num % 2) === 0) {
      num = num / 2
      counter++
    } else {
      num = (num + 1) / 2
      counter++
    }
  }
  return counter
}

Este es mi aporte, pero siento que el ejercicio no está del todo claro ni bien planteado. Mi algoritmo reduce el número literalmente a “la menor cantidad de pasos posibles”, el 15 lo reduce en 4 pasos, y no en los 5 que pide el ejercicio, y el 328593 lo reduce en 19 pasos y no en los 23 que pide, y para colmo me los tira como errores, cuando claramente estoy logrando el objetivo, estoy reduciendo números a 1 en la menor cantidad posible de pasos. Para esa gracia, el enunciado debía decir “debe reducir el 15 en 5 pasos y el 328593 en 23 pasos, NO en menos”. Este ejercicio deja mucho que desear, y si confunde a los que vamos un poquito adelante, no me quiero ni imaginar a los que vienen empezando.

Buen dia, asi me funciono

export function solution(num) {
  // Tu código aquí 👈
  let resp = 0;
  if (num == 1) {
    resp = 0;
  }
  else{
    while (num > 1) {
      if (num % 2 === 0) {
        num = num / 2;
      }
      else if (num % 4 == 3) {
        num++
      }
      else {
        num--;
      }
      resp++;
    }
  }
  return resp;
}

En Java:

public class Code24 {

    public static void main(String[] args) {

        System.out.println(solution(15));

    }

    public static int solution(int a) {

        int count = 0;

        while (a > 1) {
            count++;
            if (a % 2 == 0) {
                a = a / 2;
            } else if (a % 4 == 3) {
                a++;
            } else {
                a--;
            }
        }
        return count;

    }

}

aqui un link de excel con el cual logre indetificar un patron con los numeros, tal vez sea util para alguien que no logre ver como hacerlo.
Lo mas importante a tener en cuenta es que no en todos los numeros hay que sumar para obtener la solucion mas optima, asi mismo con restarlos todos, ciertos numeros tienen que restarse o sumarse para conseguir la solucion mas optima. https://1drv.ms/x/s!AjCAxZ1IzCpyrBX9Kkfi-pUCbX6x?e=xCV9zK

Acabe entendiendo el problema, pero no pude resolverlo por mí mismo por falta de conocimiento de sintaxis. Tiempo al tiempo.

export function solution(num) {
  let resp = 0;
  while (num > 1) {
    num = num % 2 === 0 ? num / 2 : num % 4 === 3 ? num + 1 : num - 1;
    resp++;
  }
  return resp;
}

.
.
.
.
.
.
.
.
.
.
.
.
.
Al final he tenido que cruzar mi respuesta con la solución para eliminar el último paso, me salian 24 para el 32859 xD, buen truco el %4

export function solution(numero) {
  let pasos = 0;

  if (numero == 0) return 0;

  while (numero !== 1) {
    if (numero % 2 === 0) {
      numero /= 2;
    } else if (numero % 4 === 1 || numero === 3) {
      numero -= 1;
    } else {
      numero += 1;
    }
    pasos++;
  }
  return pasos;
}

La solucion del problema en python

numero=int(input("Introduce un numero => "))

while numero>1:
  if type(numero/2)==float:
    numero=numero-1
  else:
    numero=numero/2

print(numero)

Hola, os comparto mi solución. Un saludo.

export function solution(num) {
  let pasos = 0; // Inicializamos un contador de pasos en cero.

  while (num > 1) { // Mientras el número no sea igual a 1, repetiremos lo siguiente:

    pasos++; // Aumentamos el contador de pasos en uno en cada iteración.

    if (num % 2 === 0) {
      // Si el número es par, lo dividimos por 2.
      num = Math.floor(num / 2);
    } else if (num % 4 === 1 || num === 3) {
      // Si el número es impar y, al restar 1, es divisible por 4 o es igual a 3,
      // entonces restamos 1 al número.
      num -= 1;
    } else {
      // Si el número es impar y no cumple la condición anterior,
      // entonces sumamos 1 al número.
      num += 1;
    }
  }

  return pasos; // Devolvemos el contador de pasos, que nos dice cuántos pasos tomó para reducir el número a 1.
}

// Ejemplo de uso:
console.log(solution(15)); // Resultado: 5

Me demore mucho haciendo este ejercicio. La verdad si estaba algo para pensar. Lo que me molesta es la parte de pruebas. No se como lo aplicaria. Es la primera vez que lo veo y al parecer me falta mucho por aprender y convertirme en un buen programador. Lo bueno es que algo nuevo siempre se debe aprender y mejorarlo.

export function solution(num) {
  // Tu código aquí 👈
  let numerito = 0
  while (num > 1) {
    numerito = numerito + 1
    if (num % 2 === 0) {
      num = num / 2
    } else {
      num = (num + 1) || (num - 1)
    }
  }
  console.log("Tu respuesta es : " + numerito)
}

solution(15)

Solo aplique lo que sabia. En pruebas me salio todo error pero con el tiempo mejorare.

aqui mu aporte:

<export function solution(num) {
  if (num === 0) {
    return 0;
  }
  let steps = 0;
  while (num != 1) {
    if (num % 2 == 0) {
      num = num / 2;
    } else if (num == 3 || num % 4 == 1) {
      num = num - 1;
    } else {
      num = num + 1;
    }
    steps++;
  }
  return steps;
}
solution(15);> 

export function solution(num) {
// Tu código aquí 👈
var paso = 0
while (num > 1) {
if (num % 2 === 0) {
num = num / 2
} else if (((num - 1) / 2) % 2 == 0) {
num–
} else {
num++
}
console.log(num)
paso++
}
return paso
}

Soy muy nuevo en escribir código y estos ejercicios me están costando mucho trabajo, ya que no entiendo bien lo que están pidiendo y desconozco como funciona el lenguaje, pero seguiré aprendiendo y esforzándome. Por el momento estoy viendo las soluciones, estudiando y tratando de entender como funcionan

PARTIDA DE CABEZA

export function solution(num) {

let contador = 0;
while (num > 1) {
contador++
if (num % 2 === 0) {
num = num / 2;
} else if (num % 4 === 1 || num === 3) {
num = num - 1
} else {
num = num +1
}

}
return contador
}

Este fue el código que utilicé al principio, y que si bien no pasa las prueba, si cumple con descomponer el numero y contar el numero de pasos que se realizan, aunque no de la manera mas eficiente como vi que otros lo hicieron.

<export function solution(num) {
  var count = 0;

  while (num !== 1) {
    if (num == 0) {
      break;
    } else if (num % 2 === 0) {
      num = num / 2;
  
    } else {
      num -= 1;
      num = num / 2;

    }
count++;
  }

  return count;
}> 
function solution(n) {
  let steps = 0; // inicializar el contador de pasos

  while (n > 1) { // repetir mientras n sea mayor que uno
    if (n % 2 === 0) { // si n es par
      n = n / 2; // dividirlo por dos
    } else if (n !== 3 && (n + 1) % 4 === 0) { // si sumarle uno hace que sea divisible por cuatro y no es tres
      n = n + 1; // sumarle uno
    } else { // si no
      n--; // restarle uno
    }
    steps++; // incrementar el contador de pasos
  }

  return steps; // devolver la solución
}

console.log(solution(15)); // probar con el ejemplo dado

mi código:

function pasosreducirauno(num){
  let pasos = 0;
  while(num > 1){
    if(num % 2 == 0){
      num = num / 2;
    }else{
      num = (num + 1);
    }
    pasos++;
  }
  return pasos;
}

alert(pasosreducirauno(4))

Esta es mi solución.

function solution(num) {
    var contador = 0

    while (num > 1) {
        contador++
        if (num % 2 === 0) {
            num = num / 2
        } else if (num % 4 === 1 || num === 3) {
            num--
        } else {
            num++
        }
    }

    return contador
}

Mi solución fue la siguiente utilizando mi algoritmo principal y haciendo un control de errores

export function solution(num) {
  let number = num
  let count = 0

//Algoritmo Principal

  while (number >= 2) {
    if (number % 2 != 0) {
      number = number - 1
    }
    else {
      number = number / 2
    }
    count++
  }

  // Control de Errores
  if (count > 1 || number >= 2) {
    count = count - 1
  } else {
    count = 0
  }
  return count
}

Mi solución.

export function solution(num) {
  let res = 0

  if (num == 0) {
    res = num + 1
  } else {
    res = num / num
  }
  console.log(res)
}

solution(15)

Una solución algo diferente, siempre estoy dividiendo en 2 en cada paso independientemente de la condición así logro obtener un menor número de pasos y siempre se reduce a 1.

export function solution(num) {
  let i = 0;
  while (num > 1) {
    i++;
    if (num % 2 != 0) {
      num--
    }
    num=num / 2;
  }
  return i;
}
export function solution(num) {
  // Tu código aquí 
  var pasos = 0;
  while (num > 1) {
    if (num % 2 == 0) {
      num /= 2;
    } else if (((num + 1) / 2) % 2 == 0) {
      num += 1;
    } else {
      num -= 1
    }
    pasos += 1;
  }
  return pasos;
}

Mi solución

export function solution(num) {
  // Tu código aquí 👈
  var pasos = 0;
  while (num > 1) {
    if (num % 2 == 0) {
      num /= 2;
    } else if (((num + 1) / 2) % 2 == 0) {
      num += 1;
    } else {
      num -= 1
    }
    pasos += 1;
  }
  return pasos;
}

el codigo que utilice, obviamente con ayuda de los comentarios por que no llego a entender todo

export function solution(num) {
  let count = 0;
  while (num > 1) {
    count++;
    if (num % 2 === 0) {
      num = match.floor(num / 2);
      console.log("modulo 2 de n =0; " + num)
    }
    else if (num % 4 === 1 || num === 3) {
      num -= 1;
      console.log("modulo 4 de n = 1 || n = 0; " + n)
    }
    else {
      num += 1;
      console.log("n + 1 " + num)
    }
  }
}
return count;
 function solution(num) {
  let counter = 0;
  if (num === 0) {
    return 0;
  }

  while (num !== 1) {
    if (num % 2 === 0) {
      num = num / 2;
    } else {
      if (num === 3) {
        num = num - 1;
      } else if ((num + 1) % 4 === 0) {
        num = num + 1;
      } else {
        num = num - 1;
      }
    }
    counter++;
  }

  return counter;
}

mi solución pasa todas las pruebas, menos la ultima (con el nro: 328593) y aun no entiendo bien porqué.

export function solution(num) {
  let pasos = 0;
  if (num <= 1) {
    return 0;
  }

  while (num != 1) {
    if (num % 2 == 0) {
      num = num / 2;
      pasos++;
    }
    else {
      num = num + 1;
      pasos++;
    }
  }
  return pasos;
}

Mi aporte por aquí chicos

export function solution(num) {
// Tu código aquí 👈
var sum = 0;
while (num > 1) {
if (num % 2 == 0) {
num /= 2;
}
else if (((num - 1) / 2) % 2 == 0) {
num–
}
else {
num++
}
sum++
}

return sum;
}

Mi solucion usando recursividad, espero que a alguno le sea util

export function solution(num) {
  if (num == 1 || num == 0 ) {
    return 0;
  }
  else if (num % 2 == 0) {
    return 1 + solution(num / 2);
  }
  else if (solution(num + 1) > solution(num - 1)) {
    return 1 + solution(num - 1);
  }
  else {
    return 1 + solution(num + 1);
  }
}```

Lo intenté:

export function solution(num) {
  // Tu código aquí 👈
  let i = 0;
  while (num > 1) {
    if (num % 2 === 0) {
      num = num / 2;
      console.log("El número se divide por dos, resultado: " + num);
    }
    else if (num % 2 !== 0 && num > 0) {
      num -= 1;
      console.log("Al número se le resta uno, resultado: " + num);
    }
    else {
      num += 1;
      console.log("Al número se le suma uno, resultado: " + num);
    }
    i++;
  }
  //console.log("Pasos: " + i);
  return i;
}

Algo sencillo para analizar

export function solution(num) {
  let step = 0
  while (num > 1) {
    if (num % 2 == 0) {
      num /= 2
      step += 1
    } else if(((num + 1) / 2) % 2 == 0){
      num +=  1
      step += 1
    } else {
      num -= 1
      step += 1
    }
  }
  return step
}
export function solution(num) {
  // Tu código aquí 👈
  let steps = 0;
  if (num === 0) { 
    num++;
  }

  while (num !== 1 ) {
    if (num % 2 === 0) {
      num /= 2;
    } else if (num === 3 || num % 4 === 1) {
      num--;
    }  else if (num === 0) { 
      num + 1;
    } else {
      num++;
    }
    steps++;
  }

  return steps
}

Muchos hemos coincidido en el uso del módulo 4 para implementar el algoritmo, también hay que tener en cuenta que para el número 3 sucede una excepción. Si no se corrige, modifica los resultados de casi todos los siguientes números.

Here mi solution. Once more time the explanation in the exercise is so confused:

function reducir(num){
for (let i=0;i<num;i++){
if (num%2 == 0){
num = num/2;
console.log(“el nuevo valor a dividir es”,num);
} else {
num = (num+1)/2;
console.log(“el nuevo valor a dividir es”,num);
}
}
return num;
}
num=56;
reducir(num);

Saludos!!! dejo mi solución:

Mi solución recrea todas las combinaciones posibles entre (n+1), (n-1) y la división entre 2 cuando es par, a fin de dar como resultado la menor cantidad de pasos posibles para que el número se reduzca a 1. Para ello usé funciones recursivas 😄.

En lo único que difiero para las pruebas es que al ingresar el número 1 como input, tenga como resultado 1, porque 1 no tendría que reducirse, por tanto el resultado debería ser 0 a mi modo de ver 😛.

export function solution(num) {

    let arrayPasos = [];
  
    function reiterative(num, step = 0) {
  
      let pasos = step;
      let numero = num;
  
      if (numero % 2 == 0) {
        // Aquí entra si es PAR
        numero = numero / 2;
        pasos++;
        reiterative(numero, pasos);
  
      } else {
        // Aquí entra si es IMPAR
  
        if (numero === 1) {
          arrayPasos.push(pasos);
        } else {
  
          let nMasUno = numero + 1;
          let nMenosUno = numero - 1;
          pasos++;
          reiterative(nMasUno, pasos);
          reiterative(nMenosUno, pasos);
        }
      }
    }
  
    if (Number.isInteger(num) && num > 0) {
  
      reiterative(num);
      return Math.min(...arrayPasos);
  
    } else {
      console.log('Input no válido, ingrese un entero mayor a 0.');
      return 0;
    }
  
  }

estos ejercicios no se si soy el único que piensa que lo que piden no concuerda con lo real, pienso si piden que sea un numero reducido la menor cantidad posible creo que 5 no es la menor cantidad puesto que si a 15 le agrego 1 da 16 y /2 =8 (count1) 8/2=4 (c.2) 4/2=2 (c.3) y2/2=1 (count 4). estos ejercicios me tienen confundido en gran parte .

mi idea

export function solution(num) {
  let contador=0,num2
  while (num>1) {
    if (num % 2 == 0) {
      num=num/2
    } else {
      num2 = num+1
      num2 = num2 / 2
      if (num2 %  2 == 0) {
        num++
      } else {
        num--
      }
    }
    contador++
  }
  return contador
}

ESTA ES LA FUNCION QUE CREE , PODRIAN AYUDARME A VER EN QUE FALLO:
expor funtion solution(num) {
var count=0 ;
while (num>1){
count++ ;
if ( num % 2 == 0){
num/=2
}
else {
num+1 , num/=2
}
console.log(num);
}
return count ;
}

un resultado mucho mas simplificado.

function solution(num) {
  let resp = 0;
  while (num > 1) {
    num = num % 2 === 0 ? num / 2 : num % 4 === 3 ? num + 1 : num - 1;
    resp++;
  }
  return resp;
}
const solution = (num) => {
  if(num <= 1) return 0;
  let steps = 0;
 	do {
    num = num % 2 == 0 ? num / 2 : ((num + 1) / 2) % 2 == 0 ? num + 1 : num - 1;
    steps++;
  } while (num > 1);
  return steps;
}

Creo que hay un error en las pruebas, cuando es 1 debería devolver 1:

export function solution(num) {
  let operation = 0
  while (num > 1) {
    operation++
    num = num % 2 == 0 ? num / 2 : (num % 4 == 3 ? num + 1 : num - 1)
  }
  return operation
}

Aun no se como escribir el codigo con esas funciones xd, yo estoy probando todo con el console.log.

var num = 10
var contador = 0

while (num > 1) {
if (num % 2 == 0) {
num = num / 2
contador++;
} else {
num = num - 1
contador++;
}
}

console.log(contador)
console.log(num)

export function solution(num) {
let operaciones = 0;
if (num != 0) {
while (num != 1) {
if (num % 2 == 0) {
num /= 2
operaciones += 1;
console.log(num, " Es par")
} else {
console.log(num, " Es impar")
//Buscar si el número anterior o siguiente a este impar al dividirlo da otro par porque es la forma más rápida
let num1 = num + 1;
let n1 = num1 / 2;
let num2 = num - 1;
let n2 = num2 / 2;
if (n1 % 2 == 0) {
console.log(num, " num1 ")
num = num1;
operaciones += 1;
} else {
console.log(num, " num2 ")
num = num2;
operaciones += 1;
}
}
}
console.log("Son “, operaciones, " operaciones”)
return operaciones;
} else {
console.log(operaciones)
return operaciones;
}
}

solution(328593);

Mi solución.

export function solution(num) {
  let steps = 0;
  while (num > 1) {
    if (num % 2 == 0) num /= 2;
    else if(num % 4 == 3 || num % 3 == 1) num+=1
    else num --;
    steps += 1;
  }
  return steps;

}

Comparto mi solución:

<let num1 = 5
function resultado (){
  if (num1%2==0){
    resultado1= num1/2
    console.log("La división es: "+resultado1)
  }
  else if(num1%2!=0){
    nuevonum=num1+1
    console.log("El nuevo numero es: "+nuevonum)
    nuevoresul = nuevonum / 2
    console.log("La división es: "+nuevoresul)
  }
}
resultado ()> 

Quizá un poco larga pero ahí vamos jeje

No se ni como lo hice 😅

export function solution(num) {
  let x = 1
  let i = 0

  while (num > x && num != 1) { 
    if (num % 2 == 0) {
      num = num / 2;
    } else if (num % 4 == 3) {
      num++;
    } else {
      num--;
    }
    i++;
  }
    console.log(num)
  return i;
  
}
export function solution(num) {

  function esPar(num) {
    if (num % 2 === 0)
      return (true);
    else
      return (false);
  }

  function mejorSumaoResta(num) {

    let pruebaSuma = num+1;

    let dato = pruebaSuma / 2;
    let dato2 = esPar(dato);
    if (dato2 === false)
      return ('Resta');
    else
      return ('Suma');
  }

  let respuesta = 0;

  while (num > 1) {

    let dato1 = esPar(num);
    let opcion = '';

    if (dato1 === true) {
      num = num / 2;
      respuesta++;
    }
    else {
      opcion = mejorSumaoResta(num);

      if (opcion === 'Suma') {
        num++;
        respuesta++;
      }
      else {
        num--;
        respuesta++;
      }
    }
  }

  return (respuesta);
}
solution(15);

Mi solución: Tuve el detalle del 0 pero creo que es por el hecho de que se trata de “reducir” propiamente, pero creo que puede incluirse si se cambiase la indicación a “llevarlo a 1”

export function solution(num) {
  var cont = 0;
  while (num > 1 || num == 0) {
    if (num % 2 == 0) {
      if (num == 0) {
        num++;
      } else {
        num /= 2;
      }
    } else {
      if (num % 4 == 3 && num != 3) {
        num++;
      } else {
        num--;
      }
    }
    cont++;
  }
  return cont;
}
function solution(num) {
  let resp = 0;
  while (num > 1) {
    if (num % 2 === 0) {
      num = num/ 2;
    } else if (num % 4 === 3) {
      num++;
    } else if (num % 4 === 1) {
      num--;
    }
    resp++; 
  }
  return resp;
}

My solution

export function solution(num) {
  let steps = 0;
  while (num > 1) {
    if (num % 2 == 0) {
      num = num / 2;
    }else if ((num +1) % 4 == 0) {
      num++;
    } else {
      num--;
    }
    steps++;
  }
  return steps;
}

Solución usando recursividad:

export function solution(num) {
  if (num === 0 || num === 1) return 0

  if (num % 2 === 0)
    return 1 + solution(num / 2)

  return 1 + Math.min(solution(num - 1), solution(num + 1))
}
undefined