Repository navigation
Expand file tree
/
Copy pathpascal.html
More file actions
211 lines (206 loc) · 13.1 KB
/
Copy pathpascal.html
File metadata and controls
211 lines (206 loc) · 13.1 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
<!DOCTYPE html>
<html lang="ru">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<title>Треугольник Паскаля — Прогрессии</title>
<link rel="stylesheet" href="assets/lab.css">
</head>
<body>
<script src="assets/catalog.js"></script>
<script src="assets/lab.js"></script>
<script>
const { F, fmt, D } = Lab;
// строки до 64 храним в BigInt — значения выходят за пределы точности Number
const ROWS = [[1n]];
for (let n = 1; n < 64; n++) {
const prev = ROWS[n - 1], row = [1n];
for (let k = 1; k < n; k++) row.push(prev[k - 1] + prev[k]);
row.push(1n);
ROWS.push(row);
}
const big = v => { const s = v.toString(); return s.length > 4 ? s.replace(/\B(?=(\d{3})+(?!\d))/g, ' ') : s; };
const FIB = [1, 1]; while (FIB.length < 70) FIB.push(FIB[FIB.length - 1] + FIB[FIB.length - 2]);
let hover = null;
function layout(s) {
const { w, h, p } = s;
const top = 92, bottom = 24;
const n = p.N;
const cell = Math.min((w - 40) / n, (h - top - bottom) / (n * .88), 64);
const rowH = cell * .88;
const y0 = top + Math.max(0, (h - top - bottom - n * rowH) / 2);
return { cell, rowH, pos: (r, k) => [w / 2 + (k - r / 2) * cell, y0 + (r + .5) * rowH] };
}
Lab.model({
id: 'pascal',
unit: 'Строка',
rate: p => Math.max(1.2, p.N / 10),
labels: { problem: 'Правило', solution: 'Закономерности', terms: 'Суммы строк' },
params: [
{ key: 'mode', label: 'Что показать', type: 'seg', value: 'num', options: [
{ value: 'num', label: 'Числа' }, { value: 'odd', label: 'Чётность' }, { value: 'fib', label: 'Диагонали' } ] },
{ key: 'N', sym: 'n', label: 'строк', min: 3, max: 64, value: 12 },
],
compute: p => ({}),
duration: p => p.N,
problem: (p, m, v) => `По краям треугольника стоят единицы, а каждое внутреннее число равно сумме двух чисел над ним.
<span class="q">${p.mode === 'odd' ? 'Закрасим нечётные числа — какой узор получится?' : p.mode === 'fib' ? 'Сложим числа вдоль «пологих» диагоналей — что за суммы выйдут?' : 'Какие закономерности спрятаны в этих числах?'}</span>`,
problemNote: () => 'Наведите курсор на любое число — подсветятся два числа, из которых оно получилось.',
solutionOptions: { reveal: false },
solution: p => {
const r = Math.min(p.N - 1, 5);
const coeffs = ROWS[r].map(String);
const terms = coeffs.map((c, k) => {
const a = r - k, b = k;
return `${c === '1' ? '' : c}${a ? 'a' + (a > 1 ? `^{${a}}` : '') : ''}${b ? 'b' + (b > 1 ? `^{${b}}` : '') : ''}`;
}).join(' + ');
const base = [
{ t: 'Правило построения', f: F('C_n^k = C_{n-1}^{k-1} + C_{n-1}^k'), c: `<span style="font-size:14px">${F('C_n^k')} — число способов выбрать <i>k</i> предметов из <i>n</i></span>`, always: true },
{ t: `Бином Ньютона: строка ${r} — коэффициенты`, f: F(`(a + b)^{${r}} = ${terms}`), always: true },
{ t: 'Суммы строк — степени двойки', f: F('C_n^0 + C_n^1 + \\ldots + C_n^n = 2^n'), always: true },
];
if (p.mode === 'odd') base.push({ t: 'Треугольник Серпинского', f: `<span style="font-size:14.5px">Нечётные числа образуют фрактал. Его размерность ${F('\\log_2 3 \\approx 1,585')} — «между» линией и плоскостью. Лучше всего видно при 32 или 64 строках.</span>`, always: true });
else if (p.mode === 'fib') base.push({ t: 'Суммы по пологим диагоналям — числа Фибоначчи', f: F('F_{d+1} = C_d^0 + C_{d-1}^1 + C_{d-2}^2 + \\ldots'), c: F('1 + 3 + 1 = 5,\\quad 1 + 4 + 3 = 8'), always: true });
else base.push({ t: 'Степени одиннадцати', f: F('11^2 = 121,\\quad 11^3 = 1331,\\quad 11^4 = 14641'), always: true });
return { steps: base };
},
terms: p => p.mode === 'fib'
? { items: Array.from({ length: p.N }, (_, d) => ({ i: `d=${d}`, x: big(BigInt(FIB[d])) })), max: 24 }
: { items: Array.from({ length: p.N }, (_, n) => ({ i: `n=${n}`, x: big(1n << BigInt(n)) })), max: 24 },
onChange: () => { hover = null; },
hud: (p, m, t) => {
const r = Math.min(Math.ceil(t - 1e-9), p.N);
if (hover) {
const [n, k] = hover;
return [{ k: 'Число', v: F(`C_{${n}}^{${k}}`) }, { k: 'Значение', v: big(ROWS[n][k]), tone: 'acc' }];
}
return [
{ k: 'Строк', v: String(r), u: `из ${p.N}` },
{ k: p.mode === 'fib' ? 'Диагональ' : 'Сумма строки', v: r ? (p.mode === 'fib' ? big(BigInt(FIB[r - 1])) : big(1n << BigInt(r - 1))) : '—', tone: 'acc' },
];
},
pointer(s, x, y, type) {
if (type === 'leave') { const was = hover; hover = null; return !!was; }
const L = layout(s);
const rows = Math.min(Math.ceil(s.t - 1e-9), s.p.N);
let best = null;
for (let n = 0; n < rows; n++) {
const [, py] = L.pos(n, 0);
if (Math.abs(py - y) > L.rowH / 2) continue;
const k = Math.round((x - s.w / 2) / L.cell + n / 2);
if (k >= 0 && k <= n) best = [n, k];
}
const changed = JSON.stringify(best) !== JSON.stringify(hover);
hover = best;
return changed;
},
about: `
<p class="lead">Простое правило — каждое число равно сумме двух над ним — порождает треугольник, в котором зашифрованы биномиальные коэффициенты, степени двойки, числа Фибоначчи и даже фрактал.</p>
<h3>История</h3>
<p>Треугольник знали задолго до Паскаля: персидский математик <strong>аль-Караджи</strong> описал его в XI веке, в Китае он называется треугольником Ян Хуэя (XIII в.), в Иране — треугольником Хайяма, в Италии — Тартальи. <strong>Блез Паскаль</strong> в 1653 году написал о нём систематический трактат.</p>
<h3>Скрытые закономерности</h3>
<ul>
<li><strong>Бином Ньютона:</strong> строка <i>n</i> — коэффициенты раскрытия (a + b)<sup>n</sup>.</li>
<li><strong>Суммы строк:</strong> 1, 2, 4, 8, 16, … — степени двойки.</li>
<li><strong>Степени 11:</strong> 1, 11, 121, 1331, 14641 — строки, «склеенные» в число.</li>
<li><strong>Натуральные, треугольные, тетраэдрические числа</strong> — на 2-й, 3-й и 4-й диагоналях.</li>
<li><strong>«Хоккейная клюшка»:</strong> сумма чисел вдоль диагонали равна числу чуть ниже и в сторону.</li>
<li><strong>Числа Фибоначчи</strong> — суммы вдоль пологих диагоналей (режим «Диагонали»).</li>
<li><strong>Треугольник Серпинского</strong> — узор из нечётных чисел (режим «Чётность»).</li>
</ul>
<h3>Треугольник Серпинского</h3>
<p>Включите «Чётность» и поставьте 32 или 64 строки. Нечётные числа образуют самоподобный фрактал: в каждом треугольнике вырезан средний, в каждом из оставшихся — снова средний и так далее. Его размерность — log<sub>2</sub>3 ≈ 1,585.</p>
<h3>Применение</h3>
<ul>
<li><strong>Комбинаторика и вероятность:</strong> число способов выбрать <i>k</i> из <i>n</i>, биномиальное распределение.</li>
<li><strong>Теория чисел:</strong> строка с простым номером <i>p</i> — все внутренние числа делятся на <i>p</i>.</li>
<li><strong>Информатика:</strong> подсчёт путей в сетке, динамическое программирование.</li>
</ul>`,
draw(ctx, s) {
const { w, h, t, p, C, time } = s;
const dark = C.dark;
const bg = ctx.createLinearGradient(0, 0, 0, h);
bg.addColorStop(0, dark ? '#16131f' : '#fbf8ff'); bg.addColorStop(1, dark ? '#0f0d16' : '#f1ebfb');
ctx.fillStyle = bg; ctx.fillRect(0, 0, w, h);
const L = layout(s);
const rows = Math.min(Math.ceil(t - 1e-9), p.N);
const f = rows ? t - (rows - 1) : 0;
const showNum = p.mode !== 'odd' || L.cell > 30;
const diagCols = [C.violet, C.blue, C.teal, C.green, C.amber, C.orange, C.rose];
let hl = new Set();
if (hover) {
const [n, k] = hover;
hl.add(`${n},${k}`);
if (n > 0) { if (k > 0) hl.add(`${n - 1},${k - 1}`); if (k < n) hl.add(`${n - 1},${k}`); }
}
for (let n = 0; n < rows; n++) {
const row = ROWS[n];
for (let k = 0; k <= n; k++) {
let a = 1;
if (n === rows - 1 && t < p.N) a = D.clamp((f * (n + 2) - k) * 1.2, 0, 1);
if (n === rows - 1 && t >= p.N) a = 1;
if (a <= 0) continue;
const [x, y] = L.pos(n, k);
const odd = (k & (n - k)) === 0; // теорема Люка: C(n,k) нечётно ⇔ k & (n−k) = 0
let fillC, textC;
if (p.mode === 'odd') { fillC = odd ? C.acc : (dark ? '#262233' : '#ece6f6'); textC = odd ? '#fff' : C.ink3; }
else if (p.mode === 'fib') { fillC = D.alpha(diagCols[(n + k) % diagCols.length], dark ? .55 : .3); textC = C.ink; }
else { const v = Math.log10(Number(row[k]) + 1) / Math.max(1, Math.log10(Number(ROWS[p.N - 1][Math.floor((p.N - 1) / 2)]) + 1)); fillC = D.mix(dark ? '#2a2342' : '#efe9fb', C.acc, v * .85); textC = v > .55 ? '#fff' : C.ink; }
const isH = hl.has(`${n},${k}`);
const sc = (n === rows - 1 && t < p.N ? .6 + .4 * D.ease.back(a) : 1) * (isH ? 1.12 : 1);
ctx.save();
ctx.globalAlpha = a;
ctx.translate(x, y); ctx.scale(sc, sc);
const r = L.cell * .46;
if (L.cell > 8) {
D.rr(ctx, -r, -r * .9, r * 2, r * 1.8, Math.min(10, r * .5));
ctx.fillStyle = fillC; ctx.fill();
if (isH) { ctx.lineWidth = 2.5; ctx.strokeStyle = hover && hover[0] === n ? C.amber : C.ink; ctx.stroke(); }
} else {
ctx.fillStyle = fillC; ctx.fillRect(-L.cell / 2, -L.rowH / 2, L.cell + .5, L.rowH + .5);
}
if (showNum && L.cell > 18) {
const str = big(row[k]);
const fs = Math.min(L.cell * .4, (r * 2.1) / Math.max(1, str.length) * 1.7, 20);
if (fs >= 6.5) D.text(ctx, str, 0, .5, { size: fs, weight: 700, color: textC });
}
ctx.restore();
}
}
// связи для подсвеченного числа
if (hover && hover[0] > 0) {
const [n, k] = hover, [x, y] = L.pos(n, k);
[[n - 1, k - 1], [n - 1, k]].forEach(([a, b]) => {
if (b < 0 || b > a) return;
const [px, py] = L.pos(a, b);
D.arrow(ctx, px, py + L.rowH * .35, x + (px - x) * .25, y - L.rowH * .32, C.amber, 2.5, 8);
});
const parents = [k > 0 ? ROWS[n - 1][k - 1] : null, k < n ? ROWS[n - 1][k] : null].filter(v => v !== null);
const label = parents.length === 2 ? `${big(parents[0])} + ${big(parents[1])} = ${big(ROWS[n][k])}` : `край строки: 1`;
D.pill(ctx, label, x, Math.min(s.h - 20, y + L.rowH * .95), { bg: C.amber, color: '#1c1a21', size: 12.5, shadow: true });
}
// подписи сумм
if (p.mode === 'fib') {
for (let d = 0; d < rows; d++) {
const [x, y] = L.pos(d, 0);
const col = diagCols[d % diagCols.length];
const cells = [];
for (let k = 0; k <= d / 2; k++) if (d - k < rows) cells.push(L.pos(d - k, k));
if (cells.length > 1 && L.cell > 14) {
ctx.beginPath(); cells.forEach(([cx, cy], i) => (i ? ctx.lineTo(cx, cy) : ctx.moveTo(cx, cy)));
ctx.strokeStyle = D.alpha(col, .6); ctx.lineWidth = 2; ctx.stroke();
}
if (L.cell > 12) D.text(ctx, big(BigInt(FIB[d])), x - L.cell * .7, y, { size: Math.min(13, L.cell * .38), weight: 800, align: 'right', color: col });
}
} else if (L.cell > 16) {
for (let n = 0; n < rows; n++) {
const [x, y] = L.pos(n, n);
D.text(ctx, `Σ = ${big(1n << BigInt(n))}`, x + L.cell * .7, y, { size: Math.min(12, L.cell * .34), weight: 700, align: 'left', color: C.ink3 });
}
}
if (!rows) D.text(ctx, 'Нажмите ▶ — треугольник начнёт расти сверху вниз', w / 2, h / 2, { size: 15, color: C.ink3 });
},
});
</script>
</body>
</html>