No tienes acceso a esta clase

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

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

13/25
Recursos

Aportes 46

Preguntas 1

Ordenar por:

Los aportes, preguntas y respuestas son vitales para aprender en comunidad. Regístrate o inicia sesión para participar.

💪 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 💪.

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 😂

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

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

Sucesión de Fibonacci

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

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

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;

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

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

?>

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

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

Yo solo lo realice de una forma diferente, no tan optima, pero funcional, igual se que se puede mejorar, mi solución es:

<?php

$tienda_a_llegar = (int) readline("Ingrese el numero de la tienda a la que desea llegar: ");

$fibonachi = [0,1];

if($tienda_a_llegar == 1){
    echo "No ahi que tomar ningun camino";
    echo "\n";
}else{
    for ($i = 0; $i < ($tienda_a_llegar - 1); $i++) {
        
        $ultimo_valor = end($fibonachi);
        $lista_al_reves = array_reverse($fibonachi);
        
        $primer_valor = $lista_al_reves[1];
        $lista_al_derecho = array_reverse($fibonachi);

        $resultado_fibonachi = $primer_valor + $ultimo_valor;

        array_push($fibonachi, $resultado_fibonachi); 
    };
    echo "La cantidad de caminos que puede tomar son: $resultado_fibonachi \n";
};

Me enrede con la explicacion, porque no encontraba la secuencia, pero viendo los comentarios vi que era el fibonacci y lo entendi. MI APORTE.
<?php

$valor= 8;
$a=0;
$b=1;

for ($i=0; $i < $valor ; $i++) {
echo $b;
$c= $a+$b;
$a= $b;
$b= $c;
}

Lo hice de 2 maneras, la primera con caminos ya definidos que son 7 los que creé y la segunda para n números de caminos.

<?php
//Programa para ver ¿cuántos caminos hay para llegar al mismo punto?
$caminos = [
    "B"=>["AB"],
    "C"=>["ABC","AC"],
    "D"=>["ABCD","ACD","ABD"],
    "E"=>["ABCDE","ABCE","ABDE","ACDE","ACE"],
    "F"=>["ABCDEF","ABDF","ABCEF","ABCDF","ACDF","ACDEF","ACEF","ABDEF"],
    "G"=>["ABCDEFG","ABCDFG","ABCDEG","ABCEG","ABCEFG","ABDFG","ABDEFG","ABDEG","ACEG","ACEFG","ACDFG","ACDEFG","ACDEG"],
];
$llegada = ["B","C","D","E","F","G"];

echo "Averigua cuántos caminos hay para llegar al punto que quieres empezando desde el camino A.\n";
do{
    $valor_llegada = readline("¿A qué punto quieres llegar desde el punto A?. Puntos de llegada: B, C, D, E, F, G: \n");
}
while(!in_array($valor_llegada,$llegada));

foreach($caminos as $destino=>$valor){
    if($valor_llegada == $destino){
        if (count($valor) == 1){
            echo "Del camino A al camino $destino existe ". count($valor). " camino diferente. Este es: $valor[0]\n";
        }
        else{
            echo "Del camino A al camino $destino existen ". count($valor). " caminos diferentes. Estos son:\n";
            $contador = 1;
            foreach ($valor as $rutas){
                echo "Ruta $contador: $rutas\n";
                $contador++;
            }
            break;
        }
        }
        else{
        continue;
    }
}

//Caminos en general

do{
    $camino_destino = (int) readline("Estas en el camino 1, a qué camino quieres ir? \n");
}
while($camino_destino <2);
$camino_anterior = 0;
$camino_actual = 1;
for ($i=1; $i < $camino_destino; $i++) { 
   $nro_caminos = $camino_anterior + $camino_actual ;
   $camino_anterior = $camino_actual;
   $camino_actual = $nro_caminos;
}
if ($camino_destino == 2) {
    echo "Del camino 1 al camino $camino_destino solo existe $nro_caminos camino por donde llegar.\n";
} else {
    echo "Del camino 1 al camino $camino_destino existe $nro_caminos caminos por donde llegar.\n";
}

Hola!! Yo resolvi el reto de una forma diferente. Como ya tenia la cantidad de tiendas y la cantida de caminos lo cree asi:

<?php

// El usuario debe seleccionar la tienda y el programa muesta los viajes que puede aplicar hasta la tienda.

