Информация о материале: Автор: Arsen Gonian; Категория: Uncategorised; Опубликовано: 21 августа 2025; Просмотров: 12

Информация о материале: Автор: Arsen Gonian; Категория: Uncategorised; Опубликовано: 21 августа 2025; Просмотров: 43

AI / ИИ на Форте.

Работа с элементарной ИИ на Форте не является сложной задачей. Продемонстрируем это.

Возьмем простой пример со следующими исходными данными (обучающая выборка):

x1=0 x2=0 y_true=0
x1=0 x2=1 y_true=0
x1=1 x2=0 y_true=0
x1=1 x2=1 y_true=1

Можете заметить, что вводам x1 и x2 сопоставляется их логическое "И".

Подключим библиотеку для работы с вещественными числами.

S" lib/include/float2.f" INCLUDED

Нам понадобятся переменные w1, w2 - веса; b - смещение (сразу инициализируем все три нулями); x1, x2 - входные значения; learning_rate - шаг обучения, для определенности взят за "0.1"; y_true - соответствующее истинное значение из тестовой выборки.

FVARIABLE w1
FVARIABLE w2
FVARIABLE b
0E w1 F!
0E w2 F!
0E b F!
FVARIABLE x1 FVARIABLE x2
FVARIABLE learning_rate
0.1E learning_rate F!
FVARIABLE y_true

Напишем слово моделирующее поведение персептрона (назовем его "P"), которое просто вычисляет выход по формуле:

y_pred = x1*w1+x2*w2+b

затем сравниваем это значение с нулем, если меньше оставляем 0, иначе 1.
Таким образом мы совместили функцию активации с расчетом линейной комбинации для персептрона с двумя входами.

\ x1 w1 x2 w2 b P - формат вызова слова
: P ( F: x1 w1 x2 w2 b -> F: y_pred ) FSWAP FROT F* F+ FSWAP FROT F* F+ F0< IF 0E ELSE 1E THEN ;

Проверим работу слова на случайных данных:

1E 2E 3E 5E 1000E P F.
1.0000000 Ok

1*2+3*5+1000 = 1017, что явно больше нуля, следовательно, результат работы 1. Персептрон работает корректно.

Самое важное слово производящее тренировку персептрона назван - "T" (от слова Train). Входом служат исходные параметры x1, x2 и соответствующее им истинное значение, а вместо выхода - изменение переменных w1, w2 и b, что обозначено в комментарии стековой нотации буквой "V:" (от слова "VARIABLE").

: T ( F: x1 x2 y_true -> V: w1 w2 b ) \ x1 x2 y_true T - формат вызова слова
y_true F! \ x1 x2 y_true -> x1 x2
  FOVER x1 F! FDUP x2 F! \ x1 x2 -> x1 x2 x1=x1 x2=x2
  w1 F@ FSWAP w2 F@ b F@ \ x1 x2 -> x1 w1 x2 w2 b
  P \ x1 w1 x2 w2 b -> y_pred
  y_true F@ FSWAP F- \ y_pred -> y_true-y_pred=error
  learning_rate F@ F* \ error -> error*learning_rate

  FDUP x1 F@ F* w1 F@ F+ w1 F! \ error*learning_rate -> error*learning_rate w1=error*learning_rate*x1+w1
  FDUP x2 F@ F* w2 F@ F+ w2 F! \ error*learning_rate -> error*learning_rate w2=error*learning_rate*x2+w2
  b F@ F+ b F! \ error*learning_rate -> b=error*learning_rate+b
  ." Обновленные веса: w1 = " w1 F@ F. ." w2 = " w2 F@ F. ." b = " b F@ F. CR
;

Первая строка - описание слова.
Вторая - сохранение значения "y_true" в одноименной переменной.
Третья, аналогично предыдущей, сохранение значений x1, x2.
Четвертая - получаем значения переменных w1, w2 и b, одновременно выстраиваем их в том порядке, которая соответствует стековой нотации слова "P".
Пятая вызываем "P" (работа которой описана выше).
В шестой считаем ошибку по формуле error = y_true-y_pred.
В седьмой умножаем на шаг обучения, чтобы в
в девятой, десятой и одиннадцатой корректируются значения переменных w1, w2 и b по формулам:

w1=error*learning_rate*x1
w2=error*learning_rate*x2
b=error*learning_rate

Двенадцатая - вывод значения обновленных весов (контрольная информация о работе слова).

Можно протестировать это слово на следующих данных:

0E 0E 0E T
0E 1E 0E T
1E 0E 0E T
1E 1E 1E T

Окончательно можем написать слово "epochs", которая проведет обучение на тестовой выборке.

: epochs ( N -> )
  0 DO
  ." Эпоха " I . CR
  0E 0E 0E T
  0E 1E 0E T
  1E 0E 0E T
  1E 1E 1E T
  CR
  LOOP ;

Она просто прогоняет N раз (количество эпох) обучение на тестовых данных с выводом результатов о проделанной работе.

Запустим его с параметром 10.

10 epochs
Эпоха 0
Обновленные веса: w1 = 0.1000000 w2 = 0.1000000 b = -0.1000000
Обновленные веса: w1 = 0.1000000 w2 = 0.0000000 b = -0.2000000
Обновленные веса: w1 = 0.1000000 w2 = 0.0000000 b = -0.2000000
Обновленные веса: w1 = 0.2000000 w2 = 0.1000000 b = -0.1000000

