К книге
Рассказы о математикеСтраница 4
50%
Страница 4
4

Магический квадрат 4х4 был обнаружен в индийских надписях 11 века:

И наконец, известный квадрат 4х4, изображенный на гравюре немецкого художника Дюрера “Меланхолия”. Этот квадрат изображен не просто так, 2 числа 1514 указывают на дату создания гравюры.

Как можно видеть, уже математики прошлого умели строить магические квадраты разной размерности. Интересно рассмотреть их свойства.

Сумма чисел магического квадрата размера NxN зависит только от N, и определяется формулой:

Это несложно доказать, т.к. сумма всех чисел квадрата равна сумме ряда 1..N2. Действительно, для квадрата Дюрера M(4) = 34, что можно посчитать на картине. Для квадратов разной размерности суммы равны соответственно: M(3) = 15, M(4) = 34, M(5) = 65, M(6) = 111, M(7) = 175, M(8) = 260, M(9) = 369, M(10) = 505.

Напишем программу для построения магических квадратов размерности N. Первый подход будет “в лоб”, напрямую. Создадим массив, содержащий все числа от 1 до N2 и получим все возможные перестановки этого массива. Их число довольно-таки велико, и составляет 1*2*..*N = N! вариантов. Также для каждого массива необходимо проверить, является ли он “магическим”, т.е. выполняется ли требование равенства сумм.

Для получения всех перестановок воспользуемся алгоритмом, описанным здесь - https://prog-cpp.ru/permutation/.

Код программы приведен ниже:

def swap(arr, i, j):

arr[i],arr[j] = arr[j],arr[i]

def next_set(arr, n):

j = n - 2

while j != -1 and arr[j] >= arr[j + 1]: j -= 1

if j == -1:

return False

k = n - 1

while arr[j] >= arr[k]: k -= 1

swap(arr, j, k)

l = j + 1

r = n - 1

while l < r:

swap(arr, l, r)

l += 1

r -= 1

return True

def is_magic(arr, n):

for i in range(0, n):

sum1 = 0

sum2 = 0

sum3 = 0

sum4 = 0

for j in range(0, n):

sum1 += arr[i*n + j]

sum2 += arr[j*n + i]

sum3 += arr[j*n + j]

sum4 += arr[(n-j-1)*n + j]

if sum1 != sum2 or sum1 != sum3 or sum1 != sum4 or sum2 != sum3 or sum2 != sum4 or sum3 != sum4:

return False

return True

def show_squares(n):

N = n*n

arr = [i+1 for i in range(N)]

cnt = 0

while next_set(arr, N):

if is_magic(arr, n):

print(arr)

cnt += 1

return cnt

# Требуемая размерность

cnt = show_squares(3)

print("Число вариантов:", cnt)

Программа выдала 8 вариантов для N=3, время вычисления составило 2 секунды:

[2, 7, 6, 9, 5, 1, 4, 3, 8]      [6, 1, 8, 7, 5, 3, 2, 9, 4]

[2, 9, 4, 7, 5, 3, 6, 1, 8]      [6, 7, 2, 1, 5, 9, 8, 3, 4]

[4, 3, 8, 9, 5, 1, 2, 7, 6]      [8, 1, 6, 3, 5, 7, 4, 9, 2]

[4, 9, 2, 3, 5, 7, 8, 1, 6]      [8, 3, 4, 1, 5, 9, 6, 7, 2]

Действительно, как известно, существует только 1 магический квадрат 3х3:

Остальные являются лишь его поворотами или отражениями (очевидно что при повороте квадрата его свойства не изменятся).

Теперь попробуем вывести квадраты 4х4. Запускаем программу… и ничего не видим. Как было сказано выше, число вариантов перебора для 16 цифр равняется 16! или 20922789888000 вариантов. На моем компьютере полный перебор такого количества занял бы 1089 дней!

Однако посмотрим на магический квадрат еще раз:

Суммы всех элементов по горизонтали и вертикали равны. Из этого мы легко можем записать равенство его членов:

x11 + x12 + x13 + x14 = x21 + x22 + x23 + x24

x11 + x12 + x13 + x14 = x14 + x24 + x34 + x44

x11 + x12 + x13 + x14 = x13 + x23 + x33 + x43

x11 + x12 + x13 + x14 = x12 + x22 + x32 + x42