$usuario = readline("A que tienda deseas ir? ");
$caminos = array(
    2 => 1,
    3 => 2,
    4 => 3,
    5 => 5,
    6 => 8,
    7 => 13,
    8 => 21
);

foreach ($caminos as $tienda => $viajes) {    
    if ($tienda == $usuario) {
        $camino = $viajes;
        break;
    };
};

echo ("Excelente, deseas ir a la tienda $usuario \nPara llegar a ella tienes $camino caminos");

Al principio no me lo esperaba, pero al resolverla resulta que si se parece mucho a la secuencia de Fibonacci, claro que sin tener los dos unos característicos de dicha secuencia. Así que me parece que esta función se ajusta mejor al problema.

	 		 {  f(x-1) + f(x-2) , x > 1
f(x) = {  1  , x  = 1
			 {  0  ,  x <= 0

Donde:
x, es la tienda a la que se desea llegar.
f(x), el numero de caminos para llegar a x.

No pude hacerlo sin ver la explicación, no conocia la Sucesión de Fibonacci, pero mi instinto me decia que debia haber un patron…

Aqui mi resultado:

<?php

//* para llegar a la tienda 2 -> hay 1 forma de llegar
//* para llegar a la tienda 3 -> hay 2 forma de llegar
//* para llegar a la tienda 4 -> hay 3 forma de llegar
//* para llegar a la tienda 5 -> hay 5 forma de llegar
//* para llegar a la tienda 6 -> hay 8 forma de llegar
//* para llegar a la tienda 7 -> hay 13 forma de llegar
//* para llegar a la tienda 8 -> hay 21 forma de llegar


$tienda_objetivo = (int) readline('Indique el numero de la tienda a la cual desea ir: ');

if ($tienda_objetivo == 1) {
    echo "Ya estas alli. \n";
    exit();
}

if ($tienda_objetivo == 2) {
    echo "Solo hay un (1) camino para llegar. \n";
    exit();
}

if ($tienda_objetivo == 3) {
    echo "Hay dos (2) caminos para llegar. \n";
    exit();
}

$caminos_anteriores = 2;
$caminos_anteriores_al_anterior = 1;

for ($i = 4; $i <= $tienda_objetivo; $i++) {
    $total_caminos_para_llegar = $caminos_anteriores + $caminos_anteriores_al_anterior;

    //* Actualizar caminos anteriores
    $caminos_anteriores_al_anterior = $caminos_anteriores;
    $caminos_anteriores = $total_caminos_para_llegar;

    if($i < $tienda_objetivo) continue;
    
    echo "Existen $total_caminos_para_llegar caminos para llegar a la tienda $tienda_objetivo. \n";
}

Pudo ser mejor pero se entiende y funciona.

Un saludo
Acaso será la serie Fibonacci?, viendo los valores 2, 3, 5, será que la tienda 6 tiene 8 formas?.
Buen reto. Sigo viendo el video.
Bye.

Lo pensé al estilo de Fibonacci, el cual para obtener el valor de la posición actual debo sumar los dos anteriores, esa fue mi partida dentro del ciclo for… El resto es historia

<?php
	$numTienda;
	
	while(true)
	{
		$numTienda = readline('Ingrese la tienda a llegar: ');
		if($numTienda >= 2)
			break;
	}
	
	$primer = 1;
	$segundo = 0;
	$resultado;
	
	for($i = 2; $i <= $numTienda; $i++)
	{
		$resultado = $primer + $segundo;
		if($segundo > 0) $primer = $segundo;
		$segundo = $resultado;
	}
	
	echo "Existen $resultado formas de llegar a la tienda $numTienda";

Comparto mi código antes de ver la solución

<?php

$caminos = [
    "1" => 0,
    "2" => 1,
    "3" => 2,
    "4" => 3,
    "5" => 5,
    "6" => 8,
    "7" => 13,
    "8" => 21,
    "9" => 34 
];

do {

    $consulta = readline("ingresa el numero de tienda ");
     
        if ($consulta == 1){
            echo "Ya estas en la tienda indicada \n";
        } elseif ($consulta < 1 || $consulta >9){
            echo "no encontramos la tienda seleccionada";
        }else {
            foreach ($caminos as $ruta => $cantidad ){
                if ($ruta != $consulta) {
                continue;
                break;
        }
        echo "Para llegar a la tienda numero '$ruta' hay '$cantidad' rutas disponibles \n";
    }}    
    echo "\n";
    $continuar = readline("Desea intentar con otra tienda 'y = si' o cualquier tecla para salir");
    if ($continuar == "y" )
    $continuar = true;
    else 
    $continuar= false;
    echo "\n";
} while ($continuar);

pense que podria usar recursividad para la solucion y este fue el resultado
espero este entendible ❤️

<?php
//las casas cuyos caminos se pueden recorrer
$vecindario = array(
        1 => array(2, 3),
        2 => array(3, 4),
        3 => array(4, 5),
        4 => array(5, 6),
        5 => array(6, 7),
        6 => array(7, 8),
        7 => array(8),

    );

/*
$vecindario: es el vecindarion sin mas
$objetivo: es la casa para a la cual se quiere llegar
$array: arreglo de casa a visitar primero es [2,3] porque esas son las casas que puede visitar desde la casa 1
$caminos: son los caminos a recorrer
 */

function solucion($vecindario, $objetivo, $array = [2, 3],   $caminos=0){
    //visito la casa
    $visitada = array_pop($array);
    //pregunto si la casa visitada es la casa objetivo
    if($visitada == $objetivo):
        $caminos += 1;
   
    /*
        si no, pregunto si la casa visitada es menor que el objetivo, de ser asi
        puedo agregar los caminos de esa casa
        porque si es mayor no tiene caso visitar sus caminos
        porque no voy a llegar.
     */
    elseif($visitada < $objetivo):

        $array = array_merge($array, $vecindario[$visitada]);
    endif;
    
    //si todavia quedan casasa por visitar hago un llamado recursivo 
    if(count($array) !== 0):

        return solucion($vecindario, $objetivo, $array, $caminos);
    else:
        //si no quedan casas por visitar retorno el numero de caminos
        return $caminos;
    endif;

        
}

for($i = 2 ; $i <= 8; $i++):
    echo $i . "->" . solucion($vecindario, $i) . "\n";
endfor;

Asocie el numero de las rutas con la serie fibonacci y apartir de ahi construi un algoritmo basico para calcular el numero de rutas.

<?php

$houses = readline("What is the number of the house where you want to go ? ");

$sum = 0;
$temp1 = 0;
$temp2 = 1;

for ($i = 1; $i < $houses; $i++) {
    $sum = $temp1 + $temp2;
    $temp1 = $temp2;
    $temp2 = $sum;
}

echo "\n";
echo "The number of the routes is : " . $sum;
echo "\n";


?>

De alguna manera me salió a la primera

<?php
  $dinero = readline("A qué tienda quieres llegar?\n");
  $pasos_anterior = 0;
  $pasos_new = 1;
  $pasos_total = 1;
  for ($i=0; $i < ($dinero-1); $i++) {
    $pasos_total = $pasos_new + $pasos_anterior;
    $pasos_anterior = $pasos_new;
    $pasos_new = $pasos_total;
  }
  echo "La cantidad de pasos totales es $pasos_total";

así me quedo a mi

<?php
for ($i= (int) readline('¿A que tienda quieres ir?: ')-1, $x=0, $y=1; $i != 0; $i--, $y += $x, $x=$y-$x ) { 
}
echo "\nEsa tienda tiene $y caminos"; 
?>

Me fui con un while. Y aunque no me gustó como solucioné los dos primeros “tiendas”, el resto me gustó.Gran reto

<?php

$paso_objetivo = readline("Ingrese el paso al que quiere llegar: ");

$paso_actual = 1;

$num_de_pasos = [];

while ($paso_actual <= $paso_objetivo) {
    
    $cuenta_pasos =count($num_de_pasos);

    if ($cuenta_pasos < 2) {

        array_push($num_de_pasos,1);
        $pasos_a_dar = 1;
    } else{
        $a = $num_de_pasos[$cuenta_pasos-2];
        $b = $num_de_pasos[$cuenta_pasos-1];
        $pasos_a_dar = $a + $b;
        array_push($num_de_pasos,$pasos_a_dar);
    };
    $paso_actual++;
    };


echo "El número de formas de llegar al objetivo $paso_objetivo es de $pasos_a_dar";

Realmente para mi lo mas difícil fue interpretar la serie Fibonacci en el código

$tienda = readline("ingresa el numero de tienda: ");
$numeros = [0,1];
$resultado = 0;
for ($i=1; $i<$tienda; $i++) {
    if ($tienda<2) {
        break;
    }
    $resultado = $numeros[$i] + $numeros[$i-1];
    array_push($numeros, $resultado);
}

echo "Es numero de caminos es: $resultado";
echo "\n";

Mi solución

  $numb = (int)readline("Dinos a que casa deseas llegar: ");

  $numb2 = 0;
  $numb3 = 1;

  for ($i=0; $i < $numb; $i++) { 
    $numb2 += $numb3;
    $numb3 = $numb2 - $numb3;
  }

  echo "La cantidad de maneras de llegar a esa casa son: " . $numb2 . "\n";

yo resolví el reto con la secuencia fibonacci 🥳

Luego de mucho estrés y de frustración logré mi reto, acá les dejo el código.

<?php

$tiendas = (int) readline("Hasta cual tienda quieres ir?");
$num_anterior = 1;
$num_actual = 1;
$resultado;

for($i = 1;$i < $tiendas; $i++){
    $resultado = $num_anterior + $num_actual;
    $num_anterior = $num_actual;
    $num_actual = $resultado;
};
echo "Para llegar a la tienda número $tiendas hay $resultado rutas";

Para los siguientes que lean esto, se que se bloquearán, se estresarán y frustraran.
Mi consejo es q plasmen todo en papel, intenten buscarle una solución de forma calmada y dividan y vencerán!!.

Lo admito hize trampa 😦 vi que resolvia con fibonacci pero no habia investigado sobre el así que me toco aprender como funcionaba y bueno lo resovi así…

<?php
function caminos($w){
    $ways = [1,1];
    for($i = 0, $j = 1; $i <= $w-3; $i++, $j++){
        array_push($ways,$ways[$i]+$ways[$j]);
    }
    echo "{$ways[count($ways)-1]} son los caminos";
}
/*Escribe en la funcion el numero de tienda*/
caminos();

Vista en formulario

<form action="
    <?php 
        echo htmlspecialchars($_SERVER['PHP_SELF']);
    ?>"
method="post">
    <input type="text" name="shop" value="" >
    <button>Enviar</button>
</form>


<?php
if($_POST){
    $limit = $_POST['shop']; 
    function caminos($w){
        $ways = [1,1];
        for($i = 0, $j = 1; $i <= $w-3; $i++, $j++){
            array_push($ways,$ways[$i]+$ways[$j]);
        }
        echo "{$ways[count($ways)-1]} son los caminos";
    }
    /*Escribe en la funcion el numero de tienda*/
    caminos($limit);
}


?>

Esta fue mi lógica para solucionar el problema, estuvo bueno:

<?php

    $tiendita=(int)readline("A que tiendita quieres ir: ");

    $formas_llegar=0;
    $posicion=1;

    // 1,1,2,3,5,8,13,21
    // 1,2,3,4,5,6,7,8

    $i=1;
    while($i<=$tiendita){
        $formas_llegar=$formas_llegar+$posicion; // 1
        $posicion=$formas_llegar-$posicion;
        $i++;
    }

    echo "\n\t Existen $formas_llegar formas de llegar a la tiendita $tiendita";
    
    echo "\n\n";

?>

<?php

echo ’ 2 4 6 ‘;
echo “\n”;
echo ’ --------’;
echo “\n”;
echo ’ / \ / \ / \ ';
echo “\n”;
echo ’ / / / \ ';
echo “\n”;
echo '
------------*’;
echo “\n”;
echo ’ 1 3 5 7’;
echo “\n”;
echo “\n”;
echo ‘Comenzando desde 1, siempre de izquierda a derecha, el probrama tendra que decir cuantos son los caminos posibles para llegar a cualquier punto por encima de 1.’;
echo “\n”;
echo 'A continuacion, escriba la tienda a la que quiera llegar: ';
echo “\n”;

$tienda = readline();

if ($tienda < 1){
echo ‘El numero debe ser entero y superior a 1’;
die();
}

function obtener_factorial($mi_fatorial)
{
if($mi_fatorial==1)
return 1;
else
return $mi_fatorial * obtener_factorial($mi_fatorial-1);
}

$count = 0;

for($i = 0; $i <= $tienda ; $i++){
for($j = 0; $j <= $tienda;$j++){
if(1 + 1*$i + 2*$j == $tienda){

		if( $i == 1 || $j == 1 ){
			$count = $i + $j + $count;
			continue;
		}else if( $i == 0 || $j == 0 ){
			$count++;
		}else{
			$count = (obtener_factorial($i+$j)/(obtener_factorial($i)*obtener_factorial($j))) + $count;
		}
	}
}

}

echo “\n”;

echo “Numero de caminos: $count”;

echo “\n”;

Llego un poco tarde pero este es mi aporte:

<?php

//inicio = 1;

$opciones = array(1);

//Aqui se podria poner un readline() para iontroducir en consola el numero al que se quiere llegar
$quiero_llegar = 9;

$contador = 0;

for ($i=0; $i < count($opciones); $i++) { 
    
    /*Para saber en que Iteracion va puse un echo que me muestre la variable i
    echo "$i \n";*/

    if ($opciones[$i] < $quiero_llegar) {
        $opcion1 = $opciones[$i] + 1;
        $opcion2 = $opciones[$i] + 2;
        array_push($opciones, $opcion1, $opcion2);
    }  
    else if ($opciones[$i] == $quiero_llegar) {
        $contador++;
    }

    /*Para ver al final de cada iteracion como va quedando el array puse un print_r()
    print_r($opciones);*/   
};

echo "$contador";

?>

Casi no

<?php

$casas = readline("Por favor, ingrese la casa a la que quiere ir: ");
$i = 1;
$actual=0;
$ultimo =0;
$anterior =0;
while ($i <= $casas) {
    if($i>3) ($actual = $anterior + $ultimo);
    if($i == 2) ($actual = 1);
    if($i == 3) ($actual = 2);
    if($i%2 == 0){
        $ultimo = $actual;
    } else{
        $anterior =$actual;
    }
   // echo $i . "  "  . $actual . "\n";
    $i++;
}

echo "Los caminos por los que puede ir son $actual para llegar a la casa $casas";

Estuvo entretenido el ejercicio, esta es mi solución, fue menos del Código que esperaba.

<?php
$store = readline("¿A que tienda quieres llegar?");
$a = 0;
$b = 1;
for ($i= 2; $i<=$store; $i++){
    $c = $a + $b;
    echo "Hay $c caminos para la tienda $i \n" ;
    $a = $b;
    $b = $c;
}

Me gusto el reto de además de buscar conocer la cantidad de caminos poder conocer cuales son estos caminos, les dejo mi código un poco desordenado esperando sugerencias para mejorarlo:

$caminos = caminosTienda(8,[1]);
$cantidad = count($caminos);
echo "CLASE 13 RETO: El total de caminos a tomar es de $cantidad";
echo "<br>";
echo "CLASE 13 RETO: Los caminos a tomar son: ";
echo json_encode($caminos);
echo "<br>";
function posibilidades($base)
{
    $final =  array();
    $base = (is_array($base)) ? $base : array($base);
    for ($i=0; $i < 2; $i++) { 
        $txt = "arr".$i; 
        $$txt = array();
        $sig = 0;
        foreach ($base as $key => $value) {
            array_push($$txt,$value);
            $sig = $value;
        }
        if($i == 0){
            $sig = $sig + 1;
            array_push($$txt,$sig);
        }else{
            $sig = $sig + 2;
            array_push($$txt,$sig);
        }
        array_push($final,$$txt);
    }

    return $final;
}

function caminosTienda($final,$nbase)
{
    $arracumulado = array();

    for ($a=0; $a < $final; $a++) {
        
        $rutafinal2 = array();
        for($i = 0; $i < count($nbase); $i++){
            $base = $nbase[$i];
            $pos = posibilidades($base);  
            $rutafinal2 = array_merge($rutafinal2,$pos); 
        } 
        $nbase = $rutafinal2;
        $arracumulado = array_merge($arracumulado,$nbase);
    }
    return selectCaminos($final,$arracumulado);
}

function selectCaminos($limite,$arr)
{
    $narr = array();
    for ($i=0; $i < count($arr); $i++) { 
        $dato = $arr[$i];
        $ultimo = $dato[count($dato)-1];
        if($limite < $ultimo)
            continue;

        for ($j=$ultimo+1; $j <= $limite; $j++) {          
            array_push($dato,$j);
        }

        array_push($narr,$dato);
    }
    $narr = array_unique($narr, SORT_REGULAR);
    return $narr;
}

Les comparto la forma en que yo pude resolverlo

<?php

$tienda = readline("Indique a que tienda quiere llegar: ");

if($tienda > 1) {

    $posibilidades = [0, 1];

    for ($i = 0; $i < $tienda; $i++) { 
        
        array_push($posibilidades, ($posibilidades[count($posibilidades)-1] + $posibilidades[count($posibilidades)-2]));
        
    }

    echo "El numero de caminos posibles es: {$posibilidades[count($posibilidades)-2]}";

} else if( $tienda == 1){
    echo "Ya se encuentra en la tienda 1";
} else {
    echo "No se puede retroceder";
}

Excelente, en mi caso analize la relacion entre el camino a la tienda a la que quiero llegar y los caminos a las últimas dos tiendas.

Después de un rato pensando pude entender como resolver el problema y aquí les dejo mi pequeño aporte, supongo que habrá mas de una forma de resolverlo. Animo compañeros!!! si se puede!!!

<code> <?php 

$inicial = 1; 
$caminos = [0];
$casita = readline("Ingrese el numero de la casita a la que desea ir -> ") ;

echo "\n";


for($i = 1; $i <= $casita; $i++){
   array_push($caminos, $caminos[$i - 1] + $inicial);
    $inicial = $caminos[$i - 1];

     if( $i == $casita)
     echo "Existen ". $caminos[$i] . " caminos para llegar a la casa # " . $casita; 
}
?>

Los caminos posibles serian la Sucesión de Fibonacci si no estoy mal

Comparto mi solución que tiene más caracteres pero 1 línea de código menos que la solución del profesor.
En mi caso he utilizado un array para almacenar por cada tienda que pase, los caminos que hay para llegar a ella, hasta llegar a la tienda destino:

$tiendaDestino = (int) readline("Introduce el numero de la tienda destino: ");

$registroCaminosLlegarDestino = [1, 1];
$ultimoIndexArray = 1;

for ($tiendaActual = 2; $tiendaActual < $tiendaDestino; $tiendaActual++, $ultimoIndexArray++) {
    $resultadoCaminos = ($registroCaminosLlegarDestino[$ultimoIndexArray] + $registroCaminosLlegarDestino[$ultimoIndexArray - 1]);
    $registroCaminosLlegarDestino[] = $resultadoCaminos;
};

echo "Hay {$registroCaminosLlegarDestino[$ultimoIndexArray]} formas de llegar a tu tienda destino, TOMA YA! ";

Me gustaría obtener vuestro feedback. Espero que sirva como ejemplo de que podemos llegar a la misma solución de una manera distinta.

Esta parte de mi vida, esta pequeña parte de mi vida se llama felicidad 🥹🥹

Pero solo sabia hacer Fibonacci con recursividad "Porqueeee a miii😭? " y ni idea de funciones en PHP 😥. Luego google y aparece esta ecuación demoniaca que no tenía ni idea que existía. Lo se "keep skeptical stay safe ".

<?php
$n = 7;
$fib =((1+sqrt(5))**$n-(1-sqrt(5))**$n)/(2**$n*sqrt(5));
echo "Posibles caminos $fib";
**Con ciclo FOR**
$caminos = [1,1];

do {
    $casaDestino = readline("Elija una casa de destino partiendo desde la primera casa: ");
    for ($i=2; $i < $casaDestino; $i++) {
        $caminos[$i] = $caminos[$i-1] + $caminos[$i-2];
    }
    echo "La cantidad de caminos para la casa numero $casaDestino es: ". $caminos[$casaDestino-1]."\n";
}while(readline("¿Desea conocer la cantidad de camino hacia otra casa?: [si/no]") == "si");

**De forma recursiva**

<?php

function cantCaminos($casaDestino) {
    if($casaDestino < 2) {
        return $casaDestino;
    }else {
        return cantCaminos($casaDestino-1)+cantCaminos($casaDestino-2);
    }
}
do {
    $casaDestino = readline("Elija una casa de destino partiendo desde la primera casa: ");
    echo "La cantidad de caminos para la casa numero $casaDestino es de: ".cantCaminos($casaDestino)."\n";
}while(readline("¿Desea conocer la cantidad de camino hacia otra casa?. [si/no]: ") == "si");