Эпоха 1
Обновленные веса: w1 = 0.2000000 w2 = 0.1000000 b = -0.1000000
Обновленные веса: w1 = 0.2000000 w2 = 0.0000000 b = -0.2000000
Обновленные веса: w1 = 0.1000000 w2 = 0.0000000 b = -0.3000000
Обновленные веса: w1 = 0.2000000 w2 = 0.1000000 b = -0.2000000

Эпоха 2
Обновленные веса: w1 = 0.2000000 w2 = 0.1000000 b = -0.2000000
Обновленные веса: w1 = 0.2000000 w2 = 0.1000000 b = -0.2000000
Обновленные веса: w1 = 0.2000000 w2 = 0.1000000 b = -0.2000000
Обновленные веса: w1 = 0.2000000 w2 = 0.1000000 b = -0.2000000

Эпоха 3
Обновленные веса: w1 = 0.2000000 w2 = 0.1000000 b = -0.2000000
Обновленные веса: w1 = 0.2000000 w2 = 0.1000000 b = -0.2000000
Обновленные веса: w1 = 0.2000000 w2 = 0.1000000 b = -0.2000000
Обновленные веса: w1 = 0.2000000 w2 = 0.1000000 b = -0.2000000

Эпоха 4
Обновленные веса: w1 = 0.2000000 w2 = 0.1000000 b = -0.2000000
Обновленные веса: w1 = 0.2000000 w2 = 0.1000000 b = -0.2000000
Обновленные веса: w1 = 0.2000000 w2 = 0.1000000 b = -0.2000000
Обновленные веса: w1 = 0.2000000 w2 = 0.1000000 b = -0.2000000

Эпоха 5
Обновленные веса: w1 = 0.2000000 w2 = 0.1000000 b = -0.2000000
Обновленные веса: w1 = 0.2000000 w2 = 0.1000000 b = -0.2000000
Обновленные веса: w1 = 0.2000000 w2 = 0.1000000 b = -0.2000000
Обновленные веса: w1 = 0.2000000 w2 = 0.1000000 b = -0.2000000

Эпоха 6
Обновленные веса: w1 = 0.2000000 w2 = 0.1000000 b = -0.2000000
Обновленные веса: w1 = 0.2000000 w2 = 0.1000000 b = -0.2000000
Обновленные веса: w1 = 0.2000000 w2 = 0.1000000 b = -0.2000000
Обновленные веса: w1 = 0.2000000 w2 = 0.1000000 b = -0.2000000

Эпоха 7
Обновленные веса: w1 = 0.2000000 w2 = 0.1000000 b = -0.2000000
Обновленные веса: w1 = 0.2000000 w2 = 0.1000000 b = -0.2000000
Обновленные веса: w1 = 0.2000000 w2 = 0.1000000 b = -0.2000000
Обновленные веса: w1 = 0.2000000 w2 = 0.1000000 b = -0.2000000

Эпоха 8
Обновленные веса: w1 = 0.2000000 w2 = 0.1000000 b = -0.2000000
Обновленные веса: w1 = 0.2000000 w2 = 0.1000000 b = -0.2000000
Обновленные веса: w1 = 0.2000000 w2 = 0.1000000 b = -0.2000000
Обновленные веса: w1 = 0.2000000 w2 = 0.1000000 b = -0.2000000

Эпоха 9
Обновленные веса: w1 = 0.2000000 w2 = 0.1000000 b = -0.2000000
Обновленные веса: w1 = 0.2000000 w2 = 0.1000000 b = -0.2000000
Обновленные веса: w1 = 0.2000000 w2 = 0.1000000 b = -0.2000000
Обновленные веса: w1 = 0.2000000 w2 = 0.1000000 b = -0.2000000

Обратим внимание, что, начиная с Эпохи 2, веса w1 и w2, а также b не меняются (если предварительно не тестировать работу слова "T", то с Эпохи 3).

Проверим "натренированность" весов и смещения, для чего напишем последнее слово "PREDICT", которая будет предсказывать выход "y".

: PREDICT ( x1 x2 -> y. )
w1 F@ FSWAP w2 F@ b F@ P F.
;

Работа которого заключается в том, чтобы подготовить параметры для слова "P". Проверим качество тренировки:

0E 0E PREDICT
0.0000000 Ok

0E 1E PREDICT
0.0000000 Ok

1E 0E PREDICT
0.0000000 Ok

1E 1E PREDICT
1.0000000 Ok

Можно слегка изменить код, так чтобы вводить целые числа и получать целочисленный выход (чтобы облегчить ввод и сделать простым и наглядным вывод).

В слове "T" добавляем три строки преобразующие "x1 x2 y_true" из целочисленного в вещественный формат

: T ( x1 x2 y_true -> V: w1 w2 b ) \ x1 x2 y_true T - формат вызова слова
  ROT S>D D>F
  SWAP S>D D>F
  S>D D>F
  y_true F! \ x1 x2 y_true -> x1 x2
  FOVER x1 F! FDUP x2 F! \ x1 x2 -> x1 x2 x1=x1 x2=x2
  w1 F@ FSWAP w2 F@ b F@ \ x1 x2 -> x1 w1 x2 w2 b
  P \ x1 w1 x2 w2 b -> y_pred
  y_true F@ FSWAP F- \ y_pred -> y_true-y_pred=error
  learning_rate F@ F* \ error -> error*learning_rate

