Free Throw Analytics: Shooting Patterns and Strategic Decisions

Free Throw Shooting Analysis

Historical Context and Performance Metrics

The league-wide free throw percentage has remained remarkably stable around 75-77% for decades, despite advances in training and sports science. This stability suggests that free throw shooting involves complex psychological and biomechanical factors that resist simple improvement.

Factors Affecting Free Throw Percentage

Biomechanical Factors

• Release Height: Taller players with higher releases may have different arc optimization
• Hand Size: Large hands can affect ball control and touch
• Shooting Form: Consistency in mechanics is more important than specific form
• Fatigue: Free throw percentage typically decreases in 4th quarter and overtime

Situational Factors

• Home vs Away: ~2-3% improvement at home (crowd support, familiarity)
• Time of Game: Performance varies by quarter and game situation
• Score Differential: Pressure situations can affect shooting percentage
• Consecutive Attempts: First vs second free throw patterns differ

The Hack-a-Shaq Strategy

Strategic Foundation

The "Hack-a-Shaq" strategy involves intentionally fouling poor free throw shooters to limit their offensive efficiency. Named after Shaquille O'Neal, who shot 52.7% from the line over his career, this strategy transforms a player's weakness into a defensive weapon.

Mathematical Analysis of Hack-a-Shaq

The strategy is mathematically sound when the expected points from free throws are less than the expected points from allowing regular offensive possessions:

Breakeven Analysis

• League Average PPP: ~1.10 points per possession
• Breakeven FT%: ~55% (below this, hacking becomes viable)
• High-Efficiency Offense: 1.20 PPP → breakeven at 60% FT
• Elite Offense: 1.30 PPP → breakeven at 65% FT

When Hack-a-Shaq Works

Optimal Situations

1. Late Game Scenarios: Last 2 minutes when clock management matters
2. Opponent in Bonus: Team already in penalty, no additional cost
3. Poor Shooter + High Usage: Player shoots <55% and is primary offensive option
4. Transition Defense: Preventing fast break opportunities against elite transition teams

Historical Examples

• Shaquille O'Neal: 52.7% career FT → Expected value: 1.054 points
• DeAndre Jordan: Career low of 39.7% (2015-16) → 0.794 expected points
• Andre Drummond: 38.6% (2016-17) → 0.772 expected points
• Dwight Howard: Multiple seasons below 55%, frequent hack target

Counterstrategies and Adaptations

• Substitution: Remove poor shooter from game in hack situations
• Improved Shooting: Off-season focus on free throw development
• Rule Changes: NBA modified rules to limit off-ball hacking
• Strategic Fouling: Some teams now intentionally miss second FT to maintain possession

Python Code for Free Throw Pattern Analysis

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from scipy import stats
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
from sklearn.metrics import classification_report, confusion_matrix

