Reto: ¿cuántos caminos hay para llegar al mismo punto?

💪 Este es un reto MUY difícil, no te rindas

.
El objetivo de este reto tal cual no es resolverlo, sino que aprendas qué pasos seguir cuando te enfrentas con problemas así de complejos.
.
Nuestra primera intuición al querer resolver algo es meternos directamente al código y programar, pero nos pasamos por alto evaluar ciertos casos de uso que nos pueden dar una pista para resolver cualquier problema.
.
Entiendo el sentimiento de frustración cuando no podemos resolver algo, a mí me tomó literalmente días resolverlo hasta que por fin pude, no te rindas, da tu mejor esfuerzo por resolverlo, y si no lo logras no te preocupes, es normal, es un reto difícil.
.
Pero lo que quiero que te lleves de esta clase es cómo abordar un problema difícil cuando te topas con ellos 💚.
.
Si lograste resolver el reto, felicidades, y si no, también felicidades porque lo intentaste y diste lo mejor de ti para hacerlo 💪.

No lo pude hacer antes de ver la explicación del profe, pero creo que ahora le entendí.
.
Como para no sentirme tan mal le agregue un do while.
.

$tienda_anterior = 0;
$caminos = 1;

do {
    echo "Teniendo en cuenta que estas en la Tienda número 1 \n";
    $tienda_elegida = (int)readline("Ingresa el número de la tienda a la que deseas ir: \n");
} while ($tienda_elegida < 2);

for ($i=2 ; $i <= $tienda_elegida ; $i++) {

    $temporal = $caminos;
    $caminos += $tienda_anterior;
    $tienda_anterior = $temporal;
    // Esto me ayudó a ver el comportamiento
    // echo "temporal = $temporal  Caminos = $caminos Tienda anterior = $tienda_anterior \n";
}
echo "Dispones de " . $caminos . " caminos\n";

Cuento mi experiencia.
Aunque el problema se me hizo casi imposible al inicio, le di un vistazo a los comentarios y me di con el spoiler de que se trataba de la célebre sucesión de Fibonacci, la cual se puede resolver utilizando funciones recursivas.
Como castigo propio por haberme dado la solución, decidí que mi programa debía mostrar no sólo la cantidad de rutas para llegar a la tienda N, sino además debía poder imprimir cada una de ellas.
Para encontrar la solución, debí consultar la Teoría de Grafos, el cálculo para obtener la suma de todos los caminos entre el punto A y el punto B (muy interesante, por cierto), y luego de ahí a pasarlo a código de PHP sin utilizar funciones recursivas, fue todo un reto.
Les sugiero que habiliten el XDebug y el PHP Debug (si ocupan Visual Studio Code) para depurar el código, a mí me sirvió bastante para ir generando cada uno de los ciclos de las rutas y validar que el array quedara con las rutas correctas.

Ahora, la solución:
El razonamiento es que, efectivamente, el camino a la tienda N se da de unir las rutas generadas para N-1 y N-2, entonces, a través de un arreglo, hice el push de las rutas para los números intermedios hasta el número de tienda seleccionado. Luego sólo es contar cuántas rutas hay para el arreglo de la tienda N dado, así como imprimir el ciclo de todos los registros guardados en dicho arreglo. Debido a que noté que mi computadora se quedaba colgada si ponía un valor mayor a 30, limité la captura hasta 30, mientras que la impresión de las rutas está habilitada hasta la tienda 20.

<?php
$br  = "\n";
$hr  = "------------------------------------------------------------------------------------------\n";
$hhr = "==========================================================================================\n";

$rutas = [
    1 => ['1'],
    2 => ['1-2'],
];

do {
    echo `clear`;
    echo $hhr.'RETO: ¿CUÁNTAS RUTAS HAY DEL PUNTO A AL PUNTO B?'.$br.$hhr;
    $rutaSelected = readline('Captura la tienda a la que quieres llegar (máximo 30): ');
} while (!(is_numeric($rutaSelected)) || $rutaSelected <= 1 || $rutaSelected > 30);

if ($rutaSelected > array_key_last($rutas)) {
    for ($i = array_key_last($rutas) + 1; $i <= $rutaSelected; $i++) {
        $rutas += [$i => []];
        for ($j = 0; $j < count($rutas[$i - 2]); $j++) {
            array_push($rutas[$i], $rutas[$i - 2][$j].'-'.$i);
        }
        for ($k = 0; $k < count($rutas[$i - 1]); $k++) {
            array_push($rutas[$i], $rutas[$i - 1][$k].'-'.$i);
        }
    }
}

$counter = 0;
echo $br.'En total hay ';
for ($i = 0; $i < count($rutas[$rutaSelected]); $i++) {
    $counter++;
}
echo $counter.' rutas disponibles para llegar de la Tienda 1 a la Tienda '.$rutaSelected.$br;
echo $br.$hr;