x11 + x12 + x13 + x14 = x11 + x21 + x33 + x44

x11 + x12 + x13 + x14 = x31 + x32 + x33 + x34

И наконец, общая сумма: т.к. квадрат заполнен числами 1..16, то если сложить все 4 строки квадрата, то получаем 4S = 1+..+16 = 136, т.е. S=34 (что соответствует приведенной в начале главы формуле).

Это значит, что мы легко можем выразить последние элементы через предыдущие:

x14 = S - x11 - x12 - x13

x24 = S - x21 - x22 - x23

x34 = S - x31 - x32 - x33

x41 = S - x11 - x21 - x31

x42 = S - x12 - x22 - x32

x43 = S - x13 - x23 - x33

x44 = S + x14 - x14 - x24 - x34

Что это дает? Очень многое. Вместо перебора 16 вариантов суммарным количеством 16!=20922789888000 мы должны перебрать лишь 9 вариантов, что дает 9!=362880 вариантов, т.е. в 57657600 раз меньше! Как нетрудно догадаться, мы фактически выразили крайние строки квадрата через соседние, т.е. уменьшили размерность поиска с 4х4 до 3х3. Это же правило будет действовать и для квадратов большей диагонали.

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

set(range(1,16+1)) - множество чисел [1..16]

set(range(1,16+1)) - set([x11]) - множество чисел [1..16] за исключением x11.

Также добавлена простая проверка на минимальность суммы: очевидно, что сумма всех элементов не может быть меньше чем 16+1+2+3 = 22.

digits = set(range(1,16+1))

cnt = 0

for x11 in digits:

for x12 in digits - set([x11]):

for x13 in digits - set([x11, x12]):

for x14 in digits - set([x11, x12, x13]):

s = x11 + x12 + x13 + x14

if s < 22: continue

for x21 in digits - set([x11, x12, x13, x14]):

for x22 in digits - set([x11, x12, x13, x14, x21]):

for x23 in digits - set([x11, x12, x13, x14, x21, x22]):

x24 = s - x21 - x22 - x23

if x24 <= 0 or x24 in [x11, x12, x13, x14, x21, x22, x23]: continue

for x31 in digits - set([x11, x12, x13, x14, x21, x22, x23, x24]):

for x32 in digits - set([x11, x12, x13, x14, x21, x22, x23, x24, x31]):

for x33 in digits - set([x11, x12, x13, x14, x21, x22, x23, x24, x31, x32]):

       x34 = s - x31 - x32 - x33

       x41 = s - x11 - x21 - x31

x42 = s - x12 - x22 - x32

x43 = s - x13 - x23 - x33

x44 = s - x14 - x24 - x34

if x34 <= 0 or x41 <= 0 or x42 <= 0 or x43 <= 0 or x44 <= 0: continue

data = [x11, x12, x13, x14, x21, x22, x23, x24, x31, x32, x33, x34, x41, x42, x43, x44]

if len(data) != len(set(data)): continue

if is_magic(data, 4):

print data

cnt += 1

print cnt

В результате, программа проработала всего лишь около часа (вместо 3х лет!), всего было выведено 7040 квадратов размерностью 4х4. Разумеется, большинство из них являются поворотами или отражениями друг друга, было доказано что уникальных квадратов всего 880.

Вспомним магический квадрат Дюрера, в нижнем его столбце есть цифры 1514, соответствующие году создания гравюры. С помощью программы можно решить еще одну задачу: посмотреть сколько всего возможно квадратов с такими цифрами. Здесь число вариантов перебора еще меньше, т.к. еще 2 цифры фиксированы. Оказывается, помимо “авторского”, возможны всего 32 варианта, например:

1 15 14 4       2 15 14 3

5 11 8 10      5 10 7 12

12 6 9 7      11 8 9 6

16 2 3 13      16 1 4 13

Интересно, что верхний ряд помимо цифр 15 и 14 может содержать либо 1,4 либо 2,3, других вариантов нет. Разные варианты содержат лишь перестановки этих цифр.