class FreeThrowAnalyzer:
    """
    Comprehensive free throw pattern analysis system
    """

    def __init__(self, ft_data):
        """
        Initialize with free throw data

        Parameters:
        -----------
        ft_data : DataFrame
            Columns: player_id, game_id, quarter, time_remaining, score_diff,
                    home_away, ft_number, made, previous_made, season
        """
        self.data = ft_data
        self.patterns = {}

    def calculate_basic_stats(self):
        """Calculate basic free throw statistics"""
        stats = {
            'overall_pct': self.data['made'].mean(),
            'first_ft_pct': self.data[self.data['ft_number'] == 1]['made'].mean(),
            'second_ft_pct': self.data[self.data['ft_number'] == 2]['made'].mean(),
            'home_pct': self.data[self.data['home_away'] == 'home']['made'].mean(),
            'away_pct': self.data[self.data['home_away'] == 'away']['made'].mean(),
        }

        # Calculate by quarter
        for quarter in range(1, 5):
            q_data = self.data[self.data['quarter'] == quarter]
            stats[f'q{quarter}_pct'] = q_data['made'].mean()

        # Calculate clutch performance (last 2 minutes, close game)
        clutch_data = self.data[
            (self.data['time_remaining'] <= 120) &
            (abs(self.data['score_diff']) <= 5)
        ]
        stats['clutch_pct'] = clutch_data['made'].mean()

        return pd.Series(stats)

    def analyze_streaks(self):
        """Analyze hot and cold shooting streaks"""
        streaks = []

        for player_id in self.data['player_id'].unique():
            player_data = self.data[self.data['player_id'] == player_id].sort_values('game_id')

            current_streak = 0
            streak_type = None

            for made in player_data['made']:
                if made:
                    if streak_type == 'make' or streak_type is None:
                        current_streak += 1
                        streak_type = 'make'
                    else:
                        if current_streak > 0:
                            streaks.append({
                                'player_id': player_id,
                                'type': 'miss',
                                'length': current_streak
                            })
                        current_streak = 1
                        streak_type = 'make'
                else:
                    if streak_type == 'miss' or streak_type is None:
                        current_streak += 1
                        streak_type = 'miss'
                    else:
                        if current_streak > 0:
                            streaks.append({
                                'player_id': player_id,
                                'type': 'make',
                                'length': current_streak
                            })
                        current_streak = 1
                        streak_type = 'miss'

        return pd.DataFrame(streaks)

    def test_hot_hand_fallacy(self):
        """
        Test for hot hand effect in free throw shooting
        Compare P(make | previous make) vs P(make | previous miss)
        """
        # Filter to second free throws (where previous attempt exists)
        second_fts = self.data[self.data['ft_number'] == 2].copy()

        prob_make_after_make = second_fts[
            second_fts['previous_made'] == True
        ]['made'].mean()

        prob_make_after_miss = second_fts[
            second_fts['previous_made'] == False
        ]['made'].mean()

        # Chi-square test for independence
        contingency = pd.crosstab(
            second_fts['previous_made'],
            second_fts['made']
        )
        chi2, p_value, dof, expected = stats.chi2_contingency(contingency)

        return {
            'prob_make_after_make': prob_make_after_make,
            'prob_make_after_miss': prob_make_after_miss,
            'difference': prob_make_after_make - prob_make_after_miss,
            'chi2_statistic': chi2,
            'p_value': p_value,
            'hot_hand_exists': p_value < 0.05 and prob_make_after_make > prob_make_after_miss
        }

    def pressure_analysis(self):
        """Analyze performance under pressure situations"""
        # Define pressure levels
        self.data['pressure_level'] = 'low'

        # Medium pressure: close game OR late in quarter
        medium_pressure = (
            (abs(self.data['score_diff']) <= 10) |
            (self.data['time_remaining'] <= 180)
        )
        self.data.loc[medium_pressure, 'pressure_level'] = 'medium'

        # High pressure: close game AND late in game
        high_pressure = (
            (abs(self.data['score_diff']) <= 5) &
            (self.data['quarter'] >= 4) &
            (self.data['time_remaining'] <= 120)
        )
        self.data.loc[high_pressure, 'pressure_level'] = 'high'

        # Calculate performance by pressure level
        pressure_stats = self.data.groupby('pressure_level')['made'].agg([
            'mean', 'count', 'std'
        ]).round(4)

        return pressure_stats

    def hack_a_shaq_simulator(self, player_ft_pct, opponent_ppp, num_simulations=10000):
        """
        Simulate hack-a-shaq strategy effectiveness

        Parameters:
        -----------
        player_ft_pct : float
            Player's free throw percentage (0-1)
        opponent_ppp : float
            Opponent's points per possession
        num_simulations : int
            Number of simulations to run
        """
        # Simulate hack strategy
        hack_results = np.random.binomial(2, player_ft_pct, num_simulations)
        hack_mean = hack_results.mean()
        hack_std = hack_results.std()

        # Simulate regular defense (assume normal distribution around PPP)
        regular_results = np.random.normal(opponent_ppp, 0.5, num_simulations)
        regular_results = np.clip(regular_results, 0, 4)  # Realistic scoring range
        regular_mean = regular_results.mean()
        regular_std = regular_results.std()

        # Calculate effectiveness
        points_saved = regular_mean - hack_mean
        hack_advantage = points_saved > 0

        # Statistical test
        t_stat, p_value = stats.ttest_ind(regular_results, hack_results)

        return {
            'hack_expected_points': hack_mean,
            'hack_std': hack_std,
            'regular_expected_points': regular_mean,
            'regular_std': regular_std,
            'points_saved_per_possession': points_saved,
            'hack_is_effective': hack_advantage,
            'statistical_significance': p_value < 0.05,
            'p_value': p_value,
            'recommendation': 'USE HACK STRATEGY' if (hack_advantage and p_value < 0.05) else 'DO NOT HACK'
        }

    def predict_ft_make_probability(self, features=['quarter', 'time_remaining',
                                                     'score_diff', 'ft_number']):
        """
        Build logistic regression model to predict free throw success
        """
        # Prepare features
        X = self.data[features].copy()

        # Add engineered features
        X['is_clutch'] = ((self.data['time_remaining'] <= 120) &
                          (abs(self.data['score_diff']) <= 5)).astype(int)
        X['is_home'] = (self.data['home_away'] == 'home').astype(int)

        y = self.data['made']

        # Split data
        X_train, X_test, y_train, y_test = train_test_split(
            X, y, test_size=0.2, random_state=42
        )

        # Train model
        model = LogisticRegression(random_state=42, max_iter=1000)
        model.fit(X_train, y_train)

        # Predictions
        y_pred = model.predict(X_test)
        y_pred_proba = model.predict_proba(X_test)[:, 1]

        # Evaluation
        accuracy = model.score(X_test, y_test)

        # Feature importance
        feature_importance = pd.DataFrame({
            'feature': X.columns,
            'coefficient': model.coef_[0]
        }).sort_values('coefficient', key=abs, ascending=False)

        return {
            'model': model,
            'accuracy': accuracy,
            'feature_importance': feature_importance,
            'classification_report': classification_report(y_test, y_pred),
            'confusion_matrix': confusion_matrix(y_test, y_pred)
        }

    def visualize_patterns(self, player_id=None):
        """Create comprehensive visualization of free throw patterns"""
        fig, axes = plt.subplots(2, 3, figsize=(18, 12))
        fig.suptitle('Free Throw Pattern Analysis', fontsize=16, fontweight='bold')

        data = self.data[self.data['player_id'] == player_id] if player_id else self.data

        # 1. Performance by quarter
        quarter_stats = data.groupby('quarter')['made'].mean()
        axes[0, 0].bar(quarter_stats.index, quarter_stats.values, color='skyblue', edgecolor='black')
        axes[0, 0].set_xlabel('Quarter')
        axes[0, 0].set_ylabel('FT%')
        axes[0, 0].set_title('Free Throw % by Quarter')
        axes[0, 0].set_ylim([0, 1])
        axes[0, 0].axhline(y=data['made'].mean(), color='red', linestyle='--', label='Overall Avg')
        axes[0, 0].legend()

        # 2. Home vs Away
        home_away_stats = data.groupby('home_away')['made'].mean()
        axes[0, 1].bar(home_away_stats.index, home_away_stats.values,
                       color=['lightcoral', 'lightgreen'], edgecolor='black')
        axes[0, 1].set_ylabel('FT%')
        axes[0, 1].set_title('Home vs Away Performance')
        axes[0, 1].set_ylim([0, 1])

        # 3. Performance by score differential
        data['score_bucket'] = pd.cut(data['score_diff'],
                                       bins=[-np.inf, -10, -3, 3, 10, np.inf],
                                       labels=['Down 10+', 'Down 3-10', 'Close', 'Up 3-10', 'Up 10+'])
        score_stats = data.groupby('score_bucket')['made'].mean()
        axes[0, 2].bar(range(len(score_stats)), score_stats.values,
                       color='mediumpurple', edgecolor='black')
        axes[0, 2].set_xticks(range(len(score_stats)))
        axes[0, 2].set_xticklabels(score_stats.index, rotation=45, ha='right')
        axes[0, 2].set_ylabel('FT%')
        axes[0, 2].set_title('Performance by Score Differential')
        axes[0, 2].set_ylim([0, 1])

        # 4. First vs Second FT
        ft_number_stats = data.groupby('ft_number')['made'].mean()
        axes[1, 0].bar(ft_number_stats.index, ft_number_stats.values,
                       color='orange', edgecolor='black')
        axes[1, 0].set_xlabel('Free Throw Number')
        axes[1, 0].set_ylabel('FT%')
        axes[1, 0].set_title('First vs Second Free Throw')
        axes[1, 0].set_ylim([0, 1])

        # 5. Performance over time in game
        data['time_bucket'] = pd.cut(data['time_remaining'],
                                      bins=[0, 120, 300, 600, np.inf],
                                      labels=['0-2 min', '2-5 min', '5-10 min', '10+ min'])
        time_stats = data.groupby('time_bucket')['made'].mean()
        axes[1, 1].bar(range(len(time_stats)), time_stats.values,
                       color='teal', edgecolor='black')
        axes[1, 1].set_xticks(range(len(time_stats)))
        axes[1, 1].set_xticklabels(time_stats.index, rotation=45, ha='right')
        axes[1, 1].set_ylabel('FT%')
        axes[1, 1].set_title('Performance by Time Remaining')
        axes[1, 1].set_ylim([0, 1])

        # 6. Pressure analysis
        pressure_stats = self.pressure_analysis()
        axes[1, 2].bar(range(len(pressure_stats)), pressure_stats['mean'].values,
                       color=['lightgreen', 'yellow', 'red'], edgecolor='black')
        axes[1, 2].set_xticks(range(len(pressure_stats)))
        axes[1, 2].set_xticklabels(pressure_stats.index)
        axes[1, 2].set_ylabel('FT%')
        axes[1, 2].set_title('Performance by Pressure Level')
        axes[1, 2].set_ylim([0, 1])

        plt.tight_layout()
        return fig