if ($rutaSelected <= 20) {
    do {
        $opt = readline('¿Deseas imprimir las posibles rutas generadas? (S/N): ');
    } while (!($opt === 'S' || $opt === 'N'));

    if ($opt === 'S') {
        echo $br.'Las posibles rutas generadas son: '.$br;
        for ($i = 0; $i < count($rutas[$rutaSelected]); $i++) {
            echo $i + 1 .":\t".$rutas[$rutaSelected][$i].$br;
        }
    }
    echo $br.$hr;
}

Con este reto y el current y el temp, recordé la clase de Algoritmos y Estructuras de datos en la que tanto llore 😂

Sucesión de Fibonacci

Mi solución buscando la serie Fibonacci. Hay que notar que se puede obtener hasta el número 1476avo de la sucesión consistente en el valor 1.3069892237634E+308. Más allá PHP me manda valor INF. Quizá con otro algoritmo podamos construir una pila para valores más grandes.

<?php
//calculo de la serie de fibonacci hasta un lugar determinado

$place = readline("A que tienda quieres llegar: ");

$n1 = 1;
$n2 = 1;
$i = 2;
//echo "0, 1, ";
while ($i < $place){
    $nt = $n2;
    $n2 = $n1 + $n2;
    $n1 = $nt;
    $i++;
    //echo "$n2, ";
};
echo "\n";
echo "La cantidad de caminos hasta la tienda $place son $n2";
echo "\n";

pista: Busca el patrón (sucesión).

**Logre pulir un poco mi logica para este ejercicio **

$TiendaInicial = 0;
$TiendaSecundaria = 1;
$TiendaDeseada = 9;

for ($i = 2; $i <= $TiendaDeseada + 1; $i++) { #empiezo a validar desde la tienda 2
    
    $resultado = $TiendaInicial + $TiendaSecundaria;
    $TiendaInicial = $TiendaSecundaria;
    $TiendaSecundaria = $resultado;

    if ($TiendaDeseada == 1)  echo "tu ya estas en la tienda a la que necesitas llegar :V <br>";
    if ($i == $TiendaDeseada) echo "para llegar a la tienda " . $i . " se puede llegar de  " . $resultado . " maneras" . "<br>";          
}

Explicación en el código para los que como a mí, nos costó entenderlo

<?php

/*
2 -> 1
3 -> 2
4 -> 3
5 -> 5
6 -> 8
7 -> 13
8 -> 21
*/

//Variable que especifica hasta que numero de la serie se quiere generar
$numero_maximo_serie = 5;

//Variables que almacenan los ultimos dos numeros generados en la serie
$numero_anterior = 0;
$numero_actual = 1;

//Ciclo que inicia en 2 ya que los primeros dos numeros de la serie son 0 y 1
for ($i = 2; $i <= $numero_maximo_serie; $i++) { 
    // Creamos una variable temporal para guardar el numero actual antes de sumarlo con el anterior
    $numero_temporal = $numero_actual;
    //Nuevo numero generado en la serie es la suma del numero actual y el anterior
    $numero_actual = $numero_actual + $numero_anterior; 
    //El numero anterior ahora es el numero que se guardo temporalmente
    $numero_anterior = $numero_temporal; 

    //Se imprime el nuevo numero generado en la serie
    echo $numero_actual . "\n";
}
?>

Más problemas de este tipo

Este problema es interesante por el hecho de que uno no debe hacer exactamente lo que el enunciado dice como suele pasarnos con los problemas que venimos viendo hasta ahora.
Este problema requiere un análisis y cierta capacidad de abstracción para llegar a la conclusión que se trata de la sucesión de Fibonacci. Y, además, cómo calcular Fibonacci es otro tema amplio, ya que para números gigantes (con n = 10^9, por ejemplo) seguramente no basta con calcular término a término (Spoiler: se puede hacer con exponenciación de matrices, pero no viene al caso).
Si les gustó este problema, aunque no lo hayan podido resolver, les podría llegar a interesar lo que es la programación competitiva.

¿Qué es la Programación Competitiva?

Es un deporte electrónico que se basa en la resolución de problemas de este tipo en una ventana de tiempo determinada. Hay distintas plataformas en las que pueden encontrar problemas de este tipo.

Recomendaciones si quieren investigar del tema

Plataforma con problemas: https://codeforces.com
Libro introductorio: https://cses.fi/book/book.pdf

Mi código (No se si a las patadas pero funciona) xD:

<?php

//Creando un array para la secuencia
$secuencia = [];
//Ingresar la casa de destino:
$casa_destino = 8;
//Para las 2 primeras posiciones se introducen los valores 1 y 2


if ($casa_destino == 2){
   array_push($secuencia,1);
}
else if ($casa_destino == 3){
   array_push($secuencia,1,2);
   }
