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

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.

💚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
`

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

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

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.

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

}
> 

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

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

num=num/num

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

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
  }

}

no entiendo este problema

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

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

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

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

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)

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
}