# Example usage
if __name__ == "__main__":
    # Generate sample data
    np.random.seed(42)
    n_samples = 5000

    sample_data = pd.DataFrame({
        'player_id': np.random.choice(['Player_A', 'Player_B', 'Player_C'], n_samples),
        'game_id': np.random.randint(1, 100, n_samples),
        'quarter': np.random.randint(1, 5, n_samples),
        'time_remaining': np.random.randint(0, 720, n_samples),
        'score_diff': np.random.randint(-20, 21, n_samples),
        'home_away': np.random.choice(['home', 'away'], n_samples),
        'ft_number': np.random.choice([1, 2], n_samples),
        'made': np.random.choice([0, 1], n_samples, p=[0.25, 0.75]),
        'previous_made': np.random.choice([True, False], n_samples),
        'season': 2024
    })

    # Initialize analyzer
    analyzer = FreeThrowAnalyzer(sample_data)

    # Basic statistics
    print("=== Basic Free Throw Statistics ===")
    print(analyzer.calculate_basic_stats())

    # Hot hand analysis
    print("\n=== Hot Hand Fallacy Test ===")
    hot_hand_results = analyzer.test_hot_hand_fallacy()
    for key, value in hot_hand_results.items():
        print(f"{key}: {value}")

    # Hack-a-Shaq simulation
    print("\n=== Hack-a-Shaq Simulation ===")
    hack_results = analyzer.hack_a_shaq_simulator(
        player_ft_pct=0.45,
        opponent_ppp=1.15
    )
    for key, value in hack_results.items():
        print(f"{key}: {value}")

    # Pressure analysis
    print("\n=== Pressure Analysis ===")
    print(analyzer.pressure_analysis())

    # Predictive modeling
    print("\n=== Predictive Model Results ===")
    model_results = analyzer.predict_ft_make_probability()
    print(f"Model Accuracy: {model_results['accuracy']:.4f}")
    print("\nFeature Importance:")
    print(model_results['feature_importance'])