else{
   array_push($secuencia,1,2);
   for ($i=3; $i < $casa_destino ; $i++) { 
        //cuento el numero de elementos en el array 
        $numero_elem = count($secuencia)-1;
        $ultimo = $numero_elem;
        $penultimo = $numero_elem-1;
        $suma_ultimo_par = $secuencia[$ultimo] + $secuencia[$penultimo];
        //creo un ultimo valor con la sumatoria de los 2 ultimos elementos
        array_push($secuencia,$suma_ultimo_par);
        }
}

if ($casa_destino < 2 )
   echo "La casa de destino tiene que ser mayor a 1";
   else
echo "Para ir a la casa $casa_destino, el número posible de caminos es: " . $secuencia[count($secuencia)-1];

Mi solución para el reto

<?php

$result = 1;
$number_store = readline("Escriba a que tienda desea llegar: ");

for ($i=1, $a=0; $i < $number_store; $i++) {
    $result += $a;
    $a = $result - $a;
}

echo "Para llegar a la tienda $number_store hay $result caminos diferentes";

Mi solución

$numeroDeseado = 8;
$aux = 0;
$result = 1;
for ($i=1; $i < $numeroDeseado; $i++) { 
    $result = $result + $aux;
    $aux = $result - $aux;
}
echo $result;

<?php 
$total_de_caminos = 0;
$valor_anterior_anterior = 0;
$valor_anterior = 1;
$punto_camino = readline("Ingrese el punto del camino por el cual desea consultar:");

if($punto_camino > 0){
    for($i=1 ; $i<$punto_camino; $i++){
        $total_de_caminos = ($valor_anterior + $valor_anterior_anterior);
        $valor_anterior_anterior = $valor_anterior;
        $valor_anterior = $total_de_caminos;
    }
    echo "el número de caminos posibles hasta el punto $punto_camino es: $total_de_caminos";
}
else{
    echo "Debe ingresar un valor superior a 1. \n";
}

?>

Ejercicios como este son los que se encuentra uno en entrevistas de trabajo, ya sea en live coding o a través de plataformas con tiempo limite. Que bueno que hayan incluido este tipo de ejemplos, ojalá lo sigan haciendo en este y otros cursos. También sería bueno que Platzi incluyera un curso orientado a resolver este tipo de retos, estilo Cracking de Coding Interview, es muy frustrante durante un proceso de selección para un trabajo no poder finalizarlo a tiempo o quedarte congelado y no poder avanzar.

Considerando que es Fibonacci yo utilicé la fórmula:

<?php

function fibonacci_formula($n) {
    $phi = (1 + sqrt(5)) / 2;
    $psi = (1 - sqrt(5)) / 2;
    return (int) round((pow($phi, $n) - pow($psi, $n)) / sqrt(5));
};

echo fibonacci_formula((int) readline("Enter a number: "));

echo "\n";

?>

Uff, sí me puso a pensar, pero logré hacerlo sin ver el video ni los comentarios.

$tienda_a_llegar = readline("¿A cuál tienda quieres llegar? ");
$formas_de_llegar = array(0,1);

if($tienda_a_llegar < 2) {
    echo "Introduzca un número mayor a 1";
}
if($tienda_a_llegar > 99) {
    echo "Introduzca un número menor a 99";
}
else{
    for($i = 2; $i < 100; $i++){

        $nueva_forma_de_llegar = $formas_de_llegar[$i-1] + $formas_de_llegar[$i-2];
        array_push($formas_de_llegar, $nueva_forma_de_llegar);
    
        foreach ($formas_de_llegar as $caminos) {
            if($tienda_a_llegar == $i){
                echo "  HAY $formas_de_llegar[$i] FORMAS DE LLEGAR A LA TIENDA $i \n\n";
                break;
            };
        }
    }
}

Al principio pensé que se podía devolver, solo pude hacer el camino par, impar, y el del centro. Eso pasa por no leer bien o escuchar, luego de quemarme la cabeza volví a mirar y bueno toco replantearse

<?php

$number_stores = readline ("Write how mane houses are there: ");
$store = array();

for ($i=1; $i <= $number_stores; $i++) { 
    array_push($store, $i);
}
$start = readline("where am I?: ");
$finally = readline("Where I want arrive?: ");
$before_store = 0;
$currenly = 1;
if ($start < $finally) {
    for ( $i = array_search( $start, $store ) ; $i < array_search( $finally, $store ); $i++) { 
        $temporary = $currenly;
        $currenly += $before_store;
        $before_store = $temporary;
    }
    echo "there are " . $currenly . " to arrive" . "\n";
}
elseif($start > $finally){
    echo "Sorry, This program isn't going backwards" . "\n";
}else{
    echo "I'm at the same store" . "\n";
}

?>

Esta es mi solución para el reto, lo entendí como la serie Fibonacci.

