Test Preparation - Rust Edition

Complete preparation materials for coding assessment, implemented in Rust for optimal performance and efficiency.

📋 Test Overview

• Duration: 60 minutes
• Questions: 2 coding problems
• Focus: Algorithm efficiency, clean code, time management
• Language: Rust (chosen for performance and safety)

🎯 Key Success Factors

1. Algorithm Efficiency (Most Critical): Time/space complexity heavily weighted
2. Time Management: Read both questions first, assess difficulty
3. Clean Code: Readable, idiomatic Rust solutions
4. Pattern Recognition: Know the common problem types

📁 Project Structure (Cargo Workspace)

├── Cargo.toml                    # Workspace configuration
├── tools/                        # Development utilities
│   ├── performance_check.sh      # Complete performance validation
│   └── README.md                 # Tools documentation
├── exercises/                    # Your implementations (Rust crate)
│   ├── Cargo.toml               # Package configuration
│   ├── src/                     # Source code (standard Rust structure)
│   │   ├── lib.rs              # Library exports
│   │   ├── exercise1.rs        # CSV Price Analysis (OHLC)
│   │   ├── exercise2.rs        # Financial Command Processor
│   │   ├── exercise3.rs        # Data Structure Transformations
│   │   ├── exercise4.rs        # Iterator Mastery
│   │   └── exercise5.rs        # State Machine Simulation
│   └── tests/                   # Package-specific tests
│       ├── exercise1_tests.rs   # CSV analysis tests
│       ├── exercise2_tests.rs   # Financial command tests
│       ├── exercise3_tests.rs   # Data transformation tests
│       ├── exercise4_tests.rs   # Iterator tests
│       └── exercise5_tests.rs   # Portfolio simulation tests
├── solutions/                   # Reference solutions (Rust crate)
│   ├── Cargo.toml               # Package configuration
│   ├── src/                     # Source code
│   │   ├── lib.rs              # Library exports
│   │   ├── solution_exercise1.rs # OHLC price analysis
│   │   ├── solution_exercise2.rs # Financial commands
│   │   ├── solution_exercise3.rs # Data transformations
│   │   ├── solution_exercise4.rs # Iterator operations
│   │   └── solution_exercise5.rs # Portfolio state machine
│   └── tests/                   # Empty (reference implementations)
├── benches/                     # Performance benchmarking
│   ├── exercise1_benchmark.rs   # Exercise 1 benchmarks
│   ├── exercise2_benchmark.rs   # Exercise 2 benchmarks
│   ├── exercise3_benchmark.rs   # Exercise 3 benchmarks
│   ├── exercise4_benchmark.rs   # Exercise 4 benchmarks
│   ├── exercise5_benchmark.rs   # Exercise 5 benchmarks
│   └── README.md                # Benchmarking guide
├── tests/                       # Workspace-level integration tests
│   └── performance_tests.rs     # Performance regression tests
├── test_prep_guide.md           # Detailed preparation guide
├── test_day_guide.md            # Test day strategy and checklist
├── Cargo.toml                   # Rust project configuration
└── README.md                    # This file

🚀 Quick Start

1. Build the entire workspace:

   cargo build --workspace

2. Run individual exercise tests:

   # From workspace root (recommended)
   cargo test -p exercises --test exercise1_tests # CSV Price Analysis
   cargo test -p exercises --test exercise2_tests # Financial Commands
   cargo test -p exercises --test exercise3_tests # Data Transformations
   cargo test -p exercises --test exercise4_tests # Iterator Mastery
   cargo test -p exercises --test exercise5_tests # State Simulation
   
   
   # Or from exercises directory
   cd exercises && cargo test
      # For specific tests
      cargo test --test exercise2_tests

3. Run all package tests:

   cargo test --workspace    # Tests all packages
   cargo test -p exercises   # Tests just exercises package
   cargo test -p solutions   # Tests just solutions package

4. Performance validation (Recommended):

   ./tools/performance_check.sh    # Complete performance validation

5. Individual benchmarks:

   # Exercise-specific benchmarks
   cargo bench --bench exercise1_benchmark    # CSV Price Analysis
   cargo bench --bench exercise2_benchmark    # Financial Commands
   cargo bench --bench exercise3_benchmark    # Data Transformations
   cargo bench --bench exercise4_benchmark    # Iterator Mastery
   cargo bench --bench exercise5_benchmark    # State Simulation
   
   # Run all benchmarks
   cargo bench --workspace
   
   # View HTML benchmark reports
   open target/criterion/report/index.html