R Code for Statistical Modeling

# Free Throw Statistical Modeling in R
# Advanced statistical analysis of free throw shooting patterns

library(tidyverse)
library(lme4)          # Mixed effects models
library(broom)         # Tidy model outputs
library(car)           # ANOVA and regression diagnostics
library(ggplot2)       # Visualization
library(gridExtra)     # Multiple plots
library(boot)          # Bootstrap methods

# ==================== Data Preparation ====================

# Load and prepare free throw data
prepare_ft_data <- function(file_path) {
  data <- read.csv(file_path) %>%
    mutate(
      # Create categorical variables
      quarter_factor = factor(quarter),
      period = case_when(
        quarter <= 2 ~ "First Half",
        quarter == 3 ~ "Third Quarter",
        quarter >= 4 ~ "Fourth Quarter/OT"
      ),

      # Pressure situations
      is_clutch = (time_remaining <= 120 & abs(score_diff) <= 5),
      is_close_game = abs(score_diff) <= 10,

      # Game context
      is_home = (home_away == "home"),

      # Time bins
      time_category = cut(time_remaining,
                         breaks = c(0, 60, 120, 300, 720),
                         labels = c("0-1min", "1-2min", "2-5min", "5+min")),

      # Score context
      score_context = cut(score_diff,
                         breaks = c(-Inf, -10, -5, 5, 10, Inf),
                         labels = c("Down 10+", "Down 5-10", "Close", "Up 5-10", "Up 10+"))
    )

  return(data)
}

# ==================== Hierarchical Modeling ====================