hola para todos, les comparto mi programa¡¡¡¡

<?php
$num_tienda=readline("ingrese a que tienda quiere llegar por favor: ");//2, 3, 4, 5, 6

$suma=0;
$caminos=[0, 1];

for($i=1;$i<$num_tienda;$i++){//3, 4, 5
    for($j=0;$j<$i;$j++){//2, 3, 4
        $suma=$caminos[$j]+$caminos[$i];//1+2=3, 2+3=5, 3+5=8
    }
    array_push($caminos, $suma);//0, 1, 1, 2, 3, 5, 8
}
echo "el numero de caminos posibles para llegar a la tienda $num_tienda es: $suma";
echo "\n";
?>

Esto es un grafo, es más complicado qué esto, pero para no entrar en detalles la pregunta es cuatas cadenas hay de un vertice " a " a un vertice " b " el detalle es saber que no podemos utilizar el vertice c para ir al b, es decir si queremos llegar a la tienda 5 no podemos usar la tienda 6, (aunque en grafo si lo estudias si sé puede pero esto no es aclarado en el ejercicio). Simpre el vertice de salida y el de llegada tendra 2 y solo 2 aristas. El problema es que se quiso hacer la secuencia fibonacci cuando por ejemplo para la tienda 4 hay 4 formas de llegar.

Salir de 1 y tomar 3 o 2 y depues 4 eso hace dos caminos
Luego salir de 1 y tomar 3 o 2 y luego pasar al inverso y luego al 4 eso hace otro dos caminos.

Mi solución 😃

<?php


// Validar input
do{
    $tienda  = readline("A que tienda quieres llegar? ");
    if ($tienda < 1)    
        echo "La tienda empieza desde 1 :( \n";
}while($tienda < 1);

// A la tienda 1 se llega de 0 maneras porque ya estamos ahí
$formas = [0,1,2];

// El problema se soluciona con la serie de fibonacci
for($i = 2; $i < $tienda; $i++)
    array_push($formas,$formas[$i] + $formas[$i-1]);

echo "\nEl numero de formas de llegar a la tienda $tienda es {$formas[$tienda-1]} \n";

les comparto la manera en que lo hice:

tienda 2 : 1
tienda 3 : 2
tienda 4 : 3
tienda 5 : 5
tienda 6 : 8
tienda 7 : 13
tienda 8 : 21
tienda 9 : 34

<?php

$numero_de_tienda = (int) readline("por favor ingresa una tienda del 1 al 9: ");
$anterior = 0;
$actual = 1;

for ($i=2; $i <= $numero_de_tienda; $i++) { 
    $temp = $actual;
    $actual += $anterior;
    $anterior = $temp;  
}

if ($numero_de_tienda == 1) {
    echo "Estas en la tienda #1";
}
else {
    echo "Esta tienda tiene $actual formas de llegar \n";
}
 

Mi aporte!

<?php

$valor_actual = 1;
$valor_anterior = 0;
$resultado = 0;

$numero_de_tienda = readline('Digita el numero de la tienda a saber los camino: ');

for ($i = 0; $i < $numero_de_tienda; $i++) {
    $resultado = $valor_actual + $valor_anterior;
    $valor_actual = $valor_anterior;
    $valor_anterior = $resultado;
}

echo "La tienda $numero_de_tienda tiene $resultado caminos para llegar";
echo "\n";

Lo logre pero practicamente al azar, ya que al saber el resultado que tenia que lograr y el patron para ello, fui combinando operaciones con mis variables al azar :c no me siento satisfecho, de todos modos les dejo mi resultado:

<?php

//Reto "Cuantos caminos hay para ir a x destino"
//calculo de la serie de fibonacci hasta un lugar determinado



$destino = readline("A donde quieres llegar?: ");
$d1 = 1;
$d2 = 1;


if ($destino >= 2) {

    for ($i=2; $i < $destino; $i++) { 
        $df = $d2;
        $d2 = $d1 + $d2;
        $d1 = $df;
         
    }
    
    echo "Su destino final tiene $d2 caminos \n";
} else {
    echo "Inicias en el destino 1, no puedes ir a donde ya te encuentras \n";
}

?>

aqui les dejo mi aporte

<?php

// Arreglo que contiene información sobre las tiendas y sus rutas
$tienda = array(
    'tienda de pepe' => array(
        'descripcion' => 'Estas son las rutas',
        'rutas' => array(
            'si estás en la tienda 2: primer camino' => "El camino por agua directamente a la tienda 1 \n",
            'si estás en la tienda 3: segundo camino' => "De la tienda 3 directamente por tierra \n",
        ),
    ),
    'tienda de lucia' => array(
        'descripcion' => 'Estas son las rutas',
        'rutas' => array(
            'si estás en la tienda 1: primer camino' => "El camino del agua directamente a la tienda 2 \n",
            'si estás en la tienda 1: segundo camino' => "De la tienda 1 a la 3 por tierra y de la 3 a la 2 por agua \n",
        ),
    ),
);