6. Performance regression testing:

   cargo test --test performance_tests    # Performance regression tests

7. Practice under time pressure:

   • Set a 30-40 minute timer per exercise
   • Run tests for each exercise: cargo test -p exercises exercise{N}_tests
   • Focus on algorithm efficiency and clean code
   • Use ./tools/performance_check.sh to validate performance

Command Reference Table

Task	Command	Description
Build	cargo build --workspace	Build all packages
Test All	cargo test --workspace	Run all tests
Test Exercise	cargo test -p exercises exercise1_tests	Test specific exercise
Performance	./tools/performance_check.sh	Complete validation
Benchmarks	cargo bench --bench exercise1_benchmark	Benchmark specific exercise
All Benchmarks	cargo bench --workspace	Run all benchmarks
View Reports	open target/criterion/report/index.html	HTML benchmark reports

📊 Question Patterns

Question 1: CSV/Data Processing (~20-25 min)

• CSV parsing and line-by-line processing
• Calculate aggregates (OHLC prices, statistics)
• Sorting and ordering with business logic
• Formatted output with precision

Practice: cargo test -p exercises exercise1_tests

Question 2: Complex Logic (~30-35 min)

Variant A: State Simulation (Most Common)

• Process commands from CSV
• State management over time
• Multiple conditional branches
• Financial calculations

Variant B: Complex Data Operations

• Heavy string manipulation
• Extensive conditional logic
• Sorting and filtering collections
• HashMap-intensive operations

Practice:

cargo test -p exercises exercise2_tests    # Financial commands
cargo test -p exercises exercise4_tests    # Iterator operations
cargo test -p exercises exercise5_tests    # State simulation

🛠️ Essential Rust Patterns

Efficient CSV Processing

let lines: Vec<&str> = csv_data.trim().split('\n').collect();
let mut data: BTreeMap<String, Vec<f64>> = BTreeMap::new();

for line in &lines[1..] {  // Skip header
    let fields: Vec<&str> = line.split(',').collect();
    if let (Ok(key), Ok(value)) = (fields[0].parse::<String>(), fields[1].parse::<f64>()) {
        data.entry(key).or_insert(Vec::new()).push(value);
    }
}

State Management

#[derive(Debug)]
struct State {
    balance: f64,
    rate: f64,
    // ... other fields
}

impl State {
    fn process_command(&mut self, command: &str) -> Result<(), String> {
        // Command processing logic
        Ok(())
    }
}

Efficient Data Structures

• HashMap: O(1) lookups for state tracking
• BTreeMap: Sorted iteration when needed
• Vec: Dynamic arrays for data collection
• VecDeque: When you need queue operations

⏱️ Time Management Strategy

1. Reading Phase (5 min): Read both questions completely
2. Planning Phase (5 min): Check test cases, assess difficulty
3. Implementation Phase: Q1 (20-25 min) + Q2 (30-35 min)
4. Review Phase (5-10 min): Test and submit

Key Decision: Identify which question is harder and consider tackling it first to ensure completion.

🚨 Critical Reminders

• Algorithm Efficiency: Brute force solutions pass tests but score poorly
• Test Cases: Check them FIRST to understand requirements
• Over-engineering: Simple efficient solution > complex incomplete code
• Submission: Click BOTH "Submit test" AND "Finish test"
• Time Pressure: Questions are longer than expected - pace yourself

🏆 Practice Strategy

1. Master the Exercises: Complete all 5 exercises with comprehensive tests
2. Time Pressure Practice: Set 30-40 minute timers per exercise, run tests to verify
3. Algorithm Focus: For each problem, think "What's the optimal approach?"
4. Code Quality: Write clean, readable Rust code under pressure
5. Edge Cases: All exercises include comprehensive edge case testing
6. Performance Validation: Use ./tools/performance_check.sh for complete validation
7. Benchmark Analysis: Run individual benchmarks to understand performance characteristics
8. Compare Implementations: Use benchmarks to compare your code vs solutions
9. Review Solutions: Compare with solutions package for different approaches

📊 Performance Analysis

Understanding Your Results

Exercise 1 (CSV Price Analysis): Your implementation should be competitive (~2-4 µs/iter)