# Mixed effects model for player and game effects
fit_hierarchical_model <- function(data) {
  # Random intercepts for player and game
  model <- glmer(made ~ quarter_factor + time_remaining +
                   abs(score_diff) + is_home + ft_number +
                   (1 | player_id) + (1 | game_id),
                 data = data,
                 family = binomial(link = "logit"),
                 control = glmerControl(optimizer = "bobyqa"))

  return(model)
}

# Extract and interpret random effects
analyze_random_effects <- function(model) {
  # Player-specific effects
  player_effects <- ranef(model)$player_id %>%
    rownames_to_column("player_id") %>%
    rename(player_effect = `(Intercept)`) %>%
    mutate(
      adjusted_probability = plogis(player_effect),
      skill_level = case_when(
        player_effect > 0.5 ~ "Elite",
        player_effect > 0 ~ "Above Average",
        player_effect > -0.5 ~ "Below Average",
        TRUE ~ "Poor"
      )
    ) %>%
    arrange(desc(player_effect))

  return(player_effects)
}

# ==================== Clutch Performance Analysis ====================

clutch_performance_model <- function(data) {
  # Compare clutch vs non-clutch performance
  clutch_data <- data %>%
    mutate(situation = ifelse(is_clutch, "Clutch", "Non-Clutch"))

  # Model with interaction
  model <- glm(made ~ situation * player_id + quarter_factor + is_home,
               data = clutch_data,
               family = binomial(link = "logit"))

  # Calculate clutch differential for each player
  clutch_stats <- clutch_data %>%
    group_by(player_id, situation) %>%
    summarise(
      ft_pct = mean(made),
      attempts = n(),
      makes = sum(made),
      .groups = "drop"
    ) %>%
    pivot_wider(names_from = situation, values_from = c(ft_pct, attempts, makes)) %>%
    mutate(
      clutch_differential = ft_pct_Clutch - `ft_pct_Non-Clutch`,
      clutch_performer = clutch_differential > 0
    ) %>%
    arrange(desc(clutch_differential))

  return(list(model = model, stats = clutch_stats))
}

# Statistical test for clutch performance
test_clutch_significance <- function(data, player_id_val) {
  player_data <- data %>% filter(player_id == player_id_val)

  clutch_makes <- player_data %>% filter(is_clutch) %>% pull(made)
  regular_makes <- player_data %>% filter(!is_clutch) %>% pull(made)

  # Proportion test
  clutch_n <- length(clutch_makes)
  clutch_success <- sum(clutch_makes)
  regular_n <- length(regular_makes)
  regular_success <- sum(regular_makes)

  test_result <- prop.test(
    x = c(clutch_success, regular_success),
    n = c(clutch_n, regular_n),
    alternative = "two.sided"
  )

  return(test_result)
}

# ==================== Hack-a-Shaq Bayesian Analysis ====================

bayesian_hack_analysis <- function(player_ft_pct, opponent_ppp,
                                   prior_alpha = 1, prior_beta = 1) {
  # Bayesian approach to hack-a-shaq decision
  # Using Beta prior for FT percentage

  # Posterior parameters (assuming observed data)
  n_attempts <- 100
  n_makes <- round(player_ft_pct * n_attempts)

  posterior_alpha <- prior_alpha + n_makes
  posterior_beta <- prior_beta + (n_attempts - n_makes)

  # Expected points from hacking (2 FT attempts)
  expected_ft_points <- 2 * (posterior_alpha / (posterior_alpha + posterior_beta))

  # Credible interval for FT percentage
  ft_ci <- qbeta(c(0.025, 0.975), posterior_alpha, posterior_beta)

  # Expected points range
  expected_points_range <- 2 * ft_ci

  # Probability that hacking is better than regular defense
  prob_hack_better <- pbeta(opponent_ppp / 2, posterior_alpha, posterior_beta)

  decision <- list(
    expected_ft_points = expected_ft_points,
    ft_ci_lower = ft_ci[1],
    ft_ci_upper = ft_ci[2],
    expected_points_lower = expected_points_range[1],
    expected_points_upper = expected_points_range[2],
    opponent_ppp = opponent_ppp,
    prob_hack_better = prob_hack_better,
    recommendation = ifelse(prob_hack_better > 0.75,
                           "STRONGLY RECOMMEND HACK",
                           ifelse(prob_hack_better > 0.5,
                                 "CONSIDER HACK",
                                 "DO NOT HACK"))
  )

  return(decision)
}

# ==================== Streak Analysis ====================

