Matrici numpy 3 - Challenge

Scarica zip esercizi

Naviga file online

Proponiamo ora degli esercizi senza soluzione. Accetti la sfida?

Sfida - La macchinetta che produce scienza

✪✪ Gilberto, Rocky e Clelia sono data scientist nello stesso laboratorio di ricerca.

Oggi hanno deciso di chiamare la pausa e sono ora davanti alla macchinetta del caffè a chiacchierare.

Il discorso arriva su quante bevande hanno preso alle macchinette nell’ultima settimana e di conseguenza a quanti soldi hanno speso per cercare di avere le energie per scrivere i loro paper.

Dopo un po’ di discussione qualitativa entra in gioco la deformazione professionale e preparano una matrice a tre righe e tre colonne in cui:

  • Ciascuna colonna rappresenta uno di loro tre

  • Ciascuna riga rappresenta una delle bevande acquistabili dalla macchinetta

Vogliono ora calcolare:

  1. stampare la somma delle colonne

  2. stampare la somma delle righe

  3. chi di loro ha speso in totale più soldi

  4. quale bevanda è la più gettonata

SUGGERIMENTO: usate le funzioni di numpy!

>>> arr[0]
[4.0,9.0,3.0]         # riga

>>> arr[:,1]
[4.0,9.0,3.0,7.0]   # colonna

  • mat.fill(8)

  • print(np.sum(arr, axis=1))

[1]:

import numpy as np

m = np.array(
    [
#        Gilberto   Rocky     Clelia
        [5.0,       8.0,      1.0],   # Thè
        [7.0,       3.0,      2.0],   # Caffè
        [9.0,       2.0,      8.0]    # Ginseng
    ]
)

# scrivi qui


Spesa di ciascuno:
        Gilberto Rocky Clelia
         [21. 13. 11.]
Spesa per tipo:
        The Caffè Ginseng
         [14. 12. 19.]
Dei tre ha speso di più il numero:  [0]
La bevanda preferita è la numero:  [2]

Sfida - Kombattimento Morale

✪✪✪ Il temuto torneo del Kombattimento Morale sta per iniziare: ogni anno atleti arroganti si sfidano a insulti senza pietà fino a far crollare il morale dell’avversario: a questa edizione n nuovi sfidanti entreranno a far parte del torneo, effettuando una serie di round contro gli n incombenti reduci dall’anno precedente. Le vittorie degli sfidanti sono rappresentate su un tabellone: tutti gli sfidanti nuovi che entrano nel torneo sono sempre raffigurati a sinistra, gli incombenti a destra. Il tabellone è una matrice di 1 e 0: ogni nuovo sfidante effettua m round contro lo stesso incombente, e ogni volta che il nuovo sfidante vince, viene segnato un 1 sul tabellone, altrimenti uno 0. Può capitare che vi sia un pareggio tra numero di incontri vinti e persi, in tal caso l’Imperatore provvede ad eliminare barbaramente entrambi i contendenti dal torneo.

Esempio:

Skarpon            [1,0,0,0,0,1,1,0]   Baracca
SottoCosto         [1,1,1,0,1,1,0,0]   Rettilio
Raiban             [1,0,1,0,1,0,0,1]   GhiriGoro
Johnny Colpobasso  [1,1,0,0,0,1,1,0]   Gin Tseng
Liu Kanguro        [0,1,0,1,1,1,1,0]   KinTarallo
Katana             [0,0,1,1,0,0,1,1]   Kannone

su m=8 round totali, Skarpon ne ha vinti 3 contro Baracca, invece Raiban ha vinto 4 round contro GhiriGoro e risulta quindi in pareggio.

Scrivi una funzione pareggio che produce un np.ndarray dove per ogni coppia di contendenti vi è True se la serie di round è risultata in un pareggio, e False altrimenti.

mat = np.array([[1,0,0,0,0,1,1,0],
                [1,1,1,0,1,1,0,0],
                [1,0,1,0,1,0,0,1],
                [1,1,0,0,0,1,1,0],
                [0,1,0,1,1,1,1,0],
                [0,0,1,1,0,0,1,1]])
>>> pareggio(mat)
[ [False],
  [False],
  [ True],
  [ True],
  [False],
  [ True]]
>>> type(pareggio(mat))
<class 'numpy.ndarray'>

  • ASSUMI m sia sempre pari

  • PROVA a risolvere l’esercizio ragionando ‘per vettori’, con una sola linea di codice

  • NON usare cicli (niente for, while, list comprehensions …)

  • SUGGERIMENTO: per trasporre gli array in verticale usa reshape

[2]:

import numpy as np


def pareggio(mat):
    raise Exception('TODO IMPLEMENT ME !')

m1 = np.array([[0,0]])
res = pareggio(m1)
print(res)  # strano qua stampa float, mentre in pareggio_pro dei boolean
assert type(res) == np.ndarray
assert np.allclose(res, np.array([ [False] ]))

m2 = np.array([[1,0]])
assert np.allclose(pareggio(m2), np.array([ [True] ]))
m3 = np.array([[0,1]])
assert np.allclose(pareggio(m3), np.array([ [True] ]))
m4 = np.array([[1,1]])  # True
assert np.allclose(pareggio(m4), np.array([ [False] ]))
m5 = np.array([[1,1],
               [0,1]])
assert np.allclose(pareggio(m5), np.array([ [False],
                                            [True] ]))
m6 = np.array([[0,1],
               [1,0]])
assert np.allclose(pareggio(m6), np.array([ [True],
                                            [True] ]))
m7 = np.array([[1,1,0,0],
               [1,1,0,1],
               [1,0,0,1]])
assert np.allclose(pareggio(m7), np.array([ [True],
                                            [False],
                                            [True] ]))
m8 = np.array([[1,0,0,0,0,1,1,0],
               [1,1,1,0,1,1,0,0],
               [1,0,1,0,1,0,0,1],
               [1,1,0,0,0,1,1,0],
               [0,1,0,1,1,1,1,0],
               [0,0,1,1,0,0,1,1]])
assert np.allclose(pareggio(m8), np.array([ [False],
                                            [False],
                                            [ True],
                                            [ True],
                                            [False],
                                            [ True] ]))

[ ]: