Роздрукуйте всі 3 на 3 міцні квадрати


24

Міцний квадрат (подібний до магічного квадрата ) - це розташування цілих чисел 1 до N 2 на сітці N по N таким чином, що кожна підгрупа 2 на 2 має однакову суму.

Наприклад, для N = 3 один міцний квадрат - це

1 5 3
9 8 7
4 2 6

тому що чотири 2 на 2 підмережі

1 5
9 8
5 3
8 7
9 8
4 2
8 7
2 6

вся сума до тієї ж суми, 23:

23 = 1 + 5 + 9 + 8 = 5 + 3 + 8 + 7 = 9 + 8 + 4 + 2 = 8 + 7 + 2 + 6

Тепер є міцні квадрати для більш високих значень N і навіть прямокутних версій, але ваше єдине завдання в цій задачі - вивести всі можливі 3 на 3 міцні квадрати. Існує рівно 376 чітких квадратів 3 на 3, включаючи ті, що є відображеннями або обертаннями інших, і не всі вони мають однакову суму 23.

Напишіть програму або функцію, яка не вводить, але друкує або повертає рядок з усіх 376 міцних квадратів у будь-якому порядку, розділених порожніми рядками, до двох необов'язкових кінцевих рядків. Кожен квадрат повинен складатися з трьох рядків з трьох пробілів, розділених ненульовими десятковими цифрами.

Ось дійсний приклад виводу:

1 5 3
9 8 7
4 2 6

1 5 6
8 7 3
4 2 9

1 5 6
8 9 3
2 4 7

1 5 7
9 6 3
2 4 8

1 6 2
8 9 7
4 3 5

1 6 2
9 7 8
4 3 5

1 6 3
9 8 7
2 5 4

1 6 7
8 5 2
3 4 9

1 6 7
9 4 3
2 5 8

1 7 2
9 4 8
5 3 6

1 7 2
9 6 8
3 5 4

1 7 4
8 3 5
6 2 9

1 7 4
9 2 6
5 3 8

1 7 6
9 2 4
3 5 8

1 8 2
5 9 4
6 3 7

1 8 3
6 5 4
7 2 9

1 8 3
9 2 7
4 5 6

1 8 4
5 7 2
6 3 9

1 8 4
6 9 3
2 7 5

1 8 4
9 3 6
2 7 5

1 8 6
7 3 2
4 5 9

1 9 2
5 6 4
7 3 8

1 9 2
6 4 5
7 3 8

1 9 2
6 8 5
3 7 4

1 9 2
8 3 7
4 6 5

1 9 3
7 2 5
6 4 8

1 9 3
7 6 5
2 8 4

1 9 4
5 8 2
3 7 6

1 9 4
6 7 3
2 8 5

1 9 4
8 2 5
3 7 6

1 9 5
7 2 3
4 6 8

1 9 5
7 4 3
2 8 6

2 3 5
9 8 6
4 1 7

2 3 6
9 7 5
4 1 8

2 4 3
8 9 7
5 1 6

2 4 3
9 7 8
5 1 6

2 4 6
7 8 3
5 1 9

2 4 7
8 9 3
1 5 6

2 4 8
9 6 3
1 5 7

2 5 3
9 4 8
6 1 7

2 5 4
9 3 7
6 1 8

2 5 4
9 8 7
1 6 3

2 5 7
6 8 1
4 3 9

2 5 7
6 9 1
3 4 8

2 5 8
7 6 1
3 4 9

2 5 8
9 4 3
1 6 7

2 6 1
7 9 8
5 3 4

2 6 1
8 7 9
5 3 4

2 6 3
5 9 4
7 1 8

2 6 4
5 8 3
7 1 9

2 6 7
9 1 4
3 5 8

2 6 8
7 4 1
3 5 9

2 7 1
8 4 9
6 3 5

2 7 1
8 6 9
4 5 3

2 7 3
5 6 4
8 1 9

2 7 3
6 4 5
8 1 9

2 7 3
9 1 8
5 4 6

2 7 5
4 8 1
6 3 9

2 7 5
6 9 3
1 8 4

2 7 5
9 3 6
1 8 4

2 8 1
4 9 5
7 3 6

2 8 4
7 6 5
1 9 3

2 8 5
4 9 1
3 7 6

2 8 5
6 7 3
1 9 4

2 8 6
7 4 3
1 9 5

2 9 1
4 6 5
8 3 7

2 9 1
5 4 6
8 3 7

2 9 1
5 8 6
4 7 3

2 9 1
7 3 8
5 6 4

2 9 3
6 1 5
7 4 8

2 9 4
3 7 1
6 5 8

2 9 4
3 8 1
5 6 7

2 9 5
4 7 1
3 8 6

2 9 5
7 1 4
3 8 6

2 9 6
5 3 1
4 7 8

2 9 6
5 4 1
3 8 7

3 2 5
9 8 7
4 1 6

3 2 6
8 9 5
4 1 7

3 2 7
9 6 5
4 1 8

3 4 2
7 9 8
6 1 5

3 4 2
8 7 9
6 1 5

3 4 5
9 2 7
6 1 8

3 4 8
6 9 1
2 5 7

3 4 9
7 6 1
2 5 8

3 4 9
8 5 2
1 6 7

3 5 1
7 8 9
6 2 4

3 5 2
8 4 9
7 1 6

3 5 4
9 1 8
6 2 7

3 5 4
9 6 8
1 7 2

3 5 8
9 1 4
2 6 7

3 5 8
9 2 4
1 7 6

3 5 9
7 4 1
2 6 8

3 6 1
7 8 9
4 5 2

3 6 2
4 9 5
8 1 7

3 6 8
7 1 2
4 5 9

3 7 2
4 6 5
9 1 8

3 7 2
5 4 6
9 1 8

3 7 2
8 1 9
6 4 5

3 7 4
6 1 5
8 2 9

3 7 4
6 8 5
1 9 2

3 7 6
4 9 1
2 8 5

3 7 6
5 8 2
1 9 4

3 7 6
8 2 5
1 9 4

3 8 1
4 5 6
9 2 7

3 8 1
7 2 9
6 5 4

3 8 4
2 9 1
6 5 7

3 8 6
4 7 1
2 9 5

3 8 6
7 1 4
2 9 5

3 8 7
5 4 1
2 9 6

3 9 1
5 2 7
8 4 6

3 9 1
5 6 7
4 8 2

3 9 2
5 1 6
8 4 7

3 9 4
2 6 1
7 5 8

3 9 4
2 8 1
5 7 6

3 9 6
4 2 1
5 7 8

3 9 6
5 1 2
4 8 7

4 1 6
9 8 7
3 2 5

4 1 7
8 9 5
3 2 6

4 1 7
9 8 6
2 3 5

4 1 8
9 6 5
3 2 7

4 1 8
9 7 5
2 3 6

4 2 6
9 8 7
1 5 3

4 2 7
6 9 3
5 1 8

4 2 7
9 3 6
5 1 8

4 2 8
7 6 3
5 1 9

4 2 9
8 7 3
1 5 6

4 3 5
8 9 7
1 6 2

4 3 5
9 2 8
6 1 7

4 3 5
9 7 8
1 6 2

4 3 7
5 8 2
6 1 9

4 3 7
8 2 5
6 1 9

4 3 7
9 1 6
5 2 8

4 3 9
6 8 1
2 5 7

4 5 2
7 3 9
8 1 6

4 5 2
7 8 9
3 6 1

4 5 3
8 1 9
7 2 6

4 5 3
8 6 9
2 7 1

4 5 6
3 8 1
7 2 9

4 5 6
9 2 7
1 8 3

4 5 9
7 1 2
3 6 8

4 5 9
7 3 2
1 8 6

4 6 2
3 8 5
9 1 7

4 6 5
2 9 1
7 3 8

4 6 5
8 3 7
1 9 2

4 6 8
7 2 3
1 9 5

4 7 1
5 3 8
9 2 6

4 7 1
6 2 9
8 3 5

4 7 3
5 1 6
9 2 8

4 7 3
5 8 6
2 9 1

4 7 5
2 6 1
8 3 9

4 7 8
5 3 1
2 9 6

4 8 1
2 7 5
9 3 6

4 8 1
3 9 6
5 7 2

4 8 1
6 3 9
5 7 2

4 8 2
5 6 7
3 9 1

4 8 3
1 9 2
7 5 6

4 8 6
3 2 1
7 5 9

4 8 7
5 1 2
3 9 6

4 9 1
2 8 5
6 7 3

4 9 1
3 7 6
5 8 2

4 9 1
5 2 8
6 7 3

4 9 2
1 7 3
8 5 6

4 9 2
1 8 3
7 6 5

4 9 3
1 6 2
8 5 7

4 9 3
1 8 2
6 7 5

4 9 5
2 3 1
7 6 8

4 9 5
3 1 2
7 6 8

4 9 6
3 2 1
5 8 7

5 1 6
8 9 7
2 4 3

5 1 6
9 7 8
2 4 3

5 1 8
6 9 3
4 2 7

5 1 8
9 3 6
4 2 7

5 1 9
7 6 3
4 2 8

5 1 9
7 8 3
2 4 6

5 2 3
7 8 9
6 1 4

5 2 8
7 3 4
6 1 9

5 2 8
9 1 6
4 3 7

5 3 2
6 8 9
7 1 4

5 3 4
7 9 8
2 6 1

5 3 4
8 2 9
7 1 6

5 3 4
8 7 9
2 6 1

5 3 6
9 4 8
1 7 2

5 3 8
4 7 1
6 2 9

5 3 8
7 1 4
6 2 9

5 3 8
9 2 6
1 7 4

5 4 3
7 2 9
8 1 6

5 4 6
3 7 2
8 1 9

5 4 6
9 1 8
2 7 3

5 6 4
1 9 2
8 3 7

5 6 4
7 3 8
2 9 1

5 6 7
3 8 1
2 9 4

5 7 2
1 8 4
9 3 6

5 7 2
3 9 6
4 8 1

5 7 2
6 3 9
4 8 1

5 7 4
1 6 2
9 3 8

5 7 6
2 3 1
8 4 9

5 7 6
2 8 1
3 9 4

5 7 6
3 1 2
8 4 9

5 7 8
4 2 1
3 9 6

5 8 2
1 9 4
6 7 3

5 8 2
3 7 6
4 9 1

5 8 7
3 2 1
4 9 6

5 9 1
3 2 7
8 6 4

5 9 1
3 4 7
6 8 2

5 9 2
1 7 4
6 8 3

5 9 2
4 1 7
6 8 3

5 9 4
1 3 2
8 6 7

5 9 4
2 1 3
8 6 7

6 1 4
7 8 9
5 2 3

6 1 5
7 9 8
3 4 2

6 1 5
8 7 9
3 4 2

6 1 7
9 2 8
4 3 5

6 1 7
9 4 8
2 5 3

6 1 8
9 2 7
3 4 5

6 1 8
9 3 7
2 5 4

6 1 9
5 8 2
4 3 7

6 1 9
7 3 4
5 2 8

6 1 9
8 2 5
4 3 7

6 2 3
5 9 8
7 1 4

6 2 4
7 8 9
3 5 1

6 2 7
9 1 8
3 5 4

6 2 8
5 4 3
7 1 9

6 2 9
4 7 1
5 3 8

6 2 9
7 1 4
5 3 8

6 2 9
8 3 5
1 7 4

6 3 2
5 7 9
8 1 4

6 3 5
8 4 9
2 7 1

6 3 7
5 2 4
8 1 9

6 3 7
5 9 4
1 8 2

6 3 9
4 8 1
2 7 5

6 3 9
5 7 2
1 8 4

6 4 2
3 8 7
9 1 5

6 4 5
2 7 3
9 1 8

6 4 5
8 1 9
3 7 2

6 4 8
7 2 5
1 9 3

6 5 1
3 7 8
9 2 4

6 5 1
3 9 8
7 4 2

6 5 4
1 8 3
9 2 7

6 5 4
7 2 9
3 8 1

6 5 7
2 4 1
8 3 9

6 5 7
2 9 1
3 8 4

6 5 8
3 2 1
7 4 9

6 5 8
3 7 1
2 9 4

6 7 1
4 2 9
8 5 3

6 7 3
1 9 4
5 8 2

6 7 3
2 8 5
4 9 1

6 7 3
5 2 8
4 9 1

6 7 5
1 3 2
9 4 8

6 7 5
1 8 2
4 9 3

6 7 5
2 1 3
9 4 8

6 8 1
2 3 7
9 5 4

6 8 2
3 4 7
5 9 1

6 8 3
1 7 4
5 9 2

6 8 3
4 1 7
5 9 2

6 8 4
1 2 3
9 5 7

6 9 2
1 3 5
8 7 4

6 9 2
1 4 5
7 8 3

6 9 3
1 2 4
8 7 5

6 9 3
2 1 5
7 8 4

6 9 4
1 2 3
7 8 5

7 1 4
5 9 8
6 2 3

7 1 4
6 8 9
5 3 2

7 1 6
8 2 9
5 3 4

7 1 6
8 4 9
3 5 2

7 1 8
5 9 4
2 6 3

7 1 9
5 4 3
6 2 8

7 1 9
5 8 3
2 6 4

7 2 3
5 6 9
8 1 4

7 2 4
3 9 6
8 1 5

7 2 4
6 3 9
8 1 5

7 2 6
8 1 9
4 5 3

7 2 9
3 8 1
4 5 6

7 2 9
6 5 4
1 8 3

7 3 4
2 8 5
9 1 6

7 3 4
5 2 8
9 1 6

7 3 4
6 1 9
8 2 5

7 3 6
4 2 5
9 1 8

7 3 6
4 9 5
2 8 1

7 3 8
2 9 1
4 6 5

7 3 8
5 6 4
1 9 2

7 3 8
6 4 5
1 9 2

7 4 2
3 9 8
6 5 1

7 4 8
6 1 5
2 9 3

7 4 9
3 2 1
6 5 8

7 5 1
3 6 9
8 4 2

7 5 2
1 8 6
9 3 4

7 5 2
1 9 6
8 4 3

7 5 6
1 4 2
9 3 8

7 5 6
1 9 2
4 8 3

7 5 8
2 6 1
3 9 4

7 5 9
3 2 1
4 8 6

7 6 1
2 5 8
9 4 3

7 6 1
3 4 9
8 5 2

7 6 2
4 1 9
8 5 3

7 6 5
1 8 3
4 9 2

7 6 8
2 3 1
4 9 5

7 6 8
3 1 2
4 9 5

7 8 3
1 4 5
6 9 2

7 8 4
2 1 5
6 9 3

7 8 5
1 2 3
6 9 4

8 1 4
5 6 9
7 2 3

8 1 4
5 7 9
6 3 2

8 1 5
3 9 6
7 2 4

8 1 5
6 3 9
7 2 4

8 1 6
7 2 9
5 4 3

8 1 6
7 3 9
4 5 2

8 1 7
4 9 5
3 6 2

8 1 9
3 7 2
5 4 6

8 1 9
5 2 4
6 3 7

8 1 9
5 6 4
2 7 3

8 1 9
6 4 5
2 7 3

8 2 4
3 6 7
9 1 5

8 2 5
4 3 7
9 1 6

8 2 5
6 1 9
7 3 4

8 2 6
3 4 5
9 1 7

8 2 9
6 1 5
3 7 4

8 3 5
1 7 4
9 2 6

8 3 5
4 1 7
9 2 6

