Show description
Recursive Functions for CSE 240
Recursive Functions for CSE 240
Recursive Functions Across 20 Languages
A CSE 240 Companion for Your ASU Journey
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.…
Recursive Functions for CSE 240
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Recursive Functions for CSE 240</title>
<link rel="preconnect" href="https://fonts.googleapis.com">
<link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
<link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;600;700&display=swap" rel="stylesheet">
<script src="https://cdn.tailwindcss.com"></script>
<style>
/* Basic ShadCN-like Theming */
body {
font-family: 'Inter', sans-serif;
background-color: #09090b; /* zinc-950 */
color: #fafafa; /* zinc-50 */
}
.card {
background-color: #18181b; /* zinc-900 */
border: 1px solid #27272a; /* zinc-800 */
border-radius: 0.75rem;
padding: 1.5rem;
transition: all 0.2s ease-in-out;
}
.card:hover {
border-color: #6d28d9; /* violet-700 */
transform: translateY(-4px);
box-shadow: 0 10px 15px -3px rgba(109, 40, 217, 0.1), 0 4px 6px -2px rgba(109, 40, 217, 0.05);
}
.card-title {
color: #fafafa; /* zinc-50 */
font-weight: 600;
font-size: 1.25rem;
margin-bottom: 0.5rem;
display: flex;
align-items: center;
}
.card-title .icon {
width: 24px;
height: 24px;
margin-right: 0.75rem;
}
.card-description {
color: #a1a1aa; /* zinc-400 */
margin-bottom: 1.5rem;
font-size: 0.95rem;
line-height: 1.6;
}
pre {
background-color: #09090b; /* zinc-950 */
border: 1px solid #27272a; /* zinc-800 */
border-radius: 0.5rem;
padding: 1rem;
white-space: pre-wrap; /* Allow code to wrap */
word-break: break-word; /* Break long lines */
font-family: 'Fira Code', 'Courier New', monospace;
font-size: 0.875rem;
}
code {
font-family: inherit;
}
/* Manual Syntax Highlighting */
.keyword { color: #c084fc; } /* purple-400 */
.function { color: #60a5fa; } /* blue-400 */
.type { color: #facc15; } /* yellow-400 */
.string { color: #a3e635; } /* lime-400 */
.number { color: #f97316; } /* orange-500 */
.comment { color: #71717a; } /* zinc-500 */
.operator { color: #f472b6; } /* pink-400 */
.variable { color: #e5e7eb; } /* gray-200 */
</style>
</head>
<body class="p-4 sm:p-8">
<header class="text-center mb-12">
<h1 class="text-4xl font-bold tracking-tight text-white mb-2">Recursive Functions Across 20 Languages</h1>
<p class="text-lg text-zinc-400">A CSE 240 Companion for Your ASU Journey</p>
</header>
<main class="grid grid-cols-1 md:grid-cols-2 lg:grid-cols-3 gap-6">
<!-- Python -->
<div class="card">
<h2 class="card-title">Python</h2>
<p class="card-description">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.</p>
<pre><code><span class="keyword">def</span> <span class="function">calculate_study_hours</span>(<span class="variable">module_number</span>):
<span class="comment"># Base case: Module 1 takes a baseline of 3 hours.</span>
<span class="keyword">if</span> <span class="variable">module_number</span> <span class="operator">==</span> <span class="number">1</span>:
<span class="keyword">return</span> <span class="number">3</span>
<span class="comment"># Recursive step: Each subsequent module takes its number in hours,</span>
<span class="comment"># plus all the hours from previous modules.</span>
<span class="keyword">else</span>:
<span class="keyword">return</span> <span class="variable">module_number</span> <span class="operator">+</span> <span class="function">calculate_study_hours</span>(<span class="variable">module_number</span> <span class="operator">-</span> <span class="number">1</span>)
<span class="comment"># How many hours for the first 4 modules?</span>
<span class="function">print</span>(<span class="function">calculate_study_hours</span>(<span class="number">4</span>)) <span class="comment"># Output: 10 (4 + 3 + 2 + 1)</span>
</code></pre>
</div>
<!-- JavaScript -->
<div class="card">
<h2 class="card-title">JavaScript</h2>
<p class="card-description">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.</p>
<pre><code><span class="keyword">function</span> <span class="function">unlockConcept</span>(<span class="variable">currentConceptID</span>, <span class="variable">finalConceptID</span>) {
<span class="comment">// Base case: You've reached the final concept for the week.</span>
<span class="keyword">if</span> (<span class="variable">currentConceptID</span> <span class="operator">>=</span> <span class="variable">finalConceptID</span>) {
<span class="variable">console</span>.<span class="function">log</span>(<span class="string">`Concept <span class="variable">${finalConceptID}</span> mastered! Module complete.`</span>);
<span class="keyword">return</span>;
}
<span class="comment">// Recursive step: Study the current concept and move to the next.</span>
<span class="variable">console</span>.<span class="function">log</span>(<span class="string">`Studying concept <span class="variable">${currentConceptID}</span>...`</span>);
<span class="function">unlockConcept</span>(<span class="variable">currentConceptID</span> <span class="operator">+</span> <span class="number">1</span>, <span class="variable">finalConceptID</span>);
}
<span class="function">unlockConcept</span>(<span class="number">1</span>, <span class="number">5</span>);
</code></pre>
</div>
<!-- C -->
<div class="card">
<h2 class="card-title">C</h2>
<p class="card-description">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.</p>
<pre><code><span class="keyword">#include</span> <span class="string"><stdio.h></span>
<span class="comment">// Imagine this function traces memory addresses.</span>
<span class="keyword">void</span> <span class="function">trace_pointer</span>(<span class="type">int</span> <span class="variable">pointer_level</span>) {
<span class="comment">// Base case: We've reached the actual data.</span>
<span class="keyword">if</span> (<span class="variable">pointer_level</span> <span class="operator"><=</span> <span class="number">0</span>) {
<span class="function">printf</span>(<span class="string">"Reached the value!\\n"</span>);
<span class="keyword">return</span>;
}
<span class="comment">// Recursive step: "Dereference" and go to the next level.</span>
<span class="function">printf</span>(<span class="string">"Level %d pointer -> \\n"</span>, <span class="variable">pointer_level</span>);
<span class="function">trace_pointer</span>(<span class="variable">pointer_level</span> <span class="operator">-</span> <span class="number">1</span>);
}
<span class="keyword">int</span> <span class="function">main</span>() {
<span class="function">trace_pointer</span>(<span class="number">3</span>); <span class="comment">// Simulate a pointer-to-pointer-to-int (int***)</span>
<span class="keyword">return</span> <span class="number">0</span>;
}
</code></pre>
</div>
<!-- C++ -->
<div class="card">
<h2 class="card-title">C++</h2>
<p class="card-description">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.</p>
<pre><code><span class="keyword">#include</span> <span class="string"><iostream></span>
<span class="keyword">void</span> <span class="function">compile_project</span>(<span class="type">int</span> <span class="variable">remaining_files</span>) {
<span class="comment">// Base case: No files left to compile.</span>
<span class="keyword">if</span> (<span class="variable">remaining_files</span> <span class="operator"><=</span> <span class="number">0</span>) {
<span class="variable">std::cout</span> <span class="operator"><<</span> <span class="string">"Project compiled successfully!"</span> <span class="operator"><<</span> <span class="variable">std::endl</span>;
<span class="keyword">return</span>;
}
<span class="comment">// Recursive step: Compile one file and reduce the count.</span>
<span class="variable">std::cout</span> <span class="operator"><<</span> <span class="string">"Compiling file "</span> <span class="operator"><<</span> <span class="variable">remaining_files</span> <span class="operator"><<</span> <span class="string">"..."</span> <span class="operator"><<</span> <span class="variable">std::endl</span>;
<span class="function">compile_project</span>(<span class="variable">remaining_files</span> <span class="operator">-</span> <span class="number">1</span>);
}
<span class="keyword">int</span> <span class="function">main</span>() {
<span class="function">compile_project</span>(<span class="number">5</span>);
<span class="keyword">return</span> <span class="number">0</span>;
}
</code></pre>
</div>
<!-- Java -->
<div class="card">
<h2 class="card-title">Java</h2>
<p class="card-description">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.</p>
<pre><code><span class="keyword">public class</span> <span class="type">Debugger</span> {
<span class="keyword">public static void</span> <span class="function">debugCode</span>(<span class="type">int</span> <span class="variable">bugsRemaining</span>) {
<span class="comment">// Base case: No bugs left! Time to submit.</span>
<span class="keyword">if</span> (<span class="variable">bugsRemaining</span> <span class="operator"><=</span> <span class="number">0</span>) {
<span class="type">System</span>.<span class="variable">out</span>.<span class="function">println</span>(<span class="string">"All bugs fixed. Code is clean!"</span>);
<span class="keyword">return</span>;
}
<span class="comment">// Recursive step: Fix a bug and check the rest of the code.</span>
<span class="type">System</span>.<span class="variable">out</span>.<span class="function">println</span>(<span class="string">"Squashing bug #"</span> <span class="operator">+</span> <span class="variable">bugsRemaining</span>);
<span class="function">debugCode</span>(<span class="variable">bugsRemaining</span> <span class="operator">-</span> <span class="number">1</span>);
}
<span class="keyword">public static void</span> <span class="function">main</span>(<span class="type">String</span>[] <span class="variable">args</span>) {
<span class="function">debugCode</span>(<span class="number">4</span>);
}
}
</code></pre>
</div>
<!-- C# -->
<div class="card">
<h2 class="card-title">C#</h2>
<p class="card-description">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.</p>
<pre><code><span class="keyword">using</span> <span class="type">System</span>;
<span class="keyword">public class</span> <span class="type">Student</span> {
<span class="keyword">public static void</span> <span class="function">MasterTopic</span>(<span class="type">int</span> <span class="variable">difficulty</span>) {
<span class="comment">// Base case: The topic is easy enough to understand.</span>
<span class="keyword">if</span> (<span class="variable">difficulty</span> <span class="operator"><=</span> <span class="number">10</span>) {
<span class="type">Console</span>.<span class="function">WriteLine</span>(<span class="string">"Topic mastered!"</span>);
<span class="keyword">return</span>;
}
<span class="comment">// Recursive step: Study to reduce difficulty and try again.</span>
<span class="type">Console</span>.<span class="function">WriteLine</span>($<span class="string">"Topic difficulty is {difficulty}. Reviewing..."</span>);
<span class="function">MasterTopic</span>(<span class="variable">difficulty</span> <span class="operator">-</span> <span class="number">15</span>); <span class="comment">// Each session helps!</span>
}
<span class="keyword">public static void</span> <span class="function">Main</span>(<span class="type">string</span>[] <span class="variable">args</span>) {
<span class="function">MasterTopic</span>(<span class="number">50</span>); <span class="comment">// Start with a tough topic.</span>
}
}
</code></pre>
</div>
<!-- TypeScript -->
<div class="card">
<h2 class="card-title">TypeScript</h2>
<p class="card-description">Before submitting an assignment, you run a series of checks. This typed function recursively works through a checklist, ensuring everything is perfect for submission.</p>
<pre><code><span class="keyword">function</span> <span class="function">validateAssignment</span>(<span class="variable">checksLeft</span>: <span class="type">number</span>): <span class="type">void</span> {
<span class="comment">// Base case: All checks passed.</span>
<span class="keyword">if</span> (<span class="variable">checksLeft</span> <span class="operator"><=</span> <span class="number">0</span>) {
<span class="variable">console</span>.<span class="function">log</span>(<span class="string">'Assignment is valid and ready to submit!'</span>);
<span class="keyword">return</span>;
}
<span class="comment">// Recursive step: Perform a check and move to the next.</span>
<span class="variable">console</span>.<span class="function">log</span>(<span class="string">`Running check #<span class="variable">${checksLeft}</span>... OK.`</span>);
<span class="function">validateAssignment</span>(<span class="variable">checksLeft</span> <span class="operator">-</span> <span class="number">1</span>);
}
<span class="function">validateAssignment</span>(<span class="number">3</span>);
</code></pre>
</div>
<!-- SQL -->
<div class="card">
<h2 class="card-title">SQL</h2>
<p class="card-description">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.</p>
<pre><code><span class="comment">-- Create a table of course prerequisites</span>
<span class="keyword">CREATE TABLE</span> <span class="variable">Courses</span> (<span class="type">id</span> <span class="type">TEXT</span>, <span class="variable">prereq_id</span> <span class="type">TEXT</span>);
<span class="keyword">INSERT INTO</span> <span class="variable">Courses</span> <span class="keyword">VALUES</span> (<span class="string">'CSE100'</span>, <span class="keyword">NULL</span>), (<span class="string">'CSE120'</span>, <span class="string">'CSE100'</span>), (<span class="string">'CSE240'</span>, <span class="string">'CSE120'</span>);
<span class="comment">-- Recursive Query to find the full path</span>
<span class="keyword">WITH RECURSIVE</span> <span class="function">course_path</span>(<span class="variable">id</span>, <span class="variable">path</span>) <span class="keyword">AS</span> (
<span class="keyword">SELECT</span> <span class="variable">id</span>, <span class="variable">id</span> <span class="keyword">FROM</span> <span class="variable">Courses</span> <span class="keyword">WHERE</span> <span class="variable">id</span> <span class="operator">=</span> <span class="string">'CSE100'</span> <span class="comment">-- Base case</span>
<span class="keyword">UNION ALL</span>
<span class="keyword">SELECT</span> <span class="variable">c.id</span>, <span class="variable">p.path</span> <span class="operator">||</span> <span class="string">' -> '</span> <span class="operator">||</span> <span class="variable">c.id</span> <span class="comment">-- Recursive step</span>
<span class="keyword">FROM</span> <span class="variable">Courses c</span>, <span class="function">course_path</span> <span class="variable">p</span>
<span class="keyword">WHERE</span> <span class="variable">c.prereq_id</span> <span class="operator">=</span> <span class="variable">p.id</span>
)
<span class="keyword">SELECT</span> <span class="variable">path</span> <span class="keyword">FROM</span> <span class="function">course_path</span> <span class="keyword">WHERE</span> <span class="variable">id</span> <span class="operator">=</span> <span class="string">'CSE240'</span>;
<span class="comment">-- Result: "CSE100 -> CSE120 -> CSE240"</span>
</code></pre>
</div>
<!-- Go -->
<div class="card">
<h2 class="card-title">Go</h2>
<p class="card-description">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.</p>
<pre><code><span class="keyword">package</span> <span class="variable">main</span>
<span class="keyword">import</span> <span class="string">"fmt"</span>
<span class="keyword">func</span> <span class="function">completeLab</span>(<span class="variable">taskID</span> <span class="type">int</span>) {
<span class="comment">// Base case: Last task is done.</span>
<span class="keyword">if</span> <span class="variable">taskID</span> <span class="operator"><=</span> <span class="number">0</span> {
<span class="variable">fmt</span>.<span class="function">Println</span>(<span class="string">"Lab project complete!"</span>)
<span class="keyword">return</span>
}
<span class="comment">// Recursive step: Finish a task and start the next.</span>
<span class="variable">fmt</span>.<span class="function">Printf</span>(<span class="string">"Completing task #%d...\\n"</span>, <span class="variable">taskID</span>)
<span class="function">completeLab</span>(<span class="variable">taskID</span> <span class="operator">-</span> <span class="number">1</span>)
}
<span class="keyword">func</span> <span class="function">main</span>() {
<span class="function">completeLab</span>(<span class="number">4</span>)
}
</code></pre>
</div>
<!-- Swift -->
<div class="card">
<h2 class="card-title">Swift</h2>
<p class="card-description">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.</p>
<pre><code><span class="keyword">func</span> <span class="function">prepareForExam</span>(<span class="variable">daysLeft</span>: <span class="type">Int</span>) {
<span class="comment">// Base case: It's exam day!</span>
<span class="keyword">if</span> <span class="variable">daysLeft</span> <span class="operator"><=</span> <span class="number">0</span> {
<span class="function">print</span>(<span class="string">"Good luck on the exam!"</span>)
<span class="keyword">return</span>
}
<span class="comment">// Recursive step: Study for today and decrement the day count.</span>
<span class="function">print</span>(<span class="string">"\(daysLeft) days left. Time for a study session!"</span>)
<span class="function">prepareForExam</span>(<span class="variable">daysLeft</span>: <span class="variable">daysLeft</span> <span class="operator">-</span> <span class="number">1</span>)
}
<span class="function">prepareForExam</span>(<span class="variable">daysLeft</span>: <span class="number">3</span>)
</code></pre>
</div>
<!-- Kotlin -->
<div class="card">
<h2 class="card-title">Kotlin</h2>
<p class="card-description">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.</p>
<pre><code><span class="keyword">fun</span> <span class="function">solveProblemSet</span>(<span class="variable">problemsLeft</span>: <span class="type">Int</span>) {
<span class="comment">// Base case: No more problems to solve.</span>
<span class="keyword">if</span> (<span class="variable">problemsLeft</span> <span class="operator"><=</span> <span class="number">0</span>) {
<span class="function">println</span>(<span class="string">"Assignment finished!"</span>)
<span class="keyword">return</span>
}
<span class="comment">// Recursive step: Solve one problem, then tackle the rest.</span>
<span class="function">println</span>(<span class="string">"Solving problem #$problemsLeft..."</span>)
<span class="function">solveProblemSet</span>(<span class="variable">problemsLeft</span> <span class="operator">-</span> <span class="number">1</span>)
}
<span class="keyword">fun</span> <span class="function">main</span>() {
<span class="function">solveProblemSet</span>(<span class="number">5</span>)
}
</code></pre>
</div>
<!-- R -->
<div class="card">
<h2 class="card-title">R</h2>
<p class="card-description">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.</p>
<pre><code><span class="function">analyze_dataset</span> <span class="operator"><-</span> <span class="keyword">function</span>(<span class="variable">data_points</span>) {
<span class="comment"># Base case: The dataset is small enough for a final conclusion.</span>
<span class="keyword">if</span> (<span class="variable">data_points</span> <span class="operator"><</span> <span class="number">10</span>) {
<span class="keyword">return</span>(<span class="string">"Insight found!"</span>)
}
<span class="comment"># Recursive step: Subset the data and analyze the smaller piece.</span>
<span class="function">cat</span>(<span class="string">"Analyzing"</span>, <span class="variable">data_points</span>, <span class="string">"points. Subsetting...\\n"</span>)
<span class="function">analyze_dataset</span>(<span class="variable">data_points</span> <span class="operator">/</span> <span class="number">2</span>)
}
<span class="function">analyze_dataset</span>(<span class="number">100</span>)
</code></pre>
</div>
<!-- And 8 more languages... -->
<!-- PHP -->
<div class="card">
<h2 class="card-title">PHP</h2>
<p class="card-description">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.</p>
<pre><code><span class="keyword"><?php</span>
<span class="keyword">function</span> <span class="function">generate_study_guide</span>(<span class="variable">$topics</span>) {
<span class="comment">// Base case: No topics left in the array.</span>
<span class="keyword">if</span> (<span class="function">empty</span>(<span class="variable">$topics</span>)) {
<span class="keyword">return</span>;
}
<span class="comment">// Recursive step: Print the first topic and process the rest.</span>
<span class="variable">$current_topic</span> <span class="operator">=</span> <span class="function">array_shift</span>(<span class="variable">$topics</span>);
<span class="keyword">echo</span> <span class="string">"<li><span class="variable">$current_topic</span></li>"</span>;
<span class="function">generate_study_guide</span>(<span class="variable">$topics</span>);
}
<span class="variable">$module_topics</span> <span class="operator">=</span> [<span class="string">'Pointers'</span>, <span class="string">'Structs'</span>, <span class="string">'File I/O'</span>];
<span class="keyword">echo</span> <span class="string">"<ul>"</span>;
<span class="function">generate_study_guide</span>(<span class="variable">$module_topics</span>);
<span class="keyword">echo</span> <span class="string">"</ul>"</span>;
<span class="keyword">?></span>
</code></pre>
</div>
<!-- Ruby -->
<div class="card">
<h2 class="card-title">Ruby</h2>
<p class="card-description">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.</p>
<pre><code><span class="keyword">def</span> <span class="function">review_flashcards</span>(<span class="variable">cards</span>)
<span class="comment"># Base case: No cards left to review.</span>
<span class="keyword">if</span> <span class="variable">cards</span>.<span class="function">empty?</span>
<span class="function">puts</span> <span class="string">"All cards reviewed!"</span>
<span class="keyword">return</span>
<span class="keyword">end</span>
<span class="comment"># Recursive step: Review the top card, then the rest of the deck.</span>
<span class="variable">current_card</span> <span class="operator">=</span> <span class="variable">cards</span>.<span class="function">shift</span>
<span class="function">puts</span> <span class="string">"Reviewing: #{current_card}"</span>
<span class="function">review_flashcards</span>(<span class="variable">cards</span>)
<span class="keyword">end</span>
<span class="variable">flashcards</span> <span class="operator">=</span> [<span class="string">"Paradigm"</span>, <span class="string">"Pointer"</span>, <span class="string">"Recursion"</span>]
<span class="function">review_flashcards</span>(<span class="variable">flashcards</span>)
</code></pre>
</div>
<!-- Rust -->
<div class="card">
<h2 class="card-title">Rust</h2>
<p class="card-description">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.</p>
<pre><code><span class="keyword">fn</span> <span class="function">check_memory_safety</span>(<span class="variable">block_id</span>: <span class="type">u32</span>) {
<span class="comment">// Base case: Innermost block is reached and is safe.</span>
<span class="keyword">if</span> <span class="variable">block_id</span> <span class="operator">==</span> <span class="number">0</span> {
<span class="function">println!</span>(<span class="string">"All blocks are memory safe."</span>);
<span class="keyword">return</span>;
}
<span class="comment">// Recursive step: Verify current block and check its parent.</span>
<span class="function">println!</span>(<span class="string">"Checking block {} for safety... OK."</span>, <span class="variable">block_id</span>);
<span class="function">check_memory_safety</span>(<span class="variable">block_id</span> <span class="operator">-</span> <span class="number">1</span>);
}
<span class="keyword">fn</span> <span class="function">main</span>() {
<span class="function">check_memory_safety</span>(<span class="number">3</span>);
}
</code></pre>
</div>
<!-- Dart -->
<div class="card">
<h2 class="card-title">Dart</h2>
<p class="card-description">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.</p>
<pre><code><span class="keyword">void</span> <span class="function">buildUiWidget</span>(<span class="type">int</span> <span class="variable">complexity</span>) {
<span class="comment">// Base case: The simplest widget needs no more nesting.</span>
<span class="keyword">if</span> (<span class="variable">complexity</span> <span class="operator"><=</span> <span class="number">1</span>) {
<span class="function">print</span>(<span class="string">' Building final Text Widget...'</span>);
<span class="keyword">return</span>;
}
<span class="comment">// Recursive step: Build a container and nest a simpler widget inside.</span>
<span class="function">print</span>(<span class="string">'Building Container Widget of complexity $complexity...'</span>);
<span class="function">buildUiWidget</span>(<span class="variable">complexity</span> <span class="operator">-</span> <span class="number">1</span>);
}
<span class="keyword">void</span> <span class="function">main</span>() {
<span class="function">buildUiWidget</span>(<span class="number">3</span>);
}
</code></pre>
</div>
<!-- MATLAB -->
<div class="card">
<h2 class="card-title">MATLAB</h2>
<p class="card-description">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.</p>
<pre><code><span class="keyword">function</span> <span class="variable">det_val</span> <span class="operator">=</span> <span class="function">simple_recursive_determinant</span>(<span class="variable">matrix</span>)
<span class="comment">% NOTE: This is a simplified example for a 3x3 matrix.</span>
[<span class="variable">rows</span>, <span class="variable">~</span>] <span class="operator">=</span> <span class="function">size</span>(<span class="variable">matrix</span>);
<span class="comment">% Base case: The determinant of a 2x2 matrix.</span>
<span class="keyword">if</span> <span class="variable">rows</span> <span class="operator">==</span> <span class="number">2</span>
<span class="variable">det_val</span> <span class="operator">=</span> <span class="variable">matrix</span>(<span class="number">1</span>,<span class="number">1</span>)<span class="operator">*</span><span class="variable">matrix</span>(<span class="number">2</span>,<span class="number">2</span>) <span class="operator">-</span> <span class="variable">matrix</span>(<span class="number">1</span>,<span class="number">2</span>)<span class="operator">*</span><span class="variable">matrix</span>(<span class="number">2</span>,<span class="number">1</span>);
<span class="keyword">return</span>;
<span class="keyword">end</span>
<span class="comment">% Recursive step (simplified for first element expansion)</span>
<span class="variable">sub_matrix</span> <span class="operator">=</span> <span class="variable">matrix</span>(<span class="number">2</span>:<span class="keyword">end</span>, <span class="number">2</span>:<span class="keyword">end</span>);
<span class="variable">det_val</span> <span class="operator">=</span> <span class="variable">matrix</span>(<span class="number">1</span>,<span class="number">1</span>) <span class="operator">*</span> <span class="function">simple_recursive_determinant</span>(<span class="variable">sub_matrix</span>);
<span class="keyword">end</span>
</code></pre>
</div>
<!-- Scala -->
<div class="card">
<h2 class="card-title">Scala</h2>
<p class="card-description">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.</p>
<pre><code><span class="keyword">object</span> <span class="type">Course</span> {
<span class="keyword">def</span> <span class="function">processTopics</span>(<span class="variable">topics</span>: <span class="type">List</span>[<span class="type">String</span>]): <span class="type">Unit</span> <span class="operator">=</span> <span class="variable">topics</span> <span class="keyword">match</span> {
<span class="comment">// Base case: The list of topics is empty.</span>
<span class="keyword">case</span> <span class="type">Nil</span> <span class="operator">=></span> <span class="function">println</span>(<span class="string">"All topics processed."</span>)
<span class="comment">// Recursive step: Process the head and recur on the tail.</span>
<span class="keyword">case</span> <span class="variable">head</span> :: <span class="variable">tail</span> <span class="operator">=></span>
<span class="function">println</span>(s<span class="string">"Processing: $head"</span>)
<span class="function">processTopics</span>(<span class="variable">tail</span>)
}
<span class="keyword">def</span> <span class="function">main</span>(<span class="variable">args</span>: <span class="type">Array</span>[<span class="type">String</span>]): <span class="type">Unit</span> <span class="operator">=</span> {
<span class="keyword">val</span> <span class="variable">moduleTopics</span> <span class="operator">=</span> <span class="type">List</span>(<span class="string">"Scheme"</span>, <span class="string">"Prolog"</span>, <span class="string">"OOP"</span>)
<span class="function">processTopics</span>(<span class="variable">moduleTopics</span>)
}
}
</code></pre>
</div>
<!-- Perl -->
<div class="card">
<h2 class="card-title">Perl</h2>
<p class="card-description">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.</p>
<pre><code><span class="keyword">sub</span> <span class="function">parse_log_file</span> {
<span class="keyword">my</span> (<span class="variable">$line_number</span>) <span class="operator">=</span> <span class="variable">@_</span>;
<span class="comment"># Base case: We've reached the end of the log snippet.</span>
<span class="keyword">if</span> (<span class="variable">$line_number</span> <span class="operator">></span> <span class="number">3</span>) {
<span class="function">print</span> <span class="string">"Log file parsed.\\n"</span>;
<span class="keyword">return</span>;
}
<span class="comment"># Recursive step: Print a log line and move to the next.</span>
<span class="function">print</span> <span class="string">"Parsing log line <span class="variable">$line_number</span>...\\n"</span>;
<span class="function">parse_log_file</span>(<span class="variable">$line_number</span> <span class="operator">+</span> <span class="number">1</span>);
}
<span class="function">parse_log_file</span>(<span class="number">1</span>);
</code></pre>
</div>
<!-- Bash -->
<div class="card">
<h2 class="card-title">Bash</h2>
<p class="card-description">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.</p>
<pre><code><span class="keyword">#!/bin/bash</span>
<span class="function">organize_project_files</span>() {
<span class="keyword">local</span> <span class="variable">level</span><span class="operator">=</span><span class="variable">$1</span>
<span class="keyword">local</span> <span class="variable">prefix</span><span class="operator">=</span><span class="variable">$2</span>
<span class="comment"># Base case: Stop creating directories after a certain depth.</span>
<span class="keyword">if</span> [[ <span class="variable">$level</span> <span class="operator">-le</span> <span class="number">0</span> ]]; <span class="keyword">then</span>
<span class="keyword">return</span>
<span class="keyword">fi</span>
<span class="comment"># Recursive step: Create a directory and then create a sub-directory.</span>
<span class="keyword">local</span> <span class="variable">dir_name</span><span class="operator">=</span><span class="string">"<span class="variable">${prefix}</span>_level_<span class="variable">${level}</span>"</span>
<span class="function">mkdir</span> <span class="string">"$dir_name"</span>
<span class="function">echo</span> <span class="string">"Created directory: <span class="variable">$dir_name</span>"</span>
<span class="function">cd</span> <span class="string">"<span class="variable">$dir_name</span>"</span>
<span class="function">organize_project_files</span> $((<span class="variable">level</span> <span class="operator">-</span> <span class="number">1</span>)) <span class="string">"sub"</span>
<span class="function">cd</span> ..
}
<span class="function">organize_project_files</span> <span class="number">2</span> <span class="string">"module"</span>
</code></pre>
</div>
</main>
</body>
</html>