Также изменится "epochs" которое вызывает уже исправленное "T".

: epochs ( N -> )
  0 DO
  ." Эпоха " I . CR
  0 0 0 T
  0 1 0 T
  1 0 0 T
  1 1 1 T
  CR
  LOOP ;

И наконец, в "PREDICT" преобразуем вход "x1 x2" в вещественный, а результат "y." из вещественного (точка в конце обозначает тот факт, что он печатается на экран, а не остается на стеке).

: PREDICT ( x1 x2 -> y. )
  SWAP S>D D>F
  S>D D>F
  w1 F@ FSWAP w2 F@ b F@ P F>D D>S .
;

результат тренировки будет выглядеть так:

0 0 PREDICT
0 Ok
0 1 PREDICT
0 Ok
1 0 PREDICT
0 Ok
1 1 PREDICT
1 Ok

Логическое "ИЛИ"

Возьмем другую серию данных. Теперь вводам сопоставим их логическое "ИЛИ".

x1=0 x2=0 y_true=0
x1=0 x2=1 y_true=1
x1=1 x2=0 y_true=1
x1=1 x2=1 y_true=1

в коде предыдущего примера изменится только слово:

: epochs ( N -> )
  0 DO
  ." Эпоха " I . CR
  0E 0E 0E T
  0E 1E 1E T
  1E 0E 1E T
  1E 1E 1E T
  CR
  LOOP ;

После обучения, слово PREDICT выдаст следующие результаты:

0E 0E PREDICT
0.0000000 Ok

0E 1E PREDICT
1.0000000 Ok

1E 0E PREDICT
1.0000000 Ok

1E 1E PREDICT
1.0000000 Ok

Проверьте это самостоятельно. Заметим, что с Эпохи 2 коэффициенты перестают меняться.

Операция "Исключающее ИЛИ"

Теперь исходные данные будут выглядеть так:

x1=0 x2=0 y_true=0
x1=0 x2=1 y_true=1
x1=1 x2=0 y_true=1
x1=1 x2=1 y_true=0

Аналогично изменится только слово "epochs":

: epochs ( N -> )
  0 DO
  ." Эпоха " I . CR
  0E 0E 0E T
  0E 1E 1E T
  1E 0E 1E T
  1E 1E 0E T
  CR
  LOOP ;

После обучения (тоже 10 эпох), получим:

0E 0E PREDICT
1.0000000 Ok

0E 1E PREDICT
1.0000000 Ok

1E 0E PREDICT
0.0000000 Ok

1E 1E PREDICT
0.0000000 Ok

Что не является правильным результатом. Даже после Эпохи 9 коэффициенты меняются. Можете по экспериментировать самостоятельно с гораздо большим количеством эпох. Результат аналогичный даже после 1000 эпох ("1000 epochs"). Задача "Исключающее ИЛИ" не разрешима на персептроне, необходимо более сложные модели для такой простой операции.

Чтобы получить корректные результаты для каждого примера вводите код заново в новое окно консоли, или инициализируйте переменные заново:

0E w1 F!
0E w2 F!
0E b F!

Пример 1 - логическое "И" (окончательный код, можно "копи пастить")

S" lib/include/float2.f" INCLUDED

FVARIABLE w1
FVARIABLE w2
FVARIABLE b
0E w1 F!
0E w2 F!
0E b F!
FVARIABLE x1 FVARIABLE x2
FVARIABLE learning_rate
0.1E learning_rate F!
FVARIABLE y_true

: P ( F: x1 w1 x2 w2 b -> F: y_pred ) FSWAP FROT F* F+ FSWAP FROT F* F+ F0< IF 0E ELSE 1E THEN ;

: T ( F: x1 x2 y_true -> V: w1 w2 b ) \ x1 x2 y_true T - формат вызова слова
y_true F! \ x1 x2 y_true -> x1 x2
FOVER x1 F! FDUP x2 F! \ x1 x2 -> x1 x2 x1=x1 x2=x2
w1 F@ FSWAP w2 F@ b F@ \ x1 x2 -> x1 w1 x2 w2 b
P \ x1 w1 x2 w2 b -> y_pred
y_true F@ FSWAP F- \ y_pred -> y_true-y_pred=error
learning_rate F@ F* \ error -> error*learning_rate

FDUP x1 F@ F* w1 F@ F+ w1 F! \ error*learning_rate -> error*learning_rate w1=error*learning_rate*x1+w1
FDUP x2 F@ F* w2 F@ F+ w2 F! \ error*learning_rate -> error*learning_rate w2=error*learning_rate*x2+w2
b F@ F+ b F! \ error*learning_rate -> b=error*learning_rate+b
." Обновленные веса: w1 = " w1 F@ F. ." w2 = " w2 F@ F. ." b = " b F@ F. CR
;

: epochs ( N -> )
0 DO
." Эпоха " I . CR
0E 0E 0E T
0E 1E 0E T
1E 0E 0E T
1E 1E 1E T
CR
LOOP ;

10 epochs

: PREDICT ( x1 x2 -> y. )
w1 F@ FSWAP w2 F@ b F@ P F.
;

0E 0E PREDICT

0E 1E PREDICT