# Test for independence in consecutive shots (Runs test)
runs_test_independence <- function(player_shots) {
  # Convert to binary sequence
  sequence <- player_shots$made

  # Count runs
  runs <- rle(sequence)
  n_runs <- length(runs$lengths)

  # Expected runs under independence
  n <- length(sequence)
  n_makes <- sum(sequence)
  n_misses <- n - n_makes

  expected_runs <- 1 + (2 * n_makes * n_misses) / n
  var_runs <- (2 * n_makes * n_misses * (2 * n_makes * n_misses - n)) /
              (n^2 * (n - 1))

  # Z-test statistic
  z_stat <- (n_runs - expected_runs) / sqrt(var_runs)
  p_value <- 2 * (1 - pnorm(abs(z_stat)))

  result <- list(
    observed_runs = n_runs,
    expected_runs = expected_runs,
    z_statistic = z_stat,
    p_value = p_value,
    is_independent = p_value > 0.05
  )

  return(result)
}

# Autocorrelation analysis
autocorrelation_analysis <- function(data) {
  # Group by player and calculate ACF
  player_acf <- data %>%
    group_by(player_id) %>%
    arrange(game_id, quarter, desc(time_remaining)) %>%
    summarise(
      acf_lag1 = acf(made, lag.max = 1, plot = FALSE)$acf[2],
      n_attempts = n(),
      .groups = "drop"
    ) %>%
    filter(n_attempts >= 50)  # Minimum sample size

  # Overall ACF significance test
  overall_acf <- acf(data$made, lag.max = 5, plot = TRUE)

  return(list(player_acf = player_acf, overall_acf = overall_acf))
}

# ==================== Fatigue Analysis ====================

fatigue_regression <- function(data) {
  # Add cumulative minutes played (proxy for fatigue)
  data_with_fatigue <- data %>%
    group_by(player_id, game_id) %>%
    arrange(quarter, desc(time_remaining)) %>%
    mutate(
      cumulative_possessions = row_number(),
      fatigue_index = quarter + (1 - time_remaining/720)
    ) %>%
    ungroup()

  # Model FT% as function of fatigue
  model <- glm(made ~ fatigue_index + player_id + is_home,
               data = data_with_fatigue,
               family = binomial(link = "logit"))

  # Extract fatigue coefficient
  fatigue_effect <- tidy(model) %>%
    filter(term == "fatigue_index")

  return(list(model = model, fatigue_effect = fatigue_effect))
}

# ==================== Visualization Functions ====================

plot_player_comparison <- function(data, players) {
  comparison_data <- data %>%
    filter(player_id %in% players) %>%
    group_by(player_id, quarter) %>%
    summarise(ft_pct = mean(made), .groups = "drop")

  ggplot(comparison_data, aes(x = quarter, y = ft_pct,
                              color = player_id, group = player_id)) +
    geom_line(size = 1.2) +
    geom_point(size = 3) +
    scale_y_continuous(labels = scales::percent, limits = c(0, 1)) +
    labs(title = "Free Throw Performance by Quarter",
         x = "Quarter",
         y = "FT%",
         color = "Player") +
    theme_minimal() +
    theme(legend.position = "bottom")
}

plot_pressure_impact <- function(data) {
  pressure_data <- data %>%
    mutate(
      pressure = case_when(
        is_clutch ~ "Clutch",
        is_close_game ~ "Close Game",
        TRUE ~ "Regular"
      )
    ) %>%
    group_by(pressure) %>%
    summarise(
      ft_pct = mean(made),
      se = sd(made) / sqrt(n()),
      .groups = "drop"
    )

  ggplot(pressure_data, aes(x = pressure, y = ft_pct, fill = pressure)) +
    geom_bar(stat = "identity", alpha = 0.7) +
    geom_errorbar(aes(ymin = ft_pct - 1.96*se, ymax = ft_pct + 1.96*se),
                  width = 0.2) +
    scale_y_continuous(labels = scales::percent, limits = c(0, 1)) +
    labs(title = "Free Throw Performance Under Pressure",
         x = "Game Situation",
         y = "FT% (with 95% CI)") +
    theme_minimal() +
    theme(legend.position = "none")
}