// Solicitar al usuario que ingrese la tienda de su interés
$caminos = readline('Por favor, ingresa la tienda de tu interés: ');

// Verificar si la tienda ingresada existe en el arreglo
if(isset($tienda[$caminos])) {//isset nos ayuda a identificar si la variable solicitada existe en el arreglo
    // Obtener las rutas de la tienda seleccionada
    $ruta = $tienda[$caminos]['rutas'];

    // Mostrar las rutas disponibles para la tienda seleccionada
    foreach ($ruta as $tiendaSolicitada => $descripcion) {
        echo "$tiendaSolicitada $descripcion";
    }
} else {
    // Si la tienda no existe, mostrar un mensaje de error
    echo 'La tienda ingresada no existe';
}

echo "\n";

?>

Fue difícil, pero logré entender la lógica. D:

$punto_objetivo = 2; //por defecto, el punto objetivo es dos
$caminos_punto_actual = 1;//por defecto, se tiene un camino a este punto.
$caminos_punto_anterior = 0;//por defecto, el valor anterior es cero
$punto_objetivo = readline('Digita el punto objetivo: ');//se le pregunta al usuario cual es el punto objetivo

if($punto_objetivo >= 2){
    echo "La cantidad de caminos para el punto $punto_objetivo es: ";
    for ($i=2; $i <= $punto_objetivo; $i++) { // punto objetivo = 8
        $temp = $caminos_punto_actual; // 13
        $caminos_punto_actual += $caminos_punto_anterior; // 13 + 8 = 21
        $caminos_punto_anterior = $temp; //13
    }
    echo $caminos_punto_actual . "\n";
}else{
    echo "La entrada no fue correcta. \n";
}
echo "\n";
// EO: La cantidad de caminos para el punto 8 es: 21

Mi solucion del reto 👨‍💻

<?php
/*

¿De cuantas formas puedo ir de la tienda 1 a la tienda n sin 
retroceder en el camino? Es decir, yendo siempre de izquierda a derecha.

*/

$limite_tienda = readline("Selecciona la tienda a la que quieres llegar: ");
$secuencia_tienda = [0, 1];

for ($i = 0, $j = 1; $i < $limite_tienda - 1; $i++, $j++) {
    array_push($secuencia_tienda, $secuencia_tienda[$i] + $secuencia_tienda[$j]);
}

$valor = end($secuencia_tienda);

print_r("Los caminos posibles para llegar a la tienda $limite_tienda son: " . $valor . " caminos posibles entre agua y tierra.");

echo PHP_EOL;

<?php
$numero_de_tienda = 20;
$a = 0;
$b = 1;
$tienda = 2;
while ($tienda <= $numero_de_tienda){
    $c = ($a+$b);
    echo"Tienda $tienda - Rutas $c /n";
    $a = $b;
    $b = $c;
    $tienda++;
}

 

Gente, yo viendo que sólo nos imitábamos a 8 números (y por suerte me di cuenta que era la secuencia de fibonacci), decidí enfocarlo desde el punto de vista de un array. Así me quedó:

$tiendas_caminos = [
    "2" => 1,
    "3" => 2,
    "4" => 3,
    "5" => 5,
    "6" => 8,
    "7" => 13,
    "8" => 21,  
];

echo "Introduce la tienda a la que quieres llegar: \n";
$tienda_elegida = readline();

while ($tienda_elegida < 2 || $tienda_elegida > 8) {
    echo "La tienda que elegiste no está registrada. \nIntroduzca otra tienda: \n";
    $tienda_elegida = readline();
};

if ($tienda_elegida > 1 && $tienda_elegida < 9) {
    echo "hay " . $tiendas_caminos[$tienda_elegida] . " caminos para llegar a la tienda " . $tienda_elegida ."\n";
};

$caminos = [0,1,2];
$resultado = 0;

$entrada = readline("Ingresa el destino: ");

for ($i=2; $i < ($entrada-1); $i++) {
$resultado = $caminos[$i-1] + $caminos[$i];

array_push($caminos,$resultado);
}
print_r($caminos);
echo "El numero de caminos posibles son: ". $caminos[$entrada-1];

¡Así resolví el reto!

<?php

 $array_caminos = [1,1];

 do {
    $tienda_llegada = readline("Ingresa el número de tienda la que deseas llegar: ");
 } while ($tienda_llegada < 2);

 
 $length = count($array_caminos);
 while($length < $tienda_llegada){
    array_push($array_caminos, ($array_caminos[$length - 1] + $array_caminos[$length - 2]) );
    $length = count($array_caminos);
 }

 $formas_llegar = $array_caminos[$length - 1];

 echo "Las formas de llegar a la tienda $tienda_llegada son $formas_llegar \n";>