1E 0E PREDICT

1E 1E PREDICT

Пример 2 - логическое "ИЛИ"

S" lib/include/float2.f" INCLUDED

FVARIABLE w1
FVARIABLE w2
FVARIABLE b
0E w1 F!
0E w2 F!
0E b F!
FVARIABLE x1 FVARIABLE x2
FVARIABLE learning_rate
0.1E learning_rate F!
FVARIABLE y_true

: P ( F: x1 w1 x2 w2 b -> F: y_pred ) FSWAP FROT F* F+ FSWAP FROT F* F+ F0< IF 0E ELSE 1E THEN ;

: T ( F: x1 x2 y_true -> V: w1 w2 b ) \ x1 x2 y_true T - формат вызова слова
y_true F! \ x1 x2 y_true -> x1 x2
FOVER x1 F! FDUP x2 F! \ x1 x2 -> x1 x2 x1=x1 x2=x2
w1 F@ FSWAP w2 F@ b F@ \ x1 x2 -> x1 w1 x2 w2 b
P \ x1 w1 x2 w2 b -> y_pred
y_true F@ FSWAP F- \ y_pred -> y_true-y_pred=error
learning_rate F@ F* \ error -> error*learning_rate

FDUP x1 F@ F* w1 F@ F+ w1 F! \ error*learning_rate -> error*learning_rate w1=error*learning_rate*x1+w1
FDUP x2 F@ F* w2 F@ F+ w2 F! \ error*learning_rate -> error*learning_rate w2=error*learning_rate*x2+w2
b F@ F+ b F! \ error*learning_rate -> b=error*learning_rate+b
." Обновленные веса: w1 = " w1 F@ F. ." w2 = " w2 F@ F. ." b = " b F@ F. CR
;

: epochs ( N -> )
0 DO
." Эпоха " I . CR
0E 0E 0E T
0E 1E 1E T
1E 0E 1E T
1E 1E 1E T
CR
LOOP ;

10 epochs

: PREDICT ( x1 x2 -> y. )
w1 F@ FSWAP w2 F@ b F@ P F.
;

0E 0E PREDICT

0E 1E PREDICT

1E 0E PREDICT

1E 1E PREDICT

Пример 3 - "Исключающее ИЛИ"

S" lib/include/float2.f" INCLUDED

FVARIABLE w1
FVARIABLE w2
FVARIABLE b
0E w1 F!
0E w2 F!
0E b F!
FVARIABLE x1 FVARIABLE x2
FVARIABLE learning_rate
0.1E learning_rate F!
FVARIABLE y_true

: P ( F: x1 w1 x2 w2 b -> F: y_pred ) FSWAP FROT F* F+ FSWAP FROT F* F+ F0< IF 0E ELSE 1E THEN ;

: T ( F: x1 x2 y_true -> V: w1 w2 b ) \ x1 x2 y_true T - формат вызова слова
y_true F! \ x1 x2 y_true -> x1 x2
FOVER x1 F! FDUP x2 F! \ x1 x2 -> x1 x2 x1=x1 x2=x2
w1 F@ FSWAP w2 F@ b F@ \ x1 x2 -> x1 w1 x2 w2 b
P \ x1 w1 x2 w2 b -> y_pred
y_true F@ FSWAP F- \ y_pred -> y_true-y_pred=error
learning_rate F@ F* \ error -> error*learning_rate

FDUP x1 F@ F* w1 F@ F+ w1 F! \ error*learning_rate -> error*learning_rate w1=error*learning_rate*x1+w1
FDUP x2 F@ F* w2 F@ F+ w2 F! \ error*learning_rate -> error*learning_rate w2=error*learning_rate*x2+w2
b F@ F+ b F! \ error*learning_rate -> b=error*learning_rate+b
." Обновленные веса: w1 = " w1 F@ F. ." w2 = " w2 F@ F. ." b = " b F@ F. CR
;

: epochs ( N -> )
0 DO
." Эпоха " I . CR
0E 0E 0E T
0E 1E 1E T
1E 0E 1E T
1E 1E 0E T
CR
LOOP ;

10 epochs

: PREDICT ( x1 x2 -> y. )
w1 F@ FSWAP w2 F@ b F@ P F.
;

0E 0E PREDICT

0E 1E PREDICT

1E 0E PREDICT

1E 1E PREDICT

Как и было сказано ранее отличие всех трех примеров только в коде слова "epochs".

Информация о материале: Автор: Arsen Gonian; Категория: Uncategorised; Опубликовано: 13 марта 2024; Просмотров: 1033

Шахматы

Шахматы — это настольная стратегическая игра, которая играется на квадратной доске размером 8x8 клеток. В игре участвуют два игрока, каждый из которых управляет армией из 16 фигур: 1 король, 1 ферзь, 2 ладьи, 2 слона, 2 коня и 8 пешек. Основная цель игры — поставить мат королю противника, то есть создать такую позицию, при которой король соперника не может избежать взятия.

Основные правила и фигуры:

