Recursive Functions Across 20 Languages

Python

This function models how study time compounds. Each CSE 240 module builds on the last, so you might need more time as you go deeper. This function calculates the total study hours needed up to a certain module.

def calculate_study_hours(module_number):
    # Base case: Module 1 takes a baseline of 3 hours.
    if module_number == 1:
        return 3
    # Recursive step: Each subsequent module takes its number in hours,
    # plus all the hours from previous modules.
    else:
        return module_number + calculate_study_hours(module_number - 1)

# How many hours for the first 4 modules?
print(calculate_study_hours(4))  # Output: 10 (4 + 3 + 2 + 1)

JavaScript

Imagine your course concepts are locked. You can only unlock the next one after understanding the current one. This function simulates "unlocking" concepts recursively until you've mastered them all.

function unlockConcept(currentConceptID, finalConceptID) {
  // Base case: You've reached the final concept for the week.
  if (currentConceptID >= finalConceptID) {
    console.log(`Concept ${finalConceptID} mastered! Module complete.`);
    return;
  }

  // Recursive step: Study the current concept and move to the next.
  console.log(`Studying concept ${currentConceptID}...`);
  unlockConcept(currentConceptID + 1, finalConceptID);
}

unlockConcept(1, 5);

C

In C, you'll master pointers. This function simulates recursively "dereferencing" a pointer. Each call goes one level deeper into memory, like peeling layers of an onion, until it reaches the base value.

#include <stdio.h>

// Imagine this function traces memory addresses.
void trace_pointer(int pointer_level) {
    // Base case: We've reached the actual data.
    if (pointer_level <= 0) {
        printf("Reached the value!\\n");
        return;
    }

    // Recursive step: "Dereference" and go to the next level.
    printf("Level %d pointer -> \\n", pointer_level);
    trace_pointer(pointer_level - 1);
}

int main() {
    trace_pointer(3); // Simulate a pointer-to-pointer-to-int (int***)
    return 0;
}

C++

A C++ project is made of many files. The compiler processes them one by one. This function simulates the process, "compiling" one file at a time until none are left and the project is built.

#include <iostream>

void compile_project(int remaining_files) {
    // Base case: No files left to compile.
    if (remaining_files <= 0) {
        std::cout << "Project compiled successfully!" << std::endl;
        return;
    }

    // Recursive step: Compile one file and reduce the count.
    std::cout << "Compiling file " << remaining_files << "..." << std::endl;
    compile_project(remaining_files - 1);
}

int main() {
    compile_project(5);
    return 0;
}

Java

Debugging is a recursive process. You fix one bug, which reduces the number of problems, then you tackle the next. This function models the satisfaction of squashing bugs one by one.

public class Debugger {
    public static void debugCode(int bugsRemaining) {
        // Base case: No bugs left! Time to submit.
        if (bugsRemaining <= 0) {
            System.out.println("All bugs fixed. Code is clean!");
            return;
        }

        // Recursive step: Fix a bug and check the rest of the code.
        System.out.println("Squashing bug #" + bugsRemaining);
        debugCode(bugsRemaining - 1);
    }

    public static void main(String[] args) {
        debugCode(4);
    }
}

C#

Mastering a tough topic in CSE 240 takes repeated effort. This function simulates reducing a topic's "difficulty" with each recursive study session until it becomes manageable.

using System;

public class Student {
    public static void MasterTopic(int difficulty) {
        // Base case: The topic is easy enough to understand.
        if (difficulty <= 10) {
            Console.WriteLine("Topic mastered!");
            return;
        }

        // Recursive step: Study to reduce difficulty and try again.
        Console.WriteLine($"Topic difficulty is {difficulty}. Reviewing...");
        MasterTopic(difficulty - 15); // Each session helps!
    }

    public static void Main(string[] args) {
        MasterTopic(50); // Start with a tough topic.
    }
}

TypeScript

Before submitting an assignment, you run a series of checks. This typed function recursively works through a checklist, ensuring everything is perfect for submission.

