Mitläufer

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

Anleitung

In dieser Übung bist du ein großer Sportfan und hast gerade deine Leidenschaft für NBA-Basketball entdeckt. Da NBA-Basketball für dich neu ist, tauchst du tief in die NBA-Geschichte ein, behältst Teams, Trainer, ihre Sieg- und Niederlagenstatistiken im Blick und vergleichst sie miteinander.

Da du noch kein Lieblingsteam hast, entwickelst du außerdem einen Algorithmus, um herauszufinden, ob du für ein bestimmtes Team die Daumen drücken solltest.

Du hast sieben Aufgaben, die dir helfen, deinen eigenen root-for-a-team-Algorithmus zu entwickeln.

1. Definiere das Modell

Definiere das Coach-Record mit den folgenden zwei Feldern:

• name: der Name des Trainers, vom Typ String.
• former_player: gibt an, ob der Trainer früher Spieler war, vom Typ Bool.

Definiere das Stats-Record mit den folgenden zwei Feldern:

• wins: die Anzahl der Siege, vom Typ Int.
• losses: die Anzahl der Niederlagen, vom Typ Int.

Definiere das Team-Record mit den folgenden drei Feldern:

• name: der Name des Teams, vom Typ String.
• coach: der Trainer des Teams, vom Typ Coach.
• stats: die Statistiken des Teams, vom Typ Stats.

2. Erstelle den Trainer eines Teams

Implementiere die Funktion create_coach, die den Namen des Trainers und seinen früheren Spielerstatus als Parameter entgegennimmt und das zugehörige Coach-Record zurückgibt:

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

3. Erstelle die Statistiken eines Teams

Implementiere die Funktion create_stats, die die Anzahl der Siege und die Anzahl der Niederlagen als Parameter entgegennimmt und das zugehörige Stats-Record zurückgibt:

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

4. Erstelle ein Team

Implementiere die Funktion create_team, die den Teamnamen, den Trainer und das Record als Parameter entgegennimmt und das zugehörige Team-Record zurückgibt:

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. Ersetze den Trainer

NBA-Besitzer sind ungeduldig, und du hast festgestellt, dass schlechte Teamergebnisse oft dazu führen, dass der Trainer ersetzt wird. Implementiere die Funktion replace_coach, die das Team und seinen neuen Trainer als Parameter entgegennimmt und das Team mit dem neuen Trainer zurückgibt:

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. Prüfe auf dasselbe Team

Während du dich in die Statistiken vertiefst, führst du Listen mit Teams und ihren Records. Manchmal machst du Fehler, und dann stehen doppelte Einträge in deiner Liste. Implementiere die Funktion is_same_team, die zwei Teams entgegennimmt und True zurückgibt, wenn es dasselbe Team ist, andernfalls 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. Prüfe, ob du für ein Team die Daumen drücken solltest

Nachdem du viele Teams und Spiele betrachtet hast, hast du einen Algorithmus entwickelt. Wenn eine der folgenden Bedingungen wahr ist, drückst du für dieses Team die Daumen:

• Der Name des Trainers ist „Gregg Popovich“
• Der Trainer ist ein ehemaliger Spieler
• Der Name des Teams ist „Chicago Bulls“
• Das Team hat 60 oder mehr Spiele gewonnen
• Das Team hat mehr Niederlagen als Siege

Implementiere die Funktion root_for_team, die ein Team entgegennimmt und True zurückgibt, wenn du für dieses Team die Daumen drücken solltest, andernfalls 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