Фигуры и их ходы:
- Король: Ходит на одну клетку в любом направлении.
- Ферзь: Ходит на любое количество клеток по горизонтали, вертикали или диагонали.
- Ладья: Ходит на любое количество клеток по горизонтали или вертикали.
- Слон: Ходит на любое количество клеток по диагонали.
- Конь: Ходит буквой "Г" — две клетки в одном направлении и одна в перпендикулярном. Конь — единственная фигура, которая может перепрыгивать через другие фигуры.
- Пешка: Ходит на одну клетку вперед, но бьет на одну клетку по диагонали. На первом ходе может сделать два шага вперед. Если пешка достигает последнего ряда (8-го или 1-го), она может быть превращена в любую другую фигуру (чаще всего в ферзя).
Цель игры:
- Шах: Это ситуация, когда король находится под угрозой взятия. Игрок должен устранить угрозу, иначе он проиграет.
- Шах и мат: Это ситуация, при которой король находится под шахом и не может избежать взятия в следующий ход. Это завершает игру, и игрок, поставивший мат, побеждает.
- Пат: Это ситуация, при которой игрок, чей ход, не может сделать ни одного допустимого хода, но при этом его король не находится под шахом. Пат приводит к ничьей.
Дополнительные правила:
- Рокировка: Специальный ход, при котором король и ладья перемещаются одновременно. Король перемещается на две клетки в сторону ладьи, а ладья ставится на клетку, через которую король перепрыгнул. Рокировка возможна только при выполнении определенных условий (например, король и ладья еще не ходили, между ними нет других фигур, король не находится под шахом и не проходит через клетки, находящиеся под угрозой).
- Взятие на проходе: Это специальный ход пешкой, который возможен, если пешка противника сделала два шага вперед с исходной позиции, а ваша пешка могла бы взять её, если бы она сделала один шаг. Взятие на проходе должно быть выполнено сразу же после такого хода.

Стратегия и тактика:

Шахматы требуют как стратегического планирования на протяжении всей игры, так и тактических расчетов для выигрыша отдельных фигур и позиций. Хорошие шахматисты должны уметь предсказывать ходы противника, рассчитывать возможные последствия своих действий на несколько шагов вперед и понимать общую позиционную игру.

История и культура:

Шахматы имеют долгую историю, восходящую к Индии VI века, где игра, известная как "чатуранга", была предшественником современных шахмат. Со временем шахматы распространились по всему миру, приобретая популярность в различных культурах.

