engineering/opencompletion.com
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Add game theory programming courses for Python and C

Browse source 
NEW ACTIVITIES:

activity46-game-theory-python.yaml - Game theory implementation in Python
- Representing games with dictionaries
- Payoff matrix as dict with tuple keys
- Query functions and game simulation
- One-shot and repeated games
- Tit-for-Tat strategy implementation
- Function composition and abstraction

activity47-game-theory-c.yaml - Game theory implementation in C
- Defining Payoff struct for outcomes
- 2D arrays for payoff matrices
- Memory-efficient game representation
- Strategy lookup functions
- Enum for self-documenting code
- Pointer and struct fundamentals

Both activities:
- Teach programming through game theory concepts
- Follow pedagogical best practice (concepts first, code examples in feedback)
- Validate with zero errors/warnings
- Progressive difficulty (structures → functions → simulation)
- Real-world application of abstract concepts
- Engage students with strategic thinking + coding
This commit is contained in:
Claude 2025-11-09 15:36:12 +00:00
parent b8bf7261cb
commit 4e72fed8be
No known key found for this signature in database
2 changed files with 1037 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

509
research/activity46-game-theory-python.yaml Normal file
View file

@ -0,0 +1,509 @@
default_max_attempts_per_step: 3
classifier_model: "MODEL_1"
feedback_model: "MODEL_1"
tokens_for_ai_rubric: |
Evaluate the student's ability to implement game theory concepts in Python.
Consider:
- Correct Python syntax
- Understanding of game theory concepts
- Code logic and structure
- Use of appropriate data structures
- Ability to translate concepts to code
sections:
- section_id: introduction
title: Programming Game Theory in Python
steps:
- step_id: welcome
title: Code Meets Strategy
content_blocks:
- "# Game Theory Programming with Python 🐍🎮"
- ""
- "**Learn Python by implementing game theory!**"
- ""
- "You'll learn to:"
- "✓ Represent games as data structures"
- "✓ Implement payoff matrices"
- "✓ Code Prisoner's Dilemma simulations"
- "✓ Find Nash Equilibria programmatically"
- "✓ Simulate repeated games with strategies"
- ""
- "**Prerequisites:**"
- "- Basic Python knowledge (variables, functions, loops)"
- "- Understanding of basic game theory (Nash Equilibrium, Prisoner's Dilemma)"
- ""
- "**Why this matters:**"
- "- Learn to model strategic situations"
- "- Practice data structures (dictionaries, lists)"
- "- Build simulations and experiments"
- "- Apply theory to real code"
question: Ready to implement game theory in Python?
tokens_for_ai: Accept positive as 'ready', language preference as 'set_language', else 'off_topic'
buckets: [ready, set_language, off_topic]
transitions:
ready:
next_section_and_step: payoff_matrix:step_1
set_language:
metadata_add: {language: "the-users-response"}
counts_as_attempt: false
next_section_and_step: introduction:welcome
off_topic:
counts_as_attempt: false
next_section_and_step: introduction:welcome
- section_id: payoff_matrix
title: Representing Games as Data
steps:
- step_id: step_1
title: Payoff Matrix Structure
content_blocks:
- "## Representing Payoff Matrices in Python 📊"
- ""
- "**The challenge:**"
- "How do we represent a 2-player game in code?"
- ""
- "**Game structure:**"
- "- Two players (Row, Column)"
- "- Each has strategies (actions)"
- "- Each outcome has payoffs for both players"
- ""
- "**Conceptual approach:**"
- "A payoff matrix maps strategy pairs to payoff tuples"
- "- Input: (player1_strategy, player2_strategy)"
- "- Output: (player1_payoff, player2_payoff)"
- ""
- "**Data structure choice:**"
- "Python dictionaries are perfect!"
- "- Keys: tuples of strategy pairs"
- "- Values: tuples of payoffs"
- ""
- "**Example concept (Prisoner's Dilemma):**"
- "```"
- "Strategies: 'cooperate' or 'defect'"
- "Payoffs: (player1_years, player2_years)"
- "If both cooperate: (-1, -1)"
- "If both defect: (-2, -2)"
- "If one defects while other cooperates: (0, -3) or (-3, 0)"
- "```"
question: "Write Python code to create a dictionary representing the Prisoner's Dilemma payoff matrix. Use strategy pairs as keys (tuples like ('cooperate', 'defect')) and payoff tuples as values."
tokens_for_ai: |
Looking for Python dictionary with:
- Keys: tuples of (player1_strategy, player2_strategy)
- Values: tuples of (player1_payoff, player2_payoff)
- Four outcomes: (C,C), (C,D), (D,C), (D,D)
Correct payoffs (years in prison):
- ('cooperate', 'cooperate'): (-1, -1)
- ('cooperate', 'defect'): (-3, 0)
- ('defect', 'cooperate'): (0, -3)
- ('defect', 'defect'): (-2, -2)
Categorize as:
- correct: Proper dictionary with all 4 outcomes and correct payoffs
- correct_structure: Right structure, minor payoff errors
- uses_dictionary: Uses dict but wrong format
- wrong_approach: Different data structure
- needs_help: Very basic or confused
- set_language: Language preference
- off_topic: Unrelated
feedback_tokens_for_ai: |
If correct:
- Excellent! Dictionary maps strategy pairs to payoffs perfectly.
- This structure makes lookups easy.
- Show how to access: payoff_matrix[('cooperate', 'defect')] → (-3, 0)
If structure right but payoffs wrong:
- Great structure! But check payoffs:
- Both cooperate: (-1, -1) - best mutual outcome
- Both defect: (-2, -2) - mutual punishment
- One defects: (0, -3) or (-3, 0) - betrayal
If wrong approach:
- Show correct dictionary structure with example.
- Explain why dict with tuple keys is elegant for this.
buckets: [correct, correct_structure, uses_dictionary, wrong_approach, needs_help, set_language, off_topic]
transitions:
correct:
ai_feedback:
tokens_for_ai: |
Perfect implementation!
Your dictionary elegantly maps strategy pairs to payoffs.
Access is simple: matrix[('cooperate', 'defect')] gives (-3, 0).
This structure scales to more complex games!
metadata_add: {score: "n+2", concepts_mastered: "n+1"}
next_section_and_step: payoff_matrix:step_2
correct_structure:
ai_feedback:
tokens_for_ai: |
Great structure! Minor payoff correction needed:
- Both cooperate: (-1, -1)
- Both defect: (-2, -2)
- One defects: betrayer gets 0, cooperator gets -3
Show the corrected version.
metadata_add: {score: "n+1"}
next_section_and_step: payoff_matrix:step_2
uses_dictionary:
ai_feedback:
tokens_for_ai: |
Good use of dictionary!
For game matrices, use tuple keys:
payoff_matrix = {
('cooperate', 'cooperate'): (-1, -1),
('cooperate', 'defect'): (-3, 0),
...
}
next_section_and_step: payoff_matrix:step_1
wrong_approach:
ai_feedback:
tokens_for_ai: |
Python dictionaries with tuple keys work best!
Example format:
game = {('action1', 'action2'): (payoff1, payoff2)}
This allows easy lookup of any strategy combination.
next_section_and_step: payoff_matrix:step_1
needs_help:
content_blocks:
- "Start with: game = {}"
- "Add entries like: ('cooperate', 'cooperate'): (-1, -1)"
- "You need 4 entries total for all strategy combinations"
next_section_and_step: payoff_matrix:step_1
set_language:
metadata_add: {language: "the-users-response"}
counts_as_attempt: false
next_section_and_step: payoff_matrix:step_1
off_topic:
next_section_and_step: payoff_matrix:step_1
- step_id: step_2
title: Querying the Matrix
content_blocks:
- "## Using the Payoff Matrix 🔍"
- ""
- "**Now that you have a payoff matrix, let's use it!**"
- ""
- "**Task:** Write a function that determines outcomes"
- ""
- "**Function requirements:**"
- "- Name: `get_payoffs`"
- "- Parameters: `payoff_matrix`, `player1_action`, `player2_action`"
- "- Returns: tuple of (player1_payoff, player2_payoff)"
- ""
- "**What the function does:**"
- "Looks up the payoffs for the given strategy combination"
- ""
- "**Think about:**"
- "- How do you access dictionary values?"
- "- How do you create the lookup key from the two actions?"
question: "Write a Python function called `get_payoffs` that takes a payoff matrix dictionary and two player actions, then returns the payoff tuple for that strategy combination."
tokens_for_ai: |
Looking for function that:
- Takes 3 parameters: payoff_matrix (dict), player1_action, player2_action
- Creates tuple key: (player1_action, player2_action)
- Returns: payoff_matrix[(player1_action, player2_action)]
Acceptable variations:
- def get_payoffs(matrix, p1, p2): return matrix[(p1, p2)]
- def get_payoffs(payoff_matrix, action1, action2): ...
Categorize as:
- correct: Proper function with correct lookup
- correct_logic: Right idea, minor syntax issues
- missing_tuple: Tries to lookup without creating tuple key
- confused: Wrong approach
- set_language: Language preference
- off_topic: Unrelated
feedback_tokens_for_ai: |
If correct:
- Perfect! Your function correctly creates a tuple key and looks it up.
- Example: get_payoffs(game, 'cooperate', 'defect') → (-3, 0)
- Clean, simple, and reusable!
If correct logic but syntax issues:
- Right approach! Small syntax fix needed.
- Show corrected version.
- Explain the fix.
If missing tuple:
- Remember: dictionary keys are tuples!
- Need to create (player1_action, player2_action) first.
- Then look it up in the matrix.
buckets: [correct, correct_logic, missing_tuple, confused, set_language, off_topic]
transitions:
correct:
ai_feedback:
tokens_for_ai: |
Excellent function!
Your code cleanly creates the tuple key and returns the payoffs.
This abstraction makes game simulation much easier.
You can now query any strategy combination!
metadata_add: {score: "n+2", concepts_mastered: "n+1"}
next_section_and_step: simulation:step_1
correct_logic:
ai_feedback:
tokens_for_ai: |
Great logic! Minor syntax adjustment:
Show corrected function.
Explain what was fixed and why it matters.
metadata_add: {score: "n+1"}
next_section_and_step: simulation:step_1
missing_tuple:
ai_feedback:
tokens_for_ai: |
Close! Don't forget to create the tuple key:
def get_payoffs(payoff_matrix, p1_action, p2_action):
key = (p1_action, p2_action)
return payoff_matrix[key]
next_section_and_step: payoff_matrix:step_2
confused:
content_blocks:
- "A function that takes the matrix and both actions"
- "Creates a tuple from the two actions: (action1, action2)"
- "Uses that tuple to look up the payoffs in the dictionary"
next_section_and_step: payoff_matrix:step_2
set_language:
metadata_add: {language: "the-users-response"}
counts_as_attempt: false
next_section_and_step: payoff_matrix:step_2
off_topic:
next_section_and_step: payoff_matrix:step_2
- section_id: simulation
title: Simulating Strategic Interactions
steps:
- step_id: step_1
title: One-Shot Game Simulator
content_blocks:
- "## Simulating Game Outcomes 🎲"
- ""
- "**Building a simple game simulator**"
- ""
- "**Requirements:**"
- "- Function name: `play_game`"
- "- Parameters: `payoff_matrix`, `strategy1`, `strategy2`"
- "- Should call your `get_payoffs` function"
- "- Print the outcome in a readable format"
- "- Return the payoffs"
- ""
- "**Example output format:**"
- "```"
- "Player 1 chose: cooperate"
- "Player 2 chose: defect"
- "Payoffs: Player 1 = -3, Player 2 = 0"
- "```"
- ""
- "**Conceptual flow:**"
- "1. Get payoffs using your get_payoffs function"
- "2. Display what each player chose"
- "3. Display the resulting payoffs"
- "4. Return the payoffs for further use"
question: "Write a `play_game` function that simulates one round of a game, prints the outcome, and returns the payoffs. Use your `get_payoffs` function from earlier."
tokens_for_ai: |
Looking for function that:
- Calls get_payoffs(payoff_matrix, strategy1, strategy2)
- Prints player choices and payoffs
- Returns the payoff tuple
Should show understanding of:
- Function composition (using get_payoffs)
- Print statements for output
- Returning values
Categorize as:
- correct: Complete function with print and return
- missing_print: Has logic but doesn't print
- missing_return: Prints but doesn't return
- correct_concept: Right idea, minor issues
- confused: Wrong approach
- set_language: Language preference
- off_topic: Unrelated
feedback_tokens_for_ai: |
If correct:
- Excellent! Your simulator uses function composition nicely.
- The print statements make outcomes clear.
- Returning payoffs allows chaining simulations.
- This is how game theory research is done programmatically!
If missing print:
- Good logic! Add print statements to show:
- What each player chose
- The resulting payoffs
- Makes debugging and understanding easier!
If missing return:
- Good output! But also return the payoffs.
- This lets you use the function in larger simulations.
- return payoffs at the end.
Show complete example if needed.
buckets: [correct, missing_print, missing_return, correct_concept, confused, set_language, off_topic]
transitions:
correct:
ai_feedback:
tokens_for_ai: |
Perfect simulator!
You've built function composition (play_game uses get_payoffs).
Print statements provide visibility.
Return value enables further analysis.
You're ready for repeated game simulation!
metadata_add: {score: "n+2", concepts_mastered: "n+1"}
next_section_and_step: repeated_games:step_1
missing_print:
ai_feedback:
tokens_for_ai: |
Good structure! Add print statements:
print(f"Player 1 chose: {strategy1}")
print(f"Player 2 chose: {strategy2}")
print(f"Payoffs: Player 1 = {payoffs[0]}, Player 2 = {payoffs[1]}")
Makes the simulation observable!
metadata_add: {score: "n+1"}
next_section_and_step: repeated_games:step_1
missing_return:
ai_feedback:
tokens_for_ai: |
Great output! Just add:
return payoffs
This lets you accumulate results over many rounds!
metadata_add: {score: "n+1"}
next_section_and_step: repeated_games:step_1
correct_concept:
ai_feedback:
tokens_for_ai: |
Right approach! Small improvements:
Show polished version.
Explain the refinements.
next_section_and_step: repeated_games:step_1
confused:
content_blocks:
- "Your function should:"
- "1. Call get_payoffs to get the payoffs"
- "2. Print what each player chose"
- "3. Print the payoffs"
- "4. Return the payoffs tuple"
next_section_and_step: simulation:step_1
set_language:
metadata_add: {language: "the-users-response"}
counts_as_attempt: false
next_section_and_step: simulation:step_1
off_topic:
next_section_and_step: simulation:step_1
- section_id: repeated_games
title: Repeated Game Strategies
steps:
- step_id: step_1
title: Tit-for-Tat Strategy
content_blocks:
- "## Implementing Strategic Behavior 🔄"
- ""
- "**The Tit-for-Tat Strategy:**"
- "1. Start with cooperation"
- "2. Then copy opponent's previous move"
- ""
- "**Implementation challenge:**"
- "Create a function that implements Tit-for-Tat logic"
- ""
- "**Function requirements:**"
- "- Name: `tit_for_tat`"
- "- Parameter: `opponent_last_move` (or None for first move)"
- "- Returns: 'cooperate' or 'defect'"
- ""
- "**Logic:**"
- "- If it's the first move (opponent_last_move is None): return 'cooperate'"
- "- Otherwise: return whatever the opponent played last"
- ""
- "**Why this is powerful:**"
- "- Nice (starts with cooperation)"
- "- Retaliatory (punishes defection)"
- "- Forgiving (returns to cooperation)"
- "- Simple to understand and implement"
question: "Write a `tit_for_tat` function that takes an opponent's last move (or None for first round) and returns the appropriate strategy according to Tit-for-Tat logic."
tokens_for_ai: |
Correct logic:
- If opponent_last_move is None: return 'cooperate'
- Else: return opponent_last_move
Acceptable implementations:
- Simple if/else
- Ternary operator
- Return with 'or' default
Categorize as:
- correct: Proper Tit-for-Tat logic
- correct_logic: Right idea, minor syntax
- wrong_first_move: Doesn't handle None case
- always_cooperates: Ignores opponent's move
- confused: Wrong logic
- set_language: Language preference
- off_topic: Unrelated
feedback_tokens_for_ai: |
If correct:
- Perfect Tit-for-Tat implementation!
- First move: cooperate (nice)
- After: copy opponent (retaliatory & forgiving)
- This won Axelrod's tournament!
- Show usage example.
If correct logic:
- Great logic! Small syntax refinement:
- Show corrected version.
If wrong first move:
- Remember: Tit-for-Tat starts with cooperation!
- Check if opponent_last_move is None (first round).
- If None, return 'cooperate'.
If always cooperates:
- You need to copy the opponent's move!
- After first round, return opponent_last_move.
- That's what makes it "tit for tat"!
buckets: [correct, correct_logic, wrong_first_move, always_cooperates, confused, set_language, off_topic]
transitions:
correct:
ai_feedback:
tokens_for_ai: |
Excellent Tit-for-Tat implementation!
Your code captures the strategy perfectly:
- Nice: starts with cooperation
- Retaliatory: copies opponent's defection
- Forgiving: copies opponent's return to cooperation
This simple strategy is remarkably effective!
metadata_add: {score: "n+2", concepts_mastered: "n+1", activity_completed: "true"}
correct_logic:
ai_feedback:
tokens_for_ai: |
Great logic! Minor polish:
Show refined version.
Your understanding of the strategy is solid!
metadata_add: {score: "n+1", activity_completed: "true"}
wrong_first_move:
ai_feedback:
tokens_for_ai: |
Almost there! Handle the first move:
def tit_for_tat(opponent_last_move):
if opponent_last_move is None:
return 'cooperate' # Be nice first
return opponent_last_move # Then copy
next_section_and_step: repeated_games:step_1
always_cooperates:
ai_feedback:
tokens_for_ai: |
That's "always cooperate," not Tit-for-Tat!
Tit-for-Tat must COPY the opponent's last move.
Only the FIRST move is automatically cooperate.
next_section_and_step: repeated_games:step_1
confused:
content_blocks:
- "Tit-for-Tat logic:"
- "1. First move (when opponent_last_move is None): cooperate"
- "2. All other moves: copy opponent's last move"
- "Use an if statement to check for None"
next_section_and_step: repeated_games:step_1
set_language:
metadata_add: {language: "the-users-response"}
counts_as_attempt: false
next_section_and_step: repeated_games:step_1
off_topic:
metadata_add: {activity_completed: "true"}

