commit b26113b586be3aadd22c201624d7306cdf3757d3 · dunkirk.sh/aoc-2025

+178 -15

vis/08/generate.ts

···

       10
        
       		return { x, y, z };

     

       11
        
       	});

     

       12
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       13
        
       const inputData = JSON.stringify(junctions);

     

       0
        
       
     

       14
        
       

     

       15
        
       const html = `<!DOCTYPE html>

     

       16
        
       <html lang="en">

     
···

       198
        
       				<div class="control-row">

     

       199
        
       					<label for="speed">Speed:</label>

     

       200
        
       					<input type="range" id="speed" min="0" max="1000" value="900" step="5">

     

       201
       -
       					<span class="info" id="stepInfo">Step: 0 / 1000</span>

     

       202
        
       				</div>

     

       203
        
       				<div class="legend">

     

       204
        
       					<div class="legend-item"><div class="legend-box junction"></div> Isolated Junction (small)</div>

     
···

       208
        
       			</div>

     

       209
        
       

     

       210
        
       			<div class="stats">

     

       211
       -
       				<div id="statsInfo">Circuits: ${junctions.length} | Largest: 0 | Product: 0</div>

     

       212
        
       				<div style="margin-top: 5px; font-size: 11px;"><a href="../index.html">[Return to Index]</a></div>

     

       213
        
       			</div>

     

       214
        
       		</div>

     
···

       296
        
       				}

     

       297
        
       				return Array.from(circuits.values()).sort((a, b) => b - a);

     

       298
        
       			}

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       299
        
       		}

     

       300
        
       

     

       301
       -
       		// Build animation stages (connections to make)

     

       302
        
       		const stages = [];

     

       303
        
       		const uf = new UnionFind(junctions.length);

     

       304
        
       		const connections = [];

     

       0
        
       
     

       0
        
       
     

       305
        
       

     

       306
       -
       		for (let step = 0; step <= 1000; step++) {

     

       0
        
       
     

       307
        
       			const circuitSizes = uf.getCircuitSizes();

     

       308
        
       			const top3 = circuitSizes.slice(0, 3);

     

       309
        
       			const product = top3.length >= 3 ? top3[0] * top3[1] * top3[2] : 0;

     

       0
        
       
     

       310
        
       			

     

       311
        
       			stages.push({

     

       312
        
       				connections: [...connections],

     

       313
       -
       				circuits: circuitSizes.length,

     

       314
        
       				largest: circuitSizes[0] || 1,

     

       315
        
       				product,

     

       316
       -
       				circuitSizes: [...circuitSizes]

     

       0
        
       
     

       317
        
       			});

     

       318
        
       

     

       319
       -
       			if (step < 1000) {

     

       320
       -
       				const pair = pairs[step];

     

       321
       -
       				uf.union(pair.i, pair.j);

     

       322
       -
       				connections.push(pair);

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       323
        
       			}

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       324
        
       		}

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       325
        
       

     

       326
        
       		// Three.js setup

     

       327
        
       		const scene = new THREE.Scene();

     
···

       382
        
       			return mesh;

     

       383
        
       		});

     

       384
        
       

     

       385
       -
       		// Connection lines - pre-render all cylinders

     

       386
        
       		let connectionCylinders = [];

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       387
        
       		

     

       388
        
       		// Pre-create all connection cylinders

     

       389
       -
       		console.log('Pre-rendering', pairs.slice(0, 1000).length, 'connections...');

     

       390
       -
       		pairs.slice(0, 1000).forEach((pair, idx) => {

     

       391
        
       			const j1 = junctions[pair.i];

     

       392
        
       			const j2 = junctions[pair.j];

     

       393
        
       			

     
···

       533
        
       

     

       534
        
       		function updateUI() {

     

       535
        
       			const stage = stages[currentStage];

     

       536
       -
       			stepInfo.textContent = \`Step: \${currentStage} / 1000\`;

     

       537
       -
       			statsInfo.textContent = \`Circuits: \${stage.circuits} | Largest: \${stage.largest} | Product: \${stage.product.toLocaleString()}\`;

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       538
        
       			

     

       539
        
       			prevBtn.disabled = currentStage === 0;

     

       540
        
       			nextBtn.disabled = currentStage === stages.length - 1;

···

       10
        
       		return { x, y, z };

     

       11
        
       	});

     

       12
        
       

     

       13
       +
       // Calculate all pairwise distances

     

       14
       +
       function distance(a, b) {

     

       15
       +
       	return Math.sqrt((a.x - b.x) ** 2 + (a.y - b.y) ** 2 + (a.z - b.z) ** 2);

     

       16
       +
       }

     

       17
       +
       

     

       18
       +
       const pairs = [];

     

       19
       +
       for (let i = 0; i < junctions.length; i++) {

     

       20
       +
       	for (let j = i + 1; j < junctions.length; j++) {

     

       21
       +
       		pairs.push({

     

       22
       +
       			i,

     

       23
       +
       			j,

     

       24
       +
       			distance: distance(junctions[i], junctions[j]),

     

       25
       +
       		});

     

       26
       +
       	}

     

       27
       +
       }

     

       28
       +
       

     

       29
       +
       // Sort by distance

     

       30
       +
       pairs.sort((a, b) => a.distance - b.distance);

     

       31
       +
       

     

       32
       +
       // Union-Find for circuit tracking

     

       33
       +
       class UnionFind {

     

       34
       +
       	constructor(n) {

     

       35
       +
       		this.parent = Array.from({ length: n }, (_, i) => i);

     

       36
       +
       		this.size = Array(n).fill(1);

     

       37
       +
       	}

     

       38
       +
       

     

       39
       +
       	find(x) {

     

       40
       +
       		if (this.parent[x] !== x) {

     

       41
       +
       			this.parent[x] = this.find(this.parent[x]);

     

       42
       +
       		}

     

       43
       +
       		return this.parent[x];

     

       44
       +
       	}

     

       45
       +
       

     

       46
       +
       	union(x, y) {

     

       47
       +
       		const rootX = this.find(x);

     

       48
       +
       		const rootY = this.find(y);

     

       49
       +
       

     

       50
       +
       		if (rootX === rootY) return false;

     

       51
       +
       

     

       52
       +
       		if (this.size[rootX] < this.size[rootY]) {

     

       53
       +
       			this.parent[rootX] = rootY;

     

       54
       +
       			this.size[rootY] += this.size[rootX];

     

       55
       +
       		} else {

     

       56
       +
       			this.parent[rootY] = rootX;

     

       57
       +
       			this.size[rootX] += this.size[rootY];

     

       58
       +
       		}

     

       59
       +
       

     

       60
       +
       		return true;

     

       61
       +
       	}

     

       62
       +
       

     

       63
       +
       	getCircuitSizes() {

     

       64
       +
       		const circuits = new Map();

     

       65
       +
       		for (let i = 0; i < this.parent.length; i++) {

     

       66
       +
       			const root = this.find(i);

     

       67
       +
       			circuits.set(root, this.size[root]);

     

       68
       +
       		}

     

       69
       +
       		return Array.from(circuits.values()).sort((a, b) => b - a);

     

       70
       +
       	}

     

       71
       +
       

     

       72
       +
       	getCircuitCount() {

     

       73
       +
       		const roots = new Set();

     

       74
       +
       		for (let i = 0; i < this.parent.length; i++) {

     

       75
       +
       			roots.add(this.find(i));

     

       76
       +
       		}

     

       77
       +
       		return roots.size;

     

       78
       +
       	}

     

       79
       +
       }

     

       80
       +
       

     

       81
       +
       // Build animation stages for Part 1 (first 1000 connections) and Part 2 (until single circuit)

     

       82
       +
       const stages = [];

     

       83
       +
       const uf = new UnionFind(junctions.length);

     

       84
       +
       const connections = [];

     

       85
       +
       let part2ConnectionIndex = -1;

     

       86
       +
       let part2Product = 0;

     

       87
       +
       

     

       88
       +
       let step = 0;

     

       89
       +
       while (true) {

     

       90
       +
       	const circuitSizes = uf.getCircuitSizes();

     

       91
       +
       	const top3 = circuitSizes.slice(0, 3);

     

       92
       +
       	const product = top3.length >= 3 ? top3[0] * top3[1] * top3[2] : 0;

     

       93
       +
       	const circuitCount = uf.getCircuitCount();

     

       94
       +
       

     

       95
       +
       	stages.push({

     

       96
       +
       		connections: [...connections],

     

       97
       +
       		circuits: circuitCount,

     

       98
       +
       		largest: circuitSizes[0] || 1,

     

       99
       +
       		product,

     

       100
       +
       		circuitSizes: [...circuitSizes],

     

       101
       +
       		part2Product: part2Product,

     

       102
       +
       	});

     

       103
       +
       

     

       104
       +
       	// Check if we've reached a single circuit (Part 2 complete)

     

       105
       +
       	if (circuitCount === 1 && part2ConnectionIndex === -1) {

     

       106
       +
       		part2ConnectionIndex = step - 1; // The previous connection completed it

     

       107
       +
       		if (part2ConnectionIndex >= 0) {

     

       108
       +
       			const lastPair = pairs[part2ConnectionIndex];

     

       109
       +
       			part2Product = junctions[lastPair.i].x * junctions[lastPair.j].x;

     

       110
       +
       		}

     

       111
       +
       		// Update the current stage with the part2Product

     

       112
       +
       		stages[stages.length - 1].part2Product = part2Product;

     

       113
       +
       	}

     

       114
       +
       

     

       115
       +
       	// Stop after reaching single circuit, or if we've exhausted pairs

     

       116
       +
       	if (circuitCount === 1 || step >= pairs.length) {

     

       117
       +
       		break;

     

       118
       +
       	}

     

       119
       +
       

     

       120
       +
       	const pair = pairs[step];

     

       121
       +
       	uf.union(pair.i, pair.j);

     

       122
       +
       	connections.push(pair);

     

       123
       +
       	step++;

     

       124
       +
       }

     

       125
       +
       

     

       126
       +
       console.log(

     

       127
       +
       	"Part 1: After 1000 connections, product =",

     

       128
       +
       	stages[Math.min(1000, stages.length - 1)].product,

     

       129
       +
       );

     

       130
       +
       console.log(

     

       131
       +
       	"Part 2: Single circuit at connection",

     

       132
       +
       	part2ConnectionIndex,

     

       133
       +
       	", product =",

     

       134
       +
       	part2Product,

     

       135
       +
       );

     

       136
       +
       

     

       137
        
       const inputData = JSON.stringify(junctions);

     

       138
       +
       const maxConnections = stages[stages.length - 1].connections.length;

     

       139
        
       

     

       140
        
       const html = `<!DOCTYPE html>

     

       141
        
       <html lang="en">

     