8 3 5
6 2 9
4 7 1

8 3 7
1 9 2
5 6 4

8 3 7
4 6 5
2 9 1

8 3 7
5 4 6
2 9 1

8 3 9
2 4 1
6 5 7

8 3 9
2 6 1
4 7 5

8 4 2
3 6 9
7 5 1

8 4 3
1 9 6
7 5 2

8 4 6
5 2 7
3 9 1

8 4 7
5 1 6
3 9 2

8 4 9
2 3 1
5 7 6

8 4 9
3 1 2
5 7 6

8 5 2
1 6 7
9 4 3

8 5 2
3 4 9
7 6 1

8 5 3
4 1 9
7 6 2

8 5 3
4 2 9
6 7 1

8 5 6
1 2 3
9 4 7

8 5 6
1 7 3
4 9 2

8 5 7
1 6 2
4 9 3

8 6 2
1 4 7
9 5 3

8 6 3
2 1 7
9 5 4

8 6 4
3 2 7
5 9 1

8 6 7
1 3 2
5 9 4

8 6 7
2 1 3
5 9 4

8 7 4
1 3 5
6 9 2

8 7 5
1 2 4
6 9 3

9 1 5
3 6 7
8 2 4

9 1 5
3 8 7
6 4 2

9 1 6
2 8 5
7 3 4

9 1 6
4 3 7
8 2 5

9 1 6
5 2 8
7 3 4

9 1 7
3 4 5
8 2 6

9 1 7
3 8 5
4 6 2

9 1 8
2 7 3
6 4 5

9 1 8
4 2 5
7 3 6

9 1 8
4 6 5
3 7 2

9 1 8
5 4 6
3 7 2

9 2 4
3 7 8
6 5 1

9 2 6
1 7 4
8 3 5

9 2 6
4 1 7
8 3 5

9 2 6
5 3 8
4 7 1

9 2 7
1 8 3
6 5 4

9 2 7
4 5 6
3 8 1

9 2 8
5 1 6
4 7 3

9 3 4
1 8 6
7 5 2

9 3 6
1 8 4
5 7 2

9 3 6
2 7 5
4 8 1

9 3 8
1 4 2
7 5 6

9 3 8
1 6 2
5 7 4

9 4 3
1 6 7
8 5 2

9 4 3
2 5 8
7 6 1

9 4 7
1 2 3
8 5 6

9 4 8
1 3 2
6 7 5

9 4 8
2 1 3
6 7 5

9 5 3
1 4 7
8 6 2

9 5 4
2 1 7
8 6 3

9 5 4
2 3 7
6 8 1

9 5 7
1 2 3
6 8 4

Ваша програма повинна створити ці самі 376 міцних квадратів, не обов'язково в цьому порядку. Вихідні дані не повинні бути детермінованими, тобто ви можете виводити їх у різних порядках на різних пробігах до тих пір, поки вони всі є.

Виграє найкоротший код у байтах.

Тема міцних квадратів виникла з цього мого повідомлення в чаті, яке призвело до великої кількості дискусій щодо їх властивостей та способів їх створення. Реквізит для Пітера Тейлора , feersum і Sp3000 для продовження дискусії, і особливо до El'endia Starman для розробки відповідної послідовності OEIS .


Я не впевнений, чи правильно я інтерпретував правило останнього рядка . Результат моєї попередньої редакції закінчився на 5 7 3\n\n, тому після останнього квадрата є один порожній рядок. Це допустимо?
Денніс

2
Так, я отримую додатковий реквізит! : P
El'endia Starman

Можливо, розмістіть вихід десь в іншому місці, щоб він не надто довгий на цій сторінці.
Райан

Відповіді:


9

Pyth, 38 34 33 32 байт

Vfq2l{sMX2.DR2.:T5b.pS9Vc3NjdH)k

5 байтів, збережених у форматі Jakube

1 байт, збережений перемиканням на підрядки Пітера Тейлора довжиною п'ять, видаліть підхід середніх