plot_hack_simulation <- function(ft_pct, opponent_ppp) {
  # Simulate distributions
  n_sim <- 10000
  hack_points <- rbinom(n_sim, 2, ft_pct)
  regular_points <- rnorm(n_sim, opponent_ppp, 0.5)
  regular_points <- pmax(0, pmin(4, regular_points))

  sim_data <- data.frame(
    points = c(hack_points, regular_points),
    strategy = rep(c("Hack", "Regular"), each = n_sim)
  )

  ggplot(sim_data, aes(x = points, fill = strategy)) +
    geom_histogram(alpha = 0.6, position = "identity", binwidth = 0.5) +
    geom_vline(xintercept = 2 * ft_pct, color = "red", linetype = "dashed",
               size = 1) +
    geom_vline(xintercept = opponent_ppp, color = "blue", linetype = "dashed",
               size = 1) +
    labs(title = "Hack-a-Shaq Strategy Simulation",
         subtitle = sprintf("FT%%: %.1f%% | Opponent PPP: %.2f",
                           ft_pct * 100, opponent_ppp),
         x = "Points Per Possession",
         y = "Frequency",
         fill = "Strategy") +
    theme_minimal()
}

# ==================== Main Analysis Pipeline ====================

run_complete_analysis <- function(data_path) {
  # Load data
  cat("Loading and preparing data...\n")
  ft_data <- prepare_ft_data(data_path)

  # Hierarchical model
  cat("Fitting hierarchical model...\n")
  hier_model <- fit_hierarchical_model(ft_data)
  print(summary(hier_model))

  # Player effects
  cat("\nAnalyzing player-specific effects...\n")
  player_effects <- analyze_random_effects(hier_model)
  print(head(player_effects, 10))

  # Clutch analysis
  cat("\nAnalyzing clutch performance...\n")
  clutch_results <- clutch_performance_model(ft_data)
  print(clutch_results$stats)

  # Streak independence
  cat("\nTesting for shooting streaks...\n")
  player_list <- unique(ft_data$player_id)
  for (player in player_list[1:3]) {  # Test first 3 players
    player_data <- ft_data %>% filter(player_id == player)
    runs_result <- runs_test_independence(player_data)
    cat(sprintf("\n%s - Runs Test p-value: %.4f (Independent: %s)\n",
                player, runs_result$p_value, runs_result$is_independent))
  }

  # Fatigue analysis
  cat("\nAnalyzing fatigue effects...\n")
  fatigue_results <- fatigue_regression(ft_data)
  print(fatigue_results$fatigue_effect)

  return(list(
    data = ft_data,
    hierarchical_model = hier_model,
    player_effects = player_effects,
    clutch_results = clutch_results,
    fatigue_results = fatigue_results
  ))
}

# Example: Hack-a-Shaq decision for specific player
cat("\n=== Hack-a-Shaq Bayesian Analysis ===\n")
hack_decision <- bayesian_hack_analysis(
  player_ft_pct = 0.45,
  opponent_ppp = 1.15
)
print(hack_decision)

Clutch Free Throw Shooting

Defining Clutch Situations

Clutch free throws are typically defined as free throw attempts in high-pressure situations:

• Final 2 Minutes: Last 2 minutes of 4th quarter or overtime
• Close Game: Score differential of 5 points or less
• Playoff Games: Postseason situations with elimination implications
• High Stakes: Free throws that directly determine game outcome

Clutch Performance Patterns

Notable Clutch Performers

Clutch Excellence

• Reggie Miller: 91.1% career FT, even better in playoffs
• Steve Nash: 90.4% career, maintained in clutch situations
• Dirk Nowitzki: 87.9% career, legendary clutch performer
• Kevin Durant: 88.5% career, excels under pressure

Memorable Clutch Moments

• LeBron James (2013 Finals): Key late-game free throws vs Spurs
• Kawhi Leonard (2019 Playoffs): Consistent clutch FT shooting
• Ray Allen (Career): 89.4% FT shooter, reliable in pressure
• Kobe Bryant: 83.7% career, numerous game-winning FTs

Factors Affecting Clutch Performance

1. Crowd Noise: Opposing crowds attempt to distract, especially playoffs
2. Mental Pressure: Awareness of game implications can affect routine
3. Physical Fatigue: Late-game fatigue impacts shooting mechanics
4. Timeout Icing: Opposing coaches call timeouts to disrupt rhythm
5. Experience: Veteran players often perform better in clutch

Routine and Psychological Factors

Pre-Shot Routines

Consistent pre-shot routines are critical for free throw success. Research shows that routine consistency correlates more strongly with success than the specific routine itself.

Common Routine Elements