···

       323
        
       				<div class="control-row">

     

       324
        
       					<label for="speed">Speed:</label>

     

       325
        
       					<input type="range" id="speed" min="0" max="1000" value="900" step="5">

     

       326
       +
       					<span class="info" id="stepInfo">Step: 0 / ${stages.length - 1}</span>

     

       327
        
       				</div>

     

       328
        
       				<div class="legend">

     

       329
        
       					<div class="legend-item"><div class="legend-box junction"></div> Isolated Junction (small)</div>

     
···

       333
        
       			</div>

     

       334
        
       

     

       335
        
       			<div class="stats">

     

       336
       +
       				<div id="statsInfo">Circuits: ${junctions.length} | Largest: 0 | Part 1: 0 | Part 2: 0</div>

     

       337
        
       				<div style="margin-top: 5px; font-size: 11px;"><a href="../index.html">[Return to Index]</a></div>

     

       338
        
       			</div>

     

       339
        
       		</div>

     
···

       421
        
       				}

     

       422
        
       				return Array.from(circuits.values()).sort((a, b) => b - a);

     

       423
        
       			}

     

       424
       +
       

     

       425
       +
       			getCircuitCount() {

     

       426
       +
       				const roots = new Set();

     

       427
       +
       				for (let i = 0; i < this.parent.length; i++) {

     

       428
       +
       					roots.add(this.find(i));

     

       429
       +
       				}

     

       430
       +
       				return roots.size;

     

       431
       +
       			}

     

       432
        
       		}

     

       433
        
       

     

       434
       +
       		// Build animation stages for Part 1 (first 1000 connections) and Part 2 (until single circuit)

     

       435
        
       		const stages = [];

     

       436
        
       		const uf = new UnionFind(junctions.length);

     

       437
        
       		const connections = [];

     

       438
       +
       		let part2ConnectionIndex = -1;

     

       439
       +
       		let part2Product = 0;

     

       440
        
       

     

       441
       +
       		let step = 0;

     

       442
       +
       		while (true) {

     

       443
        
       			const circuitSizes = uf.getCircuitSizes();

     

       444
        
       			const top3 = circuitSizes.slice(0, 3);

     

       445
        
       			const product = top3.length >= 3 ? top3[0] * top3[1] * top3[2] : 0;

     

       446
       +
       			const circuitCount = uf.getCircuitCount();

     

       447
        
       			

     

       448
        
       			stages.push({

     

       449
        
       				connections: [...connections],

     

       450
       +
       				circuits: circuitCount,

     

       451
        
       				largest: circuitSizes[0] || 1,

     

       452
        
       				product,

     

       453
       +
       				circuitSizes: [...circuitSizes],

     

       454
       +
       				part2Product: part2Product

     

       455
        
       			});

     

       456
        
       

     

       457
       +
       			// Check if we've reached a single circuit (Part 2 complete)

     

       458
       +
       			if (circuitCount === 1 && part2ConnectionIndex === -1) {

     

       459
       +
       				part2ConnectionIndex = step - 1; // The previous connection completed it

     

       460
       +
       				if (part2ConnectionIndex >= 0) {

     

       461
       +
       					const lastPair = pairs[part2ConnectionIndex];

     

       462
       +
       					part2Product = junctions[lastPair.i].x * junctions[lastPair.j].x;

     

       463
       +
       				}

     

       464
       +
       				// Update the current stage with the part2Product

     

       465
       +
       				stages[stages.length - 1].part2Product = part2Product;

     

       466
       +
       			}

     

       467
       +
       

     

       468
       +
       			// Stop after reaching single circuit, or if we've exhausted pairs

     

       469
       +
       			if (circuitCount === 1 || step >= pairs.length) {

     

       470
       +
       				break;

     

       471
        
       			}

     

       472
       +
       

     

       473
       +
       			const pair = pairs[step];

     

       474
       +
       			uf.union(pair.i, pair.j);

     

       475
       +
       			connections.push(pair);

     

       476
       +
       			step++;

     

       477
        
       		}

     

       478
       +
       

     

       479
       +
       		console.log('Part 1: After 1000 connections, product =', stages[Math.min(1000, stages.length - 1)].product);

     

       480
       +
       		console.log('Part 2: Single circuit at connection', part2ConnectionIndex, ', product =', part2Product);

     

       481
        
       

     

       482
        
       		// Three.js setup

     

       483
        
       		const scene = new THREE.Scene();

     