Logre el reto este es el codigo:

<?php
echo "introduce el numero de la casa ";
$nCasa =(int) readline("");

$penultimo = 0;
$ultimo = 1;
for ($i = 2; $i < $nCasa; $i ++) {
    $total = ($ultimo + $penultimo) ; 
    $penultimo = (int) $ultimo;
    $ultimo = (int) $total;
    echo "caminos para la casa $i son: $total \n";
};

este es el resultado al oprimir 20

introduce el numero de la casa 20
caminos para la casa 2 son: 1
caminos para la casa 3 son: 2
caminos para la casa 4 son: 3
caminos para la casa 5 son: 5
caminos para la casa 6 son: 8
caminos para la casa 7 son: 13
caminos para la casa 8 son: 21
caminos para la casa 9 son: 34
caminos para la casa 10 son: 55
caminos para la casa 11 son: 89
caminos para la casa 12 son: 144
caminos para la casa 13 son: 233
caminos para la casa 14 son: 377
caminos para la casa 15 son: 610
caminos para la casa 16 son: 987
caminos para la casa 17 son: 1597
caminos para la casa 18 son: 2584
caminos para la casa 19 son: 4181

  #funcion fibonnacci

  $fibonacci = 0;
  $numero=1;
  $ciclos = 10;

  echo $fibonacci.'<br>';

  for($i=0; $i<10; $i++){

    $temp = $fibonacci;
    $fibonacci = $numero;
    $numero = $temp + $fibonacci;

    echo $i.' -> '.$fibonacci.'<br>';

  }

Este codigo solo imprime la cantidad de rutas que puede tomar para llegar a “n” numero de tiendas.

<?php
header("Content-type: application/json; charset=utf-8");

$tienda_destino = readline("A cuál tienda quieres ir: ");
$anterior = 0;
$actual = 1;
 
for ($i = 2; $i <= $tienda_destino; $i++) { 
    $temp = $actual;
    $actual += $anterior;
    $anterior = $temp;
}


echo "Para llegar a la tinda $tienda_destino puedes tomar $actual caminos";


echo "\n"
?>

Mi solucion del reto

	<?php
    //2 -> 1
    //3 -> 2
    //4 -> 3
    //5 -> 5
    //6 -> 8
    //7 -> 13
    //8 -> 21
    //9 -> 34

    $numeroTienda = readline('Ingresa el numero de tienda = ');
    $anterior = 0;
    $actual = 1;
    for($i=2;$i<=$numeroTienda;$i++){
        $caminos = $anterior + $actual;
        $anterior = $actual;
        $actual = $caminos; 
    }
    echo "Los caminos a recorer $numeroTienda son = $caminos"
?>

Me tardé un tiempo en darme cuenta que era la secuencia de Fibonacci, pero cuando lo hice, todo tuvo mucho más sentido

<?php

$house_num = readline("Introduce el numero de casas: ");
$num_1 = 0;
$num_2 = 1;
for ($i = 2; $i < $house_num; $i++) {
    $aux = $num_1 + $num_2;
    $num_1 = $num_2;
    $num_2 = $aux;
}
if ($house_num == 2)
    echo "1 \n";
else 
    echo $num_1 + $aux . "\n";

Hola!

Este es mi ejercicio… me iba complicando la vida! 😅

Me tomó bue rato darme cueta que el rango de la función es la serie de Fibonacci. Estoy publicando esto antes de ver la solución del ejercicio 😃
Acá mi codigo:

<?php

$a = 1;
$b = 1;
$c = 1;
do{
    $aumentar = readline("Indique el numero de casa: ");
} while ($aumentar <= 1);

for($i = 0; $i < $aumentar-2; $i++){
    $c = $a + $b;
    $b = $a;
    $a = $c;
}

echo "Existen $c formas de llegar a la casa $aumentar.\n";
 

Bien Complicado.

<?php

$numero_de_casa = 50;
$anterior = 0;
$actual = 1;

echo $anterior;
echo $actual;

for ($i=2; $i <= $numero_de_casa ; $i++) { 
   $veces = $anterior + $actual;
   $anterior = $actual;
   $actual = $veces;

   echo "Hay $veces caminos";

}

Desde que Retax empezó a explicar el problema con los nodos me di cuenta casi de una que se trataba de la sucesión de Fibonacci. La clave acá está en entender muy bien el problema e ir resolviéndolo paso a paso y muy detalladamente hasta encontrar un patrón lógico entre los datos y, de ahí, empezar a iterar.
.
Este tipo de problemas suelen escucharse muy complicados la primera vez que los leemos, pero en realidad, no es así y simplemente debemos es desglosarlos e, incluso, la solución es bastante sencilla como en este caso.
.
Adjunto mi solución:

<?php

