<jupyter_start><jupyter_text>Esercizio \[60 pts\](campo minato) Conteggio di cammini in una griglia rettangolare con celle proibite. Bimo cammina sulle celle di un campo minato dalla forma di una griglia rettangolare $m\times n$. Le mine sono indicate da un "*" mentre le altre celle (" ") sono tutte transitabili.Le mosse consentite portano Bimo dalla cella $(i,j)$ alla cella $(i+1,j)$ oppure $(i,j+1)$, sempre ove queste siano transitabili.Organizzati per calcolare quanti sono i cammini possibili tra due celle date e per rispondere ad altre domande di questo tipo. Notice: Anche se ne hai quì ogni opportunità, non ti è però richiesto in alcun modo di scrivere del codice per condurre a termine il tuo esercizio. Puoi fare tutto a mano e vogliamo essere chiari che noi non facciamo alcuna differenza tra i punti conquistati in un modo piuttosto che in un altro (noi guardiamo ai risultati e ci piace che voi vi ingegniate a modo vostro per portarli a casa, in tutta libertà). Sei incoraggiato piuttosto a ricercare l'approccio per tè più pratico, sicuro, e conveniente. E magari quello che puoi trovare più piacevole e stimolante quando svlgi l'esercizio da casa, dove ti suggerisco sperimentare, potrebbe anche essere diverso .Ciò nononostante, per facilitare chi di voi volesse scrivere del codice a proprio supporto, abbiamo aggiunto alla mappa di $m$ righe ed $n$ colonne una riga e colonna iniziale (di indice zero), fatte interamente di mine, perchè non si crei confusione col fatto che gli indici di liste ed array in programmazione partono da zero.<jupyter_code>display(Markdown(f"Un robot, inizialmente situato nella cella ${chr(64+start_point[0])}{start_point[1]}={start_point}$, deve portarsi nella cella "\
                + f"${chr(64+target_point[0])}{target_point[1]}={target_point}$." \
                + f"Le celle che riportano il simbolo '*' contengono una mina od altre trapole mortali, ed il robot deve evitarle." \
                + f"I movimenti base possibili sono il passo verso destra (ad esempio il primo passo potrebbe avvenire dalla cella $A1$ alla cella $A2$)" \
                + f" ed il passo verso il basso (ad esempio, come unica altra alternativa per il primo passo il robot "\
                + f"potrebbe portarsi quindi nella cella $B1$).\n" \
                + f"Quanti sono i possibili percorsi che può fare il robot per andare dalla cella ${chr(64+start_point[0])}{start_point[1]}$ alla cella ${chr(64+target_point[0])}{target_point[1]}$?"))
visualizza(mappa)<jupyter_output>╒════╤═════╤═════╤═════╤═════╤═════╤═════╤═════╤═════╤═════╕
│    │ 1   │ 2   │ 3   │ 4   │ 5   │ 6   │ 7   │ 8   │ 9   │
╞════╪═════╪═════╪═════╪═════╪═════╪═════╪═════╪═════╪═════╡
│ A  │     │     │     │     │     │     │     │     │ *   │
├────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤
│ B  │     │     │     │     │ *   │ *   │     │     │     │
├────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤
│ C  │     │ *   │     │ *   │     │     │     │     │     │
├────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤
│ D  │     │     │     │     │     │     │     │ *   │     │
├────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤
│ E  │     │     │ *   │     │ *   │     │     │     │     │
├────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤
│ F  │     │     │     │     │     │     │ *   │     │     │
├────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤
│ G  │     │ *   │     │     │     │     │     │     │     │
├────┼─────┼─────┼─────┼[...]<jupyter_text>__Richieste__:<jupyter_code>display(Markdown(f"1. __\[10 pts\]__ A mano o tramite un programma componi la matrice $num\_paths\_to$ di dimensione $(m+1)\\times(n+1)$ e tale per cui in $num\_paths\_to[i][j]$ sia riposto il numero di cammini dalla cella ${chr(64+start_point[0])}{start_point[1]}={start_point}$ alla generica cella $(i,j)$, per ogni $i = 0,..., m+1$ e $j = 0,..., n+1$."))
num_paths_to =[
                    [  0,   0,   0,   0,   0,   0,   0,   0,   0,   0], 
                    [  0,   1,   1,   1,   1,   1,   1,   1,   1,   0], 
                    [  0,   1,   2,   3,   4,   0,   0,   0,   0,   0], 
                    [  0,   1,   0,   3,   0,   0,   0,   0,   0,   0], 
                    [  0,   1,   1,   3,   3,   3,   3,   3,   0,   0], 
                    [  0,   1,   2,   0,   3,   0,   3,   6,   6,   6], 
                    [  0,   1,   3,   3,   6,   6,   9,   0,   6,  12], 
                    [  0,   1,   0,   3,   9,  15,  24,  24,  30,  42], 
                    [  0,   1,   1,   4,  13,  28,  52,  86, 106, 148]
                ]

