qwen3-coder:30b

Keep your feline friend hydrated with this durable stainless steel cat water fountain. The circulating system draws fresh, clean water into an inviting basin, encouraging natural drinking habits. Its hygienic metal construction resists build-up and is simple to maintain. This sleek dispenser promotes better hydration for cats of all sizes. Give your pet the gift of proper care—order yours today.

{"name": "AquaPur X2 Trinkbrunnen", "brand": "PetFlow", "price_eur": 29.99, "weight_g": 800, "features": ["Dreifach-Filter", "extrem leises 2-Watt-Pumpsystem", "spuelmaschinenfestem Edelstahlaufsatz"], "in_stock": false}

[{"id":1,"sentiment":"positive"},{"id":2,"sentiment":"negative"},{"id":3,"sentiment":"neutral"},{"id":4,"sentiment":"negative"},{"id":5,"sentiment":"positive"},{"id":6,"sentiment":"neutral"},{"id":7,"sentiment":"neutral"},{"id":8,"sentiment":"negative"},{"id":9,"sentiment":"positive"},{"id":10,"sentiment":"neutral"}]

That’s an old chestnut—life punishes those who come too late. We pulled the whole thing out of a terrible mess, but now we mustn’t skip steps or act rashly.
---
Der Wert zeigt sich erst bei der Anwendung: Unser knapper Etat zwang uns, Kompromisse einzugehen, doch der Start verlief trotzdem reibungslos.

1. ^\d{4}-(0[1-9]|1[0-2])-(0[1-9]|[1]\d|2[0-9])$
2. SELECT customer_id, SUM(amount) FROM orders GROUP BY customer_id ORDER BY 2 DESC LIMIT 5;
3. .items[].id
4. nav a[href^="http"]
5. awk '{print $1}' access.log | sort -u | wc -l

1. Canberra
2. 1989
3. W
4. I'm a teapot
5. Franz Kafka
6. Saturn
7. 101010
8. 443
9. Linus Torvalds
10. 97

1. Fresh water flow for happy cats. Stay hydrated now.
2. Smell the comfort. Baked fresh daily for you.
3. Compare all AI models, unbiased choice guaranteed.
4. Block out noise. Immerse yourself in pure sound.
5. One simple vault for every password. Secure your digital life.

1. Photorealistic hero shot of a high-end ergonomic gaming chair in a moody, neon-drenched streaming room. Depth of field, bokeh background lighting, cinematic atmosphere.
2. Close-up product photograph of an artisanal gin bottle resting on a richly textured bar top. Moody evening light, soft rim lighting, condensation details.
3. Hyperrealistic street photography of an e-scooter leaning against vivid graffiti wall in the early morning. Bright natural light, sharp focus, urban grit aesthetic.

1. HydroFlow—Stay hydrated, effortlessly every day.
2. AquaGlow—Your smart guide to perfect hydration levels.
3. SipSync—Gentle reminders for optimum health balance.
4. QuenchMate—Never forget a drink again.
5. ClarityBottle—Drink smarter, live better, feel amazing.

```html
<style>
/* Keyframes for the rotation */
@keyframes spin {
  to { transform: rotate(360deg); }
}

/* Spinner structure and appearance */
.spinner {
  width: 60px;
  height: 60px;
  border: 5px solid rgba(255, 255, 255, 0.3); /* Light background ring */
  border-radius: 50%; /* Perfect circle shape */
  border-top-color: #007bff; /* Accent color for the moving part */
  animation: spin 1s linear infinite; /* Apply animation */
}

/* Optional: Center the spinner on the page for demonstration */
body {
    display: flex;
    justify-content: center;
    align-items: center;
    height: 100vh;
    background-color: #222;
}
</style>

<div class="spinner"></div>
```

Ein Akku speichert Energie chemisch, ähnlich wie ein riesiger Vorrat an Muskelkraft, der gespeichert werden kann. Im Inneren reagieren dort Stoffe miteinander und erzeugen so einen „Drang“, dass etwas fließen will. Stell dir diese Ladung vor wie das Wasser in einem Rohr: Der Akku drückt die winzigen Energiepakete (Elektronen) geordnet durch Schaltungen. Dieser kontinuierliche Fluss von elektrischer Kraft ist es, der deinen Blitz oder dein Spielzeug zum Laufen bringt.

Sie ziehen aus der Kiste, die mit **„Gemischt“** beschriftet ist.

Ihr Stich entscheidet, da diese Kiste definitiv nicht gemischt sein kann. Angenommen, Sie ziehen einen Apfel; die Kiste enthält daher tatsächlich die Äpfel. Da nun das korrekte „Äpfel“-Inhaltvolumen identifiziert ist, muss jede andere Kiste ihr wahres Inventar aus den verbleibenden zwei Möglichkeiten nehmen. Die Kiste mit der Aufschrift „Äpfel“ kann nicht reine Äpfel enthalten und muss somit Birnen enthalten. Zusammenfassend gilt: Das Label „Gemisch“ enthält die echten Äpfel, das Label „Äpfel“ die echten Birnen, und das Label „Birnen“ das gemischtste Verhältnis von beidem.

1. Sehr geehrte Damen und Herren/Sehr geehrte/r Herr/Frau [Name], wir bitten um vielmals um Verständnis, dass wir den ursprünglich vereinbarten Liefertermin nicht halten können; wir melden uns umgehend mit einem überarbeiteten Zeitplan zurück.
2. Update: Der Deliverable-Termin wird durch Engpässe verpasst. Wir rechnen alternativ mit [neues Datum].
3. Sorry, das wird leider schwierig – wir schaffen den Termin nicht. Ich schick dir später einen neuen rough Plan.

1. VitaSip
2. 830 g
3. PureFlow
4. 19,51 EUR
5. 3

{"name": "Trinkflasche Pro", "price": 29.90, "tags": ["outdoor", "sport"], "stock": {"berlin": 12, "muenchen": 7, "hamburg": null}, "active": true}

```html
<!DOCTYPE html>
<html>
<head>
<title>Sorting Race</title>
<style>
body {display: flex; justify-content: center; background-color: #1e1e2f; font-family: sans-serif;}
#container {display: flex; gap: 20px; padding: 20px;}
.panel {flex: 1; border: 2px solid #4a386d; background-color: #25253e; }
h2 {color: #eeeeef; text-align: center; margin-top: 0;}
</style>
</head>
<body>

<div id="container">
    <div class="panel"><canvas id="bubbleCanvas" width="280" height="300"></canvas><h2>Bubble Sort</h2></div>
    <div class="panel"><canvas id="insertionCanvas" width="280" height="300"></canvas><h2>Insertion Sort</h2></div>
    <div class="panel"><canvas id="selectionCanvas" width="280" height="300"></canvas><h2>Selection Sort</h2></div>
</div>

<script>
const SIZE = 40;
let arrOriginal = [];

function shuffle(arr) {
    for (let i = arr.length - 1; i > 0; i--) {
        const j = Math.floor …

Excerpt — the full answer is on the round page.

```html
<!DOCTYPE html>
<html>
<head>
    <title>Hexagon Physics</title>
    <style>body {margin: 0; overflow: hidden;} canvas {display: block;}</style>