$store = readline("A cuál tienda te gustaría dirigirte? ");

$paths = [0, 1];

for ($i = 0; $i < $store; $i++)
  array_push($paths, $paths[$i] + $paths[$i + 1]);

$possibilities = $paths[$store] === 1 ? 'posibilidad' : 'posibilidades';

echo "Para llegar a la tienda $store tienes {$paths[$store]} $possibilities" . PHP_EOL;

Aquí esta mi solución. Algo rebuscada pero al menos llegué al mismo resultado:

<?php
$tienda_destino = readline("¿A cuál tienda desea llegar?: ");
$caminos = 0; /* Cantidad de caminos para llegar a la tienda "p" */
$p = 1; /* La tienda por la que llevamos el conteo, que debe igualarse a la tienda destino */
$a = 0; /* Cantidad de caminos de la tienda "p-2" */
$b = 0; /* Cantidad de caminos de la tienda "p-1" */
if ($tienda_destino > 0){
  while($p != $tienda_destino){
    if ($p == 1){
      $caminos++; /* 1 */
      $a = $caminos; /* 1 */
      $p++; /* 2 */
    } else if ($p == 2){
      $caminos++; /* 2 */
      $p++; /* 3 */
    } else if ($p == 3){
      $b = $caminos; /* 2 */
      $caminos = $b + $a; /* 2 + 1 = 3 */
      $p++; /* 4 */
    } else if ($p >= 4){
      $a = $b; /* 2 */
      $b = $caminos; /* 3 */
      $caminos = $b + $a; /* 3 + 2 = 5 */
      $p++; /* 5 */
    }
  }
}
echo "Hay $caminos rutas";

Lo hice con un array, tome el numero de tiendas como el indice y el resultado era lo que contenia cada inidice. Se los muetro a continuacion:

<?php 