visualizza_e_valuta('num_paths_to',num_paths_to_1_corr)
display(Markdown(f"2. __\[10 pts\]__ Componi ora una matrice $num\_paths\_from$ di dimensione $(m+2)x(n+2)$" \
                    +f" e tale per cui in $num\_paths\_from[i][j]$, per ogni $i = 1,..., m+1$ e $j = 1,..., n+1$," \
                    +f" sia riposto il numero di cammini dalla generica cella $(i,j)$ alla cella "\
                    +f"${chr(64+target_point[0])}{target_point[1]}={target_point})$."))
num_paths_from=[
                    [  *,   *,   *,   *,   *,   *,   *,   *,   *,   *], 
                    [  *,    ,    ,    ,    ,    ,    ,    ,    ,   *], 
                    [  *,    ,    ,    ,    ,   *,   *,    ,    ,    ], 
                    [  *,    ,   *,    ,   *,    ,    ,    ,    ,    ], 
                    [  *,    ,    ,    ,    ,    ,    ,    ,   *,    ], 
                    [  *,    ,    ,   *,    ,   *,    ,    ,    ,    ], 
                    [  *,    ,    ,    ,    ,    ,    ,   *,    ,    ], 
                    [  *,    ,   *,    ,    ,    ,    ,    ,    ,    ], 
                    [  *,    ,    ,    ,    ,    ,    ,    ,    ,    ]
                ]
visualizza_e_valuta('num_paths_from',num_paths_from_1_corr)
display(Markdown(f"3. __\[10 pts\]__ Quanti sono i percorsi con partenza in ${chr(64+start_point[0])}{start_point[1]}={start_point}$ ed arrivo in "\
                 +f"${chr(64+target_point[0])}{target_point[1]}={target_point}$."))


display(Markdown(f"4. __\[10 pts\]__ Quanti sono i percorsi con partenza in ${chr(64+middle_point_1[0])}{middle_point_1[1]}={middle_point_1}$ ed arrivo in "\
                 +f"${chr(64+target_point[0])}{target_point[1]}={target_point}$."))
display(Markdown(f"5. __\[10 pts\]__ Quanti sono i percorsi con partenza in ${chr(64+start_point[0])}{start_point[1]}={start_point}$ ed arrivo in ${chr(64+middle_point_2[0])}{middle_point_2[1]}={middle_point_2}$?"))
display(Markdown(f"6. __\[10 pts\]__ Quanti sono i percorsi che partono da ${chr(64+start_point[0])}{start_point[1]}={start_point}$, passano da ${chr(64+middle_point_3[0])}{middle_point_3[1]}={middle_point_3}$, ed arrivano in ${chr(64+target_point[0])}{target_point[1]}={target_point}$?"))<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.20741497591592467, 'fraction_numerical': 0.03225806451612903, 'mean_word_length': 2.1634349030470914, 'pattern_counts': {'":': 0, '<': 8, '<?xml version=': 0, '>': 8, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 26, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '2', 'dir': 'jupyter-structured-clean-dedup', 'id': '338673', 'license': 'MIT', 'n_tokens_mistral': 2933, 'n_tokens_neox': 2765, 'n_words': 694, 'path': 'Verificatori/Robot_senza_Gemme/Stampino/robot_senza_gemme.ipynb', 'repo_name': 'romeorizzi/eduexams', 'size': '6851'}