Сегодня шахматы играют важную роль в культуре и спорте, с миллионами игроков по всему миру и множеством международных турниров, включая престижный матч за звание чемпиона мира. В последние годы интерес к шахматам возрос благодаря доступности онлайн-игр и популярным сериалам, таким как "Ход королевы" (The Queen's Gambit).

8 ферзей

Размещение 8 ферзей на шахматной доске размером 8 на 8 возможно 92 способами. Разумеется при условии, что ни одни из них не угрожает остальным.

Перейдя по ссылке вы увидите все эти варианты на отдельной странице.

Ферзь 8 x 8

Разместить 5 ферзей на шахматной доске размером 5 на 5 возможно 10 способами

Ферзь 5 x 5

Разместить 6 ферзей на шахматной доске размером 6 на 6 возможно 4 способами

Ферзь 6 x 6

Разместить 7 ферзей на шахматной доске размером 7 на 7 возможно 40 способами

Ферзь 7 x 7

Размещение 2, 3, 4 Ферзей на полях соответствующих размеров при аналогичном условии невозможно (тривиальный случай одного ферзя на поле 1 x 1 не рассматриваем).

Разместить 9 ферзей на шахматной доске размером 9 на 9 возможно 352 способами

Ферзь 9 x 9

Разместить 10 ферзей на шахматной доске размером 10 на 10 возможно 726 способами

Ферзь 10 x 10

Информация о материале: Автор: Arsen Gonian; Категория: Uncategorised; Опубликовано: 13 марта 2024; Просмотров: 3198

Игры на JS

JavaScript (JS) — один из самых популярных языков программирования для создания веб-приложений, включая игры. Вот несколько примеров игр, которые можно создать на JavaScript:

Бросок Мяча под углом к горизонту

Бросок мяча под углом к горизонту — это классическая задача из области кинематики, которая описывает движение тела, брошенного с определенной скоростью под некоторым углом к горизонту. Рассмотрим основные моменты и формулы, связанные с этим движением.

поиграть

Игра Камень, ножницы, бумага

Камень-ножницы-бумага: классическая детская игра, в которой участники одновременно выбирают один из трех символов - камень, ножницы или бумагу. Победитель определяется по правилам: камень побеждает ножницы, ножницы побеждают бумагу, бумага побеждает камень.

поиграть

Игра Кено

Кено: лотерейная игра, в которой игрок выбирает набор чисел из общего диапазона. Затем производится случайное извлечение чисел, и игрок получают выигрыш в зависимости от совпадения чисел на своей карте с выигрышными номерами.

поиграть

Игра Кости

Кости: игра, в которой бросается кубик (кубики) с числами. В зависимости от выпавшего значения, игроки могут делать ставки на различные исходы (результаты) бросков.

поиграть

Игра Монетка (орел или решка)

Монетка - это игра, в которой бросают монету и делают ставки на то, какой стороной она упадет - орел или решка. Просто нажмите на картинку Орла или Решки, затем на кнопку "Выбрать".

поиграть

Игра Слот-машина

Нажмите кнопку "Испытать судьбу", чтобы получить символы в случайном порядке. Игрок выигрывает, если выпадает три одинаковые фигуры

поиграть

Игра Виселица

Знакомая всем с детства игра. Просто угадывайте буквы, чтобы разгадать слово. В данном исполнении игра стала похожа на "Поле чудес".

поиграть

Игра Угадайка

Знакомая с детства игра. Просто введите число от 1 до 100. Решите математическую задачу: за какое максимальное количество ходов гарантированно можно угадать число.

поиграть

Игра Питон

Игра "Питон" ("Змейка") - это цифровое воплощение простоты и увлекательности. В ней игрок управляет змеей, которая ползет по пиксельному миру в поисках яблок и других фруктов и овощей. С каждым съеденным фруктом змея удлиняется, а игра ускоряется. Это испытание ловкости, стратегии и терпения, где каждое движение может привести к новому рекорду или неожиданному концу. Змея скользит между препятствиями, создавая узоры на экране, напоминающие танец в бесконечном лабиринте. Эта игра - отражение эры ретро-игр, где простые концепции превращаются в часы захватывающего геймплея.

поиграть

Библиотеки и движки для создания игр на JS:

Phaser.js: Популярный игровой фреймворк для 2D-игр. Предлагает множество инструментов для создания игр, начиная от управления анимацией и физикой, заканчивая аудио поддержкой и управлением пользователем.
Three.js: Используется для создания 3D-графики в браузере, включая сложные игры с трёхмерными мирами.
Babylon.js: Еще один мощный фреймворк для разработки 3D-игр и приложений в браузере.
p5.js: Библиотека, подходящая для создания интерактивных графических приложений, включая игры.

Информация о материале: Автор: Arsen Gonian; Категория: Uncategorised; Опубликовано: 29 декабря 2023; Просмотров: 485

Translated using translate google. The original language is Russian. Original page https://hi-aga.ru/index.php/homepage/for-31-40

Example thirty-one.

: FOR31 ( N>0 -> ) \ выводим A1 A2 ... AN
2E \ A0=2
0 \ N –> N 0 , пределы цикла
DO
1E FSWAP F/ \ A0 -> 1/A0
2E F+ \ 1/A0 -> 1/A0+2
FDUP F. \ вывод копию 2+1/A0
LOOP FDROP ; \ сбрасываем последний «2+1/A0», очищаем стек после себя
\ Результат работы программы (при N=10):
10 FOR31
2.5000000 2.4000000 2.4166667 2.4137931 2.4142857 2.4142012 2.4142157 2.4142132 2.4142136 2.4142136 Ok

Example thirty-two.

: FOR32 ( N>0 -> ) \ выводим последовательность чисел A1 A2 ... AN
1E    \ A0=1
1+ 1           \ N –> N 0 , пределы цикла
DO
  1E F+ \ A[k-1]+1
  I S>D D>F F/ \ (A[k-1]+1)/I , «I – это k в нашем случае»
  FDUP F. \ вывод копию (A[k-1]+1)/I
LOOP FDROP ;
\ Пример работы слова (при N=10):
10 FOR32
2.0000000 1.5000000 0.8333333 0.4583333 0.2916666 0.2152777 0.1736111 0.1467013 0.1274112 0.1127411 Ok

Example thirty-three.

: FOR33 ( N>1 -> ) \ вывести F1, F2, ... FN, если F1=1, F2=1, FK=F[K-2]+F[K-1]
DUP 3 < \ N –> N N<3
IF DROP 1 . 1 . EXIT THEN \ Если «N<3», то печатаем «1 1» и выходим
1 . 1 . \ печатаем первые два элемента «1 1»
1 1 ROT \ N -> 1 1 N , иначе считаем FN
1+ 3 \ 1 1 N -> 1 1 N+1 3 – готовим пределы цикла
DO \ 1 1 N+1 3 -> 1 1
2DUP +                 \ 1 1 -> 1 1 1+1 , из предыдущих двух получаем очередной элемент
  ROT DROP \ F[K-2] F[K-1] F[K] -> F[K-1] F[K] , удаляем элемент F[K-2]
  DUP . \ вывод копию F[K]
LOOP DROP DROP ;

Let's check for the first twenty Fibonacci numbers (we can see that this function is growing quite quickly, be careful with overflow when calculating a large number of terms of the series, so the 46th element is equal to “1836311903”, and the 47th will be negative due to overflow if operations can be rewritten to work with positive numbers, we won’t get further than the 48th element, you can rewrite them with operations for double precision numbers if necessary, but they can also be “overcome” if you really want to, a computer is just a computing machine, not a “magic device” "):
20 FOR33
1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765  Ok

Example thirty-four. Identical to the previous one (differing only in the formula), we obtain from it with minor changes and replacing operations for integer numbers with real ones (due to division in the formula for AK).
: FOR34 ( N>1 -> )  \ вывести A1=1 A2=2 ... AK={A[K-2]+2*A[K-1]}/3 ... AN
DUP 3 <                    \ N –> N N<3
IF DROP 1 . 2 . EXIT THEN  \ Если «N<3», то печатаем «1 2» и выходим
1 . 2 .                    \ иначе считаем FN, печатаем первые два элемента «1 2»
1E 2E                      \ F: -> 1 2 , первые два элемента
1+ 3                       \ N -> N+1 3 – готовим пределы цикла
DO                         \ N+1 3 ->
    FDUP 2E F*             \ F: 1 2 -> A[K-2] A[K-1] A[K-1]*2
    FROT F+ 3E F/          \ A[K-2] A[K-1] A[K-1]*2 -> A[K-1] (A[K-1]*2+A[K-2])/3
    FDUP F.                \ вывод копию (A[K-1]*2+A[K-2])/3
LOOP FDROP FDROP ;
As a result of the above code, we get the following series of numbers:
10 FOR34
1 2 1.6666667 1.7777778 1.7407407 1.7530864 1.7489712 1.7503429 1.7498857 1.7500381  Ok

Example thirty-five. Here the next term is counted not through two, but three previous ones. In general, it differs little from previous examples. In the second line we compare N with four (instead of three), if less we print the first three elements and exit (I decided not to bother too much). Otherwise, in the fourth we print the first three elements and calculate the rest further. In the fifth we enter the first three terms to calculate the next one. In the sixth, we prepare the parameters of the cycle, followed by the cycle itself. Everything in the loop should be familiar, duplicate the top two elements and add them. Since it’s difficult to work with four elements (we didn’t want to resort to variables), we send this intermediate result to the return stack (the word “>R”), then move element A[K-3] to the top and multiply it by “-2 ", then we return the intermediate value of the sum from the return stack and calculate the final result (thus, we got rid of the A[K-3] element in one go, as it was not necessary). The rest is standard - we copy the last calculated element and display it on the screen, and after the cycle we clear the stack of three elements. The only innovation is working with the return stack. It must be handled especially carefully if you put something there (or remove it) and call another word, or use any construction that changes the order of execution of the program (may depend on the implementation of the compiler/interpreter, depending on where the loop data, conditional statements, etc. are stored etc., any change in the number of elements on the return stack or change in their values is predictably dangerous “for the health of programs”, it is better not to risk it), then the program is guaranteed to crash with an error. The return stack serves to organize a hierarchy of subroutine calls and switching between programs and is implemented at the hardware level (at least in the x86 architecture).

: FOR35 ( N>2 -> )  \ вывести F1, F2, ... FN, если F1=1, F2=2, F3=3, AK=A[K-1]+A[K-2]-2*A[K-3]
DUP 4 <                        \ N –> N N<3
IF DROP 1 . 2 . 3 . EXIT THEN  \ Если «N<3», то печатаем «1 2 3» и выходим
1 . 2 . 3 .                    \ печатаем первые три элемента «1 2 3»
1 2 ROT 3 SWAP                 \ N -> 1 2 3 N , иначе считаем FN
1+ 4                           \ 1 2 3 N -> 1 2 3 N+1 3 – готовим пределы цикла
DO                             \ 1 2 3 N+1 3  -> 1 2 3
    2DUP +                     \ 1 2 3 -> 1 2 3 2+3
    >R                         \ 1 2 3 2+3 -> 1 2 3
    ROT -2 *                   \ 1 2 3 -> 2 3 1*(-2)
    R>                         \ 2 3 1 -> 2 3 1*(-2) 2+3
    +                          \ 2 3 1*(-2) 2+3 -> 2 3 1*(-2)+2+3
    DUP .                      \ вывод копию (A[K-1]+A[K-2]-2*A[K-3])/3
LOOP DROP DROP DROP ;
\ Проверим при N=20:
20 FOR35
1 2 3 3 2 -1 -5 -10 -13 -13 -6 7 27 46 59 51 18 -49 -133 -218  Ok

Example thirty-six. Not a particularly difficult task with nested loops, requiring a little more care, and the main thing is not to forget about the need to leave data for the limits of the nested loop parameter each time. Lines two, three, and four prepare the outer loop limits and push zero (the initial value of the series total) onto the real stack. Next comes the preparation for the nested loop, the seventh line, and in the sixth line we send N to the real stack, equal to the current value of the iteration (the member of the series that needs to be raised to a power) and one as the initial value of the power of N, and then the loop itself, which raises to the power repeated multiplication. Then we reset N and sum the two remaining numbers at the top of the stack, obtaining the current sum of the series. After the outer loop we print the final result with the word “G.” (for correct display of the exponent) and delete the input parameter “K” remaining on the integer stack.

: FOR36 ( N>0 K>0 -> )  \ вычислить 1^K+2^K+...+N^K
SWAP                \ N K -> K N
1+ 1                \ K N -> K N+1 1, прогоняю сперва все N
0E                  \ F: -> 0, заносим в вещественный стек ноль – начальное значение суммы ряда
DO                  \ K N+1 1-> K
    I S>D D>F 1E    \ F: 0 -> 0 N 1, добавили «1» –начальное значение произведения «N^K»
    DUP 1+ 1        \ K -> K K+1 1
    DO              \ K K 1 -> K
        FOVER F*    \ F: 0 N 1 -> 0 N 1*N
    LOOP
    FSWAP FDROP F+  \ F: 0 N 1*N -> 0+N^K
LOOP G. DROP ;
\ Примеры вычисления суммы квадратов от 1 до 5, 6, 7 и до 10 в 10-ой степени (для проверки правильности вывода экспоненты):
5 2 FOR36
55.000000  Ok
6 2 FOR36
91.000000  Ok
7 2 FOR36
140.00000  Ok
10 10 FOR36
1.4914342e10  Ok

This example can be rewritten without the nested loop. Fort has a built-in facility for exponentiation in one operation. I’ll just give an example of exponentiation; if you wish, modify the above code yourself, because the example should show the use of a loop in a loop, and not skill and knowledge. Example 5 to the power of 5:
5E 5E F** F.
3125.0000  Ok
Example thirty-seven. A modification of the previous one, in which the limit of the inner loop parameter "K" is replaced by the current value of the outer loop parameter. In general, a minimum of edits and the problem is solved.
: FOR37 ( N>0 -> )  \ вычислить 1^1+2^2+...+N^N
1+ 1                \ I: N -> N+1 1, прогоняю все N
0E                  \ F: -> 0, заносим в вещественный стек ноль – начальное значение суммы ряда
DO                  \ I: N+1 1->
    I DUP           \ I: I I, (I=N)
    S>D D>F 1E      \ F: 0 -> 0 N 1, «1» – это начальное значение произведения «N^N»
    1+ 1            \ I: I -> I+1 1
    DO              \ I: I+1 1 ->
        FOVER F*    \ F: 0 N 1 -> 0 N 1*N
    LOOP
    FSWAP FDROP F+  \ F: 0 N 1*N -> 0+N^N
LOOP G. ;
\ Тесты:
1 FOR37
1.0000000  Ok
2 FOR37
5.0000000  Ok
3 FOR37
32.000000  Ok
4 FOR37
288.00000  Ok
5 FOR37
3413.0000  Ok

Example thirty-eight. To run the degrees in reverse order, we additionally copy the input parameter “N”, and from it we calculate “N-I+1” (for example, for “N=5”, “I=1” – “N-I+1 =5-1+1=5", "I=2" - "N-I+1=5-2+1=4 ... and "I=5" - "N-I+1=5-5+1 =1, thus obtaining a countdown for the nested loop parameter). Otherwise everything is the same as in the previous examples.
: FOR38 ( N>0 -> )  \ вычислить 1^N+2^(N-1)+...+N^1
DUP 1+ 1            \ I: N -> N N+1 1, прогоняю все N
0E                  \ F: -> 0, заносим в вещественный стек ноль – начальное значение суммы ряда
DO                  \ I: N N+1 1-> N
    I DUP           \ I: N -> N I I, (I=N)
    S>D D>F 1E      \ F: 0 -> 0 N 1, «1» – это начальное значение произведения «N^N»
    OVER SWAP –     \ I: N I  -> N N-I
    1+ 1 SWAP       \ I: N N-I -> N 1 N-I+1
    DO              \ I: N 1 N-I+1 -> N
        FOVER F*    \ F: 0 N 1 -> 0 N 1*N
        -1
    +LOOP
    FSWAP FDROP F+  \ F: 0 N 1*N -> 0+N^N
LOOP G. DROP ;
\ Тесты дают следующие результаты:
1 FOR38
1.0000000  Ok
2 FOR38
3.0000000  Ok
3 FOR38
8.0000000  Ok
4 FOR38
22.000000  Ok
5 FOR38
65.000000  Ok

Example thirty-nine. The simplest example after the previous ones. In the outer loop, we run I from A to B, and in the inner loop, we print the current value of the parameter a number of times equal to its value.
: FOR39 ( A>0 B>0 -> )  \ A (A раз) A+1 (A+1 раз)… A+N (A+N раз) {A<B}
1+ SWAP ( B+1 A )  \ A B -> B+1 A
DO                 \ B+1 A ->
    I DUP 0        \ -> I I 0, от нуля до (I-1), то есть «I» раз повторяем вложенный цикл
    DO             \ I I 0 -> I
        DUP .      \ печатаем I (I= от A до B) I раз
    LOOP
    DROP           \ удаляем I за ненадобностью, оставляем стек чистым после себя
LOOP ;
\ Тест:
2 7 FOR39
2 2 3 3 3 4 4 4 4 5 5 5 5 5 6 6 6 6 6 6 7 7 7 7 7 7 7  Ok
Example forty. In line two, I push one onto the stack - the initial value of the number of repetitions and the limits of the loop parameter. From the third to the ninth outer cycle. The fourth is the limits of the parameter of the inner loop, and from the fifth to the seventh lines of the nested loop, inside which we duplicate “I” and print it (the current value of the outer loop parameter), after which “I” is reset and the number of repetitions of the output of the current number is increased by one after which goes “CR” - just for the beauty of the output and the convenience of counting the number of repetitions when checking the results.
: FOR40 ( A>0 B>0 -> )  \ A (1 раз) A+1 (2 раз)… A+N (N раз) {A<B}
1+ SWAP 1 ROT ROT  \ A B -> 1 B+1 A, пределы цикла, а один - начало числа повторений
DO                 \ 1 B+1 A ->1
    I OVER 0       \ 1 -> 1 I 1 0
    DO             \ 1 I 1 0 -> 1 I
        DUP .      \ печатаю «I» … раз
    LOOP
    DROP 1+ CR     \ 1 I -> 1+1, сбрасываю «I» и увеличиваю число повторений
LOOP DROP ;        \ сбрасываю число повторений
\ По традиции тест:
1 10 FOR40
1
2 2
3 3 3
4 4 4 4
5 5 5 5 5
6 6 6 6 6 6
7 7 7 7 7 7 7
8 8 8 8 8 8 8 8
9 9 9 9 9 9 9 9 9
10 10 10 10 10 10 10 10 10 10
 Ok