function validateAssignment(checksLeft: number): void {
  // Base case: All checks passed.
  if (checksLeft <= 0) {
    console.log('Assignment is valid and ready to submit!');
    return;
  }

  // Recursive step: Perform a check and move to the next.
  console.log(`Running check #${checksLeft}... OK.`);
  validateAssignment(checksLeft - 1);
}

validateAssignment(3);

SQL

Courses have prerequisites. This recursive SQL query builds a path from an advanced course (like 'CSE240') back to its foundational prerequisites, showing you the full learning journey.

-- Create a table of course prerequisites
CREATE TABLE Courses (id TEXT, prereq_id TEXT);
INSERT INTO Courses VALUES ('CSE100', NULL), ('CSE120', 'CSE100'), ('CSE240', 'CSE120');

-- Recursive Query to find the full path
WITH RECURSIVE course_path(id, path) AS (
  SELECT id, id FROM Courses WHERE id = 'CSE100' -- Base case
  UNION ALL
  SELECT c.id, p.path || ' -> ' || c.id -- Recursive step
  FROM Courses c, course_path p
  WHERE c.prereq_id = p.id
)
SELECT path FROM course_path WHERE id = 'CSE240';
-- Result: "CSE100 -> CSE120 -> CSE240"

Go

Your final project might have multiple tasks that need to be completed. This Go function models completing project tasks one by one until the entire project is finished.

package main
import "fmt"

func completeLab(taskID int) {
    // Base case: Last task is done.
    if taskID <= 0 {
        fmt.Println("Lab project complete!")
        return
    }
    // Recursive step: Finish a task and start the next.
    fmt.Printf("Completing task #%d...\\n", taskID)
    completeLab(taskID - 1)
}

func main() {
    completeLab(4)
}

Swift

The final exam is looming! This function simulates a countdown, helping you plan your study sessions for each remaining day until you're fully prepared for the exam.

func prepareForExam(daysLeft: Int) {
    // Base case: It's exam day!
    if daysLeft <= 0 {
        print("Good luck on the exam!")
        return
    }

    // Recursive step: Study for today and decrement the day count.
    print("\(daysLeft) days left. Time for a study session!")
    prepareForExam(daysLeft: daysLeft - 1)
}

prepareForExam(daysLeft: 3)

Kotlin

A homework assignment is just a set of problems. This function models solving the problems in a set one by one until the assignment is ready to be turned in.

fun solveProblemSet(problemsLeft: Int) {
    // Base case: No more problems to solve.
    if (problemsLeft <= 0) {
        println("Assignment finished!")
        return
    }

    // Recursive step: Solve one problem, then tackle the rest.
    println("Solving problem #$problemsLeft...")
    solveProblemSet(problemsLeft - 1)
}

fun main() {
    solveProblemSet(5)
}

R

In data analysis, you often break down a big dataset into smaller, more focused pieces. This R function simulates recursively "zooming in" on your data until you find the specific insight you're looking for.

analyze_dataset <- function(data_points) {
  # Base case: The dataset is small enough for a final conclusion.
  if (data_points < 10) {
    return("Insight found!")
  }

  # Recursive step: Subset the data and analyze the smaller piece.
  cat("Analyzing", data_points, "points. Subsetting...\\n")
  analyze_dataset(data_points / 2)
}

analyze_dataset(100)

PHP

A study guide is built from sections and subsections. This function takes an array of topics and recursively generates an HTML nested list, perfectly modeling a structured document.

<?php
function generate_study_guide($topics) {
    // Base case: No topics left in the array.
    if (empty($topics)) {
        return;
    }
    
    // Recursive step: Print the first topic and process the rest.
    $current_topic = array_shift($topics);
    echo "<li>$current_topic</li>";
    generate_study_guide($topics);
}

$module_topics = ['Pointers', 'Structs', 'File I/O'];
echo "<ul>";
generate_study_guide($module_topics);
echo "</ul>";
?>

Ruby

Studying with flashcards is a recursive process: you review one, put it aside, and then review the rest of the pile. This function beautifully models that simple, effective study technique.