</head>
<body>
<canvas id="c"></canvas>
<script>
const c = document.getElementById(&#x27;c&#x27;);
const ctx = c.getContext(&#x27;2d&#x27;);

let W = window.innerWidth;
let H = window.innerHeight;
c.width = W;
c.height = H;

ctx.translate(W / 2, H / 2); // Center origin for easier rotation math

const N_BALLS = 8;
const G = 0.1;
const HEX_RADIUS = Math.min(W, H) * 0.45; 
const ROTATION_SPEED = 0.005;

let balls = [];
for (let i = 0; i < N_BALLS; i++) {
    balls.push({
        x: Math.random() * HEX_RADIUS * 0.8 + 10,
        y: Math.random() * HEX_RADIUS * 0.8 + 10,
        vx: (Math.random() - 0.5) * 3,
        vy: (Math.random() - 0.5) * 3,
        r: 12 + Math.floor(Math.random() * 6),
        mass: 1 + Math.random() * 3
    });
}

f …

Excerpt — the full answer is on the round page.

```html
<!DOCTYPE html>
<html>
<head>
<title>Traveling Pendulum Wave</title>
<style>body {margin:0;display:flex;justify-content:center;align-items:center;height:100vh;background:#222;}canvas {border:1px solid #333;}</style>
</head>
<body>
<canvas id="pendulumCanvas"></canvas>
<script>
const canvas = document.getElementById(&#x27;pendulumCanvas&#x27;);
const ctx = canvas.getContext(&#x27;2d&#x27;);

canvas.width = 800;
canvas.height = 400;

const N = 15; // Number of pendulums
const LOOP_LENGTH = 70;
const BOB_SIZE = 10;
const DAMPING = 0.999;

let startTime = performance.now();

function animate(timestamp) {
    ctx.clearRect(0, 0, canvas.width, canvas.height);

    const elapsed = (timestamp - startTime) / 1000;

    for (let i = 0; i < N; i++) {
        let bobX, bobY;
        // Physics approximation for coupled oscillator wave: position modulated by index &#x27;i&#x27; and time &#x27 …

Excerpt — the full answer is on the round page.

```html
<!DOCTYPE html>
<html>
<head>
<title>Pathfinding Race</title>
<style>
body { display: flex; justify-content: space-around; padding: 20px; background: #111; color: white; font-family: sans-serif; }
.panel { text-align: center; width: 30%; }
canvas { border: 2px solid #444; display: block; margin: 10px auto; background: #000; }
h2 { color: #ccc; font-size: 1.2em; }
</style>
</head>
<body>
<div class="panel"><h2>Breadth First Search (BFS)</h2><canvas id="bfsCanvas" width="400" height="400"></canvas><p id="bfsStatus">Ready...</p></div>
<div class="panel"><h2>Depth First Search (DFS)</h2><canvas id="dfsCanvas" width="400" height="400"></canvas><p id="dfsStatus">Ready...</p></div>
<div class="panel"><h2>A* Search</h2><canvas id="aStarCanvas" width="400" height="400"></canvas><p id="aStarStatus">Ready...</p></div>

<script>
    const SIZE = 25;
    const CELL_SIZE = 16;
    const START …

Excerpt — the full answer is on the round page.

```html
<!DOCTYPE html>
<html>
<head>
<title>Sorting Race</title>
<style>body{display:flex;justify-content:space-around;align-items:center;height:100vh;background:#222;color:white}canvas{border:2px solid #AAA;width:30%;max-width:700px;}h2{text-align:center;margin-bottom:5px;}</style>
</head>
<body>
<canvas id="quicksort" width="700" height="400"></canvas>
<h2>Quicksort</h2>
<canvas id="mergesort" width="700" height="400"></canvas>
<h2>Mergesort</h2>
<canvas id="heapsort" width="700" height="400"></canvas>
<h2>Heapsort</h2>

<script>
const N = 60;
let A = Array.from({length:N}, (_, i) => Math.floor(Math.random() * 90) + 1);

// Utility function to draw the array state
function drawArray(canvasId, data, highlight = []) {
    const canvas = document.getElementById(canvasId);
    const ctx = canvas.getContext(&#x27;2d&#x27;);
    ctx.clearRect(0, 0, canvas.width, canvas.height);

    const b …

Excerpt — the full answer is on the round page.

<!DOCTYPE html>
<html><head><title></title></head><body><canvas id="c"></canvas><script>const canvas=document.getElementById(&#x27;c&#x27;);const ctx=canvas.getContext(&#x27;2d&#x27;);canvas.width=800;canvas.height=400;let v0=150;let g=9.8;let startX=50;let angles=[Math.PI * (20+i*23/5)/180 for i in 5];let balls=[];const n=5;for(let i=0;i<n;i++){balls.push({x:startX,y:400-20,vx:v0*Math.cos(angles[i]),vy:v0*Math.sin(angles[i]),history:[],isGrounded:false})}function update(){if(!balls.every(b=>b.isGrounded)){requestAnimationFrame(update)}else{balls.forEach((b,i)=>{b.x=startX;b.y=400-20;b.vx=v0*Math.cos(angles[i]);b.vy=v0*Math.sin(angles[i]);b.history=[]});}ctx.clearRect(0,0,800,400);balls.forEach((b,i)=>{let t=0;if (!b.isGrounded){t+=1/60;const x_new=startX+b.vx*t;const y_new=400-20-(Math.sin(angles[i])*b.vy*t - 0.5*g*t*t);b.x=x_new;b.y=y_new;b.history.push({x:b.x,y:b.y});}else{/*Draw land …

Excerpt — the full answer is on the round page.

<!DOCTYPE html>
<html>
<head><title>Double Pendulum Chaos</title></head>
<body style="margin:0;"><canvas id="c" width="800" height="600" style="background:#000;"></canvas><script>
const canvas=document.getElementById(&#x27;c&#x27;);
const ctx=canvas.getContext(&#x27;2d&#x27;);

const L1=150,L2=150,G=9.81;
const STEPS=6000;
let historyA=[],historyB=[];
let alpha1=Math.PI/2,omega1=0,alpha2=Math.PI/2,omega2=0; // Initial state A
let beta1=Math.PI/2+0.001,beta2=Math.PI/2+0.001;       // Tiny difference for B
let gamma1=0,gamma2=0; // State variables for pendulums A and B

function solve(A,B){
    const t=STEPS*0.005;
    for(let i=0;i<STEPS;i++){
        // Pendulum A (alpha*)
        let d_cos = Math.cos(A[0]-A[2]);
        let d_sin = Math.sin(A[0]-A[2]);
        let num1=-(G*(2*Math.cos(A[0])) + G*(2*Math.cos(A[0]-A[2]))) * L1;
        let num2= -L2 * Math.sin(A[0]-A[2]) * (omega2*omega2 …

Excerpt — the full answer is on the round page.

```html
<!DOCTYPE html>
<html>
<head>
<title>Particle Fountain Simulation</title>
<style>
body { margin: 0; display: flex; justify-content: center; align-items: flex-end; height: 100vh; background-color: #1a1a1a; }
canvas { border: 1px solid #333; background-color: #000; }
#controls { position: absolute; bottom: 5%; width: 90%; text-align: center; padding: 10px; background-color: rgba(0,0,0,0.7); color: white; z-index: 10; }
</style>
</head>
<body>

<canvas id="particleCanvas"></canvas>
<div id="controls">Wind Strength: <input type="range" id="windSlider" min="-0.5" max="0.5" step="0.01" value="0"></div>

<script>
const canvas = document.getElementById(&#x27;particleCanvas&#x27;);
const ctx = canvas.getContext(&#x27;2d&#x27;);
let W, H;

canvas.width = window.innerWidth * 0.8 > 600 ? window.innerWidth * 0.8 : 600;
canvas.height = window.innerHeight * 0.7 > 400 ? window.innerHeight * 0.7 …

Excerpt — the full answer is on the round page.

```html
<!DOCTYPE html>
<html><body><canvas id="c"></canvas><script>const c=document.getElementById(&#x27;c&#x27;);c.width=800;c.height=600;const ctx=c.getContext(&#x27;2d&#x27;);let bodies=[{id:0,px:{x:-1,y,-1},py:{x:-1,y,-1},vx:{x:0,y:0},vy:{x:0,y:0},mass:597200,radius:8,color=&#x27;#ffcc00&#x27;,trail:{}},{id:1,px:{x:150,y:0},py:{x:150,y:0},vx:{x:-0.5,y:0.6},vy:{x:0,y:-0.04},mass:3.1e-3,radius:10,color=&#x27;#00bfff&#x27;,trail:{}},{id:2,px:{x:{}-250,y:0},py:{x:-250,y:0},vx:{x:0.8,y:0},vy:{x:0.04,y:0.2},mass:1e-3,radius:7,color=&#x27;#ff69b4&#x27;,trail:{}},{id:3,px:{x:-5,y:0},py:{x:-5,y:0},vx:{x:0,y:0},vy:{x:0,y:0},mass:1e-5,radius:2,color=&#x27;#99ccff&#x27;,trail:{}}];const G=1;const dt=0.1;function update(bodies) {let accs=[{x:0,y:0},{x:0,y:0},{x:0,y:0},{x:0,y:0}];for(let i=1;i<bodies.length;i++)({const p_i=bodies[i].px;const m_i=bodies[i].mass;accs[i]={x:0,y:0};}for(let i=1;i<bod …

Excerpt — the full answer is on the round page.

```html
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Spring Mass Chain Simulation</title>
    <style>
        body { margin: 0; display: flex; justify-content: center; align-items: center; min-height: 100vh; background-color: #222; }
        canvas { border: 1px solid #444; background-color: #000; cursor: crosshair; }
    </style>
</head>
<body>
    <canvas id="chainCanvas" width="800" height="300"></canvas>
    <script>
        const canvas = document.getElementById(&#x27;chainCanvas&#x27;);
        const ctx = canvas.getContext(&#x27;2d&#x27;);

        const NUM_MASSES = 12;
        const INITIAL_LENGTH = 50; // Space between adjacent masses
        let g = { k: 0.1, d: 0.9 }; // Spring stiffness and damping factor
        
        // Mass object structure { x, y, vX, vY }
        let masses = [];
        for (let i = 0; i < NUM_MASSES; i++) { …

Excerpt — the full answer is on the round page.

Der Ball kostet **0,05 Euro**.

Man kann dies durch ein Gleichungssystem lösen: Wenn der Schläger 1,00 Euro teurer ist als der Ball, addiert man diese Differenz von 1,00 Euro zu den Gesamtkosten (1,10 €), was 2,10 Euro ergibt. Durch die Division von 2,10 € durch zwei Teile (Ball und Schläger) erhält man 1,05 € für den Schläger und somit 0,05 Euro für den Ball.

Die Farben der Häuser von Position 1 bis 4 sind:

* **Position 1:** Grün
* **Position 2:** Rot
* **Position 3:** Blau
* **Position 4:** Gelb

***

### Begründung:

1. **Festlegung von Position 1 (Fakt 2):**
   Das grüne Haus steht an Position 1. Die Reihenfolge beginnt also mit: [Grün, ?, ?, ?].

2. **Bilden der Kette (Fakten 1 und 3):**
   * Fakt 1 besagt: Rot $\to$ Blau (R ist links von B).
   * Fakt 3 besagt: Blau $\to$ Gelb (Y ist rechts von B).
   Diese beiden Fakten bilden eine zusammenhängende Kette von drei Häusern: **Rot $\to$ Blau $\to$ Gelb**.

3. **Platzierung der Kette:**
   Da das grüne Haus bereits an Position 1 feststeht, muss die dreiteilige Kette (Rot, Blau, Gelb) die verbleibenden Plätze 2, 3 und 4 einnehmen.

**Endgültiges Ergebnis:**
* P1: Grün
* P2: Rot
* P3: Blau
* P4: Gelb

**1) 'to bite the bullet'**: Etwas Unangenehmes/Schwieriges mit Mut durchstehen müssen.
*Passende Entsprechung:* **Die bittere Pille schlucken.**

**2) 'the ball is in your court'**: Es ist nun an dir, etwas zu tun oder eine Entscheidung zu treffen.
*Passende Entsprechung:* **Der Ball liegt bei dir.** (Oder formeller: Die Entscheidung liegt bei Ihnen.)

**3) 'it's raining cats and dogs'**: Es regnet extrem stark/ein Platzregen fällt.
*Passende Entsprechung:* **Es gießt wie aus Eimern.**

1. Grün für dein Lächeln, gut fürs Erdreich.
2. Bambus statt Plastik. Ein einfacher Wechsel.
3. Pflege deine Zähne mit pflanzlichem Stil.

Um herauszufinden, wie viele Minuten ein normales Jahr (365 Tage) hat, müssen wir die Umrechnungen von Tagen über Stunden auf Minuten durchführen.

**Weg nachvollziehbar:**

1. **Tage in Stunden umrechnen:**
   Ein Tag hat 24 Stunden.
   $365 \text{ Tage} \times 24 \text{ Stunden/Tag} = 8760 \text{ Stunden}$

2. **Stunden in Minuten umrechnen:**
   Eine Stunde hat 60 Minuten.
   $8760 \text{ Stunden} \times 60 \text{ Minuten/Stunde} = 525.600 \text{ Minuten}$

**Endergebnis:**

525600

Die nächste Zahl ist **33**.

**Regel:** Die Differenz zwischen den aufeinanderfolgenden Zahlen verdoppelt sich bei jedem Schritt ($\text{+1, +2, +4, +8, und somit +16}$).

Bevor wir verschiffen, muss ich die Testergebnisse überprüfen und schließlich zwei Fehler beheben.

Hey [Name der Kollegin], kleine Info: Unser Meeting muss auf morgen um 10 Uhr verschoben werden! 😊

Genießen Sie Ihr Getränk stundenlang bei optimaler Temperatur. Diese hochwertige Edelstahl-Trinkflasche ist nicht nur robust, sondern auch komplett auslaufsicher und spülmaschinenfest. Ideal für Sport und unterwegs – hält zuverlässig lange!

function isPalindrome(s) {
  const cleaned = s.toLowerCase().replace(/[^a-z0-9]/g, '');

  let left = 0;
  let right = cleaned.length - 1;

  while (left < right) {
    if (cleaned[left] !== cleaned[right]) {
      return false;
    }
    left++;
    right--;
  }

  return true;
}

```json
{
  "name": "Anna Schmidt",
  "alter": 30,
  "stadt": "Freiburg",
  "hobbys": [
    "Lesen",
    "Radfahren"
  ],
  "newsletter_abonniert": true
}
```

9. Die neun Schafe, die nicht starben, sind noch am Leben.

5 Minuten.

Die Zeit ist konstant, da die Anzahl der verfügbaren Maschinen perfekt mit dem benötigten Output (Teilen) skaliert. Da alle Maschinen parallel arbeiten und immer genug Ressourcen vorhanden sind, um jede Einheit sofort zu bearbeiten, ändert sich die Bearbeitungszeit nicht.

```json
[
  {
    "datum": "2026-08-12",
    "uhrzeit": "14:30",
    "titel": "Budgetplanung"
  },
  {
    "datum": "2026-09-03",
    "uhrzeit": "09:00",
    "titel": "Zahnarzttermin"
  },
  {
    "datum": "2026-12-31",
    "uhrzeit": "20:30",
    "titel": "Silvesterparty"
  }
]
```

It's not ideal, but we shouldn't make a mountain out of a molehill—all things considered, we can live with it.

This problem utilizes the principle of **Conservation of Mechanical Energy**, which states that in a system without non-conservative forces (like friction), the total mechanical energy remains constant.

$$E_{\text{initial}} = E_{\text{final}}$$
$$\text{Kinetic } (\text{KE}) + \text{Potential } (\text{PE})$$

### Given Variables:
*   Mass ($m$) = $2 \text{ kg}$
*   Initial Height ($h_i$) = $5 \text{ m}$
*   Initial Speed ($v_i$) = $0 \text{ m/s}$ (starts from rest)
*   Gravity ($g$) = $9.8 \text{ m/s}^2$

### Energy Conservation Setup:
The block starts at height $h$ and ends at a final height of 0.

$$\frac{1}{2} m v_i^2 + m g h_i = \frac{1}{2} m v_f^2 + m g h_f$$

Since $v_i=0$ and $h_f=0$:
$$0 + m g h = \frac{1}{2} m v_f^2 + 0$$
$$m g h = \frac{1}{2} m v_f^2$$

***

### (a) Calculation of the block's speed at the bottom ($v_f$)

We use the derived conservation equation:
$$m g h = \frac …

Excerpt — the full answer is on the round page.

This problem requires two separate unit conversions.

The initial speed is $108 \text{ km/h}$.

---

### (a) Conversion to meters per second ($\text{m/s}$)

We use the following conversion factors:
*   $1 \text{ km} = 1000 \text{ m}$
*   $1 \text{ hour} = 60 \text{ minutes}$
*   $1 \text{ minute} = 60 \text{ seconds} \implies 1 \text{ hour} = 3600 \text{ seconds}$

$$\text{Speed} = 108 \frac{\text{km}}{\text{h}} \times \left(\frac{1000 \text{ m}}{1 \text{ km}}\right) \times \left(\frac{1 \text{ h}}{3600 \text{ s}}\right)$$

$$\text{Speed} = \frac{108 \times 1000}{3600} \text{ m/s}$$

$$\text{Speed} = \frac{108000}{3600} \text{ m/s}$$

$$\text{Speed} = 30.0 \text{ m/s}$$

---

### (b) Conversion to miles per hour ($\text{mph}$)

We are given the conversion factor: $1 \text{ mile} = 1.60934 \text{ km}$.
To convert $\text{km}$ to $\text{miles}$, we multiply by $\frac{1 \text{ mile}}{1.60934 …

Excerpt — the full answer is on the round page.

This problem requires calculating the orbital speed and subsequently the orbital period using basic orbital mechanics formulas.

### Given Values:
*   Altitude ($h$): $400 \text{ km}$
*   Earth's Radius ($R_E$): $\approx 6371 \text{ km}$
*   Standard Gravitational Parameter ($\mu$): $398600 \text{ km}^3/\text{s}^2$

---

### Step 1: Calculate the Orbital Radius ($r$)
The orbital radius is the distance from the center of Earth to the satellite.
$$r = R_E + h$$
$$r = 6371 \text{ km} + 400 \text{ km}$$
$$\mathbf{r = 6771 \text{ km}}$$

### (a) Estimate the Orbital Speed ($v$)

We use the formula: $v = \sqrt{\mu/r}$

$$v = \sqrt{\frac{398600 \text{ km}^3/\text{s}^2}{6771 \text{ km}}}$$
$$v = \sqrt{58.8704 \dots \text{ km}^2/\text{s}^2}$$
$$\mathbf{v \approx 7.6726 \text{ km/s}}$$

***

### (b) Estimate the Orbital Period ($T$)

We use the formula: $T = 2\pi r / v$

*Note: Since we are calcul …

Excerpt — the full answer is on the round page.

Here are the calculations using Ohm's Law and the power formulas.

### Given Values:
* Voltage ($V$) = $12 \, \text{V}$
* Current ($I$) = $0.5 \, \text{A}$

---

### (a) Calculate the resistance of the resistor ($R$).

Ohm's Law states: $V = I \times R$
To find the resistance, we rearrange the formula: $R = \frac{V}{I}$

**Calculation:**
$$R = \frac{12 \, \text{V}}{0.5 \, \text{A}}$$
$$R = 24 \, \Omega$$

**Answer (a): The resistance of the resistor is $\mathbf{24 \, \Omega}$.**

---

### (b) Calculate the electrical power dissipated in it ($P$).

The formula for electrical power when voltage and current are known is: $P = V \times I$

*(Alternatively, using the result from part (a): $P = I^2 R = (0.5 \, \text{A})^2 \times 24 \, \Omega = 0.25 \times 24 = 6 \, \text{W}$)*

**Calculation:**
$$P = 12 \, \text{V} \times 0.5 \, \text{A}$$
$$P = 6 \, \text{W}$$

**Answer (b): The electrical po …

Excerpt — the full answer is on the round page.

This problem uses the thin lens equation to determine the image characteristics.

### Given Values:
*   Focal length ($f$) = $+10 \text{ cm}$ (Positive because it is a converging lens)
*   Object distance ($d_o$) = $15 \text{ cm}$

---

## (a) Calculate the Image Distance ($d_i$)

We use the thin lens equation:
$$\frac{1}{f} = \frac{1}{d_o} + \frac{1}{d_i}$$

Rearrange the equation to solve for $\frac{1}{d_i}$:
$$\frac{1}{d_i} = \frac{1}{f} - \frac{1}{d_o}$$

Substitute the known values:
$$\frac{1}{d_i} = \frac{1}{10 \text{ cm}} - \frac{1}{15 \text{ cm}}$$

To subtract the fractions, find a common denominator (which is 30):
$$\frac{1}{d_i} = \left(\frac{3}{30 \text{ cm}}\right) - \left(\frac{2}{30 \text{ cm}}\right)$$
$$\frac{1}{d_i} = \frac{3 - 2}{30 \text{ cm}}$$
$$\frac{1}{d_i} = \frac{1}{30 \text{ cm}}$$

Invert the result to find $d_i$:
$$d_i = +30 \text{ cm}$$

**The image distance …

Excerpt — the full answer is on the round page.

Here is the step-by-step calculation to determine the required heat energy:

### Given Values:
* **Mass ($m$):** $2 \text{ kg}$
* **Specific Heat Capacity of water ($c$):** $4186 \text{ J/(kg}\cdot\text{K)}$
* **Initial Temperature ($T_{initial}$):** $20^\circ\text{C}$
* **Final Temperature ($T_{final}$):** $80^\circ\text{C}$

### 1. Calculate the Change in Temperature ($\Delta T$):
$$\Delta T = T_{final} - T_{initial}$$
$$\Delta T = 80^\circ\text{C} - 20^\circ\text{C}$$
$$\Delta T = 60^\circ\text{C}$$

*(Note: Since the temperature difference is used, a change of $60^\circ\text{C}$ is equal to a change of $60 \text{ K}$.) *

### 2. Use the Heat Energy Formula:
$$Q = m \cdot c \cdot \Delta T$$

### 3. Substitute and Calculate (in Joules):
$$Q = (2 \text{ kg}) \cdot (4186 \text{ J/(kg}\cdot\text{K)}) \cdot (60 \text{ K})$$
$$Q = 2 \cdot 4186 \cdot 60 \text{ J}$$
$$Q = 4186 \cdot 120 \text …

Excerpt — the full answer is on the round page.

This estimate requires breaking down a large, complex demand into manageable, sequential assumptions. We will track our values as we go.

***

### Step 1: Estimate Total Households

We start with the population of 10 million people. To find the number of households, we must assume an average household size (AHS).

*   **Assumption:** Let's assume a relatively high density city environment where the Average Household Size is approximately 2.8 people.
*   **Calculation:** $10,000,000 \text{ people} / 2.8 \text{ people/household} \approx 3,570,000$ households.

***

### Step 2: Estimate Total Number of Pianos (Demand Base)

Not every household has a piano. We must calculate the total number of pianos from both residential and commercial sources.

**A. Residential Pianos:**
*   **Assumption:** A professional piano is an expensive luxury, so only a small fraction of households own one. Let's …

Excerpt — the full answer is on the round page.

**In plain language, the sky appears blue because the Earth's atmosphere acts like a giant filter that scatters sunlight.**

Think of sunlight not as one single color, but as all the colors mixed together (red, orange, yellow, green, blue, indigo, violet). When this full spectrum of light reaches Earth, it bumps into the tiny gas molecules and particles floating in our air—mostly nitrogen and oxygen.

These little bits of air don't just let the light pass straight through; they scatter it out in all directions.

The key is that different colors get scattered differently:
*   **Blue light** has a smaller, shorter "wave" than red or yellow light. Because of this size difference, blue waves are much easier for those tiny air particles to grab and bounce around. They get diffused everywhere you look up.
*   **Red and Yellow light** have longer, steadier waves, so they tend to pass through th …

Excerpt — the full answer is on the round page.

This explanation will focus on conceptual understanding, using analogies and avoiding complex mathematical formalism.

***

## Part 1: Why a Moving Clock Runs Slow (Time Dilation)

The core reason time dilation exists is rooted in one absolute, unchangeable physical law: **the speed of light ($c$) is constant for everyone, no matter how fast they are moving.**

Imagine measuring time using a hypothetical "light clock." This clock operates by bouncing a beam of light between two mirrors. Every round trip represents one tick of the clock.

### The Thought Experiment (The Observer's Perspective)

1.  **Observer A** is standing next to the clock and watching it operate. To A, the light goes straight up and straight down. This path is the shortest distance, and time passes normally ($t_A$).
2.  Now, **Observer B** flies past A while the clock ticks. Observer B sees both A and the clock moving …

Excerpt — the full answer is on the round page.

This explanation will use simple analogies to describe some of the most counterintuitive physics known.

***

## The Double-Slit Experiment Explained

Imagine you are firing tiny balls (our particles) through two narrow openings (the slits). When they hit a screen behind the slits, you expect to see two distinct piles of hits—one directly behind each slit. That's the basic expectation for any localized object.

The double-slit experiment is designed to test if these tiny "balls" behave like simple bullets or if they behave like something more mysterious.

### 🔬 Scenario 1: No Detector (The Mysterious Outcome)

When scientists fire particles—like electrons or photons (light particles)—through the two slits, one at a time, and *do not* try to watch which slit they take, the pattern observed on the screen is completely unexpected.

**What is observed:** Instead of two piles of hits, the sc …

Excerpt — the full answer is on the round page.

```html
<!DOCTYPE html>
<html>
<head>
<title>Double-Slit Experiment</title>
<style>body {background: #111; display: flex; justify-content: center; align-items: center; height: 100vh; margin: 0;} canvas {border: 2px solid #444; background: #0a0a15;}</style>
</head>
<body>
<canvas id="slitCanvas" width="900" height="300"></canvas>
<script>
const canvas = document.getElementById('slitCanvas');
const ctx = canvas.getContext('2d');

let particleCount = 0;
const screenWidth = canvas.width - 100;
const slitsHeight = 40;
const slitSeparation = 80;
const d = 50; // Distance between slits (effective)
const L = 700; // Screen distance

// Function to calculate the interference pattern position y, given a random angle theta.
// This simulates the distribution P(theta) ~ 1 + cos^2(d sin(theta)/λ)
function getInterferenceY() {
    let r = Math.random();
    let angle;
    do {
        angle = Math.aco …

Excerpt — the full answer is on the round page.

```html
<!DOCTYPE html>
<html>
<head>
<title>Verlet Rope</title>
<style>body{margin:0;overflow:hidden}canvas{display:block}</style>
</head>
<body>
<canvas id="c"></canvas>
<script>
const canvas = document.getElementById('c');
const ctx = canvas.getContext('2d');
let W, H;

function resize() {
    W = canvas.width = window.innerWidth;
    H = canvas.height = window.innerHeight;
}
window.addEventListener('resize', resize);
resize();

const P = 40;
const dt = 1/60;
const GRAVITY = 9.8 / 2000; // Scaled gravity
const K_PASSES = 15;

let p = []; // Current positions
let oldP = []; // Previous positions
let fixedPoints = [];

for (let i = 0; i < P; i++) {
    p[i] = [W * 0.4 + i * (W * 0.6 / P), 50];
    oldP[i] = [...p[i]];
}

const anchor1 = p[0];
const anchor2 = p[P - 1];
fixedPoints.push(anchor1, anchor2); // Anchor the ends at the top

function update() {
    let impulseTime = Math.sin(Da …

Excerpt — the full answer is on the round page.

```html
<!DOCTYPE html>
<html>
<head><title>Wave Simulation</title></head>
<body>
<canvas id="waveCanvas"></canvas>
<script>
const canvas = document.getElementById('waveCanvas');
const ctx = canvas.getContext('2d');

let N = 120; // Width cells
let M = 90;  // Height cells
let CELL_SIZE = Math.min(window.innerWidth, window.innerHeight) / N;
canvas.width = N * CELL_SIZE;
canvas.height = M * CELL_SIZE;

const DAMPING = 0.995;
const C = 0.1; // Time step constant (controls wave speed/stability)

let currentField = new Array(N).fill(0).map(() => new Float32Array(M));
let previousField = new Array(N).fill(0).map(() => new Float32Array(M));
let nextField = new Array(N).fill(0).map(() => new Float32Array(M));

function initialize() {
    for (let x = 0; x < N; x++) {
        for (let y = 0; y < M; y++) {
            currentField[x][y] = previousField[x][y] = nextField[x][y] = 0;
        }
    } …

Excerpt — the full answer is on the round page.

```html
<!DOCTYPE html>
<html>
<head>
<title>Billiard Break Simulation</title>
<style>body { margin: 0; display: flex; justify-content: center; align-items: center; height: 100vh; background-color: #222; }</style>
</head>
<body>
<canvas id="billiardCanvas"></canvas>
<script>
const canvas = document.getElementById('billiardCanvas');
const ctx = canvas.getContext('2d');

let ws, balls = [];
const TABLE_WIDTH = 800;
const TABLE_HEIGHT = 400;
const BALL_RADIUS = 10;
const FRICTION = 0.995;
const DAMPING = 0.999;
const CUE_BALL_START_POS = { x: TABLE_WIDTH / 2, y: TABLE_HEIGHT - 3 * BALL_RADIUS };

canvas.width = TABLE_WIDTH;
canvas.height = TABLE_HEIGHT;

function createBalls(racked) {
    balls = [];
    const ballCount = racked ? 10 : 11;
    for (let i = 0; i < ballCount; i++) balls.push({ x: Math.random() * TABLE_WIDTH, y: Math.random() * TABLE_HEIGHT, vx: 0, vy: 0, r: BALL_RADIUS, id: i …

Excerpt — the full answer is on the round page.

```html
<!DOCTYPE html>
<html><head><title>Dijkstra vs A*</title></head><style>body{display:flex;justify-content:center;align-items:center;height:100vh;margin:0;background:#333;}#container{display:flex;gap:20px;}canvas{border:1px solid #ccc;background:#fff;}#stats{width:250px;color:#eee;font-family:monospace;}h3{margin-top:0;border-bottom:1px solid #444;}span{display:block;margin-bottom:5px;}</style></head><body><div id="container"><canvas id="canvas" width="600" height="480"></canvas><div id="stats"><h3>Dijkstra</h3><span id="d_exp">Exp: 0</span><span id="d_cost">Cost: N/A</span><h3>A*</h3><span id="a_exp">Exp: 0</span><span id="a_cost">Cost: N/A</span></div></div><script>
const C=document.getElementById('canvas');
const ctx=C.getContext('2d');
const W=30,H=20;
const CELL_W=C.width/W,CELL_H=C.height/H;

let grid=[],start=[1,1],end=[W-2,H-2];
let dijkstraState={cost:Infinity,expanded:0,v …

Excerpt — the full answer is on the round page.

```html
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Graham Scan Animation</title>
    <style>body {background: #111; color: white; font-family: sans-serif;} canvas {border: 1px solid #333; background: #000;}#info {margin-top: 10px;}</style>
</head>
<body>
    <canvas id="hullCanvas" width="800" height="600"></canvas>
    <div id="info">Step: <span id="stepCounter">0</span>/40</div>

<script>
    const canvas = document.getElementById('hullCanvas');
    const ctx = canvas.getContext('2d');
    const POINTS_COUNT = 40;
    let points = [];
    let sortedPoints = [];
    let hullStack = [];
    let stepCounter = 0;

    function generateRandomPoints() {
        points = [];
        for (let i = 0; i < POINTS_COUNT; i++) {
            points.push({ x: Math.random() * canvas.width, y: Math.random() * canvas.height });
        }
        stepCounter = 0;
    } …

Excerpt — the full answer is on the round page.

```html
<!DOCTYPE html>
<html>
<head><title>Huffman Visualization</title></head>
<body>
<canvas id="huffmanCanvas" width="800" height="600" style="border:1px solid #ccc; display:block; margin:20px auto;"></canvas>
<div id="info" style="text-align:center; font-family:monospace;"></div>

<script>
const canvas = document.getElementById('huffmanCanvas');
const ctx = canvas.getContext('2d');
let animationRunning = true;
let state = {
    frequencies: {},
    pq: [],
    treeRoot: null,
    stepCount: 0,
    maxSteps: 0,
    interval: 10, // ms per merge step
    animationTimeout: null
};

// --- Fixed Sample Sentence and Initialization ---
const SAMPLE_TEXT = "this is a test sentence for huffman coding visualization";

function getFrequencies(text) {
    let freq = {};
    for (const char of text.toLowerCase()) {
        if (char >= 'a' && char <= 'z') {
            freq[char] = (freq[char] | …

Excerpt — the full answer is on the round page.

```html
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Kruskal's MST Animation</title>
    <style>body {margin: 0; display: flex; justify-content: center; align-items: center; height: 100vh; background-color: #222; color: white; font-family: sans-serif;}#canvasContainer {display: flex; gap: 20px;}canvas {border: 1px solid #444; background-color: #111;}</style>
</head>
<body>

<div id="canvasContainer">
    <canvas id="mstCanvas" width="800" height="600"></canvas>
</div>
<div style="display: flex; flex-direction: column; gap: 10px;">
    <div>Accepted Edges: <span id="acceptedCount">0</span> | Total Weight: <span id="totalWeight">0.00</span></div>
    <button onclick="initializeGraph()">Restart</button>
</div>

<script>
let canvas, ctx;
const N = 25;
let nodes = [];
let edges = [];
let parent, rank;
let acceptedEdges = new Set();
let totalWeight = 0;
let edg …

Excerpt — the full answer is on the round page.

```html
<!DOCTYPE html>
<html lang="en">
<head>
    <title>N-Queens Solver Animation</title>
    <style>
        body { display: flex; justify-content: center; align-items: center; height: 100vh; margin: 0; background: #333; color: white; font-family: monospace; }
        canvas { border: 5px solid black; image-rendering: pixelated; }
    </style>
</head>
<body>
    <canvas id="board"></canvas>
    <script>
        let canvas = document.getElementById('board');
        let ctx = canvas.getContext('2d');

        const MAX_SIZE = 10;
        const MIN_SIZE = 6;
        let N = 8; // Initial size
        
        let solutionsFound = 0;
        let placementsCount = 0;
        let backtracksCount = 0;
        let animationState = { running: true, currentStep: 1 };
        let queenPositions = [];

        function initialize(size) {
            N = size;
            canvas.width = N * 60; …

Excerpt — the full answer is on the round page.

<!DOCTYPE html>
<html>
<head><title>Delaunay Triangulation</title></head>
<body><canvas id="canvas" width="600" height="400"></canvas><script>
const canvas = document.getElementById('canvas');
const ctx = canvas.getContext('2d');

let points = [];
let triangles = [];
let pointIndex = 0;
const MAX_POINTS = 30;
let animationFrameId = null;

function init() {
    points = [];
    triangles = [];
    pointIndex = 0;
    for (let i = 0; i < MAX_POINTS; i++) {
        points.push({x: Math.random() * canvas.width, y: Math.random() * canvas.height});
    }
}

function distSq(p1, p2) { return (p1.x - p2.x)**2 + (p1.y - p2.y)**2; }

// Checks if point p is inside the circumcircle of triangle defined by indices a, b, c
function inCircle(pa, pb, pc, pd) {
    const d = Math.pow(pa.x*(pb.y - pc.y) + pb.x*(pc.y - pa.y) + pc.x*(pa.y - pb.y), 2);
    const e = (pd.x - pa.x)**2 * ((pb.y - pc.y)/d)^2 + (p …

Excerpt — the full answer is on the round page.

```html
<!DOCTYPE html>
<html><head><title>AVL Tree Animator</title></head><body>
<canvas id="treeCanvas" style="border:1px solid black;"></canvas>
<div>Height: <span id="heightDisplay">0</span> | Rotations: <span id="rotationsDisplay">0</span></div>

<script>
const canvas = document.getElementById('treeCanvas');
const ctx = canvas.getContext('2d');
canvas.width = 900;
canvas.height = 500;

let AVLTree = null;
let keysToInsert = [];
let currentKeyIndex = 0;
let animationRunning = false;

class AVLNode {
    constructor(key) {
        this.key = key;
        this.left = null;
        this.right = null;
        this.height = 1;
        this.bf = 0;
    }
}

function height(node) { return node ? node.height : 0; }
function balanceFactor(node) { return (height(node.left) - height(node.right)); }
function updateNode(node) { 
    if (!node) return;
    node.height = Math.max(height(node.left), …

Excerpt — the full answer is on the round page.

```html
<!DOCTYPE html>
<html>
<head>
<title>Sieve of Eratosthenes</title>
<style>
body { display: flex; justify-content: center; align-items: flex-start; background-color: #111; color: white; font-family: sans-serif; padding-top: 20px; }
#container { display: flex; gap: 30px; max-width: 1200px; }
canvas { border: 1px solid #333; background-color: #222; }
#info { padding: 15px; background-color: #2a2a2a; border-radius: 8px; width: 250px; }
h3 { margin-top: 0; color: #4CAF50; }
</style>
</head>
<body>

<div id="container">
<canvas id="sieveCanvas" width="700" height="400"></canvas>
<div id="info">
<h3>Sieve Status</h3>
<p>Current Prime: <span id="currentPrime">N/A</span></p>
<p>Primes Found: <span id="primeCount">0</span></p>
<p>Eliminated Cells: <span id="eliminatedCount">0</span></p>
</div>
</div>

<script>
const canvas = document.getElementById('sieveCanvas');
const ctx = canvas.getCon …

Excerpt — the full answer is on the round page.

<!DOCTYPE html>
<html>
<head>
<title>Levenshtein Animation</title>
<style>
    body { background-color: #222; display: flex; justify-content: center; align-items: center; height: 100vh; margin: 0; color: white; font-family: monospace; }
    canvas { border: 1px solid #555; background-color: #111; }
</style>
</head>
<body>
<canvas id="levCanvas" width="600" height="400"></canvas>

<script>
const canvas = document.getElementById('levCanvas');
const ctx = canvas.getContext('2d');

let wordA = "algorithm"; 
let wordB = "logarithm";
let m, n; // Dimensions
let matrix, operations;
let step = 0;
let currentStage = 'INIT'; // INIT -> FILLING -> BACKTRACING

// Initialize state
function init() {
    m = wordA.length;
    n = wordB.length;
    matrix = Array(m + 1).fill(0).map(() => Array(n + 1).fill(0));
    operations = Array(m + 1).fill(0).map(() => Array(n + 1).fill(''));
    step = 0;
    cur …

Excerpt — the full answer is on the round page.

```html
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Dynamic Pathfinding Robot</title>
    <style>body { background: #222; display: flex; justify-content: center; align-items: center; height: 100vh; margin: 0; font-family: monospace; color: white;} canvas { border: 1px solid #444; }</style>
</head>
<body>
    <canvas id="gridCanvas" width="600" height="400"></canvas>
    <script>
        const canvas = document.getElementById('gridCanvas');
        const ctx = canvas.getContext('2d');

        const COLS = 30;
        const ROWS = 20;
        const CELL_SIZE = Math.min(canvas.width, canvas.height) / Math.max(COLS, ROWS);

        let map = [];
        let robotPos = { x: 1, y: 1 };
        let goalPos = { x: COLS - 2, y: ROWS - 2 };
        let currentPath = [];
        let stepsTaken = 0;
        let replanCount = 0;
        let lastMoveTime = 0; …

Excerpt — the full answer is on the round page.

```html
<!DOCTYPE html>
<html>
<head>
<title>Binary Search Animation</title>
<style>
body { background: #f0f0f0; display: flex; justify-content: center; padding: 20px; }
canvas { border: 1px solid #ccc; background: white; }
#info { margin-left: 30px; font-family: monospace; }
</style>
</head>
<body>
<canvas id="searchCanvas" width="800" height="250"></canvas>
<div id="info">Target: N/A<br>Comparisons: 0</div>

<script>
const canvas = document.getElementById('searchCanvas');
const ctx = canvas.getContext('2d');
const infoDiv = document.getElementById('info');

let arr = [];
let target = 0;
let low = 0;
let high = 39;
let comparisons = 0;
let isSearching = false;
let animationFrameId = null;

function generateArray() {
    arr = Array.from({ length: 40 }, () => Math.floor(Math.random() * 100) + 5);
    arr.sort((a, b) => a - b);
}

function setup() {
    generateArray();
    target = arr[M …

Excerpt — the full answer is on the round page.

```html
<!DOCTYPE html>
<html>
<head>
<title>Flood Fill Animation</title>
<style>
    body { background-color: #111; display: flex; justify-content: center; align-items: center; min-height: 100vh; margin: 0; }
    canvas { border: 1px solid #333; image-rendering: pixelated; }
    #info { color: white; font-family: monospace; position: absolute; top: 20px; left: 50%; transform: translateX(-50%); background: rgba(0,0,0,0.6); padding: 10px; border-radius: 5px;}
</style>
</head>
<body>

<canvas id="gameCanvas" width="600" height="400"></canvas>
<div id="info">Cells Filled: 0 | Frontier Size: 0</div>

<script>
    const canvas = document.getElementById('gameCanvas');
    const ctx = canvas.getContext('2d');
    const infoDiv = document.getElementById('info');

    let GRID_WIDTH = 60;
    let GRID_HEIGHT = 40;
    let CELL_SIZE = 10;
    let grid = [];
    
    // Color constants
    const BA …

Excerpt — the full answer is on the round page.

```html
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Animated Maze Generator</title>
    <style>body {background: #111; display: flex; justify-content: center; align-items: center; height: 100vh; margin: 0; font-family: monospace; color: white;} canvas {border: 2px solid #aaa;}</style>
</head>
<body>
    <canvas id="mazeCanvas"></canvas>

    <script>
        const canvas = document.getElementById('mazeCanvas');
        const ctx = canvas.getContext('2d');

        // Dimensions (30 cells wide, 20 cells high)
        const COLS = 30;
        const ROWS = 20;
        const CELL_SIZE = 20;
        canvas.width = COLS * CELL_SIZE + CELL_SIZE / 2; // Account for outer walls/padding
        canvas.height = ROWS * CELL_SIZE + CELL_SIZE / 2;

        // State variables
        let mazeGrid = Array(ROWS).fill(0).map(() => Array(COLS).fill(false));
        let sta …

Excerpt — the full answer is on the round page.

```html
<!DOCTYPE html>
<html>
<head>
<title>KMP Animation</title>
<style>body{background:#111;color:white;font-family:monospace;margin:0;display:flex;justify-content:center;align-items:center;min-height:100vh;}canvas{border:2px solid #444;}</style>
</head>
<body>
<canvas id="kmpCanvas" width="800" height="150"></canvas>
<script>
const canvas = document.getElementById('kmpCanvas');
const ctx = canvas.getContext('2d');

let text, pattern;
let lps;
let state = { 
    t_idx: 0, p_idx: 0, matchFound: false, comparisons: 0, totalTime: 0, finished: false
};

// --- Helper Functions ---

function computeLPSArray(P) {
    const m = P.length;
    const lpsA = new Array(m).fill(0);
    let length = 0; // length of the previous longest prefix suffix
    let i = 1;
    while (i < m) {
        if (P[i] === P[length]) {
            length++;
            lpsA[i] = length;
            i++;
        } els …

Excerpt — the full answer is on the round page.

```html
<!DOCTYPE html>
<html>
<head>
<title>Quadtree Collision Demo</title>
<style>body{background:#111;margin:0;overflow:hidden}canvas{display:block}</style>
</head>
<body><canvas id="c"></canvas><script>
const canvas = document.getElementById('c');
const ctx = canvas.getContext('2d');
let W, H, balls = [], quadroot = null, pairTests = 0, nodeCount = 0;

function init() {
    W = H = window.innerWidth * 0.95;
    canvas.width = W;
    canvas.height = H;
    balls = [];
    for (let i = 0; i < 120; i++) {
        balls.push({ x: Math.random() * W, y: Math.random() * H, vx: (Math.random() - 0.5) * 3, vy: (Math.random() - 0.5) * 3, r: 2 + Math.random() * 1.5 });
    }
    quadroot = { bounds: { x: 0, y: 0, w: W, h: H }, children: null, count: 0 };
    pairTests = 0;
    nodeCount = 0;
}

class QuadtreeNode {
    constructor(bounds) { this.bounds = bounds; this.children = []; this.items = …

Excerpt — the full answer is on the round page.

<!DOCTYPE html>
<html><body><canvas id="sandCanvas" width="300" height="150"></canvas><script>const canvas=document.getElementById("sandCanvas");const ctx=canvas.getContext("2d");let W=15;let H=10;let CELL_SIZE=20;let GRID_W=150,GRID_H=100;// Scaling dimensions for the actual simulation logic
let grid = Array(GRID_H).fill(0).map(()=>Array(GRID_W).fill(0));let nextGrid=Array(GRID_H).fill(0).map(()=>Array(GRID_W).fill(0));let stepCount=0;function init() {for(let i=0;i<GRID_H;i++)grid[i]=Object.assign([...grid[i]]);for(let i=0;i<GRID_W;i++)grid[i].fill(0);stepCount=0;console.log("Simulation initialized.");}function draw() {ctx.clearRect(0,0,canvas.width,canvas.height);let scaleX=canvas.width/GRID_W;let scaleY=canvas.height/GRID_H;for(let y=0;y<GRID_H;y++)for(let x=0;x<GRID_W;x++)if(grid[y][x])ctx.fillStyle="#D2B48C";ctx.fillRect(x*scaleX,y*scaleY,scaleX-1,scaleY-1);function update() {nextGr …

Excerpt — the full answer is on the round page.

```html
<!DOCTYPE html>
<html>
<head>
    <title>Continuous Sand Simulation</title>
    <style>body { margin: 0; background: #111; }</style>
</head>
<body>
<canvas id="sandCanvas"></canvas>
<script>
const canvas = document.getElementById('sandCanvas');
const ctx = canvas.getContext('2d');
let W, H;

function init() {
    W = window.innerWidth * 0.95;
    H = window.innerHeight * 0.8;
    canvas.width = W;
    canvas.height = H;
}
window.addEventListener('resize', init);
init();

const PARTICLE_COUNT = 1500;
let particles = [];
const GRAVITY = 9.8 / 60; // Adjusted for frame rate
const DAMPING = 0.85;     // Energy loss on impact
const MAX_VELOCITY = 20;

class Particle {
    constructor() {
        this.reset();
    }
    reset() {
        this.x = Math.random() * W * 0.3 + W * 0.1; // Start in a confined area
        this.y = -50;
        this.vx = (Math.random() - 0.5) * 5;
        thi …

Excerpt — the full answer is on the round page.

<!DOCTYPE html>
<html><head><title>Crowd Simulation</title></head><style>body{background:#333;margin:0;display:flex;justify-content:center;align-items:center;height:100vh;color:white}canvas{border:2px solid #666}</style><body><canvas id="c"></canvas><script>
const canvas = document.getElementById('c');
const ctx = canvas.getContext('2d');

const COLS = 40;
const ROWS = 30;
const CELL_SIZE = 15;
canvas.width = COLS * CELL_SIZE;
canvas.height = ROWS * CELL_SIZE;

let people = [];
let stepCount = 0;
let leavingCount = 0;

function initializePeople() {
    people = [];
    for (let i = 0; i < 60; i++) {
        const startX = Math.floor(Math.random() * (COLS - 5)) + 2;
        const startY = Math.floor(Math.random() * (ROWS - 10)) + 5;
        people.push({ x: startX, y: startY, active: true });
    }
}

function drawGrid() {
    ctx.fillStyle = '#222';
    ctx.fillRect(0, 0, canvas.width, c …

Excerpt — the full answer is on the round page.

```html
<!DOCTYPE html>
<html>
<head>
<title>Crowd Simulation</title>
<style>body {margin:0;overflow:hidden;}#canvas {display:block;background-color:#1a1a2e;}</style>
</head>
<body>
<canvas id="canvas"></canvas>
<script>
const canvas = document.getElementById('canvas');
const ctx = canvas.getContext('2d');
let width, height;

function initialize() {
    width = window.innerWidth;
    height = window.innerHeight;
    canvas.width = width;
    canvas.height = height;
}
window.addEventListener('resize', initialize);
initialize();

const NUM_PEOPLE = 60;
const EXIT_X = width * 0.95;
const EXIT_Y = height / 2;
const SEPARATION_DISTANCE = 15;
const MAX_SPEED = 3;
const STEERING_STRENGTH = 0.08;

let people = [];
let simulationRunning = true;
let leftCount = 0;
let lastLeftTime = performance.now();

function createPerson(x, y) {
    return {
        x: x,
        y: y,
        vx: (Math.random( …

Excerpt — the full answer is on the round page.

```html
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>DLA Simulation</title>
    <style>body {background: #111; margin: 0;} canvas {display: block;}</style>
</head>
<body>
    <canvas id="dlaCanvas"></canvas>
    <script>
        const canvas = document.getElementById('dlaCanvas');
        const ctx = canvas.getContext('2d');

        let COLS = 200;
        let ROWS = 150;
        let CELL_SIZE = 3; // Pixels per cell
        canvas.width = COLS * CELL_SIZE;
        canvas.height = ROWS * CELL_SIZE;

        let grid = Array(ROWS).fill(0).map(() => Array(COLS).fill(false));
        let cluster = new Set();
        let seedX = Math.floor(COLS / 2);
        let seedY = Math.floor(ROWS / 2);
        let isRunning = true;

        function draw() {
            ctx.clearRect(0, 0, canvas.width, canvas.height);
            for (const key of cluster) { …

Excerpt — the full answer is on the round page.

```html
<!DOCTYPE html>
<html>
<head>
<title>Clustering Simulation</title>
<style>body {margin:0;overflow:hidden;background:#111;}canvas {display:block;}</style>
</head>
<body>
<canvas id="c"></canvas>
<script>
const canvas = document.getElementById('c');
const ctx = canvas.getContext('2d');
let W, H;
let particles = [];
let stuckCount = 0;

function setup() {
    W = H = window.innerWidth * 0.95;
    canvas.width = W;
    canvas.height = H;
    particles = [];
    stuckCount = 0;
}

function Particle(x, y) {
    this.x = x;
    this.y = y;
    this.vx = (Math.random() - 0.5) * 0.5;
    this.vy = (Math.random() - 0.5) * 0.5;
    this.stuck = false;
}

Particle.prototype.update = function(center, radius) {
    if (this.stuck) return;

    // Brownian motion
    this.vx += (Math.random() - 0.5) * 0.2;
    this.vy += (Math.random() - 0.5) * 0.2;

    // Weak pull towards center (0, 0)
    c …

Excerpt — the full answer is on the round page.

```html
<!DOCTYPE html>
<html>
<head>
<title>Flocking Simulation</title>
<style>body {margin:0;overflow:hidden;background-color:#111}canvas {display:block;}</style>
</head>
<body>
<canvas id="flockCanvas"></canvas>
<script>
const canvas = document.getElementById('flockCanvas');
const ctx = canvas.getContext('2d');

let width, height;
let birds = [];
let MAX_BIRDS = 200;

// Constants for flocking rules
const VISION_RADIUS = 50;
const SEPARATION_DISTANCE = 10;
const COHESION_WEIGHT = 0.3;
const ALIGNMENT_WEIGHT = 0.5;
const SEPARATION_WEIGHT = 1.5;
const MAX_FORCE = 0.2;
const NEIGHBOR_COUNT_THRESHOLD = 5;

function init() {
    width = window.innerWidth;
    height = window.innerHeight;
    canvas.width = width;
    canvas.height = height;
    birds = [];
    for (let i = 0; i < MAX_BIRDS; i++) {
        birds.push(new Bird(Math.random() * width, Math.random() * height));
    }
    anima …

Excerpt — the full answer is on the round page.

```html
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Conway's Game of Life</title>
<style>body{background:#111;color:white;font-family:monospace;display:flex;flex-direction:column;align-items:center;margin:0;padding-top:20px;}canvas{border:1px solid #333;background:#000;}</style>
</head>
<body><canvas id="lifeCanvas" width="600" height="480"></canvas><div id="info">Gen: 0 | Live: 0</div><script>
const c=document.getElementById('lifeCanvas');
const ctx=c.getContext('2d');
let W=120, H=80;
c.width=W*5; c.height=H*5; // Draw at 5px per cell

// State arrays: (Cell state, Age trail)
let grid=[[0],[0]];
let ageGrid=[[0],[0]];

const A=Math.floor(Math.random);

function init() {
    grid = Array.from({length:H}, (_,y) => new Array(W).fill(0));
    ageGrid = Array.from({length:H}, (_,y) => new Array(W).fill(0));

    // Seed 1: Glider (example offset adjusted for 120x80 …

Excerpt — the full answer is on the round page.

```html
<!DOCTYPE html>
<html>
<head>
<title>Fourier Epicycles</title>
<style>body {margin: 0; overflow: hidden;} #canvas {display: block;}</style>
</head>
<body>
<canvas id="canvas"></canvas>
<script>
const canvas = document.getElementById('canvas');
const ctx = canvas.getContext('2d');

let W, H;
let N_COEFFS = 8; // Number of epicycles (Fourier coefficients)
let t = 0;
let pathTrace = [];
let currentCoeffs = [];

function resize() {
    W = window.innerWidth;
    H = window.innerHeight;
    canvas.width = W;
    canvas.height = H * 0.8; // Use 80% height for drawing area
}
window.addEventListener('resize', resize);
resize();

function generateCoefficients() {
    const sampleSize = 100;
    let x = [];
    for (let i = 0; i < sampleSize; i++) {
        x.push(i / sampleSize * Math.PI * 2 - Math.PI); // Sample x from a range
    }

    // Target curve function (e.g., sin^2(x) or simple …

Excerpt — the full answer is on the round page.

```html
<!DOCTYPE html>
<html>
<head>
<title>Animated Voronoi Diagram</title>
<style>body{margin:0;background:#111}canvas{display:block}#info{position:absolute;color:white;font-family:monospace;padding:10px;z-index:10;}
</style>
</head>
<body>

<canvas id="voronoiCanvas"></canvas>
<div id="info"></div>

<script>
const canvas = document.getElementById('voronoiCanvas');
const ctx = canvas.getContext('2d');
let W, H;

// Configuration Constants
const NUM_SEEDS = 25;
const STEP = 8; // Sampling step size (affects detail vs performance)
const VELOCITY_SCALE = 0.3;
let seeds = [];
let vels = [];
let colors = [];
let areas = [];

function init(width, height) {
    W = width;
    H = height;
    canvas.width = W;
    canvas.height = H;

    seeds = [];
    vels = [];
    colors = [];
    areas = new Array(NUM_SEEDS).fill(0);

    for (let i = 0; i < NUM_SEEDS; i++) {
        // Initialize seeds …

Excerpt — the full answer is on the round page.

```html
<!DOCTYPE html>
<html><head><title>2-Opt TSP Animation</title></head><body style="background:#111;display:flex;justify-content:center;align-items:center;height:100vh;margin:0;"><canvas id="c" width="800" height="600" style="border:1px solid #333;"></canvas><div id="info" style="position:absolute;top:20px;left:20px;color:#ccc;font-family:monospace;">Length: 0.00 | Improvements: 0</div><script>
const c = document.getElementById('c');
const ctx = c.getContext('2d');
let cities = [];
let tour = [];
let bestTour = [];
let improvementCount = 0;
let animationRunning = true;

const CANVAS_W = c.width;
const CANVAS_H = c.height;
const N_CITIES = 60; // Target number of cities

function dist(p1, p2) {
    return Math.sqrt((p1.x - p2.x)**2 + (p1.y - p2.y)**2);
}

function generateCities() {
    cities = [];
    for (let i = 0; i < N_CITIES; i++) {
        cities.push({ x: Math.random() * CA …

Excerpt — the full answer is on the round page.

<!DOCTYPE html>
<html><head><title>Infinite Noise Landscape</title><style>body{background:#000;margin:0;overflow:hidden}canvas{display:block}</style></head><body><canvas id="c"></canvas><script>let c=document.getElementById('c');let ctx=c.getContext('2d');c.width=window.innerWidth;c.height=window.innerHeight;let offset=0;let seed=Math.random();let lastTime=0;const scale=0.005;const numOctaves=6;function pseudoNoise(x,y,z){let n=Math.sin(x*123.4+seed)*453.1+Math.cos(y*987.6+seed)*453.1+Math.sin(z*543.2+seed)*453.1;return Math.abs((n-0)/453.1);}//Modified trigonometric noise function for speed and simplicity
function getNoise(x,y){let n=pseudoNoise(x*scale, y*scale, 0);return (Math.sin(x*0.1+seed)*0.4+Math.cos(y*0.1+seed)*0.4+Math.sin((x+y)*0.05+seed)*0.2)/1.0;}
function fBM(x,y){let total=0;let amplitude=1;let frequency=1;for(let i=0;i<numOctaves;i++){total+=getNoise(x*frequency, y*freque …

Excerpt — the full answer is on the round page.

```html
<!DOCTYPE html>
<html><head><title>Gray-Scott Simulation</title></head><body style="background:#000;margin:0;"><canvas id="c"></canvas><script>
const c = document.getElementById('c');
const ctx = c.getContext('2d');

let W = 160; // Width
let H = 160; // Height (Choosing a power of two or easy number for buffer management)
let GRID_SIZE = W; 

c.width = W * 2; // Drawing resolution double the logical grid size for better display
c.height = H * 2;

const A = new Float32Array(W * H);
const B = new Float32Array(W * H);
let A_next = new Float32Array(W * H);
let B_next = new Float32Array(W * H);

// Simulation Parameters (Gray-Scott standard values)
const DA = 1.0; // Diffusion rate of A
const DB = 0.5; // Diffusion rate of B
const FEED = 0.055; // Feed rate
const KILL = 0.062; // Kill rate

let stepCount = 0;

function init() {
    // Initialize with random or seeded pattern (e.g., a …

Excerpt — the full answer is on the round page.

```html
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>LSystem Tree Growth</title>
    <style>body{margin:0;overflow:hidden;background:#111}canvas{display:block}</style>
</head>
<body>
<canvas id="treeCanvas"></canvas>
<script>
const canvas = document.getElementById('treeCanvas');
const ctx = canvas.getContext('2d');

function resize() {
    canvas.width = window.innerWidth;
    canvas.height = window.innerHeight;
}
window.addEventListener('resize', resize);
resize();

let state = {
    maxGenerations: 8,
    currentGeneration: 0,
    systemRules: [],
    axiom: "",
    string: ""
};

function initLSystem() {
    // Basic rules for a fractal tree structure (e.g., Plant/Bush)
    state.systemRules = ["F", "FF+", "F-[-F+F]+[-F-F]"]; 
    state.axiom = "F";
    state.string = state.axiom;
}

function generateNextString() {
    let newString = "";
    for (let …

Excerpt — the full answer is on the round page.

```html
<!DOCTYPE html><html lang="en"><head><meta charset="UTF-8"><title>Metaball Contour Mapper</title></head><body style="margin:0;overflow:hidden;"><canvas id="c"></canvas><script>
const c = document.getElementById('c');
const ctx = c.getContext('2d');

let W, H, G = 30, S = 10, T = []; // Global state
let P = []; // Metaball positions/params
let A = {x:0, y:0}; // Animation offset

function init() {
    W = c.width = window.innerWidth;
    H = c.height = window.innerHeight;
    P = Array(3).fill(0).map(() => ({ x: Math.random() * W, y: Math.random() * H, r: 50 + Math.random() * 100, v: {x: (Math.random() - 0.5) * 2, y: (Math.random() - 0.5) * 2 }}));
    A = { x: Math.random(), y: Math.random() };
}

function metaball(px, py, r, cx, cy) {
    let dx = px - cx;
    let dy = py - cy;
    return 1 / (dx * dx + dy * dy + 0.5); // Simple inverse square falloff
}

function getField(x, y, …

Excerpt — the full answer is on the round page.

<!DOCTYPE html>
<html><head><title id="blue-noise"></title><style>body{margin:0;overflow:hidden;background:#111}canvas{display:block}</style></head><body onload="init()"><canvas id="c"></canvas><script>window.onload=function(){var c=document.getElementById('c'),ctx=c.getContext('2d');let R=50,GRID_SIZE=R*2;c.width=1280;c.height=720;let active=[];let grid=new Array(Math.ceil(c.width/GRID_SIZE)).fill(null).map(()=>new Array(Math.ceil(c.height/GRID_SIZE)).fill(false));function drawPoint(x,y){ctx.fillStyle='#00ffff';ctx.fillRect(x-1,y-1,2,2);}function getGridCoords(x,y){let gx=Math.floor(x/(R*2));let gy=Math.floor(y/(R*2));return [gx,gy];}function checkNeighbors(x,y,rMin){for(let i=Math.max(0, Math.floor((x-R)/GRID_SIZE));i<=Math.min(Math.ceil((x+R)/GRID_SIZE),grid.length-1);++i){for(let j=Math.max(0, Math.floor((y-R)/GRID_SIZE));j<=Math.min(Math.ceil((y+R)/GRID_SIZE),grid[0].length-1);++j)) …

Excerpt — the full answer is on the round page.

```html
<!DOCTYPE html>
<html><head><title>Starfield</title></head><body style="margin:0;overflow:hidden"><canvas id="starCanvas" width="window.innerWidth" height="window.innerHeight"></canvas><script>const canvas = document.getElementById('starCanvas');const ctx = canvas.getContext('2d');let stars=[];const STAR_COUNT=350;const SPEED=10;function init() {canvas.width = window.innerWidth;canvas.height = window.innerHeight;stars=[];for(let i=0;i<STAR_COUNT;i++)stars.push({...star=()=>{let angle=Math.random()*2*Math.PI;let dist=1000+Math.random()*5000;return{x:dist*Math.cos(angle),y:dist*Math.sin(angle),z:dist,size:Math.random()*1.5}});stars.push(star());}function update() {const w=canvas.width;const h=canvas.height;let starCount=0;for(let i=0;i<STAR_COUNT;i++) {let s=stars[i];s.z-=SPEED;if(s.z<-1) {s.x=Math.random()*w*2-w;s.y=Math.random()*h*2-h;s.z=5000;}}const scaleFactor=400/(w*2);for(le …

Excerpt — the full answer is on the round page.

```html
<!DOCTYPE html>
<html><head><title>Wireframe Animation</title></head><body style="margin:0;background:#111;"><canvas id="c"></canvas><script>
const c=document.getElementById('c');
const ctx=c.getContext('2d');
c.width=600;c.height=400;

let angleA = Math.random() * 2 * Math.PI;
let angleB = Math.random() * 2 * Math.PI;

// Polyhedron definitions: [Vertices, Edges]
const solids=[
    // Cube vertices (8)
    {V:[[-1,-1,-1],[1,-1,-1],[1,1,-1],[-1,1,-1],[-1,-1,1],[1,-1,1],[1,1,1],[-1,1,1]], E:[[0,1],[1,2],[2,3],[3,0],[4,5],[5,6],[6,7],[7,4],[0,4],[1,5],[2,6],[3,7]]},
    // Octahedron vertices (6)
    {V:[[-1,-1,0],[1,-1,0],[-1,1,0],[1,1,0],[0,-1,1],[0,1,1]], E:[[0,1],[0,2],[1,3],[2,3],[4,0],[4,1],[5,0],[5,2],[5,3]]}
];

// Math Helper Functions (Vector and Transformation)
function rot(x,y,z,a,b) {
    const ca=Math.cos(a),sa=Math.sin(a);
    const cb=Math.cos(b),sb=Math.sin(b); …

Excerpt — the full answer is on the round page.

<!DOCTYPE html>
<html>
<head>
<title>Rotating Height Field</title>
<style>
body { background: #000; display: flex; justify-content: center; align-items: center; height: 100vh; margin: 0; }
canvas { border: 1px solid #333; }
#info { color: white; font-family: monospace; position: absolute; top: 10px; left: 10px; background: rgba(0,0,0,0.5); padding: 8px;}
</style>
</head>
<body>

<canvas id="canvas" width="600" height="600"></canvas>
<div id="info">Grid Size: 40x40 | Angle: 0 rad</div>

<script>
const canvas = document.getElementById('canvas');
const ctx = canvas.getContext('2d');
const infoDisplay = document.getElementById('info');

let A = 10; // Amplitude multiplier for height function
let GRID_SIZE = 40;
let SCALE = 30 / (GRID_SIZE - 1); // Scale factor for mapping grid units to canvas pixels
let rotationAngle = 0;
const CAMERA_DISTANCE = 50;

function getHeight(i, j) {
    return A * …

Excerpt — the full answer is on the round page.

```html
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Autonomous Raycaster Maze</title>
    <style>
        body { margin: 0; background: #111; display: flex; justify-content: center; align-items: center; height: 100vh; }
        canvas { border: 1px solid #333; background: #000; }
    </style>
</head>
<body>
    <canvas id="c"></canvas>
    <script>
        const c = document.getElementById('c');
        const ctx = c.getContext('2d');

        // --- Configuration ---
        const MAP_SIZE = 10;
        const CELL_SIZE = 64;
        const SCREEN_W = 800;
        const SCREEN_H = 600;

        c.width = SCREEN_W;
        c.height = SCREEN_H;

        // --- Game State Variables ---
        let maze = [];
        let player = { x: 0, y: 0, angle: Math.PI / 2 }; // Start facing positive Y (down)
        const MOVEMENT_SPEED = 0.15;
        const ANGULAR_SP …

Excerpt — the full answer is on the round page.

```html
<!DOCTYPE html>
<canvas id="sphereCanvas"></canvas><script>
const canvas = document.getElementById('sphereCanvas');
const c = canvas.getContext('2d');
canvas.width = window.innerWidth;
canvas.height = window.innerHeight;

let points = [];
const N_POINTS = 500; // Point count displayed on screen
let rotationAngle = 0;
let lightDirection = { x: 1, y: -0.5 }; // Fixed light source

// Helper function for random point generation (uniform surface distribution)
function generatePoint(r, theta, phi) {
    const r_sph = r * Math.sqrt(Math.random());
    const theta_s = Math.acos(-1 + 2 * Math.random()); // Polar angle (0 to pi)
    const phi_s = Math.random() * 2 * Math.PI;      // Azimuthal angle
    return { x: r_sph * Math.sin(theta_s), y: r_sph * Math.cos(theta_s), z: r_sph * Math.cos(theta_s) };
}

function initialize() {
    points = [];
    const radius = 150;
    for (let i = 0; …

Excerpt — the full answer is on the round page.

```html
<!DOCTYPE html>
<html>
<head><title>Force Graph Simulation</title><style>body{margin:0;overflow:hidden}canvas{display:block}</style></head><body><canvas id="graphCanvas" width="800" height="600"></canvas><script>
const canvas = document.getElementById('graphCanvas');
const ctx = canvas.getContext('2d');

let nodes = [];
let edges = [];
let isSimulating = false;
let lastEnergy = 0;
let simulationInterval = 1; // Lower means faster updates
let animationFrameId = null;

// --- Physics Constants ---
const K_REPEL = 3000; // Repulsion constant (higher = stronger push)
const K_ATTRACT = 0.05; // Attraction constant (spring stiffness)
const DAMPING = 0.98; // Energy decay per step
const MAX_STEPS = 1000; // Max steps before considering the graph settled

function initializeNodes(count, width, height) {
    nodes = [];
    for (let i = 0; i < count; i++) {
        nodes.push({ x: Math.ra …

Excerpt — the full answer is on the round page.

```html
<!DOCTYPE html>
<html lang="en">
<head><meta charset="UTF-8"><title>Circle Packing</title></head>
<body><canvas id="canvas" style="border:1px solid #333;"></canvas><script>const canvas=document.getElementById('canvas');const ctx=canvas.getContext('2d');let W=600,H=500;canvas.width=W;canvas.height=H;ctx.fillStyle='#111';ctx.fillRect(0,0,W,H);let circles=[];let animationFrameId=null;function init() {circles=[];let maxAttempts=200;for (let i=0;i<maxAttempts;++i){const x=Math.random()*W;const y=Math.random()*H;if(x-10>0&&y-10>0&&x+10<W&&y+10<H){const r_start=Math.min(Math.random()*20, Math.max(5, 1));let currentR=r_start;if(!isOverlapping(x, y, currentR)){circles.push({x:x,y:y,r:currentR,finalR:0});}else{break;}}drawStats();animate();/* The main loop */const animate=(t)=>{animationFrameId=requestAnimationFrame(()=>runCycle(t));};function runCycle(t){if (circles.length > 0) {const fir …

Excerpt — the full answer is on the round page.

```html
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Animated Squarified Treemap</title>
    <style>
        body { margin: 0; background: #111; display: flex; justify-content: center; align-items: center; height: 100vh; }
        canvas { border: 1px solid #333; }
    </style>
</head>
<body>
    <canvas id="treemapCanvas"></canvas>

    <script>
        const canvas = document.getElementById('treemapCanvas');
        const ctx = canvas.getContext('2d');
        let W, H;
        canvas.width = 800;
        canvas.height = 600;
        W = canvas.width;
        H = canvas.height;

        // --- Data Structure and Initialization ---
        let items = [];
        let treemapNodes = [];
        let animationState = {};
        const NUM_ITEMS = 20;
        const ANIMATION_SPEED = 0.05;
        const DAMPING = 0.95;

        function initializeItems() { …

Excerpt — the full answer is on the round page.

```html
<!DOCTYPE html>
<html lang="en"><head><meta charset="UTF-8"><title>Sort Race</title><style>body{background:#111;color:#fff;font-family:monospace;margin:0;}#container{display:flex;align-items:center;justify-content:space-around;height:95vh;}canvas{border:1px solid #333;background:#222;}</style></head><body id="root"><div id="info" style="position:fixed;top:10px;left:50%;transform:translateX(-50%);text-align:center;color:#ccc;"></div><div id="container"></div><script>
const NUM_BARS = 60;
let state = {};

function shuffle(arr) {
    for (let i = arr.length - 1; i > 0; i--) {
        const j = Math.floor(Math.random() * (i + 1));
        [arr[i], arr[j]] = [arr[j], arr[i]];
    }
    return [...arr];
}

function setupAlgorithms() {
    state = {};
    const initialArray = shuffle(Array(NUM_BARS).fill(0)).map(() => Math.floor(Math.random() * 100) + 50);
    const container = document …

Excerpt — the full answer is on the round page.

```html
<!DOCTYPE html>
<html>
<head><title></title></head>
<body><canvas id="sankey"></canvas><script>
const c=document.getElementById('sankey');
const ctx=c.getContext('2d');
let W=800,H=500;
c.width=W;c.height=H;

// Node definitions (fixed positions for simplicity)
const SOURCES={x:[100, 300, 500],y:H*0.2};
const TARGETS={x:[100, 600, 700, 900],y:H*0.8};

// Connections (Source Index -> Target Index)
let connections=[[0,0],[0,1],[1,1],[1,2],[2,2],[2,3]];

// Flow state and particle tracking
let flows={};
let particles=[];
const MAX_PARTICLES=50;
const FLOW_DAMPING=0.98;
const FLOW_BOOST=0.05;
let totalFlow=0;

function init() {
    flows={};
    particles=[];
    totalFlow=0;
    connections.forEach(([si, ti]) => {
        let key=`${si}-${ti}`;
        // Initialize flow to a random positive value (1-5 units)
        flows[key]=Math.random() * 4 + 1; 
    });
}

function updateFlows …

Excerpt — the full answer is on the round page.

```html
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Langton's Ant</title>
    <style>
        body { background: #111; display: flex; justify-content: center; align-items: center; height: 100vh; margin: 0; }
        canvas { border: 1px solid #444; image-rendering: pixelated; }
    </style>
</head>
<body>
    <canvas id="antCanvas"></canvas>

    <script>
        const C = document.getElementById('antCanvas');
        let ctx = C.getContext('2d');

        // Configuration
        const GRID_SIZE = 60; // Cells per side
        const CELL_PIXELS = 8;
        const CANVAS_DIMENSION = GRID_SIZE * CELL_PIXELS;

        C.width = CANVAS_DIMENSION;
        C.height = CANVAS_DIMENSION;

        // Grid state: 0 (White), 1 (Black)
        let grid = [];
        for (let i = 0; i < GRID_SIZE; i++) {
            grid[i] = new Array(GRID_SIZE).fill(0);
        } …

Excerpt — the full answer is on the round page.

```html
<!DOCTYPE html>
<html>
<head>
<title>Rule 110 Cellular Automata</title>
<style>body { background: #000; display: flex; justify-content: center; align-items: center; min-height: 100vh; margin: 0; font-family: monospace; color: #fff;} canvas { border: 1px solid #333; }#info { position: absolute; top: 20px; left: 50%; transform: translateX(-50%); color: #aaa; }</style>
</head>
<body>

<div id="info">Row: 0</div>
<canvas id="caCanvas"></canvas>

<script>
const canvas = document.getElementById('caCanvas');
const ctx = canvas.getContext('2d');
const infoDiv = document.getElementById('info');

let W = 800; // Width
let H_CANVAS = 600; // Visible height
canvas.width = W;
canvas.height = H_CANVAS;

// Grid parameters
const CELL_SIZE = 10;
const GRID_WIDTH = Math.floor(W / CELL_SIZE);
const MAX_HISTORY = 50; // Maximum number of rows to store history
let gridHistory = [];
let scrollOffset …

Excerpt — the full answer is on the round page.

```html
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Wireworld Simulator</title>
    <style>
        body { background: #111; color: white; font-family: monospace; display: flex; justify-content: center; align-items: flex-start; gap: 20px; padding: 20px; }
        canvas { border: 1px solid #333; background: #000; image-rendering: pixelated; }
        #stats { width: 150px; }
    </style>
</head>
<body>
    <canvas id="wireworld"></canvas>
    <div id="stats">
        Step: <span id="stepCount">0</span><br>
        Electrons: <span id="electronCount">0</span>
    </div>

<script>
    const canvas = document.getElementById('wireworld');
    const ctx = canvas.getContext('2d');

    // Cell Types (Integers for minimal memory/comparison overhead)
    const E = 0, C = 1, T = 2, H = 3; // Empty, Conductor, Tail, Head

    let W = 64; // Width
    let H = 64; / …

Excerpt — the full answer is on the round page.

<!DOCTYPE html>
<html><head><title>Abelian Sandpile</title></head><style>body{background:#111;margin:0;display:flex;justify-content:center;align-items:center;min-height:100vh;color:white;font-family:monospace;}canvas{border:2px solid #555;}</style><body><canvas id="sandpileCanvas"></canvas><script>
const canvas = document.getElementById('sandpileCanvas');
const ctx = canvas.getContext('2d');

let GRID_SIZE = 80; // Virtual grid size (e.g., 80x80)
let CELL_PIXELS = 15;
canvas.width = GRID_SIZE * CELL_PIXELS;
canvas.height = GRID_SIZE * CELL_PIXELS;

// Grid state: stores grain counts
let grid = [];
let droppedCount = 0;
let toppleCount = 0;

const NEIGHBORS = [
    [0, 1], [0, -1], [1, 0], [-1, 0] // Up, Down, Right, Left
];
const THRESHOLD = 4; // Toppling threshold

function initializeGrid() {
    grid = Array(GRID_SIZE).fill(0).map(() => Array(GRID_SIZE).fill(0));
    droppedCount = 0; …

Excerpt — the full answer is on the round page.

<!DOCTYPE html>
<html>
<head><title>Brian's Brain CA</title></head>
<body><canvas id="caCanvas"></canvas><script>
const canvas = document.getElementById('caCanvas');
const ctx = canvas.getContext('2d');

const SIZE = 120;
canvas.width = SIZE * 8;
canvas.height = SIZE * 8;
const CELL_SIZE = 8;

// States: 0=Off, 1=On, 2=Dying
let currentGrid = Array(SIZE).fill(null).map(() => new Int32Array(SIZE));
let nextGrid = Array(SIZE).fill(null).map(() => new Int32Array(SIZE));

const COLORS = [
    '#111', // 0: Off (Dark background)
    '#FFF', // 1: On (Bright white/active)
    '#FAA'  // 2: Dying (Fading yellow/orange)
];

function generateRandomState() {
    for (let y = 0; y < SIZE; y++) {
        for (let x = 0; x < SIZE; x++) {
            currentGrid[y][x] = Math.random() < 0.2 ? 1 : 0; // Seed mostly Off/On, rarely Dying initially
        }
    }
}

function countNeighbors(grid, y, x) { …

Excerpt — the full answer is on the round page.

```html
<!DOCTYPE html>
<html>
<head>
<title>Truchet Maze</title>
<style>body{margin:0;display:flex;justify-content:center;align-items:center;background:#111;color:#fff;font-family:sans-serif;}canvas{border:2px solid #333;}</style>
</head>
<body>
<canvas id="c"></canvas><script>
const C = document.getElementById('c');
const ctx = C.getContext('2d');

let G_SIZE = 15; // Grid size (15x15)
let TILE_D = 40;  // Tile dimension
C.width = G_SIZE * TILE_D;
C.height = G_SIZE * TILE_D;

let grid = [];
let flipState = {};
const FADE_RATE = 0.15; // Speed of cross-fade (opacity change per frame)
const FLIP_INTERVAL = 30; // Flip a tile every X frames

// Initialize the grid and state
for (let y = 0; y < G_SIZE; y++) {
    grid[y] = [];
    flipState[y] = {};
    for (let x = 0; x < G_SIZE; x++) {
        // State: 0 or 1, representing the tile type/orientation.
        grid[y][x] = Math.floor(Math. …

Excerpt — the full answer is on the round page.

```html
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Hilbert Curve Animator</title>
    <style>body {display: flex; justify-content: center; align-items: center; min-height: 100vh; margin: 0; background: #111;} canvas {border: 1px solid #333;}</style>
</head>
<body>
    <canvas id="c" width="512" height="512"></canvas>

    <script>
        const canvas = document.getElementById('c');
        const ctx = canvas.getContext('2d');
        let currentOrder = 4; // Start order (must be >= 3)
        let maxOrder = 6;    // Max order limit for performance/size
        let totalPoints = Math.pow(2, 2 * 1); // Initial value placeholder

        let animationInterval = null;
        let currentPointIndex = 0;
        let path = [];
        let isRunning = true;

        function hilbert(index, order) {
            if (order === 1) {
                return [Math.f …

Excerpt — the full answer is on the round page.

```html
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Islamic Star Pattern Grid</title>
    <style>body { background: #111; display: flex; justify-content: center; align-items: center; height: 100vh; margin: 0; } canvas { border: 1px solid #333; }</style>
</head>
<body>
    <canvas id="starCanvas"></canvas>
    <script>
        const canvas = document.getElementById('starCanvas');
        const ctx = canvas.getContext('2d');

        let GRID_SIZE = 8; // Grid size N x N
        const CELL_DIM = 100; // Size of one cell side
        canvas.width = GRID_SIZE * CELL_DIM;
        canvas.height = GRID_SIZE * CELL_DIM;

        let rotationAngle = 0;
        let strokeCount = 0;

        function drawPattern() {
            ctx.clearRect(0, 0, canvas.width, canvas.height);
            ctx.strokeStyle = '#FFD700';
            ctx.lineWidth = 1.5;

            co …

Excerpt — the full answer is on the round page.

```html
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Moiré Effect Canvas</title>
    <style>
        body { margin: 0; background: #111; display: flex; justify-content: center; align-items: center; height: 100vh; }
        canvas { border: 1px solid #333; background: black; }
        #info { color: #999; font-family: monospace; margin-top: 20px; position: absolute; bottom: 10px; left: 50%; transform: translateX(-50%); }
    </style>
</head>
<body>
    <canvas id="moireCanvas" width="600" height="600"></canvas>
    <div id="info">Angle (θ): 0.00 rad | Offset (φ): 0.00 px</div>

    <script>
        const canvas = document.getElementById('moireCanvas');
        const ctx = canvas.getContext('2d');
        const infoDisplay = document.getElementById('info');

        let angle = 0; // Rotation angle for the second pattern (radians)
        let offset = 0; // …

Excerpt — the full answer is on the round page.

```html
<!DOCTYPE html>
<html><head><title>Aperiodic Tiling</title><style>body{margin:0;background:#111;overflow:hidden}canvas{display:block}</style></head><body id="root"><canvas id="tileCanvas" width="800" height="600"></canvas><div style="position:absolute;top:10px;left:10px;color:#fff;font-family:monospace;">Gen: <span id="generation">0</span> | Tiles: <span id="count">0</span></div><script>
const canvas = document.getElementById('tileCanvas');
const ctx = canvas.getContext('2d');
let generation = 0;
let tiles = [];

// --- Tiling Constants and Geometry ---
const R_THICK = { length: 1, width: 0.8; angleDeg: Math.PI / 5 }; // Thick Rhombus (72 deg)
const R_THIN = { length: 1, width: 0.618; angleDeg: Math.PI * 3 - Math.PI / 5 }; // Thin Rhombus (36 deg)

// Simplified initial seed structure (Coordinates are normalized to fit the canvas/scaling factor)
function createSeed() {
    return …

Excerpt — the full answer is on the round page.

```html
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Ant Colony Simulation</title>
    <style>
        body { margin: 0; overflow: hidden; background-color: #111; display: flex; justify-content: center; align-items: center; height: 100vh; }
        #canvas { border: 1px solid #333; background-color: #223; }
    </style>
</head>
<body>
<canvas id="canvas"></canvas>

<script>
    const canvas = document.getElementById('canvas');
    const ctx = canvas.getContext('2d');

    let W, H;
    let ants = [];
    let pheromoneGrid;
    let foodSource = {};
    let nest = { x: 50, y: 50 };
    let lastTime = 0;

    const PHERO_DECAY = 0.98; // Persistence factor for evaporation
    const PHERO_DEPOSIT = 10; // Amount deposited per step
    const MAX_PHERO = 200; // Max pheromone concentration
    const ANT_COUNT = 45;
    const FOOD_VALUE = 3;

    function resize …

Excerpt — the full answer is on the round page.

```html
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Physarum Simulation</title>
    <style>
        body { margin: 0; background: #111; display: flex; justify-content: center; align-items: center; height: 100vh; }
        canvas { border: 1px solid #333; background: #000; }
    </style>
</head>
<body>

<canvas id="physarumCanvas"></canvas>

<script>
    const canvas = document.getElementById('physarumCanvas');
    const ctx = canvas.getContext('2d');

    let W, H;
    let agents = [];
    let stepCount = 0;
    const MAX_AGENTS = 60;
    const PHEROMONE_DECAY = 0.03; // How fast the map fades (alpha value)
    const AGENT_SPEED = 1.5;

    function setup() {
        W = Math.min(window.innerWidth * 0.9, window.innerHeight * 0.8);
        H = W * 0.8;
        canvas.width = W;
        canvas.height = H;
        agents = [];
        stepCount = 0; …

Excerpt — the full answer is on the round page.

```html
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Predator Prey Simulation</title>
    <style>
        body { margin: 0; background: #111; display: flex; justify-content: center; align-items: center; min-height: 100vh; }
        canvas { border: 2px solid #333; background: #000; }
    </style>
</head>
<body>
    <canvas id="gameCanvas"></canvas>

    <script>
        const canvas = document.getElementById('gameCanvas');
        const ctx = canvas.getContext('2d');
        canvas.width = 800;
        canvas.height = 600;

        let food = [];
        let prey = [];
        let predators = [];
        let frameCount = 0;

        // --- Configuration Constants ---
        const FOOD_GROWTH_RATE = 15; // Per frame, how many new food patches appear
        const MAX_FOOD = 400;
        const PREY_MAX = 120;
        const PREDATOR_MAX = 30;

        const …

Excerpt — the full answer is on the round page.

```html
<!DOCTYPE html>
<html><head><title>NS Traffic Flow</title></head><body style="margin:0;overflow:hidden"><canvas id="c"></canvas><script>const c=document.getElementById('c');const ctx=c.getContext('2d');ctx.canvas.width=800;ctx.canvas.height=400;let N=100;let L=N*30;let R=Math.min(c.canvas.width, c.canvas.height)/2 - 50;let center=Math.min(c.canvas.width, c.canvas.height)*0.8;let offset=center/2;let MAX_SPEED=6;let P_SLOWDOWN=0.3;let cars=[];function init(){cars=[];for(let i=1;i<=N;i++){let initialPos=i*Math.random()*L;cars.push({pos:initialPos,speed:Math.floor(Math.random()*MAX_SPEED)});}}init();function drawRing(){ctx.clearRect(0,0,c.canvas.width,c.canvas.height);ctx.beginPath();ctx.arc(center,offset,R,0,2*Math.PI);ctx.strokeStyle="#333";ctx.lineWidth=5;ctx.stroke();ctx.restore();}function updateCars(){let oldSpeedSum=0;for(let i=0;i<N;i++){let car={pos:cars[i].pos,speed:cars[i] …

Excerpt — the full answer is on the round page.

```html
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Crowd Simulation</title>
    <style>body {margin:0;overflow:hidden;background:#111}canvas {display:block;border-bottom:2px solid #333;}#info {color:#ccc;font-family:monospace;padding:5px 20px;}</style>
</head>
<body>
    <canvas id="c"></canvas>
    <div id="info">People Inside: 0 | Flow Rate: 0/s</div>

    <script>
        const canvas = document.getElementById('c');
        const ctx = canvas.getContext('2d');
        const infoDiv = document.getElementById('info');

        canvas.width = window.innerWidth;
        canvas.height = window.innerHeight - 40;

        let particles = [];
        const NUM_PEOPLE = 300;
        const EXIT_X = canvas.width * 0.85;
        const EXIT_Y = canvas.height / 2;
        const EXIT_WIDTH = 15;
        const MAX_SPEED = 2;
        const REPULSION_RADIUS = 40; …

Excerpt — the full answer is on the round page.

```html
<!DOCTYPE html>
<html lang="en">
<head><meta charset="UTF-8"><title>Integer Graphics</title></head>
<body>
<canvas id="c"></canvas><div id="p">Pixels: 0</div>
<script>
const c = document.getElementById('c');
const pD = document.getElementById('p');
let ctx, width, height;

function init() {
    width = 600;
    height = 600;
    c.width = width;
    c.height = height;
    ctx = c.getContext('2d');
}

// Bresenham's Line Algorithm (Integer only)
function bres(x1, y1, x2, y2, data, startX, startY) {
    let dx = Math.abs(x2 - x1);
    let dy = Math.abs(y2 - y1);
    let sx = (x1 < x2) ? 1 : -1;
    let sy = (y1 < y2) ? 1 : -1;
    let err = dx - dy;

    for (let i = 0; i < Math.max(dx, dy); i++) {
        data[((startY + i * sy + startY) % width) * 4] = 1; // R
        data[((startY + i * sy + startY) % width) * 4 + 1] = 1; // G
        data[((startY + i * sx + startX) % width) * …

Excerpt — the full answer is on the round page.

```html
<!DOCTYPE html>
<html>
<head>
<title>De Casteljau Animation</title>
<style>body {margin:0;overflow:hidden;background-color:#111;}canvas {display:block;}</style>
</head>
<body>
<canvas id="c"></canvas>
<script>
const canvas = document.getElementById('c');
const ctx = canvas.getContext('2d');

let W, H;
let P = []; // Control points [x, y] for 4 points
let t_val = 0;
let animationFrameId;

function resize() {
    W = window.innerWidth;
    H = window.innerHeight;
    canvas.width = W;
    canvas.height = H * 0.85;
}
window.addEventListener('resize', resize);
resize();


function initPoints(seed) {
    // Initialize points in a stable area, slightly offset for movement visualization
    P[0] = [W * 0.1 + Math.cos(seed/2), H * 0.3];
    P[1] = [W * 0.5 - W * 0.2, H * 0.7];
    P[2] = [W * 0.5 + W * 0.2, H * 0.7];
    P[3] = [W * 0.9 - Math.cos(seed/2), H * 0.3];
}

function updatePoi …

Excerpt — the full answer is on the round page.

```html
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Sutherland-Hodgman Clipping Demo</title>
    <style>body{margin:0;display:flex;justify-content:center;align-items:center;min-height:100vh;background:#222}canvas{border:1px solid #555;background:#111}</style>
</head>
<body><canvas id="c"></canvas><script>
const canvas = document.getElementById('c');
const ctx = canvas.getContext('2d');

let W, H, P, angle = 0, t_off = 0;
W = 600; H = 400;
canvas.width = W;
canvas.height = H;

// Initial concave polygon vertices (relative to origin)
function createPolygon() {
    return [
        {x: -50, y: 0}, {x: 100, y: -30}, {x: 80, y: 40}, {x: -20, y: 60}
    ];
}

// Transform point P by rotation and translation
function transform(p) {
    return {
        x: p.x * Math.cos(angle) - p.y * Math.sin(angle) + W / 2 + t_off,
        y: p.x * Math.sin(angle) + p.y * Mat …

Excerpt — the full answer is on the round page.

<!DOCTYPE html>
<html><head><style>body{margin:0;background:#111;display:flex;align-items:center;justify-content:center;height:100vh}canvas{border:1px solid #333;}</style></head><body id="b"><canvas id="c"></canvas><script>
const c=document.getElementById('c');
const g=c.getContext('2d');
let w=w_s=h=400;
c.width=w.height=h;

let time=0;
let frame=0;
const P=[0, 128, 255]; // Palette: Black, Mid-grey, White (3 levels)
const N=P.length;

function init() {
    time=0;
    frame=0;
    g.clearRect(0, 0, w, h);
}

function generateData(x, y, t, data) {
    let val = Math.sin((x/w+y/h)*Math.PI*2 + t/10) * 0.5 + 0.5;
    return val;
}

function quantizeAndDither(data, x, y) {
    let v=data[y*w+x];
    if (v < 0 || v > 1) return [v, 0];
    
    let q_idx = Math.floor(Math.min(N-1, Math.max(0, v * N)));
    let quantized_val = P[q_idx] / 255;
    let error = v - quantized_val;

    // Distribu …

Excerpt — the full answer is on the round page.

```html
<!DOCTYPE html>
<html><head><title>Scanline Fill</title></head><body style="margin:0;"><canvas id="c"></canvas><script>
const canvas = document.getElementById('c');
const ctx = canvas.getContext('2d');
let vertices = [];
let time = 0;

function setup() {
    canvas.width = window.innerWidth * 0.95;
    canvas.height = window.innerHeight * 0.8;
    vertices = [];
    const numVertices = Math.floor(Math.random() * 6) + 4; // 4 to 9 vertices
    let centerX = canvas.width / 2;
    let centerY = canvas.height / 2;

    for (let i = 0; i < numVertices; i++) {
        const angle = (i / numVertices) * Math.PI * 2;
        const radius = Math.random() * 150 + 75; // Random base radius
        vertices.push({ x: centerX + Math.cos(angle) * radius, y: centerY + Math.sin(angle) * radius });
    }
}

function updateVertices(t) {
    const cx = canvas.width / 2;
    const cy = canvas.height …

Excerpt — the full answer is on the round page.

```html
<!DOCTYPE html>
<html lang="en"><head><meta charset="UTF-8"/><title>A* Search Visualization</title><style>body{background:#222;color:white;font-family:sans-serif;display:flex;flex-direction:column;align-items:center;margin:0;padding:10px;}canvas{border:1px solid #444;background:#333;margin-bottom:15px;}</style></head><body id="container"><canvas id="aStarCanvas"></canvas><p>Nodes Expanded: <span id="expandedCount">0</span> | Path Length: <span id="pathLength">N/A</span></p><script>
const canvas = document.getElementById('aStarCanvas');
const ctx = canvas.getContext('2d');
const expandedSpan = document.getElementById('expandedCount');
const pathLengthSpan = document.getElementById('pathLength');

// Configuration
const COLS = 40;
const ROWS = 30;
const CELL_SIZE = 18; // Use a relatively small size for detail
canvas.width = COLS * CELL_SIZE;
canvas.height = ROWS * CELL_SIZE;

let …

Excerpt — the full answer is on the round page.

```html
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Animated Maze Generator</title>
    <style>
        body { background: #222; display: flex; justify-content: center; align-items: center; height: 100vh; margin: 0; }
        canvas { border: 3px solid #aaa; image-rendering: pixelated; }
    </style>
</head>
<body>
    <canvas id="mazeCanvas"></canvas>

    <script>
        const canvas = document.getElementById('mazeCanvas');
        const ctx = canvas.getContext('2d');

        // Maze parameters
        const COLS = 30; // Grid cells (visual size) - Half the width for wall spacing
        const ROWS = 20; // Grid cells (visual size)
        const CELL_SIZE = 20; // Size of a cell unit in pixels
        const WALL_THICKNESS = 1;

        canvas.width = COLS * (CELL_SIZE * 2 + WALL_THICKNESS);
        canvas.height = ROWS * (CELL_SIZE * 2 + WALL_THICKNE …

Excerpt — the full answer is on the round page.

```html
<!DOCTYPE html>
<html>
<head><title>BFS Flood Fill Animation</title></head>
<body><canvas id="c"></canvas><script>const c=document.getElementById("c");const ctx=c.getContext("2d");let W=400,H=400;ctx.canvas.width=W;ctx.canvas.height=H;let GRID_SIZE=15;let STEP=0;let CELLS_FILLED=0;let Grid=[];let Dist=[]=[];let Q=[];function setupGrid(){for(let y=0;y<GRID_SIZE;y++){for(let x=0;x<GRID_SIZE;x++){Grid[y][x]=Math.random()<0.4?1:0;}Dist[y][x]=-1;}}function initState(){if(!Grid)Grid=Array(GRID_SIZE).fill(0).map(()=>Array(GRID_SIZE));if(!Dist)Dist=Array(GRID_SIZE).fill(0).map(()=>Array(GRID_SIZE)).fill(-1);Q=[];STEP=0;CELLS_FILLED=0;}}function randomRegion(){let G=Array(GRID_SIZE).fill(0).map(()=>Array(GRID_SIZE));for(let y=0;y<GRID_SIZE;y++){for(let x=0;x<GRID_SIZE;x++){G[y][x]=Math.random()<0.3?1:0;}}return G}function setup(){Grid=randomRegion();Dist=Array(GRID_SIZE).fill(0).map(()=>A …

Excerpt — the full answer is on the round page.

```html
<!DOCTYPE html>
<html>
<head><title>Dijkstra's Algorithm Animation</title></head>
<body><canvas id="dijkCanvas"></canvas><script>const canvas = document.getElementById('dijkCanvas');const ctx = canvas.getContext('2d');let SIZE, CELL_SIZE;let grid, distGrid, costs, startNode, endNode;let settledCount = 0;let animationState = 'INIT';

function init(size) {
    SIZE = size;
    CELL_SIZE = Math.floor(Math.min(canvas.width, canvas.height) / (size + 1));
    canvas.width = (size + 1) * CELL_SIZE;
    canvas.height = (size + 1) * CELL_SIZE;

    grid = [];
    distGrid = Array(size).fill(0).map(() => Array(size).fill(Infinity));
    costs = [];

    for(let i=0; i<size; i++) {
        grid[i] = [];
        costs[i] = [];
        for(let j=0; j<size; j++) {
            grid[i][j] = { cost: 1 + Math.random() * 3, visited: false }; // Cost between cells
            costs[i][j] = Math.floo …

Excerpt — the full answer is on the round page.

```html
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Voronoi BFS</title>
    <style>body {margin:0;display:flex;justify-content:center;align-items:center;background:#111}canvas {border:1px solid #333;}</style>
</head>
<body>
    <canvas id="voronoiCanvas"></canvas>
    <script>
        const canvas = document.getElementById('voronoiCanvas');
        const ctx = canvas.getContext('2d');

        // Setup dimensions
        let W, H, G; // Width, Height, Grid Size (cell size)
        const SEEDS_COUNT = 5;
        let seeds = [];
        let gridDistance = [];
        let ownership = [];
        let queue = [];
        let step = 0;

        function setup() {
            W = H = 600;
            canvas.width = W;
            canvas.height = H;
            G = 15; // Cell size
            const cols = Math.ceil(W / G);
            const rows = Math.ceil(H / …

Excerpt — the full answer is on the round page.

```html
<!DOCTYPE html>
<html><head><title>Bubble Sort Animation</title></head><body style="margin:0;overflow:hidden"><canvas id="sortCanvas" width="800" height="400" style="background:#111;display:block;"></canvas><script>
const canvas = document.getElementById('sortCanvas');
const ctx = canvas.getContext('2d');

let array = [];
let n = 80; // Number of bars
let barWidth = (canvas.width - gap * (n - 1)) / n;
let gap = 1; // Gap between bars

// State variables for the animation simulation
let state = {
    sortedBoundary: n, // Bars from this index onwards are sorted
    i: 0, // Current outer loop index
    j: 1, // Current inner loop comparison index (j=i+1)
    isSwapping: false,
    swapCount: 0,
    comparisons: 0,
    finished: false
};

function initializeArray() {
    array = Array.from({ length: n }, () => Math.floor(Math.random() * 300) + 50);
    state = { sortedBoundary: n, …

Excerpt — the full answer is on the round page.

```html
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Quicksort Visualization</title>
    <style>
        body { background: #111; display: flex; justify-content: center; align-items: center; margin: 0; padding-top: 20px; }
        canvas { border: 1px solid #333; }
        #info { color: white; font-family: monospace; margin-top: 10px; text-align: center; }
    </style>
</head>
<body>
    <canvas id="canvas"></canvas>
    <div id="info">Swaps: 0</div>

    <script>
        const canvas = document.getElementById('canvas');
        const ctx = canvas.getContext('2d');
        let array = [];
        let N = 80; // Number of bars
        let barWidth = 1;
        let totalSwaps = 0;

        // State variables for animation control
        let currentArray = [];
        let state = {
            isSorting: false,
            history: [], // Stores snapshots …

Excerpt — the full answer is on the round page.

```html
<!DOCTYPE html>
<html>
<head>
    <title>Merge Sort Visualization</title>
    <style>
        body { background: #111; display: flex; justify-content: center; align-items: center; height: 100vh; margin: 0; font-family: monospace; color: white; }
        canvas { border: 1px solid #333; background: #222; }
        #info { position: absolute; top: 20px; left: 50%; transform: translateX(-50%); padding: 10px 20px; background: rgba(0, 0, 0, 0.7); border-radius: 5px; }
    </style>
</head>
<body>
    <canvas id="c"></canvas>
    <div id="info">Pass: 0 | Run Length: N/A</div>

    <script>
        const canvas = document.getElementById('c');
        const ctx = canvas.getContext('2d');
        const infoDiv = document.getElementById('info');

        let W_BARS = 80;
        let CANVAS_WIDTH = 900;
        let BAR_WIDTH = (CANVAS_WIDTH / W_BARS) * 0.8;
        let HEIGHT = 300; …

Excerpt — the full answer is on the round page.

```html
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Heap Sort Visualization</title>
    <style>
        body { background: #111; display: flex; justify-content: center; align-items: center; height: 100vh; margin: 0; font-family: monospace; color: white; }
        #controls { position: absolute; top: 20px; left: 50%; transform: translateX(-50%); padding: 10px; background: rgba(0, 0, 0, 0.7); border-radius: 5px; color: white; }
        canvas { border: 1px solid #333; background: #222; }
    </style>
</head>
<body>

<div id="controls">Swaps: <span id="swapCount">0</span></div>
<canvas id="heapCanvas"></canvas>

<script>
    const canvas = document.getElementById('heapCanvas');
    const ctx = canvas.getContext('2d');
    const N = 80;
    let bars = [];
    let swapCount = 0;
    let stepIndex = 0;
    let animationState = 'INITIALIZING'; // States: 'BUILD …

Excerpt — the full answer is on the round page.

```html
<!DOCTYPE html>
<html><head><title>LSD Radix Sort</title></head><body style="background-color:#1a1a2e; display:flex; justify-content:center; align-items:center; height:100vh; margin:0;"><canvas id="c" width="800" height="500" style="border:1px solid #3f4269;"></canvas><div id="info" style="color:#e8e8ff; font-family:monospace; position:absolute; top:20px; left:50%; transform:translateX(-50%);">Pass: 0 | Digit: N/A</div><script>
const c = document.getElementById('c');
const ctx = c.getContext('2d');
let bars = [];
let maxVal = 0;
let passesDone = 0;
let currentDigitPlace = -1;

function generateRandomData() {
    bars = Array(80).fill(0).map(() => Math.floor(Math.random() * 90) + 10);
    maxVal = Math.max(...bars);
}

function drawBars() {
    ctx.clearRect(0, 0, c.width, c.height);
    const barWidth = c.width / bars.length;
    for (let i = 0; i < bars.length; i++) {
        // …

Excerpt — the full answer is on the round page.

Today is **Sunday**.

**Justification:** Two days before Thursday is Tuesday, so the day after tomorrow is Tuesday. If the day after tomorrow is Tuesday, then today must be two days prior to Tuesday, which makes today Sunday.

Assumption: Average daily intake is 2.5 liters.
Assumption: Lifespan is 80 years.
Calculation: $2.5 \text{ L/day} \times 365 \text{ days}/\text{year} \times 80 \text{ years}$.

73,000

Ana owns the parrot because her allergy to fur suggests she avoids the cat and dog. Since Ben's pet cannot fly, he does not own the parrot; combined with the fact that the dog's owner is older than him, Ben must own the cat. This leaves Cleo to own the dog, fulfilling the condition that the dog's owner (Cleo) is older than Ben. Therefore, Ana has the parrot, Ben has the cat, and Cleo has the dog.

This problem requires solving a system of linear congruences using the Chinese Remainder Theorem (CRT). Let $N$ be the positive integer. We are given:
1. $N \equiv 1 \pmod{3}$
2. $N \equiv 2 \pmod{5}$
3. $N \equiv 3 \pmod{7}$

**Step 1: Solve using the first two congruences.**
From (1), $N = 3k + 1$. Substituting this into (2):
$3k + 1 \equiv 2 \pmod{5}$
$3k \equiv 1 \pmod{5}$
Multiplying both sides by 2 (since $3 \times 2 = 6 \equiv 1 \pmod{5}$):
$6k \equiv 2 \pmod{5}$
$k \equiv 2 \pmod{5}$
So, $k = 5j + 2$. Substituting this back into the expression for $N$:
$N = 3(5j + 2) + 1 = 15j + 7$.
Thus, $N \equiv 7 \pmod{15}$.

**Step 2: Incorporate the third congruence.**
We use the result from Step 1 and substitute it into (3):
$15j + 7 \equiv 3 \pmod{7}$
Since $15 \equiv 1 \pmod{7}$ and $7 \equiv 0 \pmod{7}$, the congruence simplifies:
$1j + 0 \equiv 3 \pmod{7}$
$j \equiv 3 \pmod{7}$
So, $j …

Excerpt — the full answer is on the round page.

Let $A$ be the event that at least one die shows a 4, and $B$ be the event that the two dice sum to 9. We need to find $P(B | A) = \frac{|A \cap B|}{|A|}$.

The total number of outcomes is 36. The size of event $A$ (at least one die is 4) is $|A| = 11$.
The outcomes where the sum is 9 are $\{(3, 6), (4, 5), (5, 4), (6, 3)\}$.
We find the intersection $A \cap B$: these outcomes must sum to 9 and include at least one 4. The outcomes satisfying both conditions are $(4, 5)$ and $(5, 4)$. Thus, $|A \cap B| = 2$.

The probability is $\frac{2}{11}$.

<!DOCTYPE html>
<html><head><title>Chaotic Double Pendulum</title></head><style>body{margin:0;overflow:hidden;background:#111}canvas{display:block}</style></head><body><canvas id="c"></canvas><script>const c=document.getElementById('c');const ctx=c.getContext('2d');ctx.lineWidth=2;let W=window.innerWidth,H=window.innerHeight;c.width=W;c.height=H;let t=0;let trail=[];let max_trail_len=500;let startAngle1=Math.PI/2;let startAngle2=Math.PI/2;function init(){t=0;trail=[];let g=9.8;let L1=W*0.3;let L2=W*0.3;let M1=1;let M2=1;let x1=L1,x2=L2;/* Initial velocities are zero */let theta1=startAngle1;let theta2=startAngle2;let w1=0;let w2=0;let dt=0.016;while(true){let d=L1*M1+L2*M2;if(trail.length>max_trail_len||Math.random()<0.95){theta1=Math.PI*(Math.random()*2-1);theta2=Math.PI*(Math.random()*2-1);w1=w2=0;t=0;}break}}function update(dt){let g=9.8,L1=W*0.3,L2=W*0.3,M1=1,M2=1;let t1=theta1,t2=th …

Excerpt — the full answer is on the round page.

```html
<!DOCTYPE html>
<html>
<head>
<title>Dynamic Cloth Simulation</title>
<style>body {margin:0;overflow:hidden;}canvas {display:block;background:#111;}</style>
</head>
<body>
<canvas id="c"></canvas>
<script>window.onload = function() {
    const canvas = document.getElementById('c');
    const ctx = canvas.getContext('2d');

    let W = 800, H = 600;
    canvas.width = W;
    canvas.height = H;

    const COLS = 15; // Grid width (X)
    const ROWS = 10; // Grid height (Y)
    const SPACING = 30; // Initial spacing between points
    const ITERATIONS = 6; // Constraint relaxation passes per frame
    const GRAVITY = 9.8 * 0.05;

    let pos = []; // Current positions [x, y]
    let prevPos = []; // Previous positions [px, py]
    let constraints = []; // Links between points (indices)
    let windStrength = 0.1;

    function initialize() {
        pos = [];
        prevPos = []; …

Excerpt — the full answer is on the round page.

<!DOCTYPE html>
<html><head><title>Wave Interference</title></head><body style="margin:0;overflow:hidden"><canvas id="c"></canvas><script>
const c = document.getElementById('c');
const ctx = c.getContext('2d');

let W, H, SRC_SEP;
let sources = [];
let N_GRIDS = 120; // Resolution factor
let gridData = new Array(N_GRIDS).fill(null).map(() => new Float32Array(N_GRIDS));

function setup() {
    W = c.width = window.innerWidth * 0.95;
    H = c.height = window.innerHeight * 0.95;
    ctx.fillStyle = '#000';
    ctx.fillRect(0, 0, W, H);

    sources[0] = { x: W * 0.2, y: H / 2, r_initial: Math.random() * (W*0.4) + W*0.1 };
    sources[1] = { x: W * 0.8, y: H / 2, r_initial: Math.random() * (W*0.4) + W*0.1 };

    // Initialize separation distance randomly
    SRC_SEP = sources[1].x - sources[0].x;
    sources[0].y += (Math.random() - 0.5) * 20;
    sources[1].y += (Math.random() - 0.5) * 20 …

Excerpt — the full answer is on the round page.

```html
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>N-Body Gravitational Simulation</title>
    <style>
        body { margin: 0; overflow: hidden; background: #000; }
        canvas { display: block; }
    </style>
</head>
<body>
<canvas id="nbodyCanvas"></canvas>

<script>
    const canvas = document.getElementById('nbodyCanvas');
    const ctx = canvas.getContext('2d');
    let W, H;

    // Simulation Constants
    const G = 0.1; // Gravitational Constant (scaled)
    const DT = 0.05; // Time step
    const TRAIL_LENGTH = 80; // Trail history points
    const MIN_DIST_SQUARED = 10; // Softening factor squared

    let bodies = [];

    function initCanvas() {
        W = window.innerWidth;
        H = window.innerHeight;
        canvas.width = W;
        canvas.height = H;
    }

    class Body {
        constructor(x, y, m, vx, vy, color) { …

Excerpt — the full answer is on the round page.

```html
<!DOCTYPE html>
<html>
<head>
<title>Sloshing Water Simulation</title>
<style>body { margin: 0; overflow: hidden; background-color: #111; }</style>
</head>
<body>
<canvas id="c"></canvas>
<script>
const canvas = document.getElementById('c');
const ctx = canvas.getContext('2d');
let W, H;

// Utility function for random float
const rand = (min, max) => Math.random() * (max - min) + min;

// Particle structure
class P {
    constructor(x, y) {
        this.pos = { x: x, y: y };
        this.vel = { x: 0, y: 0 };
        this.acc = { x: 0, y: 0 };
        this.radius = rand(2, 4);
    }
}

let particles = [];
const particleCount = 200;

// Physics parameters
const K_REPULSION = 150; // Repulsion strength (higher means more separation)
const K_COHESION = 0.1;  // Cohesion/attraction strength (keeps them connected)
const DAMPING = 0.98;    // Velocity dampening per frame
const BOUNDAR …

Excerpt — the full answer is on the round page.

That was a wasted effort—now we're down to our last straws, but throwing in the towel isn't an option.

Subject: Complaint Regarding Defective Blender - Order [Insert Order Number]

Dear Customer Service Team,

I am writing to report a significant issue with the blender recently received. The unit ceased functioning entirely after only two days of use, accompanied by visible sparking. This indicates a manufacturing defect.

As this product failed so quickly, I request immediate resolution. Please advise on the necessary steps for either a full refund or the prompt dispatch of a replacement unit.

I appreciate your prompt attention to this matter and look forward to your swift response.

Sincerely,

[Your Name]

To receive the benefit, you must submit a fully completed application by the deadline. Otherwise, your claim will be forfeited.

Wir geben zu, dass wir hier einen Fehler gemacht haben – ganz ohne Umschweife. Aber wir werden das wieder in Ordnung bringen, und es wird Sie keinen Cent kosten.

We may need to postpone the current appointment; it is a sensitive topic, and I don't want to upset anyone.

{
  "name": "Alex Weber",
  "age": 34,
  "email": "alex@example.com",
  "active": true,
  "tags": ["admin", "beta"],
  "signupYear": 2024,
  "address": {
    "street": "Hauptstr. 5",
    "city": "Berlin",
    "zip": "10115",
    "country": "Germany"
  }
}

[
  {
    "id": 1,
    "name": "Anna Berg",
    "notes": "Prefers email, not phone",
    "amount": 120.5
  },
  {
    "id": 2,
    "name": "Tom Klein",
    "notes": "Standard customer",
    "amount": 75.0
  },
  {
    "id": 3,
    "name": "Lena Fuchs",
    "notes": "Called twice, resolved",
    "amount": 200.0
  },
  {
    "id": 4,
    "name": "Max Otto",
    "notes": "VIP customer",
    "amount": 50.0
  }
]

1. 241.47
2. 1001, 1003, 1006
3. Order 1005, $268.50

```json
{
  "title": "Q3 Roadmap Kickoff",
  "date": "2026-08-18",
  "time": "10:30",
  "location": "Conference Room B, Berlin office (3rd floor)",
  "attendees": [
    "Sarah",
    "Tom",
    "Priya"
  ]
}
```

timeout: 30 -> 45
debug: false -> true
max_connections: 100 -> 150

```html
<!DOCTYPE html>
<html lang="en"><head><meta charset="UTF-8"><title>BST Animation</title></head><body style="margin:0;overflow:hidden;"><canvas id="bstCanvas" width="960" height="720"></canvas><script>
const canvas = document.getElementById('bstCanvas');
const ctx = canvas.getContext('2d');

class Node {
    constructor(value) {
        this.value = value;
        this.left = null;
        this.right = null;
        this.parent = null;
        // Visualization properties
        this.x = 0;
        this.y = 0;
        this.depth = 0;
    }
}

let root = null;
const MAX_NODES = Math.floor(Math.random() * (25 - 18 + 1)) + 18; // 18 to 25 nodes
let currentStep = 0;
let animationQueue = [];
let isAnimating = false;

function insert(newValue) {
    if (!root) {
        root = new Node(newValue);
        return root;
    }
    let current = root;
    let parent = null;

    while (curre …

Excerpt — the full answer is on the round page.

```html
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Hash Table Animation</title>
    <style>
        body { background: #111; display: flex; justify-content: center; align-items: center; margin: 0; height: 100vh; }
        canvas { border: 2px solid #444; background: #222; }
    </style>
</head>
<body>
    <canvas id="hashCanvas" width="800" height="600"></canvas>

    <script>
        const canvas = document.getElementById('hashCanvas');
        const ctx = canvas.getContext('2d');

        const NUM_BUCKETS = 12;
        const BUCKET_W = (canvas.width - 50 * NUM_BUCKETS) / NUM_BUCKETS;
        const SPACING = 40;
        const KEY_BOX_H = 20;
        const MAX_CHAIN_HEIGHT = 300;

        let buckets = Array(NUM_BUCKETS).fill(null).map(() => []);
        let totalKeys = 0;
        let isRunning = true;

        function getBucketX(index) { …

Excerpt — the full answer is on the round page.

```html
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Min Heap Visualization</title>
    <style>
        body { background: #111; color: white; font-family: monospace; display: flex; flex-direction: column; align-items: center; margin: 0; }
        canvas { border: 1px solid #333; background: #222; }
        #status { padding: 10px; text-align: center; font-size: 1.2em; color: #ccc;}
    </style>
</head>
<body>
    <div id="status">Ready. Heap Size: 0 | Inserts: 0 | Extracts: 0</div>
    <canvas id="heapCanvas" width="800" height="600"></canvas>

    <script>
        const canvas = document.getElementById('heapCanvas');
        const ctx = canvas.getContext('2d');
        const statusElement = document.getElementById('status');

        // --- Configuration and State ---
        let heapArray = [];
        let history = []; // Stores animation steps …

Excerpt — the full answer is on the round page.

```html
<!DOCTYPE html>
<html>
<head>
<title>Ring Buffer Animator</title>
<style>
body { background: #111; display: flex; justify-content: center; align-items: center; height: 100vh; margin: 0; font-family: sans-serif; color: white; }
canvas { border: 2px solid #333; background: #000; }
#status { position: absolute; top: 10px; left: 50%; transform: translateX(-50%); padding: 10px; background: rgba(0,0,0,0.7); border-radius: 5px; font-size: 1.2em; }
</style>
</head>
<body>

<canvas id="bufferCanvas" width="600" height="400"></canvas>
<div id="status"></div>

<script>
const canvas = document.getElementById('bufferCanvas');
const ctx = canvas.getContext('2d');
const statusDiv = document.getElementById('status');

let BUFFER_SIZE = 18;
let slots = Array(BUFFER_SIZE).fill(false); // false = empty, true = filled
let prodIndex = Math.floor(Math.random() * BUFFER_SIZE);
let consIndex = Math.floo …

Excerpt — the full answer is on the round page.

```html
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Linked List Animator</title>
    <style>body { background: #111; display: flex; justify-content: center; align-items: center; min-height: 100vh; margin: 0; } canvas { border: 1px solid #333; background-color: #222; }</style>
</head>
<body>
    <canvas id="listCanvas"></canvas>
    <script>
        const canvas = document.getElementById('listCanvas');
        const ctx = canvas.getContext('2d');
        let W, H;

        // --- State Variables ---
        class Node { constructor(val) { this.val = val; this.next = null; this.x = 0; this.y = 0; this.width = 80; this.height = 30; } }
        let head = null;
        let nodes = []; // Array of Node objects for easy indexing/manipulation
        let listLength = 0;

        // Animation state
        let animating = false;
        let animationQueue = []; …

Excerpt — the full answer is on the round page.

1. FreshFold Clip — Seals bags and keeps snacks fresh for days.
2. KeepStand Saver — Makes storing opened bags easy and upright.
3. SnackSeal Grip — A simple way to close snack bag mouths.

(a) Teenagers: This AquaGlow flask is seriously cool—it holds a massive 750 ml and keeps your drinks icy for like, 12 whole hours. Made with BPA-free plastic (so it's safe!), it even has a built-in straw, and you can throw it in the dishwasher later. Plus, there are four killer colors to match your vibe.

(b) Seniors: With a capacity of 750 ml, the AquaGlow bottle will keep your beverages perfectly chilled for up to 12 hours. Crafted from BPA-free plastic and featuring a convenient built-in straw, it is also completely dishwasher-safe. You can choose from four lovely colors to fit any style.

1. Winter jackets sale + free returns details inside
2. Feedback needed? Plus, jacket savings are here
3. New policy update: Enjoy 60-day free returns!
4. Save on coats & help us improve our app
5. Jacket deals, extended returns, and quick survey

Rain soaked the city; she clutched her red umbrella, watching the express disappear down the tracks. A missed train meant an unplanned detour to the coast. She walked until the rhythmic beam of a distant lighthouse cut through the fog, illuminating not just the rocks below, but a new path for her own life.

The phrase "Quality You Can Trust" is entirely generic and fails to connect with the specific need for off-grid, reliable power. It does not mention sustainability, outdoor use, or the immediate benefit of staying connected while hiking or camping.
1. Off-Grid Power. Onward Bound.
2. Solar Charging for Uncharted Journeys.

```html
<!DOCTYPE html>
<html><head><title>Sort Race</title><style>body{background:#111;color:#eee;font-family:monospace}#container{display:flex;width:98%;max-width:1200px;margin:auto;}canvas{border:1px solid #333;background:#222;}#status{padding:10px 0;text-align:center;font-size:1.2em}h3{margin:5px 0;color:#aaa}</style></head><body>
<div id="status">Selection Sort vs Shell Sort</div>
<div id="container">
    <canvas id="canvasL"></canvas>
    <canvas id="canvasR"></canvas>
</div>

<script>
const C = { canvasL: document.getElementById('canvasL'), ctxL: null, canvasR: document.getElementById('canvasR'), ctxR: null };
let A = []; // Global initial array state
let V_L = []; // Visualization array Left
let V_R = []; // Visualization array Right

// State variables
const N = 30;
const W = 20; // Width of bars (approx)
const H = 450; // Height of canvas
const PADDING = 10;
const CX_L = PADDIN …

Excerpt — the full answer is on the round page.

```html
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>BFS Maze Animator</title>
    <style>
        body { background: #111; display: flex; justify-content: center; align-items: center; height: 100vh; margin: 0; }
        canvas { border: 2px solid #444; background: #222; }
    </style>
</head>
<body>
    <canvas id="mazeCanvas"></canvas>

    <script>
        const canvas = document.getElementById('mazeCanvas');
        const ctx = canvas.getContext('2d');

        let COLS = 20;
        let ROWS = 15;
        let CELL_SIZE = 30;
        canvas.width = COLS * CELL_SIZE;
        canvas.height = ROWS * CELL_SIZE;

        // State variables
        let maze = [];
        let start = { r: 0, c: 0 };
        let goal = { r: ROWS - 1, c: COLS - 1 };
        let visitedCells = new Set(); // Stores coordinates "r,c"
        let queue = [];
        let distMap = …

Excerpt — the full answer is on the round page.

```html
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Prim's MST Visualization</title>
    <style>
        body { background: #111; color: #eee; font-family: sans-serif; display: flex; flex-direction: column; align-items: center; margin: 0; padding: 20px; }
        #container { display: flex; gap: 20px; max-width: 1400px; width: 95%; }
        canvas { border: 1px solid #333; background: #222; }
        #info { width: 250px; padding: 10px; background: #2e2e2e; border-radius: 5px; display: flex; flex-direction: column; justify-content: space-between; }
        .stat-box p { margin: 5px 0; font-size: 1.1em; }
        #weightChartCanvas { background: #2e2e2e; border: 1px solid #333; margin-top: 10px; }
    </style>
</head>
<body>

<div id="container">
    <canvas id="mainCanvas" width="800" height="600"></canvas>
    <div id="info">
        <div> …

Excerpt — the full answer is on the round page.

```html
<!DOCTYPE html>
<html lang="en"><head><meta charset="UTF-8"><title>Flocking Simulation</title></head><body style="margin:0;background:#000;"><canvas id="c"></canvas><script>
const c = document.getElementById('c');
const ctx = c.getContext('2d');
let W, H;
let boids = [];
let predator = { x: 0, y: 0, vx: 0, vy: 0 };

function init() {
    W = window.innerWidth * 0.95;
    H = window.innerHeight * 0.85;
    c.width = W;
    c.height = H;
    boids = [];
    for (let i = 0; i < 60; i++) {
        boids.push({ x: Math.random() * W, y: Math.random() * H, vx: Math.cos(Math.random() * Math.PI) * 1 + 0.5, vy: Math.sin(Math.random() * Math.PI) * 1 + 0.5, maxForce: 1, maxSpeed: 2, sepWeight: 1.5, alignWeight: 1.0, cohWeight: 1.0 });
    }
    predator = { x: W / 2, y: H / 2, vx: (Math.random() - 0.5) * 0.1, vy: (Math.random() - 0.5) * 0.1 };
}

function limit(v, max) { return Math.min(Math …

Excerpt — the full answer is on the round page.

<!DOCTYPE html>
<html><head><title>Maze Runner</title></head><body style="background:#111;margin:0;display:flex;justify-content:center;padding-top:20px;"><canvas id="mazeCanvas" width="640" height="480" style="border:1px solid #333;"></canvas><div id="stats" style="color:#eee;text-align:center;margin-top:10px;"></div><script>
const CANVAS = document.getElementById('mazeCanvas');
const CTX = CANVAS.getContext('2d');
const STATS_DIV = document.getElementById('stats');

// Grid constants (Approx 25x18)
const COLS = 25;
const ROWS = 18;
const CELL_SIZE = Math.min(CANVAS.width, CANVAS.height) / Math.max(COLS, ROWS); // Scale uniformly
const WALL_COLOR = '#333';
const PATH_COLOR = '#000';
const ACTIVE_COLOR = '#FFD700'; // Gold for current cell
const STACK_PATH_COLOR = '#4CAF50'; // Green for stack path
const EXPLORED_COLOR = '#222'; // Muted grey/dark color for backtracked paths
const SOLUTIO …

Excerpt — the full answer is on the round page.

The weekly status update was decided to move from Friday afternoons to Monday mornings, effective next week. Priya will update the shared labeling guide with her new five-label system by Wednesday, and Tom must send out an updated calendar invite reflecting this schedule change by end of day Friday. The discussion regarding the office plant budget has been deferred until the next meeting.

Migrate from the retiring /v1/reports API to the new /v3/reports endpoint by September 30, 2026, or your integrations will fail.

1. Maria -- finalize and send new homepage copy for review -- by this Thursday
2. Ben -- review homepage copy and provide feedback -- by Friday
3. Chen -- push a fix for the contact form bug -- by Monday
4. Maria -- chase the client about new logo colors -- today
5. Ben -- send the updated privacy policy draft to legal -- by next Wednesday

The blender jug leaks liquid from around the base seal when filled past the halfway line. Furthermore, speeds 4 through 7 operate identically on the control dial. Finally, the motor automatically shuts off after approximately 90 seconds of continuous blending due to overheating.

1. Combine 100g whole wheat flour and 100g water at ~21°C. Wait for 24 hours.
2. Discard half; feed remaining starter with 100g flour and 100g water. Wait 24 hours.
3. Repeat this discard-and-feed process daily for approximately five more days.
4. Monitor closely until visible bubbles appear, indicating readiness by day seven.
5. It is active when it reliably doubles within 4–6 hours of feeding.

```html
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Fireworks</title>
    <style>body {margin:0;overflow:hidden;background-color:#000; }</style>
</head>
<body>
<canvas id="c"></canvas>
<script>
const canvas = document.getElementById('c');
const ctx = canvas.getContext('2d');
let W, H;

function resize() {
    W = canvas.width = window.innerWidth;
    H = canvas.height = window.innerHeight;
}
window.addEventListener("resize", resize);
resize();

let particles = [];
let rockets = [];
const GRAVITY = 0.03;
const DRAG = 0.98;

class Particle {
    constructor(x, y, vx, vy, color, size, lifespan) {
        this.x = x;
        this.y = y;
        this.vx = vx * (0.5 + Math.random() * 1.5); // Initial outward burst velocity
        this.vy = vy * (0.5 + Math.random() * 1.5);
        this.color = color;
        this.size = size;
        this.opacity = 1; …

Excerpt — the full answer is on the round page.

```html
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Rain Simulation</title>
<style>
body { margin: 0; overflow: hidden; background-color: #1a2b3c; }
canvas { display: block; cursor: crosshair; }
#counter { position: absolute; top: 10px; left: 10px; color: rgba(255, 255, 255, 0.7); font-family: monospace; font-size: 16px; }
</style>
</head>
<body>
<canvas id="rainCanvas"></canvas>
<div id="counter">Droplets: 0</div>
<script>
const canvas = document.getElementById('rainCanvas');
const ctx = canvas.getContext('2d');
let W, H;

function resize() {
    W = window.innerWidth;
    H = window.innerHeight;
    canvas.width = W;
    canvas.height = H;
}
window.addEventListener('resize', resize);
resize();

const MAX_DROPLETS = 150;
let droplets = [];
let frameCount = 0;

class Droplet {
    constructor(x, y) {
        this.x = x;
        this.y = y;
        this.size = Ma …

Excerpt — the full answer is on the round page.

```html
<!DOCTYPE html><html><head><title>Metaball Lava Lamp</title></head><body style="background: #111; margin: 0;"><canvas id="c" width="400" height="600" style="display: block;"></canvas><script>const c = document.getElementById('c');
const ctx = c.getContext('2d');

let blobs = [];
const NUM_BLOBS = 7;
const MAX_RADIUS = 30;
const GRID_SIZE = 15; // Coarse grid for metaballs

function init() {
    blobs = [];
    for (let i = 0; i < NUM_BLOBS; i++) {
        blobs.push({
            x: Math.random() * c.width,
            y: Math.random() * c.height / 2 + 50,
            r: MAX_RADIUS * (0.8 + Math.random() * 0.4),
            vx: (Math.random() - 0.5) * 0.1,
            vy: 0,
            temp: Math.random(), // 0 (cool/sink) to 1 (hot/rise)
        });
    }
    gameLoop();
}

function updateBlob(b) {
    // Temperature logic (Heating at bottom, cooling at top)
    let yRatio = b. …

Excerpt — the full answer is on the round page.

```html
<!DOCTYPE html>
<html lang="en">
<head></head><body style="margin:0;overflow:hidden"><canvas id="c"></canvas><script>
const canvas = document.getElementById('c');
const ctx = canvas.getContext('2d');
let W, H;

function resize() {
    W = canvas.width = window.innerWidth;
    H = canvas.height = window.innerHeight;
}
window.addEventListener("resize", resize);
resize();

let treeState = {};
let animationFrameId = null;
let startTime = Date.now();

class Branch {
    constructor(x, y, length, angle, maxDepth) {
        this.start = { x: x, y: y };
        this.targetLength = length;
        this.angle = angle; // Radians
        this.maxDepth = maxDepth;
        this.progress = 0.0; // 0.0 to 1.0 for growth animation
        this.isFinished = false;
    }

    // Calculate current position based on progress
    getEnd(time) {
        const p = this.progress * (this.targetLength / 1 …

Excerpt — the full answer is on the round page.

```html
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Noise Flowfield</title>
    <style>body { margin: 0; overflow: hidden; background: #000; }</style>
</head>
<body>
<canvas id="c"></canvas>
<script>
const canvas = document.getElementById('c');
const ctx = canvas.getContext('2d');

let W, H;
let particles = [];
const MAX_PARTICLES = 450;
const FLOW_STRENGTH = 1.0;
const FADE_ALPHA = 0.03;
let lastSeedTime = Date.now();

function resize() {
    W = window.innerWidth;
    H = window.innerHeight;
    canvas.width = W;
    canvas.height = H;
}
window.addEventListener('resize', resize);
resize();

// Simple pseudo-noise function (using trig functions for compactness)
function noise(x, y, t) {
    let n = Math.sin(x * 0.1 + t * 0.005) * 4;
    let m = Math.cos(y * 0.1 + t * 0.005) * 3;
    return (n + m) / 7.0;
}

function initParticles() {
    particles = []; …

Excerpt — the full answer is on the round page.

On Monday morning, the small archive opened its new reading room to local students. The room has six desks, two lamps, and a shelf for returned notebooks. Before the first group arrived, Mara checked the sign-in sheet and placed pencils beside each chair. She noticed that one window was stuck, but the hallway was quiet and the heater worked well. At nine o'clock, twelve students entered the archive, greeted the staff, and began comparing old town maps. Their teacher asked them to write short notes about every map they handled. One student found a drawing of the river bridge, and another matched it to a photograph from 1912. By noon, the class had labeled the boxes, cleaned the tables, and thanked Mara for her help. The visit ended on time, and the archive stayed open for regular visitors after lunch.

Workshop attendance report:

The registration desk recorded 18 participants: 7 from North Hall, 6 from East Studio, and 5 from River Annex. The header currently says 18 participants attended.

The event ran on Wednesday, March 4, 2026, and the room booking confirmation and the posted schedule both list Wednesday, March 4, 2026.

For the feedback survey, 15 of the 18 participants submitted forms. The draft summary says this equals 72%, but 15 out of 18 is 83% when rounded to the nearest whole percent.

The neighborhood mobile clinic launches on April 8th at the Maple Community Center, located on Maple Street. Services will operate weekly every Wednesday from 10 a.m. to 4 p.m. The clinic offers free blood pressure screenings, vaccinations, and short medical consultations. Visitors can book appointments either by phone or in person at the center. Additionally, Spanish and Vietnamese interpreters will be available during all scheduled hours for assistance.

At dawn, I stepped onto the station platform and checked the timetable. I noticed the last train number blinking on the board before the screen went dark. I waited beside the vending machine, but kept looking toward the empty tracks. The loudspeaker crackled, and I heard a short apology for the delay. Then I walked to the ticket office, where the clerk handed me a paper voucher. I folded the voucher into my notebook and thought about the missed connection. I finally boarded the replacement bus, and I sat near the back window. As the bus left town, I watched the station lights disappear behind the rain.

Maintenance note for the demo room:

The tablet is stored in the blue cabinet, and it must be charged before each session.
The projector was tested after lunch; the unit should remain unplugged overnight.
See above for the cleaning checklist.

Setup steps:
1. Unlock the cabinet.
2. Place the tablet on the stand.
3. Start the room timer.