Бігати на моїй машині потрібно приблизно півтори хвилини.

Як це працює на високому рівні:

  • Створити всі перестановки ( .pS9)

  • Довжина форми 5 підрядів ( .:T5)

  • Видаліть центральний елемент кожного ( .DR2)

  • Додайте новий рядок до центрального елемента, позначаючи його обов'язково іншою сумою ( X2 ... b)

  • Фільтр на квадрати, де всі такі суми рівні ( fq2l{)

  • Форматування та друк ( V ... Vc3NjdH)k)


Перемістіть Nвсередині циклу ( V...Vc3N) замість до циклу ( VcL3...VN). Зберігає один додатковий байт.
Якубе

8

CJam, 40 38 байт

A,1>e!3f/{2{2few:::+z}*:|,1=},Ma*Sf*N*

Дякуємо @PeterTaylor за те, що ти граєш на 2 байти!

Це закінчується миттєво за допомогою інтерпретатора Java. Він працює і за допомогою інтерпретатора, але це вимагає трохи терпіння.Спробуйте в Інтернеті.

Тестовий запуск

$ cjam sturdy-squares.cjam | head -n 8
1 5 3
9 8 7
4 2 6

1 5 6
8 7 3
4 2 9

$ cjam sturdy-squares.cjam | tail -n 8

9 5 4
2 3 7
6 8 1

9 5 7
1 2 3
6 8 4
$

Як це працює

A,1>     e# Push [1 ... 9].
e!       e# Push the array of all permutations of that array.
3f/      e# Split each into rows of length 3.
{        e# Filter; push the permutation, then:
  2{     e#   Do the following twice:
    2few e#     Split each row into overlapping splices of length 2.
         e#       [a b c] -> [[a b] [b c]]
    :::+ e#     Reduce each innermost vector to its sum.
         e#       [[a b] [b c]] -> [a+b b+c]
    z    e#     Transpose rows with columns.
  }*     e#   The result is [[s t] [u v]], the sums of all 2x2 squares.
  :|     e#   Perform set union of the pairs of sums.
  ,1=    e#   Check if the length of the result is 1 (unique sum).
},       e# Keep the array if the result was 1.
{        e# For each kept array:
  Sf*    e#   Join the elements of its rows, separating by spaces.
  ~M     e#   Dump the resulting strings and an empty string on the stack.
}%       e# Collect everything in an array.
N*       e# Join the strings, separating by linefeeds.

+1 І я був задоволений стислістю своєї відповіді!
DavidC

Тепер, коли мені вдалося пограти в гольф, я відповів достатньо, щоб залишитися на одному шарі попереду: Ma*Sf*N*заощаджує два{Sf*~M}%N*
Пітер Тейлор

@PeterTaylor Це дійсно так. Спасибі!
Денніс

8

Пітон 3, 169 168 164 байт

Взяв програму, яку я досліджував у цих міцних квадратиках / прямокутниках і гольфував її вниз. Завдяки otakucode відіграв 4 байти.

from itertools import*
r=range(1,10)
for p in permutations(r,6):
 x,y=p[0],p[5];q=p[:5]+(x+p[3]-p[2],y,y+p[1]-x,p[2]+y-x)
 if set(q)==set(r):print('%s %s %s\n'*3%q)

Пояснення

Враховуючи частково заповнений міцний квадрат таким,

a b c
d e ?
g ? ?

Решта три записи однозначно визначаються, і a+d-c, a+b-gі c+g-a. Тож я генерую всі перестановки 0..8 з шістьма елементами, обчислюю решту, а потім перевіряю, чи множина цього збігається з набором 0..8. Якщо це так, я роздруковую сітку.


Для довідки, ось оригінал (із коментарями та стороннім кодом видалено):

from itertools import permutations as P

n = 3
m = 3
permutes = P(range(m*n), m+n)