def review_flashcards(cards)
  # Base case: No cards left to review.
  if cards.empty?
    puts "All cards reviewed!"
    return
  end

  # Recursive step: Review the top card, then the rest of the deck.
  current_card = cards.shift
  puts "Reviewing: #{current_card}"
  review_flashcards(cards)
end

flashcards = ["Paradigm", "Pointer", "Recursion"]
review_flashcards(flashcards)

Rust

Rust's famous borrow checker ensures memory safety by analyzing code. This function simulates the checker recursively verifying nested code blocks, guaranteeing your program is safe before it even runs.

fn check_memory_safety(block_id: u32) {
    // Base case: Innermost block is reached and is safe.
    if block_id == 0 {
        println!("All blocks are memory safe.");
        return;
    }

    // Recursive step: Verify current block and check its parent.
    println!("Checking block {} for safety... OK.", block_id);
    check_memory_safety(block_id - 1);
}

fn main() {
    check_memory_safety(3);
}

Dart

In Flutter (powered by Dart), UIs are built from Widgets nested inside other Widgets. This function models that process, recursively building a widget tree from the outside in until the UI is complete.

void buildUiWidget(int complexity) {
  // Base case: The simplest widget needs no more nesting.
  if (complexity <= 1) {
    print('  Building final Text Widget...');
    return;
  }

  // Recursive step: Build a container and nest a simpler widget inside.
  print('Building Container Widget of complexity $complexity...');
  buildUiWidget(complexity - 1);
}

void main() {
  buildUiWidget(3);
}

MATLAB

A classic use of recursion in mathematics and engineering is calculating the determinant of a matrix. This function breaks a large matrix down into smaller 2x2 matrices to find the answer.

function det_val = simple_recursive_determinant(matrix)
    % NOTE: This is a simplified example for a 3x3 matrix.
    [rows, ~] = size(matrix);
    
    % Base case: The determinant of a 2x2 matrix.
    if rows == 2
        det_val = matrix(1,1)*matrix(2,2) - matrix(1,2)*matrix(2,1);
        return;
    end
    
    % Recursive step (simplified for first element expansion)
    sub_matrix = matrix(2:end, 2:end);
    det_val = matrix(1,1) * simple_recursive_determinant(sub_matrix);
end

Scala

Scala's functional nature shines with recursion. This function uses pattern matching to process a list of study topics—a clean and powerful way to handle recursive data structures.

object Course {
  def processTopics(topics: List[String]): Unit = topics match {
    // Base case: The list of topics is empty.
    case Nil => println("All topics processed.")
    
    // Recursive step: Process the head and recur on the tail.
    case head :: tail =>
      println(s"Processing: $head")
      processTopics(tail)
  }

  def main(args: Array[String]): Unit = {
    val moduleTopics = List("Scheme", "Prolog", "OOP")
    processTopics(moduleTopics)
  }
}

Perl

Perl is a master of text processing. This recursive subroutine simulates reading a log file or program output line by line, a common task for debugging or system administration.

sub parse_log_file {
    my ($line_number) = @_;

    # Base case: We've reached the end of the log snippet.
    if ($line_number > 3) {
        print "Log file parsed.\\n";
        return;
    }

    # Recursive step: Print a log line and move to the next.
    print "Parsing log line $line_number...\\n";
    parse_log_file($line_number + 1);
}

parse_log_file(1);

Bash

Every good project needs an organized file structure. This recursive Bash function creates a nested directory structure for your new CSE 240 assignment, ready for you to fill with code.

#!/bin/bash

organize_project_files() {
    local level=$1
    local prefix=$2

    # Base case: Stop creating directories after a certain depth.
    if [[ $level -le 0 ]]; then
        return
    fi

    # Recursive step: Create a directory and then create a sub-directory.
    local dir_name="${prefix}_level_${level}"
    mkdir "$dir_name"
    echo "Created directory: $dir_name"
    cd "$dir_name"
    organize_project_files $((level - 1)) "sub"
    cd ..
}

organize_project_files 2 "module"