···

       538
        
       			return mesh;

     

       539
        
       		});

     

       540
        
       

     

       541
       +
       		// Connection lines - pre-render all cylinders (enough to reach single circuit)

     

       542
        
       		let connectionCylinders = [];

     

       543
       +
       		

     

       544
       +
       		// Determine how many connections we need (until single circuit)

     

       545
       +
       		const maxConnections = Math.min(pairs.length, stages[stages.length - 1].connections.length);

     

       546
        
       		

     

       547
        
       		// Pre-create all connection cylinders

     

       548
       +
       		console.log('Pre-rendering', maxConnections, 'connections...');

     

       549
       +
       		pairs.slice(0, maxConnections).forEach((pair, idx) => {

     

       550
        
       			const j1 = junctions[pair.i];

     

       551
        
       			const j2 = junctions[pair.j];

     

       552
        
       			

     
···

       692
        
       

     

       693
        
       		function updateUI() {

     

       694
        
       			const stage = stages[currentStage];

     

       695
       +
       			stepInfo.textContent = \`Step: \${currentStage} / \${stages.length - 1}\`;

     

       696
       +
       			

     

       697
       +
       			const part1Result = stages[Math.min(1000, stages.length - 1)].product;

     

       698
       +
       			const part2Result = stage.part2Product || 0;

     

       699
       +
       			

     

       700
       +
       			statsInfo.textContent = \`Circuits: \${stage.circuits} | Largest: \${stage.largest} | Part 1: \${part1Result.toLocaleString()} | Part 2: \${part2Result.toLocaleString()}\`;

     

       701
        
       			

     

       702
        
       			prevBtn.disabled = currentStage === 0;

     

       703
        
       			nextBtn.disabled = currentStage === stages.length - 1;

+53 -15

vis/08/index.html

···

       184
        
       				<div class="control-row">

     

       185
        
       					<label for="speed">Speed:</label>

     

       186
        
       					<input type="range" id="speed" min="0" max="1000" value="900" step="5">

     

       187
       -
       					<span class="info" id="stepInfo">Step: 0 / 1000</span>

     

       188
        
       				</div>

     

       189
        
       				<div class="legend">

     

       190
        
       					<div class="legend-item"><div class="legend-box junction"></div> Isolated Junction (small)</div>

     
···

       194
        
       			</div>

     

       195
        
       

     

       196
        
       			<div class="stats">

     

       197
       -
       				<div id="statsInfo">Circuits: 1000 | Largest: 0 | Product: 0</div>

     

       198
        
       				<div style="margin-top: 5px; font-size: 11px;"><a href="../index.html">[Return to Index]</a></div>

     

       199
        
       			</div>

     

       200
        
       		</div>

     
···

       282
        
       				}

     

       283
        
       				return Array.from(circuits.values()).sort((a, b) => b - a);

     

       284
        
       			}

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       285
        
       		}

     

       286
        
       

     

       287
       -
       		// Build animation stages (connections to make)

     

       288
        
       		const stages = [];

     

       289
        
       		const uf = new UnionFind(junctions.length);

     

       290
        
       		const connections = [];

     

       0
        
       
     

       0
        
       
     

       291
        
       

     

       292
       -
       		for (let step = 0; step <= 1000; step++) {

     

       0
        
       
     

       293
        
       			const circuitSizes = uf.getCircuitSizes();

     

       294
        
       			const top3 = circuitSizes.slice(0, 3);

     

       295
        
       			const product = top3.length >= 3 ? top3[0] * top3[1] * top3[2] : 0;

     

       0
        
       
     

       296
        
       			

     

       297
        
       			stages.push({

     

       298
        
       				connections: [...connections],

     

       299
       -
       				circuits: circuitSizes.length,

     

       300
        
       				largest: circuitSizes[0] || 1,

     

       301
        
       				product,

     

       302
       -
       				circuitSizes: [...circuitSizes]

     

       0
        
       
     

       303
        
       			});

     

       304
        
       

     

       305
       -
       			if (step < 1000) {

     

       306
       -
       				const pair = pairs[step];

     

       307
       -
       				uf.union(pair.i, pair.j);

     

       308
       -
       				connections.push(pair);

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       309
        
       			}

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       310
        
       		}

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       311
        
       

     

       312
        
       		// Three.js setup

     

       313
        
       		const scene = new THREE.Scene();

     
···

       368
        
       			return mesh;

     

       369
        
       		});

     

       370
        
       

     

       371
       -
       		// Connection lines - pre-render all cylinders

     

       372
        
       		let connectionCylinders = [];

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       373
        
       		

     

       374
        
       		// Pre-create all connection cylinders

     

       375
       -
       		console.log('Pre-rendering', pairs.slice(0, 1000).length, 'connections...');

     

       376
       -
       		pairs.slice(0, 1000).forEach((pair, idx) => {

     

       377
        
       			const j1 = junctions[pair.i];

     

       378
        
       			const j2 = junctions[pair.j];

     

       379
        
       			

     
···

       519
        
       

     

       520
        
       		function updateUI() {

     

       521
        
       			const stage = stages[currentStage];

     

       522
       -
       			stepInfo.textContent = `Step: ${currentStage} / 1000`;

     

       523
       -
       			statsInfo.textContent = `Circuits: ${stage.circuits} | Largest: ${stage.largest} | Product: ${stage.product.toLocaleString()}`;

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       524
        
       			

     

       525
        
       			prevBtn.disabled = currentStage === 0;

     

       526
        
       			nextBtn.disabled = currentStage === stages.length - 1;

···

       184
        
       				<div class="control-row">

     

       185
        
       					<label for="speed">Speed:</label>

     

       186
        
       					<input type="range" id="speed" min="0" max="1000" value="900" step="5">

     

       187
       +
       					<span class="info" id="stepInfo">Step: 0 / 7845</span>

     

       188
        
       				</div>

     

       189
        
       				<div class="legend">

     

       190
        
       					<div class="legend-item"><div class="legend-box junction"></div> Isolated Junction (small)</div>

     
···

       194
        
       			</div>

     

       195
        
       

     

       196
        
       			<div class="stats">

     

       197
       +
       				<div id="statsInfo">Circuits: 1000 | Largest: 0 | Part 1: 0 | Part 2: 0</div>

     

       198
        
       				<div style="margin-top: 5px; font-size: 11px;"><a href="../index.html">[Return to Index]</a></div>

     

       199
        
       			</div>

     

       200
        
       		</div>

     
···

       282
        
       				}

     

       283
        
       				return Array.from(circuits.values()).sort((a, b) => b - a);

     

       284
        
       			}

     

       285
       +
       

     

       286
       +
       			getCircuitCount() {

     

       287
       +
       				const roots = new Set();

     

       288
       +
       				for (let i = 0; i < this.parent.length; i++) {

     

       289
       +
       					roots.add(this.find(i));

     

       290
       +
       				}

     

       291
       +
       				return roots.size;

     

       292
       +
       			}

     

       293
        
       		}

     

       294
        
       

     

       295
       +
       		// Build animation stages for Part 1 (first 1000 connections) and Part 2 (until single circuit)

     

       296
        
       		const stages = [];

     

       297
        
       		const uf = new UnionFind(junctions.length);

     

       298
        
       		const connections = [];

     

       299
       +
       		let part2ConnectionIndex = -1;

     

       300
       +
       		let part2Product = 0;

     

       301
        
       

     

       302
       +
       		let step = 0;

     

       303
       +
       		while (true) {

     

       304
        
       			const circuitSizes = uf.getCircuitSizes();

     

       305
        
       			const top3 = circuitSizes.slice(0, 3);

     

       306
        
       			const product = top3.length >= 3 ? top3[0] * top3[1] * top3[2] : 0;

     

       307
       +
       			const circuitCount = uf.getCircuitCount();

     

       308
        
       			

     

       309
        
       			stages.push({

     

       310
        
       				connections: [...connections],

     

       311
       +
       				circuits: circuitCount,

     

       312
        
       				largest: circuitSizes[0] || 1,

     

       313
        
       				product,

     

       314
       +
       				circuitSizes: [...circuitSizes],

     

       315
       +
       				part2Product: part2Product

     

       316
        
       			});

     

       317
        
       

     

       318
       +
       			// Check if we've reached a single circuit (Part 2 complete)

     

       319
       +
       			if (circuitCount === 1 && part2ConnectionIndex === -1) {

     

       320
       +
       				part2ConnectionIndex = step - 1; // The previous connection completed it

     

       321
       +
       				if (part2ConnectionIndex >= 0) {

     

       322
       +
       					const lastPair = pairs[part2ConnectionIndex];

     

       323
       +
       					part2Product = junctions[lastPair.i].x * junctions[lastPair.j].x;

     

       324
       +
       				}

     

       325
       +
       				// Update the current stage with the part2Product

     

       326
       +
       				stages[stages.length - 1].part2Product = part2Product;

     

       327
       +
       			}

     

       328
       +
       

     

       329
       +
       			// Stop after reaching single circuit, or if we've exhausted pairs

     

       330
       +
       			if (circuitCount === 1 || step >= pairs.length) {

     

       331
       +
       				break;

     

       332
        
       			}

     

       333
       +
       

     

       334
       +
       			const pair = pairs[step];

     

       335
       +
       			uf.union(pair.i, pair.j);

     

       336
       +
       			connections.push(pair);

     

       337
       +
       			step++;

     

       338
        
       		}

     

       339
       +
       

     

       340
       +
       		console.log('Part 1: After 1000 connections, product =', stages[Math.min(1000, stages.length - 1)].product);

     

       341
       +
       		console.log('Part 2: Single circuit at connection', part2ConnectionIndex, ', product =', part2Product);

     

       342
        
       

     

       343
        
       		// Three.js setup

     

       344
        
       		const scene = new THREE.Scene();

     
···

       399
        
       			return mesh;

     

       400
        
       		});

     

       401
        
       

     

       402
       +
       		// Connection lines - pre-render all cylinders (enough to reach single circuit)

     

       403
        
       		let connectionCylinders = [];

     

       404
       +
       		

     

       405
       +
       		// Determine how many connections we need (until single circuit)

     

       406
       +
       		const maxConnections = Math.min(pairs.length, stages[stages.length - 1].connections.length);

     

       407
        
       		

     

       408
        
       		// Pre-create all connection cylinders

     

       409
       +
       		console.log('Pre-rendering', maxConnections, 'connections...');

     

       410
       +
       		pairs.slice(0, maxConnections).forEach((pair, idx) => {

     

       411
        
       			const j1 = junctions[pair.i];

     

       412
        
       			const j2 = junctions[pair.j];

     

       413
        
       			

     
···

       553
        
       

     

       554
        
       		function updateUI() {

     

       555
        
       			const stage = stages[currentStage];

     

       556
       +
       			stepInfo.textContent = `Step: ${currentStage} / ${stages.length - 1}`;

     

       557
       +
       			

     

       558
       +
       			const part1Result = stages[Math.min(1000, stages.length - 1)].product;

     

       559
       +
       			const part2Result = stage.part2Product || 0;

     

       560
       +
       			

     

       561
       +
       			statsInfo.textContent = `Circuits: ${stage.circuits} | Largest: ${stage.largest} | Part 1: ${part1Result.toLocaleString()} | Part 2: ${part2Result.toLocaleString()}`;

     

       562
        
       			

     

       563
        
       			prevBtn.disabled = currentStage === 0;

     

       564
        
       			nextBtn.disabled = currentStage === stages.length - 1;