Show description
C Programming: Data Types, Memory & Strings
C Programming: Data Types, Memory & Strings
C Programming: Data Types, Memory & Strings
🔗 C and C++ Data Type Hierarchy
Data Type
Scalar
Function
void
Aggregate
Pointer
Arithmetic
Enumeration
Array
Structure
Variant
Floating-point
bool
Integer
enum
struct
union
float
double
char
short
int
long
signed
unsigned
Key Concepts:
Scalar Types: Single values (int, float, char, pointers)
Aggregate Types: Collections of data (arrays, structures, unions)
Function Types: Represent functions and their signatures
void Type: Represents absence of type or value
Type Qualifiers: const, volatile, restrict modify behavior
🏨 Memory Organization
Memory is byte-addressable - each byte has a unique address
Memory Layout Example:
0x1000
65 ('A')
char
1 byte
0x1001
66 ('B')
char
1 byte
0x1002
0x00
char
null terminator
0x1004
1234
int
4 bytes (typically)
0x1008
3.14159
float
4 bytes
0x100C
0x1000
char*
pointer to char (8 bytes on 64-bit)
Animate Data Flow
Memory Organization Test Points:
Each byte has a unique memory address
Addresses increase sequentially (0x1000, 0x1001, 0x1002...)
Different data types occupy different amounts of memory
Memory alignment affects where data is stored
Pointers store memory addresses as their values
📍 Byte Addressable Memory - Code Examples
// Basic pointer and address demonstration
#include <stdio.h>
int main() {
int n1 = 4, n2 = 8;
int *pt1 = &n1, *pt2 = &n2;
char c1 = 'A', c2 = 'B', c6;
char *pc1 = &c1, *pc2 = &c2, *pc3 = &c6;
// Print addresses and values
printf("c1 address = %p, c1 value = %c\n", pc1, *pc1);
printf("c2 address = %p, c2 value = %c\n", pc2, *pc2);
printf("n1 address = %p, n1 value = %d\n", pt1, *pt1);
printf("n2 address = %p, n2 value = %d\n", pt2, *pt2);
return 0;
}
// Pointer arithmetic and memory addresses
#include <stdio.h>
int main() {
int arr[] = {10, 20, 30, 40};
int *ptr = arr;
// Show how array elements are stored in consecutive memory
for(int i = 0; i < 4; i++) {
printf("arr[%d] = %d, address = %p\n",
i, *(ptr + i), (ptr + i));
}
// Show byte-level addressing
char *byte_ptr = (char*)ptr;
printf("\nByte-by-byte view of first integer:\n");
for(…
C Programming: Data Types, Memory & Strings
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>C Programming: Data Types, Memory & Strings</title>
<style>
* {
margin: 0;
padding: 0;
box-sizing: border-box;
}
body {
background: linear-gradient(135deg, #1a1a1a 0%, #2d2d2d 100%);
color: #e0e0e0;
font-family: 'Courier New', monospace;
line-height: 1.6;
min-height: 100vh;
}
.container {
max-width: 1200px;
margin: 0 auto;
padding: 20px;
}
h1 {
text-align: center;
color: #64b5f6;
margin-bottom: 30px;
text-shadow: 0 0 10px rgba(100, 181, 246, 0.3);
font-size: 2.5em;
}
h2 {
color: #81c784;
margin: 30px 0 20px 0;
border-bottom: 2px solid #404040;
padding-bottom: 10px;
font-size: 1.8em;
}
h3 {
color: #ffb74d;
margin: 20px 0 15px 0;
font-size: 1.4em;
}
.section {
background: rgba(45, 45, 45, 0.8);
margin: 20px 0;
padding: 25px;
border-radius: 10px;
border: 1px solid #404040;
box-shadow: 0 4px 15px rgba(0, 0, 0, 0.3);
}
.hierarchy-tree {
text-align: center;
margin: 20px 0;
font-family: monospace;
font-size: 14px;
}
.tree-level {
margin: 15px 0;
display: flex;
justify-content: center;
flex-wrap: wrap;
gap: 20px;
}
.tree-node {
background: linear-gradient(145deg, #404040, #505050);
padding: 8px 15px;
border-radius: 8px;
border: 2px solid #64b5f6;
color: #e0e0e0;
min-width: 100px;
text-align: center;
box-shadow: 0 2px 8px rgba(0, 0, 0, 0.4);
transition: all 0.3s ease;
}
.tree-node:hover {
transform: translateY(-2px);
box-shadow: 0 4px 12px rgba(100, 181, 246, 0.3);
}
.primitive-type {
background: linear-gradient(145deg, #2d4a2d, #3d5a3d);
border-color: #81c784;
}
.code-block {
background: #1e1e1e;
border: 1px solid #404040;
border-radius: 8px;
padding: 20px;
margin: 15px 0;
overflow-x: auto;
font-family: 'Courier New', monospace;
font-size: 14px;
line-height: 1.4;
}
.code-block pre {
color: #e0e0e0;
white-space: pre-wrap;
}
.keyword { color: #569cd6; font-weight: bold; }
.string { color: #ce9178; }
.number { color: #b5cea8; }
.comment { color: #6a9955; font-style: italic; }
.type { color: #4ec9b0; }
.memory-visual {
background: #2a2a2a;
border: 2px solid #64b5f6;
border-radius: 10px;
padding: 20px;
margin: 20px 0;
position: relative;
overflow: hidden;
}
.memory-address {
display: flex;
align-items: center;
margin: 5px 0;
padding: 8px;
background: rgba(100, 181, 246, 0.1);
border-radius: 5px;
transition: all 0.3s ease;
}
.memory-address:hover {
background: rgba(100, 181, 246, 0.2);
transform: scale(1.02);
}
.address {
width: 120px;
color: #ffb74d;
font-weight: bold;
}
.value {
width: 100px;
color: #81c784;
text-align: center;
}
.data-type {
width: 80px;
color: #f48fb1;
text-align: center;
}
.description {
color: #e0e0e0;
margin-left: 20px;
}
.animate-data {
animation: dataFlow 2s ease-in-out infinite;
}
@keyframes dataFlow {
0%, 100% { opacity: 1; }
50% { opacity: 0.5; transform: translateX(5px); }
}
.string-demo {
background: #2a2a2a;
border: 2px solid #81c784;
border-radius: 10px;
padding: 20px;
margin: 20px 0;
}
.string-chars {
display: flex;
flex-wrap: wrap;
gap: 5px;
margin: 10px 0;
}
.char-box {
width: 40px;
height: 40px;
background: rgba(129, 199, 132, 0.2);
border: 1px solid #81c784;
border-radius: 5px;
display: flex;
align-items: center;
justify-content: center;
font-weight: bold;
color: #81c784;
}
.null-terminator {
background: rgba(244, 143, 177, 0.2);
border-color: #f48fb1;
color: #f48fb1;
}
.test-points {
background: rgba(255, 183, 77, 0.1);
border: 1px solid #ffb74d;
border-radius: 8px;
padding: 15px;
margin: 15px 0;
}
.test-points ul {
margin-left: 20px;
}
.test-points li {
margin: 5px 0;
color: #e0e0e0;
}
.highlight {
background: rgba(100, 181, 246, 0.2);
padding: 2px 4px;
border-radius: 3px;
}
.interactive-btn {
background: linear-gradient(145deg, #404040, #505050);
color: #64b5f6;
border: 2px solid #64b5f6;
padding: 10px 20px;
border-radius: 8px;
cursor: pointer;
margin: 10px 5px;
font-family: 'Courier New', monospace;
transition: all 0.3s ease;
}
.interactive-btn:hover {
background: rgba(100, 181, 246, 0.1);
transform: translateY(-2px);
}
</style>
</head>
<body>
<div class="container">
<h1>C Programming: Data Types, Memory & Strings</h1>
<!-- Data Type Hierarchy Section -->
<div class="section">
<h2>🔗 C and C++ Data Type Hierarchy</h2>
<div class="hierarchy-tree">
<div class="tree-level">
<div class="tree-node">Data Type</div>
</div>
<div class="tree-level">
<div class="tree-node">Scalar</div>
<div class="tree-node">Function</div>
<div class="tree-node">void</div>
<div class="tree-node">Aggregate</div>
</div>
<div class="tree-level">
<div class="tree-node">Pointer</div>
<div class="tree-node">Arithmetic</div>
<div class="tree-node">Enumeration</div>
<div class="tree-node">Array</div>
<div class="tree-node">Structure</div>
<div class="tree-node">Variant</div>
</div>
<div class="tree-level">
<div class="tree-node">Floating-point</div>
<div class="tree-node">bool</div>
<div class="tree-node">Integer</div>
<div class="tree-node">enum</div>
<div class="tree-node">struct</div>
<div class="tree-node">union</div>
</div>
<div class="tree-level">
<div class="tree-node primitive-type">float</div>
<div class="tree-node primitive-type">double</div>
<div class="tree-node primitive-type">char</div>
<div class="tree-node primitive-type">short</div>
<div class="tree-node primitive-type">int</div>
<div class="tree-node primitive-type">long</div>
<div class="tree-node primitive-type">signed</div>
<div class="tree-node primitive-type">unsigned</div>
</div>
</div>
<h3>Key Concepts:</h3>
<div class="test-points">
<ul>
<li><strong>Scalar Types:</strong> Single values (int, float, char, pointers)</li>
<li><strong>Aggregate Types:</strong> Collections of data (arrays, structures, unions)</li>
<li><strong>Function Types:</strong> Represent functions and their signatures</li>
<li><strong>void Type:</strong> Represents absence of type or value</li>
<li><strong>Type Qualifiers:</strong> const, volatile, restrict modify behavior</li>
</ul>
</div>
</div>
<!-- Memory Organization Section -->
<div class="section">
<h2>🏨 Memory Organization</h2>
<p>Memory is <span class="highlight">byte-addressable</span> - each byte has a unique address</p>
<div class="memory-visual" id="memoryDemo">
<h3>Memory Layout Example:</h3>
<div class="memory-address">
<span class="address">0x1000</span>
<span class="value">65 ('A')</span>
<span class="data-type">char</span>
<span class="description">1 byte</span>
</div>
<div class="memory-address">
<span class="address">0x1001</span>
<span class="value">66 ('B')</span>
<span class="data-type">char</span>
<span class="description">1 byte</span>
</div>
<div class="memory-address">
<span class="address">0x1002</span>
<span class="value">0x00</span>
<span class="data-type">char</span>
<span class="description">null terminator</span>
</div>
<div class="memory-address">
<span class="address">0x1004</span>
<span class="value">1234</span>
<span class="data-type">int</span>
<span class="description">4 bytes (typically)</span>
</div>
<div class="memory-address">
<span class="address">0x1008</span>
<span class="value">3.14159</span>
<span class="data-type">float</span>
<span class="description">4 bytes</span>
</div>
<div class="memory-address">
<span class="address">0x100C</span>
<span class="value">0x1000</span>
<span class="data-type">char*</span>
<span class="description">pointer to char (8 bytes on 64-bit)</span>
</div>
</div>
<button class="interactive-btn" onclick="animateMemory()">Animate Data Flow</button>
<div class="test-points">
<h3>Memory Organization Test Points:</h3>
<ul>
<li>Each byte has a unique memory address</li>
<li>Addresses increase sequentially (0x1000, 0x1001, 0x1002...)</li>
<li>Different data types occupy different amounts of memory</li>
<li>Memory alignment affects where data is stored</li>
<li>Pointers store memory addresses as their values</li>
</ul>
</div>
</div>
<!-- Byte Addressable Memory Code Examples -->
<div class="section">
<h2>📍 Byte Addressable Memory - Code Examples</h2>
<div class="code-block">
<pre><span class="comment">// Basic pointer and address demonstration</span>
<span class="type">#include</span> <span class="string"><stdio.h></span>
<span class="keyword">int</span> <span class="keyword">main</span>() {
<span class="type">int</span> <span class="keyword">n1</span> = <span class="number">4</span>, <span class="keyword">n2</span> = <span class="number">8</span>;
<span class="type">int</span> <span class="keyword">*pt1</span> = &<span class="keyword">n1</span>, <span class="keyword">*pt2</span> = &<span class="keyword">n2</span>;
<span class="type">char</span> <span class="keyword">c1</span> = <span class="string">'A'</span>, <span class="keyword">c2</span> = <span class="string">'B'</span>, <span class="keyword">c6</span>;
<span class="type">char</span> <span class="keyword">*pc1</span> = &<span class="keyword">c1</span>, <span class="keyword">*pc2</span> = &<span class="keyword">c2</span>, <span class="keyword">*pc3</span> = &<span class="keyword">c6</span>;
<span class="comment">// Print addresses and values</span>
<span class="keyword">printf</span>(<span class="string">"c1 address = %p, c1 value = %c\n"</span>, <span class="keyword">pc1</span>, <span class="keyword">*pc1</span>);
<span class="keyword">printf</span>(<span class="string">"c2 address = %p, c2 value = %c\n"</span>, <span class="keyword">pc2</span>, <span class="keyword">*pc2</span>);
<span class="keyword">printf</span>(<span class="string">"n1 address = %p, n1 value = %d\n"</span>, <span class="keyword">pt1</span>, <span class="keyword">*pt1</span>);
<span class="keyword">printf</span>(<span class="string">"n2 address = %p, n2 value = %d\n"</span>, <span class="keyword">pt2</span>, <span class="keyword">*pt2</span>);
<span class="keyword">return</span> <span class="number">0</span>;
}</pre>
</div>
<div class="code-block">
<pre><span class="comment">// Pointer arithmetic and memory addresses</span>
<span class="type">#include</span> <span class="string"><stdio.h></span>
<span class="keyword">int</span> <span class="keyword">main</span>() {
<span class="type">int</span> <span class="keyword">arr</span>[] = {<span class="number">10</span>, <span class="number">20</span>, <span class="number">30</span>, <span class="number">40</span>};
<span class="type">int</span> <span class="keyword">*ptr</span> = <span class="keyword">arr</span>;
<span class="comment">// Show how array elements are stored in consecutive memory</span>
<span class="keyword">for</span>(<span class="type">int</span> <span class="keyword">i</span> = <span class="number">0</span>; <span class="keyword">i</span> < <span class="number">4</span>; <span class="keyword">i</span>++) {
<span class="keyword">printf</span>(<span class="string">"arr[%d] = %d, address = %p\n"</span>,
<span class="keyword">i</span>, <span class="keyword">*(ptr + i)</span>, (<span class="keyword">ptr + i</span>));
}
<span class="comment">// Show byte-level addressing</span>
<span class="type">char</span> <span class="keyword">*byte_ptr</span> = (<span class="type">char</span>*)<span class="keyword">ptr</span>;
<span class="keyword">printf</span>(<span class="string">"\nByte-by-byte view of first integer:\n"</span>);
<span class="keyword">for</span>(<span class="type">int</span> <span class="keyword">i</span> = <span class="number">0</span>; <span class="keyword">i</span> < <span class="keyword">sizeof</span>(<span class="type">int</span>); <span class="keyword">i</span>++) {
<span class="keyword">printf</span>(<span class="string">"Byte %d: %02X (address %p)\n"</span>,
<span class="keyword">i</span>, <span class="keyword">*(byte_ptr + i)</span>, (<span class="keyword">byte_ptr + i</span>));
}
<span class="keyword">return</span> <span class="number">0</span>;
}</pre>
</div>
</div>
<!-- C Strings Section -->
<div class="section">
<h2>📝 C-Style Strings</h2>
<div class="string-demo" id="stringDemo">
<h3>String "Hello" in Memory:</h3>
<div class="string-chars">
<div class="char-box">H</div>
<div class="char-box">e</div>
<div class="char-box">l</div>
<div class="char-box">l</div>
<div class="char-box">o</div>
<div class="char-box null-terminator">\0</div>
</div>
<p>Address: 0x2000 0x2001 0x2002 0x2003 0x2004 0x2005</p>
</div>
<div class="code-block">
<pre><span class="comment">// C-Style String Examples</span>
<span class="type">#include</span> <span class="string"><stdio.h></span>
<span class="type">#include</span> <span class="string"><string.h></span>
<span class="keyword">int</span> <span class="keyword">main</span>() {
<span class="comment">// Different ways to declare strings</span>
<span class="type">char</span> <span class="keyword">str1</span>[] = <span class="string">"Hello"</span>; <span class="comment">// Array on stack</span>
<span class="type">char</span> <span class="keyword">*str2</span> = <span class="string">"World"</span>; <span class="comment">// Pointer to string literal</span>
<span class="type">char</span> <span class="keyword">str3</span>[<span class="number">20</span>]; <span class="comment">// Uninitialized array</span>
<span class="type">char</span> <span class="keyword">str4</span>[<span class="number">10</span>] = {<span class="string">'T'</span>, <span class="string">'e'</span>, <span class="string">'s'</span>, <span class="string">'t'</span>, <span class="string">'\0'</span>}; <span class="comment">// Character array</span>
<span class="comment">// Show string properties</span>
<span class="keyword">printf</span>(<span class="string">"str1 = \"%s\", length = %zu\n"</span>, <span class="keyword">str1</span>, <span class="keyword">strlen</span>(<span class="keyword">str1</span>));
<span class="keyword">printf</span>(<span class="string">"str2 = \"%s\", length = %zu\n"</span>, <span class="keyword">str2</span>, <span class="keyword">strlen</span>(<span class="keyword">str2</span>));
<span class="keyword">printf</span>(<span class="string">"str4 = \"%s\", length = %zu\n"</span>, <span class="keyword">str4</span>, <span class="keyword">strlen</span>(<span class="keyword">str4</span>));
<span class="comment">// String operations</span>
<span class="keyword">strcpy</span>(<span class="keyword">str3</span>, <span class="string">"Copied"</span>);
<span class="keyword">printf</span>(<span class="string">"After strcpy: str3 = \"%s\"\n"</span>, <span class="keyword">str3</span>);
<span class="keyword">strcat</span>(<span class="keyword">str3</span>, <span class="string">" String"</span>);
<span class="keyword">printf</span>(<span class="string">"After strcat: str3 = \"%s\"\n"</span>, <span class="keyword">str3</span>);
<span class="comment">// Character-by-character access</span>
<span class="keyword">printf</span>(<span class="string">"\nCharacter-by-character access of str1:\n"</span>);
<span class="keyword">for</span>(<span class="type">int</span> <span class="keyword">i</span> = <span class="number">0</span>; <span class="keyword">str1</span>[<span class="keyword">i</span>] != <span class="string">'\0'</span>; <span class="keyword">i</span>++) {
<span class="keyword">printf</span>(<span class="string">"str1[%d] = '%c' (ASCII %d) at address %p\n"</span>,
<span class="keyword">i</span>, <span class="keyword">str1</span>[<span class="keyword">i</span>], <span class="keyword">str1</span>[<span class="keyword">i</span>], &<span class="keyword">str1</span>[<span class="keyword">i</span>]);
}
<span class="keyword">return</span> <span class="number">0</span>;
}</pre>
</div>
<div class="code-block">
<pre><span class="comment">// Advanced String Operations</span>
<span class="type">#include</span> <span class="string"><stdio.h></span>
<span class="type">#include</span> <span class="string"><string.h></span>
<span class="type">#include</span> <span class="string"><stdlib.h></span>
<span class="comment">// Custom string length function</span>
<span class="type">int</span> <span class="keyword">my_strlen</span>(<span class="keyword">const</span> <span class="type">char</span> <span class="keyword">*str</span>) {
<span class="type">int</span> <span class="keyword">count</span> = <span class="number">0</span>;
<span class="keyword">while</span>(<span class="keyword">*str</span> != <span class="string">'\0'</span>) {
<span class="keyword">count</span>++;
<span class="keyword">str</span>++;
}
<span class="keyword">return</span> <span class="keyword">count</span>;
}
<span class="comment">// Custom string copy function</span>
<span class="type">char</span>* <span class="keyword">my_strcpy</span>(<span class="type">char</span> <span class="keyword">*dest</span>, <span class="keyword">const</span> <span class="type">char</span> <span class="keyword">*src</span>) {
<span class="type">char</span> <span class="keyword">*original_dest</span> = <span class="keyword">dest</span>;
<span class="keyword">while</span>(<span class="keyword">*src</span> != <span class="string">'\0'</span>) {
<span class="keyword">*dest</span> = <span class="keyword">*src</span>;
<span class="keyword">dest</span>++;
<span class="keyword">src</span>++;
}
<span class="keyword">*dest</span> = <span class="string">'\0'</span>; <span class="comment">// Don't forget null terminator!</span>
<span class="keyword">return</span> <span class="keyword">original_dest</span>;
}
<span class="keyword">int</span> <span class="keyword">main</span>() {
<span class="type">char</span> <span class="keyword">source</span>[] = <span class="string">"Programming"</span>;
<span class="type">char</span> <span class="keyword">destination</span>[<span class="number">20</span>];
<span class="keyword">printf</span>(<span class="string">"Source length (custom): %d\n"</span>, <span class="keyword">my_strlen</span>(<span class="keyword">source</span>));
<span class="keyword">printf</span>(<span class="string">"Source length (library): %zu\n"</span>, <span class="keyword">strlen</span>(<span class="keyword">source</span>));
<span class="keyword">my_strcpy</span>(<span class="keyword">destination</span>, <span class="keyword">source</span>);
<span class="keyword">printf</span>(<span class="string">"Copied string: %s\n"</span>, <span class="keyword">destination</span>);
<span class="comment">// Dynamic string allocation</span>
<span class="type">char</span> <span class="keyword">*dynamic_str</span> = <span class="keyword">malloc</span>(<span class="number">50</span> * <span class="keyword">sizeof</span>(<span class="type">char</span>));
<span class="keyword">strcpy</span>(<span class="keyword">dynamic_str</span>, <span class="string">"Dynamic Memory"</span>);
<span class="keyword">printf</span>(<span class="string">"Dynamic string: %s\n"</span>, <span class="keyword">dynamic_str</span>);
<span class="keyword">free</span>(<span class="keyword">dynamic_str</span>); <span class="comment">// Don't forget to free!</span>
<span class="keyword">return</span> <span class="number">0</span>;
}</pre>
</div>
<button class="interactive-btn" onclick="demonstrateString()">Demonstrate String Operations</button>
</div>
<!-- Test Points Section -->
<div class="section">
<h2>🎯 Key Test Points & Concepts</h2>
<h3>Data Types & Hierarchy</h3>
<div class="test-points">
<ul>
<li>Know the difference between <span class="highlight">scalar</span> and <span class="highlight">aggregate</span> types</li>
<li>Understand <span class="highlight">type qualifiers</span>: const, volatile, restrict</li>
<li>Memory sizes: char (1), short (2), int (4), long (8), pointer (8 on 64-bit)</li>
<li>Signed vs unsigned integer ranges</li>
<li>Float vs double precision and storage</li>
</ul>
</div>
<h3>Memory Organization</h3>
<div class="test-points">
<ul>
<li>Each byte has a unique memory address</li>
<li>Addresses are typically displayed in <span class="highlight">hexadecimal</span></li>
<li>Memory alignment affects performance and layout</li>
<li>Stack vs heap memory allocation</li>
<li>Pointer arithmetic: ptr + 1 moves by sizeof(type) bytes</li>
</ul>
</div>
<h3>C Strings</h3>
<div class="test-points">
<ul>
<li>C strings are <span class="highlight">null-terminated</span> character arrays</li>
<li>String literals are stored in read-only memory</li>
<li>strlen() returns length WITHOUT the null terminator</li>
<li>Buffer overflows can occur without bounds checking</li>
<li>String functions: strcpy, strcat, strcmp, strlen, strstr</li>
<li>Always allocate space for the null terminator (\0)</li>
</ul>
</div>
<h3>Pointers & Addresses</h3>
<div class="test-points">
<ul>
<li><span class="highlight">&variable</span> gives address of variable</li>
<li><span class="highlight">*pointer</span> dereferences pointer to get value</li>
<li>Pointer arithmetic follows data type size</li>
<li>Array name is pointer to first element</li>
<li>Pointer to pointer concepts (char **)</li>
<li>NULL pointer (0x0) represents invalid address</li>
</ul>
</div>
</div>
</div>
<script>
// Animation functions
function animateMemory() {
const memoryAddresses = document.querySelectorAll('.memory-address');
memoryAddresses.forEach((addr, index) => {
setTimeout(() => {
addr.classList.add('animate-data');
setTimeout(() => {
addr.classList.remove('animate-data');
}, 1000);
}, index * 200);
});
}
function demonstrateString() {
const stringChars = document.querySelectorAll('.char-box');
stringChars.forEach((char, index) => {
setTimeout(() => {
char.style.transform = 'scale(1.2)';
char.style.backgroundColor = index < 5 ? 'rgba(129, 199, 132, 0.5)' : 'rgba(244, 143, 177, 0.5)';
setTimeout(() => {
char.style.transform = 'scale(1)';
char.style.backgroundColor = index < 5 ? 'rgba(129, 199, 132, 0.2)' : 'rgba(244, 143, 177, 0.2)';
}, 500);
}, index * 200);
});
}
// Auto-animate on page load
window.addEventListener('load', () => {
setTimeout(animateMemory, 1000);
});
// Interactive hover effects
document.querySelectorAll('.tree-node').forEach(node => {
node.addEventListener('click', () => {
node.style.transform = 'scale(1.1)';
setTimeout(() => {
node.style.transform = 'scale(1)';
}, 200);
});
});
</script>
</body>
</html>