counter = 0
for p in permutes:
    grid = [p[:n]]
    for i in range(m-1):
        grid.append([p[n+i]]+[-1]*(n-1))
    grid[1][1] = p[-1]

    s = p[0]+p[1]+p[n]+p[-1]

    has = list(p)

    fail = 0
    for y in range(1,m):
        for x in range(1,n):
            if x == y == 1: continue

            r = s-(grid[y-1][x-1] + grid[y-1][x] + grid[y][x-1])

            if r not in has and 0 <= r < m*n:
                grid[y][x] = r
                has.append(r)
            else:
                fail = 1
                break

        if fail: break

    if not fail:
        counter += 1

print(counter)

люблю цю техніку
нехай яскраво

1
Дуже приємний підхід! Ви можете зберегти кілька байтів, хоча ... у циклі, x, y = p [0], p [5], то q = p + (y + p [3] -p [2], y + p [1 ] -x, p [2] + xy)
otakucode

@otakucode: Дякую за пораду!
El'endia Starman

5

Mathematica 147 166 155 149 байт

Це створює перестановки {1,2,3 ... 9} і вибирає випадки, для яких

(сума цифр у позиціях {1,2,4,5}) =

(сума цифр у позиціях {2,3,5,6}) =

(сума цифр у позиціях {4,5,7,8}) =

(сума цифр у позиціях {5,6,8,9})