Если же говорить о квадратах большей размерности, то число вариантов перебора для них получается слишком большим. Так для квадрата 5х5, даже если выразить крайние члены через соседние, получаем 4х4 остающихся клеток, что даст нам те же самые 16! вариантов перебора. Разумеется, в реальности такие квадраты не строили методом полного перебора, существует множество алгоритмов их построения, например метод Франклина, Россера, Рауз-Болла, желающие могут поискать их самостоятельно. В архиве с книгой приложен файл “07 - magic5.cpp” для расчета квадратов 5х5 на С++, но автору так и не хватило терпения дождаться результатов.

И наконец, можно вспомнить так называемые “пандиагональные” магические квадраты. Это квадраты, в которых учитываются суммы также “косых” диагоналей, которые получаются если вырезать квадрат из бумаги и склеить его в тор. Желающие могут добавить в программу вывод таких квадратов самостоятельно.

8. Магический квадрат из простых чисел

Существует еще одна разновидность магического квадрата - составленного из простых чисел. Пример такого квадрата показан на рисунке:

29

131

107

167

89

11

71

47

149

Приведенную выше программу легко модифицировать для такого расчета: достаточно лишь заменить множество digits = set(range(1,16+1)) на другое, содержащее простые числа.

Для примера будем искать квадраты среди трехзначных простых чисел от 101 до 491.

Заменим в предыдущей версии программы строку digits = set([1,2,3,4,5,6,7,8,9]) на

primes = [ 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163,

167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251,

257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317, 331, 337, 347, 349,

353, 359, 367, 373, 379, 383, 389, 397, 401, 409, 419, 421, 431, 433, 439, 443,

449, 457, 461, 463, 467, 479, 487, 491 ]

digits = set(primes)

Таких квадратов нашлось 40, например:

233

167

389

419

263

107

137

359

293

Сумма чисел равна вполне красивому числу 789.

Т.к. число вариантов перебора больше, программа работает дольше. Время поиска составило 724с для Python-версии и 316c для программы на C++.

Если же рассматривать минимально возможный квадрат из простых чисел, то его сумма равняется тоже вполне “красивому” числу 111:

7

61

43

73

37

1

31

13

67

Примером квадрата 4х4 может быть квадрат с также “красивой” суммой 222:

97

41

73

11

17

47

83

75

59

79

13

71

49

55

53

65

9. Числа Фибоначчи

Возьмем 2 числа: 0 и 1. Следующее число рассчитаем как сумму предыдущих чисел, затем повторим процесс.

Мы получили последовательность, известную как числа Фибоначчи:

0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765, ...

Эта последовательность была названа в честь итальянского математика 12 века Леонардо Фибоначчи. Фибоначчи рассматривал задачу роста популяции кроликов. Если предположить, что новорожденная пара кроликов 1 месяц растет, через месяц начинает спариваться, и затем через каждый месяц дает потомство, то количество пар кроликов несложно подсчитать:

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

Множество растений имеют количество лепестков, равное одному из чисел Фибоначчи. Количество листьев на стебле также может описываться этим законом, например у тысячелистника.

Другое известное изображение - спираль Фибоначчи, которая строится по похожему принципу соотношения размеров прямоугольников:

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

Для примера достаточно взять фотографию циклона из космоса, и наложить обе картинки вместе:

Если взять и разделить друг на друга 2 любых соседних члена последовательности, например 233/377, получится число 0,618. Случайно это или нет, но это число - то самое “золотое сечение”, считающееся наиболее эстетичной пропорцией.

Числа Фибоначчи несложно вывести в программе на языке Python:

from decimal import *

def printNumbers(n):

i1 = Decimal(0)

i2 = Decimal(1)

for p in range(1, n+1):

print("F({}) = {}".format(p, i2))

fib = i1 + i2

i1 = i2

i2 = fib

getcontext().prec = 100

N = 100

printNumbers(N)

Интересно заметить, что растет последовательность Фибоначчи весьма быстро, уже F(300) = 222232244629420445529739893461909967206666939096499764990979600.

10. Высота звуков нот

Еще в древности человек заметил, что натянутая струна порождает колебания звука. Во времена Пифагора было замечено, что струны издают мелодичный звук, если их длина соотносится как небольшие целые числа (1:2, 2:3, 3:4 и т. д.). Звук от струны длиной 2/3 дает чистую квинту, 3/4 струны дает кварту а половина струны - октаву.

Рассмотрим струну с условной длиной = 1. Будем умножать длину струны на 3/2, если полученное число больше 2, разделим еще на 2.

Предыдущая главаГлава 4 из 8Следующая глава