528
research/activity47-game-theory-c.yaml Normal file
View file

@ -0,0 +1,528 @@
default_max_attempts_per_step: 3
classifier_model: "MODEL_1"
feedback_model: "MODEL_1"
tokens_for_ai_rubric: |
Evaluate the student's ability to implement game theory concepts in C.
Consider:
- Correct C syntax
- Proper use of structs and pointers
- Memory management awareness
- Understanding of game theory concepts
- Code structure and organization
sections:
- section_id: introduction
title: Programming Game Theory in C
steps:
- step_id: welcome
title: Systems Programming Meets Strategy
content_blocks:
- "# Game Theory Programming with C ⚙️🎮"
- ""
- "**Learn C by implementing game theory!**"
- ""
- "You'll learn to:"
- "✓ Define game structures with structs"
- "✓ Use 2D arrays for payoff matrices"
- "✓ Work with pointers and memory"
- "✓ Implement strategy functions"
- "✓ Build game simulators in C"
- ""
- "**Prerequisites:**"
- "- Basic C knowledge (variables, functions, arrays)"
- "- Understanding of basic game theory concepts"
- ""
- "**Why C for game theory:**"
- "- Performance for large simulations"
- "- Memory efficiency"
- "- Understanding low-level implementation"
- "- Foundation for understanding algorithms"
question: Ready to implement game theory in C?
tokens_for_ai: Accept positive as 'ready', language preference as 'set_language', else 'off_topic'
buckets: [ready, set_language, off_topic]
transitions:
ready:
next_section_and_step: structures:step_1
set_language:
metadata_add: {language: "the-users-response"}
counts_as_attempt: false
next_section_and_step: introduction:welcome
off_topic:
counts_as_attempt: false
next_section_and_step: introduction:welcome
- section_id: structures
title: Defining Game Structures
steps:
- step_id: step_1
title: Payoff Structure
content_blocks:
- "## Representing Payoffs in C 📐"
- ""
- "**The challenge:**"
- "How do we represent a payoff (two player outcomes) in C?"
- ""
- "**Conceptual requirement:**"
- "Each outcome has TWO values:"
- "- Player 1's payoff"
- "- Player 2's payoff"
- ""
- "**C solution: struct**"
- "A struct groups related data together"
- ""
- "**What your struct needs:**"
- "- A name (like 'Payoff' or 'Outcome')"
- "- Two integer fields for the two payoffs"
- ""
- "**Struct syntax reminder:**"
- "```"
- "struct StructName {"
- " type field1;"
- " type field2;"
- "};"
- "```"
question: "Define a C struct called 'Payoff' that contains two integer fields: 'player1' and 'player2' for storing each player's payoff."
tokens_for_ai: |
Looking for struct definition with:
- Name: Payoff (or similar like Outcome, GameResult)
- Two int fields for the two player payoffs
Correct examples:
struct Payoff {
int player1;
int player2;
};
or
typedef struct {
int p1;
int p2;
} Payoff;
Categorize as:
- correct: Valid struct with two int fields
- correct_concept: Right idea, minor syntax
- missing_fields: Struct but wrong/missing fields
- no_struct: Doesn't use struct
- confused: Wrong approach
- set_language: Language preference
- off_topic: Unrelated
feedback_tokens_for_ai: |
If correct:
- Perfect struct definition!
- Your struct groups the two payoffs together.
- Now you can create: struct Payoff outcome;
- Access: outcome.player1 = -1; outcome.player2 = -1;
If correct concept:
- Right idea! Small syntax adjustment:
- Show corrected version.
- Explain the fix.
If missing fields:
- Remember: need TWO integer fields
- One for player1's payoff
- One for player2's payoff
If no struct:
- C structs group related data!
- Show example struct format.
buckets: [correct, correct_concept, missing_fields, no_struct, confused, set_language, off_topic]
transitions:
correct:
ai_feedback:
tokens_for_ai: |
Excellent struct definition!
Your Payoff struct elegantly groups both players' outcomes.
Usage: struct Payoff p = {-1, -2}; or p.player1 = 0;
This is the foundation for representing game outcomes!
metadata_add: {score: "n+2", concepts_mastered: "n+1"}
next_section_and_step: structures:step_2
correct_concept:
ai_feedback:
tokens_for_ai: |
Great concept! Minor syntax refinement:
Show corrected struct.
Explain the adjustment made.
metadata_add: {score: "n+1"}
next_section_and_step: structures:step_2
missing_fields:
ai_feedback:
tokens_for_ai: |
Need two int fields!
struct Payoff {
int player1;
int player2;
};
This stores both players' payoffs together.
next_section_and_step: structures:step_1
no_struct:
content_blocks:
- "Use a struct to group the two payoffs:"
- "struct Payoff { ... };"
- "Include two int fields inside the braces"
next_section_and_step: structures:step_1
confused:
content_blocks:
- "Define a struct with:"
- "- Name: Payoff"
- "- Two int fields (one for each player's payoff)"
- "Don't forget the semicolon at the end!"
next_section_and_step: structures:step_1
set_language:
metadata_add: {language: "the-users-response"}
counts_as_attempt: false
next_section_and_step: structures:step_1
off_topic:
next_section_and_step: structures:step_1
- step_id: step_2
title: Payoff Matrix with 2D Array
content_blocks:
- "## 2D Array for Game Matrix 🎯"
- ""
- "**Representing a 2x2 game:**"
- ""
- "**Prisoner's Dilemma has:**"
- "- 2 strategies per player: cooperate (0) or defect (1)"
- "- 4 possible outcomes: (0,0), (0,1), (1,0), (1,1)"
- ""
- "**Perfect for a 2D array!**"
- ""
- "**Array structure:**"
- "- First index: player 1's strategy (0 or 1)"
- "- Second index: player 2's strategy (0 or 1)"
- "- Value: Payoff struct with both payoffs"
- ""
- "**Conceptual mapping:**"
- "```"
- "matrix[0][0] = both cooperate"
- "matrix[0][1] = p1 cooperates, p2 defects"
- "matrix[1][0] = p1 defects, p2 cooperates"
- "matrix[1][1] = both defect"
- "```"
- ""
- "**Array declaration concept:**"
- "You declare a 2D array of your Payoff struct"
- "Then initialize it with the four outcomes"
question: "Declare and initialize a 2D array called 'prisoners_dilemma' of Payoff structs representing the Prisoner's Dilemma game. Use indices 0=cooperate, 1=defect. Payoffs: both cooperate (-1,-1), both defect (-2,-2), one defects (0,-3) or (-3,0)."
tokens_for_ai: |
Looking for 2D array declaration and initialization:
struct Payoff prisoners_dilemma[2][2] = {
{{-1, -1}, {-3, 0}}, // p1 cooperates
{{0, -3}, {-2, -2}} // p1 defects
};
Or similar valid initialization.
Categorize as:
- correct: Valid 2D array with proper payoffs
- correct_structure: Right format, payoff errors
- wrong_dimensions: Not 2x2
- syntax_errors: C syntax issues
- confused: Wrong approach
- set_language: Language preference
- off_topic: Unrelated
feedback_tokens_for_ai: |
If correct:
- Perfect 2D array implementation!
- prisoners_dilemma[0][0] = both cooperate = {-1,-1}
- prisoners_dilemma[1][1] = both defect = {-2,-2}
- prisoners_dilemma[0][1] = p1 cooperate, p2 defect = {-3,0}
- prisoners_dilemma[1][0] = p1 defect, p2 cooperate = {0,-3}
- Efficient memory layout for game representation!
If structure right:
- Great array structure! Payoff corrections:
- Show corrected initialization.
- Explain the Prisoner's Dilemma payoffs.
If wrong dimensions:
- Need 2x2 array (2 strategies per player)
- struct Payoff name[2][2] = {...};
If syntax errors:
- Show correct C array initialization syntax.
- Explain the nested braces structure.
buckets: [correct, correct_structure, wrong_dimensions, syntax_errors, confused, set_language, off_topic]
transitions:
correct:
ai_feedback:
tokens_for_ai: |
Excellent array implementation!
Your 2D array efficiently represents the payoff matrix.
Access is simple: prisoners_dilemma[i][j]
Memory layout is contiguous and cache-friendly.
This is how game theory simulations optimize performance!
metadata_add: {score: "n+2", concepts_mastered: "n+1"}
next_section_and_step: functions:step_1
correct_structure:
ai_feedback:
tokens_for_ai: |
Great structure! Payoff corrections for Prisoner's Dilemma:
Show corrected initialization with explanations.
Explain why these specific payoffs create the dilemma.
metadata_add: {score: "n+1"}
next_section_and_step: functions:step_1
wrong_dimensions:
ai_feedback:
tokens_for_ai: |
Need 2x2 for two-strategy game:
struct Payoff game[2][2] = {
{{-1,-1}, {-3,0}},
{{0,-3}, {-2,-2}}
};
next_section_and_step: structures:step_2
syntax_errors:
ai_feedback:
tokens_for_ai: |
C array initialization uses nested braces:
struct Payoff arr[2][2] = {
{row0_col0, row0_col1},
{row1_col0, row1_col1}
};
Each Payoff is {p1_payoff, p2_payoff}
next_section_and_step: structures:step_2
confused:
content_blocks:
- "Declare: struct Payoff prisoners_dilemma[2][2]"
- "Initialize with nested braces: {{...}, {...}}"
- "Four outcomes total (2x2 = 4 combinations)"
next_section_and_step: structures:step_2
set_language:
metadata_add: {language: "the-users-response"}
counts_as_attempt: false
next_section_and_step: structures:step_2
off_topic:
next_section_and_step: structures:step_2
- section_id: functions
title: Strategy Functions
steps:
- step_id: step_1
title: Lookup Function
content_blocks:
- "## Querying the Payoff Matrix 🔍"
- ""
- "**Create a function to get payoffs**"
- ""
- "**Function requirements:**"
- "- Name: `get_payoff`"
- "- Parameters: 2D array (pointer), two strategy indices"
- "- Returns: Payoff struct"
- ""
- "**C function concepts:**"
- "- Pass 2D array as pointer"
- "- Access with array indexing"
- "- Return struct by value"
- ""
- "**What it does:**"
- "Takes strategies (0 or 1 for each player)"
- "Returns the corresponding Payoff from the matrix"
question: "Write a C function called 'get_payoff' that takes a 2D Payoff array (as pointer) and two integer strategy indices, then returns the Payoff struct for that strategy combination."
tokens_for_ai: |
Acceptable function signatures:
- struct Payoff get_payoff(struct Payoff matrix[2][2], int s1, int s2)
- struct Payoff get_payoff(struct Payoff (*matrix)[2], int s1, int s2)
Function body should:
- Return matrix[s1][s2];
Categorize as:
- correct: Valid function with proper syntax
- correct_logic: Right idea, minor syntax
- wrong_return: Doesn't return Payoff struct
- pointer_confusion: Struggles with array parameter
- confused: Wrong approach
- set_language: Language preference
- off_topic: Unrelated
feedback_tokens_for_ai: |
If correct:
- Perfect function!
- Your function cleanly accesses the 2D array.
- Returning struct by value is simple and safe here.
- Usage: struct Payoff p = get_payoff(game, 0, 1);
If correct logic:
- Great logic! Minor syntax refinement:
- Show corrected version.
- Explain the C-specific details.
If wrong return:
- Function should return struct Payoff
- return matrix[s1][s2]; gives you the Payoff struct.
If pointer confusion:
- For small 2D arrays, can pass as: struct Payoff matrix[2][2]
- Or use pointer: struct Payoff (*matrix)[2]
- Show working example.
buckets: [correct, correct_logic, wrong_return, pointer_confusion, confused, set_language, off_topic]
transitions:
correct:
ai_feedback:
tokens_for_ai: |
Excellent function implementation!
Your get_payoff function cleanly retrieves outcomes.
C's struct return makes this straightforward.
You've encapsulated the lookup logic perfectly!
metadata_add: {score: "n+2", concepts_mastered: "n+1"}
next_section_and_step: simulation:step_1
correct_logic:
ai_feedback:
tokens_for_ai: |
Great logic! Small C syntax refinement:
Show polished version.
Explain the specific C conventions used.
metadata_add: {score: "n+1"}
next_section_and_step: simulation:step_1
wrong_return:
ai_feedback:
tokens_for_ai: |
Return type should be struct Payoff:
struct Payoff get_payoff(struct Payoff matrix[2][2], int s1, int s2) {
return matrix[s1][s2];
}
next_section_and_step: functions:step_1
pointer_confusion:
ai_feedback:
tokens_for_ai: |
For 2D array parameter, simple approach:
struct Payoff get_payoff(struct Payoff matrix[2][2], int s1, int s2) {
return matrix[s1][s2];
}
C automatically handles the array as pointer.
next_section_and_step: functions:step_1
confused:
content_blocks:
- "Function signature: struct Payoff get_payoff(struct Payoff matrix[2][2], int s1, int s2)"
- "Function body: return matrix[s1][s2];"
- "This returns the Payoff at position [s1][s2]"
next_section_and_step: functions:step_1
set_language:
metadata_add: {language: "the-users-response"}
counts_as_attempt: false
next_section_and_step: functions:step_1
off_topic:
next_section_and_step: functions:step_1
- section_id: simulation
title: Game Simulation
steps:
- step_id: step_1
title: Strategy Enumeration
content_blocks:
- "## Defining Strategies with Enum 🎲"
- ""
- "**Making code readable:**"
- "Instead of 0 and 1, use named constants!"
- ""
- "**C enum for strategies:**"
- "Enums give names to integer values"
- ""
- "**What you need:**"
- "- Enum name: Strategy (or similar)"
- "- Two values: COOPERATE = 0, DEFECT = 1"
- ""
- "**Why enums improve code:**"
- "- get_payoff(game, COOPERATE, DEFECT) is clearer"
- "- Better than get_payoff(game, 0, 1)"
- "- Self-documenting code"
- "- Type safety (to some degree)"
question: "Define a C enum called 'Strategy' with two values: COOPERATE (equals 0) and DEFECT (equals 1)."
tokens_for_ai: |
Looking for enum definition:
enum Strategy {
COOPERATE = 0,
DEFECT = 1
};
Or:
typedef enum {
COOPERATE = 0,
DEFECT = 1
} Strategy;
Categorize as:
- correct: Valid enum with both values
- correct_concept: Right idea, minor syntax
- missing_values: Enum but wrong values
- no_enum: Doesn't use enum
- confused: Wrong approach
- set_language: Language preference
- off_topic: Unrelated
feedback_tokens_for_ai: |
If correct:
- Perfect enum definition!
- Now you can write: enum Strategy s = COOPERATE;
- Much more readable than: int s = 0;
- Self-documenting code is maintainable code!
If correct concept:
- Great use of enum! Small refinement:
- Show corrected version.
If missing values:
- Need both COOPERATE = 0 and DEFECT = 1
- Show correct enum.
If no enum:
- C enums create named integer constants:
- Show enum syntax.
buckets: [correct, correct_concept, missing_values, no_enum, confused, set_language, off_topic]
transitions:
correct:
ai_feedback:
tokens_for_ai: |
Excellent enum!
Your code is now self-documenting.
COOPERATE and DEFECT are much clearer than 0 and 1.
This is professional C code style!
You've mastered game theory implementation in C!
metadata_add: {score: "n+2", concepts_mastered: "n+1", activity_completed: "true"}
correct_concept:
ai_feedback:
tokens_for_ai: |
Great enum concept! Small polish:
Show refined version.
You understand C enums well!
metadata_add: {score: "n+1", activity_completed: "true"}
missing_values:
ai_feedback:
tokens_for_ai: |
Need both strategies:
enum Strategy {
COOPERATE = 0,
DEFECT = 1
};
next_section_and_step: simulation:step_1
no_enum:
content_blocks:
- "Define enum with:"
- "enum Strategy { COOPERATE = 0, DEFECT = 1 };"
- "This creates named constants"
next_section_and_step: simulation:step_1
confused:
content_blocks:
- "Enum syntax: enum Name { VALUE1 = 0, VALUE2 = 1 };"
- "Creates named integer constants"
- "Don't forget the semicolon!"
next_section_and_step: simulation:step_1
set_language:
metadata_add: {language: "the-users-response"}
counts_as_attempt: false
next_section_and_step: simulation:step_1
off_topic:
metadata_add: {activity_completed: "true"}