• Ball Handling: Number of dribbles (typically 1-5)
• Visual Alignment: Focusing on rim or specific target
• Breathing: Deep breath before release to reduce tension
• Mental Cue: Internal verbal or visual trigger phrase
• Timing: Consistent duration between receiving ball and shooting

Famous Routines

• Karl Malone: Whispered "Just do it" before each attempt
• Jason Kidd: Blew a kiss to his children before shooting
• Steve Nash: Consistent three-dribble routine with deep breath
• Gilbert Arenas: Visualized perfect arc before release

Psychological Research Findings

Choking Under Pressure

Research in sports psychology has identified several mechanisms that cause performance decline under pressure:

• Explicit Monitoring: Overthinking automatic processes disrupts execution
• Anxiety Effects: Increased arousal can impair fine motor control
• Attentional Bias: Focus shifts from task to outcome/consequences
• Working Memory Load: Pressure consumes cognitive resources

Improvement Strategies

1. Overlearning: Practice until routine becomes completely automatic
2. Pressure Training: Simulate high-pressure situations in practice
3. Pre-Performance Routines: Consistent ritual reduces anxiety
4. Positive Self-Talk: Mental reinforcement of capability
5. Mindfulness: Focus on present moment rather than outcome
6. Visualization: Mental rehearsal of successful execution

The Hot Hand Debate

The "hot hand fallacy" suggests that basketball shooting is independent from shot to shot. However, recent research has found small but significant hot hand effects in certain contexts:

• Original Theory: No correlation between consecutive shots (Gilovich, Vallone, Tversky 1985)
• Recent Findings: Small positive correlation exists when accounting for shot difficulty (Miller & Sanjurjo 2018)
• Free Throw Context: Controlled environment reduces confounding variables
• Psychological Impact: Belief in hot hand affects shot selection and confidence

Strategic Decision Making

When to Intentionally Foul

Late-Game Scenarios

Strategic fouling becomes crucial in the final minutes when trailing:

Advanced Fouling Strategy

• Foul Before 3-Point Attempt: Prevent 3-point opportunities when trailing by 3
• Selective Fouling: Switch defender to foul poorest FT shooter
• Bonus Situation: More aggressive when opponent already in penalty
• Timeout Coordination: Call timeout after made FT to advance ball

Offensive Strategy Around Free Throws

Drawing Fouls

• High-FT Shooters: Elite shooters should seek contact in late-game
• Driving Lanes: Attack rim to draw fouls when in bonus
• Pump Fakes: Use pump fakes to draw shooting fouls on perimeter
• Post Moves: Physical post play increases foul calls

Lineup Management

• Clutch Lineups: Insert best FT shooters in final minutes
• Substitution Timing: Remove poor shooters before opponent can hack
• Protect Assets: Bench poor shooters when leading in final 2 minutes
• Foul Trouble: Consider FT shooting when players in foul trouble

Analytics-Driven Decisions

Expected Value Framework

Modern teams use expected value calculations to optimize free throw-related decisions:

Data-Driven Insights

• Rest Impact: FT% decreases 2-3% on back-to-back games
• Travel Effect: Road games show 1-2% FT% decrease
• Referee Influence: Some referees call more shooting fouls
• Momentum Considerations: Made FTs can shift momentum in close games

Training and Development

Mechanical Improvement

• Form Consistency: Video analysis to ensure repeatable mechanics
• Arc Optimization: 45-50 degree arc generally optimal
• Follow Through: Complete follow-through improves accuracy
• Balance and Base: Stable lower body foundation

Mental Training

• Pressure Simulation: Practice with consequences (conditioning for misses)
• Fatigue Training: Shoot FTs after exhaustive drills
• Visualization: Mental rehearsal of successful attempts
• Crowd Noise: Practice with audio of hostile crowds

Volume and Repetition

Elite free throw shooters typically shoot hundreds of free throws per week in practice, developing muscle memory and routine consistency that translates to games.

Conclusion

Free throw analytics reveals that this seemingly simple aspect of basketball involves complex interactions between biomechanics, psychology, game theory, and statistical analysis. Understanding these patterns enables teams to make data-driven decisions about when to employ strategies like hack-a-shaq, which players to target or protect in clutch situations, and how to optimize training programs for improvement.

The combination of traditional basketball wisdom and modern analytics provides a comprehensive framework for maximizing free throw efficiency and strategic decision-making. As analytics continue to evolve, teams that effectively leverage free throw data will gain competitive advantages in close games where every point matters.