Seguace della moda

pub type Rectangle {
  Rectangle(
    Float, // The first field
    Float, // The second field
  )
}

pub type Rectangle {
  Rectangle(
    width: Float,
    height: Float,
  )
}

let a = Rectangle(height: 10.0, width: 20.0)
let b = Rectangle(width: 20.0, height: 10.0)

a == b
// -> True

let rect = Rectangle(height: 10.0, width: 20.0)

rect.height // -> 10.0
rect.width  // -> 20.0

let rect = Rectangle(height: 10.0, width: 20.0)
let tall_rect = Rectangle(..rect, height: 50.0)

tall_rect.height // -> 50.0
tall_rect.width  // -> 20.0

pub fn is_tall(rect: Rectangle) {
  case rect {
    Rectangle(height: h, width: _) if h >. 20.0 -> True
    _ -> False
  }
}

pub fn is_tall(rect: Rectangle) {
  case rect {
    Rectangle(height: h, ..) if h >. 20.0 -> True
    _ -> False
  }
}

Istruzioni

In questo esercizio sei un grande appassionato di sport e hai appena scoperto la passione per il basket NBA. Essendo nuovo al basket NBA, stai approfondendo la storia della NBA: tieni traccia di squadre, allenatori e delle loro statistiche di vittorie e sconfitte, e le confronti tra loro.

Dato che non hai ancora una squadra del cuore, svilupperai anche un algoritmo per capire se tifare per una squadra in particolare.

Hai sette attività che ti aiuteranno a sviluppare il tuo algoritmo personale tifa-per-una-squadra.

1. Definisci il modello

Definisci il record Coach con i seguenti due campi:

• name: il nome dell'allenatore, di tipo String.
• former_player: indica se l'allenatore è un ex giocatore, di tipo Bool.

Definisci il record Stats con i seguenti due campi:

• wins: il numero di vittorie, di tipo Int.
• losses: il numero di sconfitte, di tipo Int.

Definisci il record Team con i seguenti tre campi:

• name: il nome della squadra, di tipo String.
• coach: l'allenatore della squadra, di tipo Coach.
• stats: le statistiche della squadra, di tipo Stats.

2. Crea l'allenatore di una squadra

Implementa la funzione create_coach che prende come parametri il nome dell'allenatore e il suo stato di ex giocatore, e restituisce il record Coach:

create_coach("Larry Bird", True)
// -> Coach(name: "Larry Bird", former_player: True)

3. Crea le statistiche di una squadra

Implementa la funzione create_stats che prende come parametri il numero di vittorie e il numero di sconfitte, e restituisce il record Stats:

create_stats(58, 24)
// -> Stats(wins: 58, losses: 24)

4. Crea una squadra

Implementa la funzione create_team che prende come parametri il nome della squadra, l'allenatore e il record, e restituisce il record Team:

let coach = create_coach("Larry Bird", True)
let stats = create_stats(58, 24)
create_team("Indiana Pacers", coach, stats)
// -> Team(
//   name: "Indiana Pacers",
//   coach: Coach(name: "Larry Bird", FormerPlayer = True),
//   stats: Stats(wins: 58, losses: 24),
// ) 

5. Sostituisci l'allenatore

I proprietari delle squadre NBA sono impazienti: hai scoperto che i cattivi risultati di una squadra portavano spesso alla sostituzione dell'allenatore. Implementa la funzione replace_coach che prende come parametri la squadra e il suo nuovo allenatore, e restituisce la squadra con il nuovo allenatore:

let coach = create_coach("Larry Bird", True)
let record = create_stats(58, 24)
let team = create_team("Indiana Pacers", coach, record)

let new_coach = create_coach("Isiah Thomas", True)
replace_coach(team, new_coach)
// -> Team(
//   name: "Indiana Pacers",
//   coach: Coach(name: "Isiah Thomas", FormerPlayer = True),
//   stats: Stats(wins: 58, losses: 24),
// ) 

6. Verifica se è la stessa squadra

Mentre scavi nelle statistiche, tieni degli elenchi di squadre e dei loro risultati. A volte sbagli e nella tua lista compaiono voci duplicate. Implementa la funzione is_same_team che prende due squadre e restituisce True se sono la stessa squadra, altrimenti restituisce False:

let pacers_coach = create_coach("Larry Bird", True)
let pacers_stats = create_stats(58, 24)
let pacers_team = create_team("Indiana Pacers", pacers_coach, pacers_stats)

let lakers_coach = create_coach("Del Harris", False)
let lakers_stats = create_stats(61, 21)
let lakers_team = create_team("LA Lakers", lakers_coach, lakers_stats)

is_same_team(pacers_team, lakers_team)
// -> False

7. Verifica se dovresti tifare per una squadra

Dopo aver esaminato molte squadre e molte partite, hai ideato un algoritmo. Se una delle seguenti condizioni è vera, tifi per quella squadra:

• Il nome dell'allenatore è "Gregg Popovich"
• L'allenatore è un ex giocatore
• Il nome della squadra è "Chicago Bulls"
• La squadra ha vinto 60 o più partite
• La squadra ha più sconfitte che vittorie

Implementa la funzione root_for_team che prende una squadra e restituisce True se dovresti tifare per quella squadra, altrimenti restituisce False:

let spurs_coach = create_coach("Gregg Popovich", False)
let spurs_stats = create_stats(56, 26)
let spurs_team = create_team("San Antonio Spurs", spurs_coach, spurs_stats)
root_for_team(spurs_team)
// -> True