$ntienda = readline("a que tiendas quieres llegar?");
$t = array(
    0,
    1,
    1,
    2,
);
if ($ntienda < 4){
    
} else {
    for ($i=4; $i <= $ntienda; $i++) { 
        $t[$i] = $t[$i-1]+$t[$i-2];
    }
}
echo "El resultado es ".$t[$ntienda];
echo "\n";```

es facil, y sirve como entrenamiento para entender el problem del comerciante viajero

estan listos para la magia de la programación???
revisense este algoritmo y diganme que no es así…

<?php

$a = 1;
$b = 1;
$c = 1;

for ($i=2; $i < 15 ; $i++) { 
    echo "$i -> $c\n";
    $a = $b;
    $b = $c;
    $c = $b + $a;
}

<?php

$caminos = array(
2 => 1,
3 => 2,
4 => 3,
5 => 5
);

$destino = readline("tu puesto es 1, a que numero deseas llegar: ");
echo “\n”;

switch($destino) {
case 2:
echo “Tienes 1 camino\n”;
break;
case 3:
echo “Tienes 2 caminos\n”;
break;
case 4:
echo “Tienes 3 caminos\n”;
break;
case 5:
echo “Tienes 5 caminos\n”;
break;
}

<?php

$point = readLine("Enter the destiny point: ");

$prev = 0;
$counter = 1;

for ($i = 2; $i <= $point; $i++) {
    $result = $counter + $prev;
    $prev = $counter;
    $counter = $result;
}

echo $result;

Código del reto comentado:

<?php

$numero_de_tienda = (int) readline("Dime el número de tienda: "); // Le pedimos al usuario que ingrese el número de tienda que quiere evaluar

$anterior = 0; // Inicializamos la variable $anterior en 0
$actual = 1; // Inicializamos la variable $actual en 1

// Utilizamos un bucle for para recorrer cada tienda desde la segunda hasta la tienda ingresada por el usuario
for ($i = 2; $i <= $numero_de_tienda; $i++) {
    $temporal = $actual; // Guardamos el valor de $actual en una variable temporal para poder calcular el siguiente número de Fibonacci
    $actual += $anterior; // Calculamos el siguiente número de Fibonacci sumando $actual y $anterior
    $anterior = $temporal; // Actualizamos $anterior con el valor guardado en la variable temporal
}

// Mostramos el resultado del número de formas distintas de llegar a la tienda ingresada por el usuario
echo "Hay $actual formas distintas de llegar. \n";

Mi resolución:

<?php

$numero_de_tienda = readline("Digite el numero de tienda: ");
$a = 0;
$b = 1;

for($i = 0;$i < $numero_de_tienda;$i++){
    $c = $a + $b;

    $aux = $b;
    $b = $c;
    $a = $aux;
}

echo "Para llegar a tienda ".$numero_de_tienda . " tienes ". $a . " maneras de llegar\n";

Para llegar a 4 hay 4 maneras de llegar. eso cambiaria el código, quedo con esa duda. Gracias

Yo realice el reto utilizando el switch, me hice un pequeño spoiler de como lo estaban realizando, entonces quise hacerlo de una manera diferente y cumplir el reto a mi modo, me parecio una forma rapida de hacerlo ya que son 5 tiendas las cuales cada una tiene un camino que tomar distinto, y me parecio muy util utilizar los case, comparto el codigo del reto #3 espero sea de mucha ayuda para quien quiera ver como se realiza utilizando este metodo.

<?php

//Cuantos caminos puedo tomar para llegar a las diferentes tiendas.

//Tienda 1: 1 camino
//Tienda 2: 1 camino
//Tienda 3: 2 caminos
//Tienda 4: 3 caminos
//Tienda 5: 5 caminos

$Tiendas = readline("Por favor indique la tienda a la cual quiere llegar para estudiar los caminos posibles: ");
echo "\n";

switch ($Tiendas) {
    case 1:
        echo "La Tienda #1 tiene 1 camino para llegar";
        break;

    case 2:
        echo "La Tienda #2 tiene 1 camino para llegar";
        break;

    case 3:
        echo "La Tienda #3 tiene 2 caminos posibles para llegar";
        break;

    case 4:
        echo "La Tienda #4 tiene 3 caminos posibles para llegar";
        break;

    case 5:
        echo "La Tienda #5 tiene 5 caminos posibles para llegar";
        break;

    default:
        echo "Esta tienda no existe";

}

echo "\n";

Me tomó un par de horas, pero así fue como lo solucioné!

<?php

$n = readline("Hasta que tienda deseas llegar: ");

$arr = [0, 1];

for ($i = 1; $i <= $n; $i++) {
    $x = ($arr[$i - 1] + $arr[$i]);
    array_push($arr, $x);
}

echo "La cantidad de caminos disponibles que puede recorrer hasta la tienda '$n' es de $arr[$n] caminos!";

Despues de tanto pensar lo logre…

<?php
$x = 0;
$y = 1;
$pos_1 = readline("Please, give me a number and I will return the different ways number: ");

for($i = 1;$i <= $pos_1; $i++){
    $result = $x + $y;
    $x = $y;
    $y = $result;
    if ($i == $pos_1)
        echo "The number of ways to get to $pos_1 is $result. \n"; 
}

Mi solución, a mi el switch si me gusta XD

do {
  $option = readline('¿Qué tienda desea consultar?: ');

  if ($option) {
    switch($option){
      case 2:
        echo 'Existe 1 camino para la tienda 2';
        break;
      case 3:
        echo 'Existen 2 caminos para la tienda 3';
        break;
      case 4:
        echo 'Existen 3 caminos para la tienda 4';
        break;
      case 5:
        echo 'Existen 5 caminos para la tienda 5';
        break;
      case 6:
        echo 'Existen 8 caminos para la tienda 6';
        break;
      case 7:
        echo 'Existen 13 caminos para la tienda 7';
        break;
      case 8:
        echo 'Existen 21 caminos para la tienda 8';
        break;
      default: echo 'opción invalida';
    }
  }
} while (!$option);

Cuando piensas que hay que aplicar grafos, recursividad, incluso fuerza bruta, y sale con Fibonacci 🙃

Solucion recursiva:

<?php

function calculateWaysToArrive($nth_house){
    if($nth_house == 1){
        return 1;
    }else if($nth_house == 2){
        return 1;
    }else{
        return calculateWaysToArrive($nth_house - 1) + calculateWaysToArrive($nth_house - 2);
    }
};
$house = 8;
$ways = calculateWaysToArrive($house);
echo "There are $ways to arrive to the $house th house";

Dejo mi aporte usando un switch, while y array.

<?php

$cantidadTiendas = readline("Ingrese por favor la cantidad de nodos: ");

$contador = 3; // a partir de este num vamos a calcular los caminos
$array_caminos = [0,1,2]; // array de caminos

switch($cantidadTiendas){
    case 0:
        echo("0 caminos, pues no hay nodos :p\n");
        break;
    case 1:
        echo("0 caminos, para llegar a si mismo no necesita ningun camino :)\n");
        break;
    case 2:
        echo("1 camino posible.\n");
        break;
    case 3:
        echo("2 caminos posibles.\n");
        break;
    default: //si la cantidad de tiendas es mayor a 3 calculamos
        while($contador < $cantidadTiendas){
            $ultimoNum = end($array_caminos);
            $anteUltimoNum = $array_caminos[count($array_caminos)-2];
            $nuevoNum = $ultimoNum + $anteUltimoNum;

            //agrego el nuevo numero al array de caminos
            array_push($array_caminos, $nuevoNum); 
            $contador++; //incrementamos el contador
        }
        // cuando el bucle llega a su fin, calculamos el resultado
        $resultado = $nuevoNum + $ultimoNum;
        echo("$resultado caminos posibles.\n");
        break;
}