f@s_:=Length@Tally[Tr@Extract[s,#]&/@Table[{{0},{1},{3},{4}}+k,{k,{1,2,4,5}}]]>1;
Row[Grid/@(#~Partition~3&/@Select[Permutations@Range@9,f@#&]),"\n"]

Вихід (частковий вигляд)

вихід


Length[%]

376


5

CJam ( 39 37 байт)

A,1>e!{5ew{2Mtz}2*::+)-!},3f/Ma*Sf*N*

Демонстрація в Інтернеті (попередження: запуск може зайняти більше хвилини, запустивши в браузері підказки "Скасувати цей сценарій?").

Працює, фільтруючи всі можливі сітки за допомогою 5ewкарти

[a b c d e f g h i]

до

[[a b c d e]
 [b c d e f]
 [c d e f g]
 [d e f g h]
 [e f g h i]]

а потім відкинути середній елемент і середній елемент один одного елемента

[[a b d e]
 [b c e f]
 [d e g h]
 [e f h i]]

які є чотирма квадратами.


Ого, це геніально.
El'endia Starman

5

Python 3,5, 135 байт

from itertools import*
for x in permutations(range(1,10)):eval((("=="+"+x[%s]"*3)*4)[2:]%(*"013125367578",))and print("%d %d %d\n"*3%x)

Безпосередньо перевіряє суму кожного квадрата, мінус середину. Найімовірніше, все ще гольфують за принципом " itertoolsне потрібно".


2

Python2 327 271 270 263 260 байт

z,v,s={},3,range(1,10)
while len(z)<376:
 for i in range(8):v=hash(`v`);s[i],s[v%9]=s[v%9],s[i]
 m=map(lambda i:sum(s[i:i+5])-s[i+2],[0,1,3,4]);T=tuple(s)
 if all(x==m[0] for x in m) and not T in z:
  z[T]=1;print '%i %i %i\n'*3 % tuple(s[0:3]+s[3:6]+s[6:9])

------------

Це ... не так коротко, але він не використовує бібліотек. Це випадковим чином перетворює квадрат, перевіряє його на магічність, друкує його та записує, щоб запобігти дублюванню. Після того, як він надрукував 376 унікальних магічних квадратів, він зупиняється.

Я запозичив Псевдо Генератор випадкових чисел у запису Кіта Рандалла для гольфу під назвою " Побудуй генератор випадкових чисел, який пройде тести Дієхара "

z,v={},3
def R(x,y):global v;v=hash(`v`);return v
while len(z)<376:
 s=sorted(range(1,10),cmp=R)
 m=[sum(q) for q in map(lambda p:s[p[0]:p[1]+1]+s[p[2]:p[3]+1], [[i,i+1,i+3,i+4] for i in [0,1,3,4]] )]
 if all(x==m[0] for x in m) and not tuple(s) in z.keys():
  z[tuple(s)]=1;print '%i %i %i\n'*3 % tuple(s[0:3]+s[3:6]+s[6:9])

Де-гольф

# each magic square is an array of 9 numbers
#
#for example [1 9 3 7 2 5 6 4 8] 
#
#represents the following square
#
#1 9 3
#7 2 5
#6 4 8
#
# to generate a random square with each number represented only once,
# start with [1 2 3 4 5 6 7 8 9] and sort, but use a random comparison
# function so the sorting process becomes instead a random permutation.
# 
# to check each 2x2 subsquare for sums, look at the indexes into the
# array: [[0,1,3,4] = upper left,[1,2,4,5] = upper right, etc.
#
# to keep track of already-printed magic squares, use a dictionary    
# (associative array) where the 9-element array data is the key. 

from random import *
def magic(s):
 quads=[]
 for a,b,c,d in [[0,1,3,4],[1,2,4,5],[3,4,6,7],[4,5,7,8]]:
  quads+=[s[a:b+1]+s[c:d+1]]
 summ=[sum(q) for q in quads]
 same= all(x==summ[0] for x in summ)
 #print quads
 #print 'sum',summ
 #print 'same',same
 return same

magicsquares={}
while len(magicsquares.keys())<376:
        sq = sorted(range(1,10),key=lambda x:random())
        if magic(sq) and not magicsquares.has_key(tuple(sq)):
                magicsquares[tuple(sq)]=1
                print sq[0:3],'\n',sq[3:6],'\n',sq[6:9],'\n'

Нічого випадкового не повинно відбуватися. Існує рівно 376 різних квадратних рішень, і вам потрібно вивести кожне з них рівно один раз.
Захоплення Кальвіна

я надрукував рівно 376 чітких квадратних рішень, і видавав кожне з них рівно один раз. випадковість не заборонена в описі, а також не заборонена в "стандартних лазівках
яскравий

Добре, досить справедливо.
Хобі Кальвіна

Ви можете використовувати гірший генератор випадкових чисел, якщо він дає всі потрібні вам квадрати.
lirtosiast

1

Рубін 133

a=[]
[*1..9].permutation{|x|[0,1,3,4].map{|i|x[i]+x[i+1]+x[i+3]+x[i+4]}.uniq.size<2&&a<<x.each_slice(3).map{|s|s*' '}*'
'}
$><<a*'

'

Прямий підхід грубої сили. Перевірте це тут .


0

J, 83 байти

([:;@,(<LF),.~[:(<@(LF,~":)"1@#~([:*/2=/\[:,2 2+/@,;._3])"2)(3 3)($"1)1+!A.&i.])@9:

Це функція, яка виводить рядок, що містить 376 міцних квадратів. Використовує грубу силу, генерує всі перестановки з 1 по 9, формує кожну в 3x3 масив і фільтрує її, перевіряючи, чи рівні у кожному підрядному масиві 2х2. Завершується за півсекунди.

Використання

   f =: ([:;@,(<LF),.~[:(<@(LF,~":)"1@#~([:*/2=/\[:,2 2+/@,;._3])"2)(3 3)($"1)1+!A.&i.])@9:
   $ f ''  NB. A function has to take something to be invoked,
           NB. but in this case it is not used by the function
   37 {. f ''  NB. Take the first 37 characters
1 5 3
9 8 7
4 2 6

1 5 6
8 7 3
4 2 9

   _38 {. f ''  NB. Take the last 38 characters
9 5 4
2 3 7
6 8 1

9 5 7
1 2 3
6 8 4


   NB. The output string ends with two newlines
Використовуючи наш веб-сайт, ви визнаєте, що прочитали та зрозуміли наші Політику щодо файлів cookie та Політику конфіденційності.
Licensed under cc by-sa 3.0 with attribution required.