Exercise 3 (Data Transformations): Solutions are typically 10-20x faster due to optimized data structures

Benchmark Commands

# 🔧 Complete performance validation (Recommended)
./tools/performance_check.sh

# 📊 Individual exercise benchmarks
cargo bench --bench exercise1_benchmark    # CSV Price Analysis
cargo bench --bench exercise2_benchmark    # Financial Commands
cargo bench --bench exercise3_benchmark    # Data Transformations
cargo bench --bench exercise4_benchmark    # Iterator Mastery
cargo bench --bench exercise5_benchmark    # State Simulation

# 🏃 Run all benchmarks in workspace
cargo bench --workspace

# 📈 Run specific benchmark groups
cargo bench --bench exercise1_benchmark -- exercise1_small    # Small dataset only
cargo bench --bench exercise1_benchmark -- exercise1_large    # Large dataset only

# 📋 List all available benchmarks
cargo bench -- --list

# 📄 View detailed HTML reports
open target/criterion/report/index.html

# 🔍 Compare specific implementations
# Results show: your_implementation vs solution columns

Interpreting Benchmark Results

Understanding the Output:

exercise1_small/your_implementation
                 time:   [2.6494 µs 2.6841 µs 2.7249 µs]
                              ▲        ▲        ▲
                            Lower    Mean     Upper

• Lower bound: Best case performance (noise floor)
• Mean: Average performance (most useful)
• Upper bound: Worst case (outliers)

R² > 0.9: Reliable measurements (good statistical confidence)

Performance Goals:

• ✅ Exercise 1: Competitive with solutions (~2-4 µs/iter)
• ✅ Exercise 3: Solutions typically 10-20x faster (optimized data structures)
• ✅ Memory Safety: Zero-cost abstractions with Rust's guarantees
• ✅ Scalability: Performance degrades gracefully with larger datasets

Common Optimizations:

• Use integer arithmetic instead of floating point where possible
• Minimize memory allocations
• Choose appropriate data structures (HashMap vs BTreeMap vs Vec)
• Avoid unnecessary string operations

Benchmark Troubleshooting

"No benchmarks found":

# Make sure you're using the correct bench name
cargo bench --bench exercise1_benchmark

# List all available benchmarks
cargo bench -- --list

"Criterion not found" error:

# Install plotters backend for Criterion
sudo apt-get install libfontconfig-dev  # Linux
# or
brew install fontconfig                 # macOS

Inconsistent results:

• Benchmarks run in release mode - ensure cargo build --release works
• Close other applications for consistent measurements
• Run benchmarks multiple times for statistical confidence

Comparing with solutions:

• Your Exercise 1 implementation should be competitive or faster
• Exercise 3 solutions are typically much faster due to algorithmic optimizations
• Focus on understanding WHY solutions are faster, not just matching the numbers

🏗️ Development Environment

Workspace Structure

This project uses a Cargo workspace with two main packages:

• exercises: Your implementations (what you submit for assessments)
• solutions: Reference implementations for comparison and learning

Development Tools

• tools/performance_check.sh: Complete performance validation script
• Individual benchmarks: Compare your code vs solutions
• Performance regression tests: Catch slowdowns automatically
• Comprehensive test suites: Edge cases and correctness verification

Building and Testing

# Full workspace build
cargo build --workspace

# Test everything
cargo test --workspace

# Performance validation
./tools/performance_check.sh

# Individual package development
cargo test -p exercises    # Test your implementations
cargo test -p solutions    # Test reference solutions

Publishing Ready

Both packages follow standard Rust crate conventions and can be published to crates.io if desired.

🎯 Final Tips

• Rust Advantages: Zero-cost abstractions, memory safety, performance
• Efficiency Focus: HashMap lookups, efficient sorting, optimal algorithms
• Pattern Recognition: Q1 is usually CSV processing, Q2 is state simulation or complex data ops
• Performance Mindset: Always think about algorithmic complexity first
• Development Workflow: Use the performance check script regularly during development
• Mental Prep: Stay calm, read carefully, check test cases first

Remember: The problems aren't extremely hard - doing them efficiently with clean code is what wins. You've got the tools and practice - focus on algorithm efficiency and you'll succeed!

Pro Tip: Run ./tools/performance_check.sh before submitting any implementation to ensure optimal performance!

Good luck! 🚀