Математика
Научная фантастика
Научно-популярное
Комментарии 77
+1
Для фанатов Харухи решение Игана даёт точную инструкцию о том, как просмотреть все возможные варианты порядка первого сезона, используя всего 93 924 230 411.

Так я не понял, решение дает конкретную суперперестановку или все-таки количество ее элементов?

+2
Я тоже не понял. В статье написано, что уже можно брать готовую перестановку и смотреть все серии. Но при этом приводятся формулы, с помощью которых пожно вычилисть только количество элементов для нижней и верхней границы.
+1
насколько я понял — это не решение суперперестановки, а оценка решения сверху (т.е. настоящее решение может быть равно ему или быть короче).
При этом оно позволяет вычислить суперперестановку для этого количества элементов (если вы вдруг захотите начать их смотреть — у Игана есть описание алгоритма и даже код на С написан для генерирования).
0
я сам смотрел в таком порядке:
1) читаем новеллу
2) смотрим сериал.

PS: мое личное мнение — лучше в хронологическом.
+1
Как издавался. Сначала первый сезон в том порядке как он выходил, потом второй также как он выходил. Т.к. оригинальная трансляция второго сезона включает первый в порядке внутренней хронологии.
0
Что-то мне подумалось: если задача переходит в задачу коммивояжёра (с ценой), могут ли на практике (при просчете маршрутов) возникать ситуации, когда равнозначных ценовых решений несколько? Статью Эгана нашел с кодом: www.gregegan.net/SCIENCE/Superpermutations/Superpermutations.html
Код, кстати, для n 5 генерирует подстроку длиной 154
0
Да. 153. Мне непонятно: при n = 3, n = 4 наблюдается симметрия, т.е. алгоритм доходит до какой-то точки, затем фактически движется обратно — отражение. Я так понял, при n > 6 симметрия пропадает, и это одна из главных проблем.
Кстати, код Эгана и для n = 4 генерирует 34, а должен 33 вроде бы.
Я думал над алгоритмом, как бы я его писал: циклический сдвиг изначальной перестановки до замыкания с записью в файл/буфер, далее проверка последней перестановки, чтобы понять, какое число подставить для продолжения цепочки… да еще и так, чтобы перестановки не повторялись. Трудоемко получается, надо проверять все что было сгенерировано ранее, дабы не словить повторы или не нагенерировать лишнего.
Но что-то мне кажется (только кажется пока), что алгоритм Джонсона Троттера для перестановок тут бы пригодился бы (там как раз циклический сдвиг)… но не уверен.
0
для n=4

1234123142134214324132431243214231 — код Эгана
1234123142_31243121342132413214321 — oeis.org/A180632

Может Эган ошибку где-то совершил. ("_" вставил для удобства просмотра, пробел не помогает)
0
Написал незамысловатый код на С++, длина совпадает:
Код
#include <iostream>
#include <string>

struct Node {
	int value;
	Node* next;
};

// rotate and append c nodes from root to the end
void firstToLast(Node* &root, int c) {
	Node* tail = nullptr;
	Node* node;

	// grow a tail  
	for(int i=0;i<c;i++) {
		node = root;
		root = root->next;
		node->next = tail;
		tail = node;
	}

	node = root;

	// find the end
	while(node->next) {
		node = node->next;
	}

	// append to the end
	node->next = tail;
}

int main(int argv, char** argc)
{
	using namespace std;
	int n = 4;
	string result;

	// count factorial of n
	int factorial = 1;
	for(int i=2;i<=n;i++) 
		factorial *= i;
	
	Node* next;
	Node* last;
	Node* node = nullptr;
	Node* root = node;

	for(int i=n;i>0;i--) {
		next = node;
		node = new Node();
		node->value = i;
		node->next = next;
	}

	root = node;

	int sum = n;

	for(int i=1;i<=factorial;i++) {
		while(node) {
			cout << node->value;// << " ";
			if (!node->next) break;
			node = node->next;
		}

		cout << endl;

		// check divisibility
		int m = n;
		int mm = m;

		while (m > 0) {
			if (i%mm == 0) {
				cout << "==========" << endl;
				mm *= --m;
			} else {
				sum+=n-m+1;
				firstToLast(root, n-m+1);
				break;
			}
		}
		//*/
		node = root;
	}

	cout << "sum=" << sum << endl;

	return 0;
}


github.com/tigertv/superpermutation

Результат для n=4
1234
2341
3412
4123
==========
2314
3142
1423
4231
==========
3124
1243
2431
4312
==========
==========
2134
1342
3421
4213
==========
1324
3241
2413
4132
==========
3214
2143
1432
4321
==========
==========
==========
==========
sum=33

0
Как я понял, код только длину считает?
Кстати, я не заметил сразу, что
число суперперестановок = факториал числа + число суперперестановок от предыдущего. Т.е. для n = 5 120+33 и т.д. только 872 все ломает
0
(В качестве шутки). Подумалось вчера, какова верхняя граница строки для нормативного словаря русского языка, например, Ожегова. = ) коткатокно — кот, откат, каток, ток, окно, но
0
Как я понял, код только длину считает?
Да, длину считает. Теперь и строку формирует — обновил код в репозитории.
Кстати, я не заметил сразу, что
число суперперестановок = факториал числа + число суперперестановок от предыдущего.
Я тоже не заметил.)
(В качестве шутки). Подумалось вчера, какова верхняя граница строки для нормативного словаря русского языка, например, Ожегова. = ) коткатокно — кот, откат, каток, ток, окно, но
Ну тут вообще вариантов целая куча, учитывая, что длина слов разная, и еще отсекать нужно неправильные наборы cлов.
0
Класс! Очень компактный код получился и вроде бы довольно понятный.
Всего 120 строк. Начинаю жалеть, что не знаю С++ (и, видимо, ООП, раз там node, struct… Не посмотрел на ваш код и понял, что программист бы из меня не вышел: я бы если написал так, то наверное, неделю сидел, обдумывая)
Интересно, почему у Эгана за 600 строк переваливает.
Форкнул себе.
При n = 7 там симметрия сохраняется.
Интересно, как тот человек сократил до 872 для n 6
0
Эган — математик и писатель, а не программист. Ему — можно.
0
Первый форк!
Думаю, что там еще можно улучшения наделать.(дублирование кода, уменьшить проверку на деление).
Код не ООП, структуры и в Cи есть.
Можно на Си переписать, код не сильно будет отличатся.
Заменить iostream на stdio, new на какой-нибудь malloc, cout на printf.

Ну код у Эгана также, почему-то, неправильные ответы выдавал. Видимо, где-то ошибка закралась. Может писал для случая 872. У меня такого нет, я пока еще паттерн не понял.
Вот тут еще код есть какой-то на Python и еще на чем-то.
arxiv.org/abs/1408.5108

Вот такое число нужно сравнивать 872
arxiv.org/src/1408.5108v1/anc/superperm-6-866.txt
0
Я вникаю в код, пока не все понял. То, что осознал пока: создается структура для n нод, потом от исходной перестановки (если я верно понял) справа налево прокручиваются варианты, то, что в последнем знаке добавляется к общей строке, так до исходной. Не могу понять, когда алгоритм доходит до предела одной ноды, как происходит выбор следующей. Как проверяется, что надо взять следующий фрагмент цепочки не с единицы, а с двойки…
Видимо, мне пока надо его на бумаге еще обдумывать.
0
Да, в начале создается цепочка или односвязный список. Далее производится переброс узлов с головы(root лучше бы head назвал) c вращением. Сколько узлов перебрасывать определяется в зависимости от делимости номера текущего переброса. Cначала делишь на n, если не делится нацело, то перебрасываешь только один узел, если делится, то проверяешь делимость на n(n-1) если не делится — перебрасываешь 2, если делится, то проверяешь делимость n(n-1)(n-2)… ну и так далее. Так формируются цепочки которые идут последовательно. А чтоб получить результирующую строку, нужно сначала добавить значения из узлов первой цепочки, а затем добавлять только те узлы которые идут на переброс слева направо.
0
Огромная благодарность. Более или менее понял. Я со списками не работал никогда, буду знать, чего доучивать.
0
Еще мысли после чтения доказательства:
www.njohnston.ca/2014/08/obvious-does-not-imply-true-the-minimal-superpermutation-conjecture-is-false
Если по формуле из статьи смотреть (n-2) + (n-1)! + n! для n=4 нижняя граница 32, а не 33.
И для n=3 нижняя граница = 8. И вдруг неожиданно это приобретает смысл, если обратить внимание на то, что мы работает с кольцом (не знаю, какой термин употребить, имеется в виду замкнутая последовательность). Тогда для n=3 12312132 последняя единица берется из начала. В общем, изначально кольцо представлено, как цепочка. И это надо учитывать. И тогда все верно: 8, 32, 152, 872.
0
Аноним фибоначчи использовал

Пост анонима
I think I solved it.

First calculate the max string which is the number of permutations multiplied by n.
Then divide the max string by n — 1
Then add to the answer the fibonacci number located at 2(n-3)

int max_string = n! * n;
int answer = max_string / (n — 1);
answer += fib(2(n-3));

Example for n = 5;

max_string = 5! * 5 = 600
answer = 600 / 4 = 150
answer += fib(2(5-3)) = fib(4) = 3
answer = 153

Here is the first 14 using this method:

2 -> 3
3 -> 9
4 -> 33
5 -> 153
6 -> 872
7 -> 5901
8 -> 46135
9 -> 408384
10 -> 4032377
11 -> 43909467
12 -> 522549784
13 -> 6745945965
14 -> 93884331311
0
Вроде бы я понял. Два дня промучился, а всего лишь надо было
посмотреть на картинку.

Тогда на мой взгляд алгоритм такой (если не напутал):
1) Крутим до n, например n = 3
123
231
312
2) Проверяем делится ли номер итерации нацело на n (вроде также как в написанном коде у MaxVetrov и Эгана)
Делится, тогда идем по хвосту слева направо (два прохода, чтобы снова не делилось нацело )
3) То, что осталось — идет в начало, перевернутый хвост идет в конец.
4) Снова крутим.
213
132
321
5) Дошли до факториала. Остановка.

Проверил на n=4, n=5 — все верно.
Тогда, чутье подсказывает, что можно без struct, но пока не на сто процентов уверен.
0
Можно использовать std::list, хотя это тот же набор Node, c множеством операций над ними.

Я понял вашу мысль на счет кольца, перекидывать элементы не нужно.
Нужно только отслеживать какая итерация, делится ли она на n cначала. (for-loop)
А потом как-то нужно из этого кольца вытащить 2 узла, перевернуть, и опять вставить в кольцо и продолжить итерацию.
Можно и так, на выходе получаем тоже самое.(может скорость быстрее — может нет, проверять надо).

Меня вот заинтересовало, почему для 1<n<4 существует единственная комбинация(не считая комбинации начинающиeся не на 123...n),
а для n=5 их аж восемь www.njohnston.ca/superperm5.txt
Возможно и для n=5, есть более короткая комбинация.
Cкажем, длиною 152, а не 153, как везде указано.
0
Похоже, что скорость генерации перестановок быстрее. Алгоритм генерации я сделал, но последовательность пока не собрал.
Но можно уже протестировать:
Код
Похоже, и правда быстрее. Если еще оптимизировать. Но там substr и strrev но они довольно быстры в php.
0
А быстрее чем что? У вас же код на php.

PS. У вас в репозитории мой старый код лежит. Я его уже обновил, он работает быстрее.
0
Я имею в виду, что, похоже, сама генерация перестановок с этим кодом быстрее, чем генерация перестановок на php другими алгоритмами. Нет сомнений, что на С++ быстрее. Но мне на С и С++ неудобно черновой алгоритмизацией заниматься. Проверю ваш код. Нормальной идеи, как дописать в последовательность промежуточные звенья, пока так и не выпестовал.
0
Я тут подумал.) А зачем факториал высчитывать? Вызывать какую-нибудь функцию рекурсивно да и все. И нет трудоемкого деления вообще и ограничения размера для int на факториал.
0
Да. Вы были правы. Циклический сдвиг не нужен. Он и так получается разрезкой строки и разворотом первой части
0
Да, если использовать алфавит. Или использовать массив, а не строку. Если собирать последовательность, то видимо, нужно писать её в файл или какой-то промежуточный буфер, а потом в файл. Причем с интервалом. Это для больших n. Вообще, я сейчас выкинул все лишнее из кода, получился довольно интересный простенький алгоритм со спиралевидной геометрией. (Наверное, для многих не новость, но я с такой последовательностью не работал) Его, наверное, еще можно улучшить.
<?php
$n = 7;
$fact = 5040;
$perm = "1234567";
for ($i = 1; $i != $fact + 1; $i++)
	{
	print $perm . "\n";
	$mm = $i;
	$m = $n;
	while ($m > 0)
		{
		if ($mm % $m == 0) {
			$mm/= $m--;
			}
		  else
			{
			$perm = substr($perm, $n - $m + 1).strrev(substr($perm, 0, $n - $m + 1));
			continue 2;
			}
		}
	}
?>
0
Я имею ввиду для $perm = «12345678910»;, когда перемещаемое число состоит из нескольких цифр.

Деление еще можно выкинуть, думаю над этим сейчас.
0
Выдаст какой-то результат, но в контексте работы со строками последнее число в строке 12345678910 — это два числа. Достаточно задать значения в массив и будет работать корректно. Только substr надо будет на array_splice переписать и strrev на array_reverse, но разрезку и оборот части строки можно по-другому выразить.
0
Готово, не использую факториал и деление. Теперь хоть 100 чисел можно вводить.
0
Только, наверное, есть ограничения на длину результатирующей строки. Т.е. при практическом применении нужно периодически сбрасывать строку в файл и очищать переменную, но это уже частный вопрос. Не часть самого алгоритма.
Про рекурсивный вариант, нашел на Ruby.
https://rosettacode.org/wiki/Superpermutation_minimisation#Ruby
0
Можно просто файловый поток открыть и писать прямо туда.

На ruby для длины 10 используется одиночный символ 'a' как в шестнадцатеричной системе.

Не сильно ruby знаю, буду разбираться.
0
Да, можно и так. Переменная fact только переполняется при большем количестве чисел.

Для строки, я пробелов наставил между числами и в файл результирующую строку вывожу сейчас.
0
Если на строке или массиве возрастающий порядок (а в этом случае это именно так), т.е.
12345, то последняя перестановка — это реверс от первой. Т.е. 54321. По ней и можно делать остановку.
т.е. пока ( строка != «54321» ). Но каждый раз сравнивать строки, наверное, не очень хорошо. strcmp вроде бы посимвольно сравнивает. Потеря времени. Вариант с факториалом (субъективно) выглядит более строго в математическом смысле. Такой алгоритм легче понять и перевести на псевдокод или любой язык. Его уже можно воткнуть в курсовую или статью.
0
Строка, по сути, это массив символов.

Да, стравнивать «54321» каждый раз не имеет смысла, точно также как и делимость, тоже не легкая операция по сравнению с простым сравнением больше-меньше.
Рекурсию не смотрели еще?
0
Это вы хитро спрятали файлы.) Обычно .gitignore — это файл в котором записаны файлы которые не учитываются git.

Я тут подумал как еще можно оптимизировать. Если строка зеркальная, то почему бы не доходить только до середины, а потом то что получили отзеркалить на вторую половину(считать ничего не нужно) Скорость почти в 2 раза быстрее.

Тут еще варианты кода есть
github.com/search?q=superpermutation
0
Я не специально прятал. Вываливал все как есть. Не хотелось вникать, как github устроен.
Я тоже думал про то, что считать можно только до половины. Далее пройтись по выводу с конца к началу.
Алгоритм на Ruby похоже считает сумму и выводит только часть строки.
0
Это не про github — это про сам git.

Только это будет работать для зеркальной строки, а для более коротких пока паттерн не выявлен.

Можно и всю строку вывести если вместо puts вставить:

puts n<5 ? ary.join : to_16(ary)

0

Последовательность 873.


Не знаю насколько близко к классике я написал алгоритм который создаёт последовательность 873. Саму её я не нашёл чтобы проверить.


Последовательность 873
123456123451623451263451236451234651234156234152634152364152346152341652341256341253641253461253416253412653412356412354612354162354126354123654123145623145263145236145231645231465231425631425361425316425314625314265314235614235164235146235142635142365142315642315462315426315423615423165423124563124536124531624531264531246531243561243516243512643512463512436512431562431526431524631524361524316524312564312546312543612543162543126543121345621345261345216345213645213465213425613425163425136425134625134265134215634215364215346215342615342165342135642135462135426135421635421365421324561324516324513624513264513246513241563241536241532641532461532416532413562413526413524613524163524136524132564132546132541632541362541326541321456321453621453261453216453214653214356214352614352164352146352143652143256143251643251463251436251432651432156432154632154362154326154321654321

В ней 148 последовательностей с повторами(*). И максимально 4 последовательности с повторами подряд. Выглядит симметрично. Просматривается цикличность.


2 3 4 6 — Цифрами обозначено сколько идет подряд значений без повторов.
* — Каждая звёздочка это последовательность в которой есть повтор минимум одной цифры.


6*6*6*6*6**6*6*6*6*6**6*6*6*6*6**6*6*6*6*6***6*6*6*6*6**6*6*6*6*6**6*6*6*6*6**6*6*6*6*6***6*6*6*6*6**6*6*6*6*6**6*6*6*6*6**6*6*6*6*6****6*6*6*6*6**6*6*6*6*6**6*6*6*6*6**6*6*6*6*6***6*6*6*6*6**6*6*6*6*6**6*6*6*6*6**6*6*6*6*6***6*6*6*6*6**6*6*6*6*6**6*6*6*6*6**6*6*6*6*6

Последовательность 872.


Последовательность 872
12345612345162345126345123645132645136245136425136452136451234651234156234152634152364152346152341652341256341253641253461253416253412653412356412354612354162354126354123654132654312645316243516243156243165243162543162453164253146253142653142563142536142531645231465231456231452631452361452316453216453126435126431526431256432156423154623154263154236154231654231564213564215362415362145362154362153462135462134562134652134625134621536421563421653421635421634521634251634215643251643256143256413256431265432165432615342613542613452613425613426513426153246513246531246351246315246312546321546325146325416325461325463124563214563241563245163245613245631246532146532416532461532641532614532615432651436251436521435621435261435216435214635214365124361524361254361245361243561243651423561423516423514623514263514236514326541362541365241356241352641352461352416352413654213654123

https://arxiv.org/src/1408.5108v1/anc/superperm-6-866.txt


В ней 147 последовательностей с повторами(*). При этом шестёрки разбиты на двойки тройки и четвёрки. Максимально две последовательности с повторами подряд и тех 3 штуки в начале. Похоже на ручное решение головоломки.


2 3 4 6 — Цифрами обозначено сколько идет подряд значений без повторов.
* — Каждая звёздочка это последовательность в которой есть повтор минимум одной цифры.


6*6*6*4*6*6*6*6*2*6**6*6*6*6*6**6*6*6*6*6**6*6*6*6*4*4*3*3*2*6*6*6*6*4*4*6*6*6*6*2*3*6*6*6*6*3*6*3*6*6*4*4*3*6*6*6*6*3*6*2*6*6*6*4*6*6*6*6*2*4*4*6*6*6*6*2*2*6*6*6*2*3*6*2*4*6*6*6*6*2*2*6*4*6*6*4*6*6*6*6*2*3*6*6*6*6*3*2*6*6*4*6*6*4*3*6*4*6*6*6*6*2*4*6*6*6*6*2*2*6*6*6*6*4*3*2*6*4*6*6*6*6*2*6*2
+1
Ваша последовательность 873 такая же, как по алгоритму MaxVetrov.
-3
> Но только для n < 9,8 × 10^42!
Ой, камон, да там просто тупо переполнение и всё. Какой-то идиот, писавший софт для Матрицы, решил, что 10^41 хватит всем, а лид прощёлкал.
-6
Лично я не вижу реального применения для операции перестановка в классическом математическом смысле этого действия. Хорошее упражнение для мозгов, но не более.

Дело в том что выполнять классическую перестановку для целого числа на Си — не имеет смысла. Оно от этого деградирует!!!
Можно и даже иногда нужно выполнять перестановку в двоичном виде. В этом случае целое число перестаёт быть числом, и становится парой структур под объединением — над ними уже можно издеваться без деградации.

Если у кого есть примеры использования классической перестановки над десятичными числами в РЕАЛЬНОЙ жизни — то прошу поделиться.
Мне интересно!!!
0

Я как понимаю задача эквивалента какому-то классу задачи коммивояжера. А более важной задачи, полезной в бытовом практическом смысле, наверно и нет

-2
Вот по этому я и спросил конкретный случай применения!!! Но не эквивалент!!!
Потому как в задаче коммивояжера имя объекта не модифицируется.
А в классическом варианте перестановки — имя объекта является десятичное число. Само число в видимом десятичном представлении — имя. Как так?

И математики на полном серьёзе этим оперируют, что-то складывают и умножают.
Я не понимаю смысла — кто сможет мне объяснить!??
-2
Что и следовало доказать.
Простой вопрос, а ответа нету.
И кругом одни верующие фанатики.
-1
Да, мне нужен пример в котором модифицируется имя объекта перестановки. И обязательно в десятичной системе.
Не диапазон имён множества объектов (список), не вариантность состояния в списке, а смену имени объекта перестановки в десятичном представлении.
Например вот такая ахинея
9=6 потому что количество спичек для составления цифр одинаково
123=321 потому что количество цифр одинаково

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

Но если имя объекта представлено как десятичное многозначное число — начинается полная ахинея, которое я просто не понимаю.
0
Какое имя объекта? Вы о чем?
Десятичная система — это всего лишь форма представления числа.
Заверни число в двенадцатеричное представление ничего не изменится.
Ну если только умножать на 12, и делимость числа на 2,3,4,6,11,12 проверять в уме.)

И действительно, что Вы пишите по-моему не имеет никакого значения. Для чего Вам это нужно? Спички причем? Ну совпадает написание 6 и 9 если их перевернуть и что? Это всего лишь форма записи. Вставь вместо 0...9 — русский алфавит ничего не изменится.
-1
Какое имя объекта? Вы о чем?

Когда число является значением константы или переменной — то всё в норме.
Но как только начинаются математические фокусы с перестановкой, то десятичное число превращается в имя. То самое место где оно записано имеет имя в десятичном выражении. Тот самый бред.
Я-бы ещё смирился, если-б то самое число считалось адресом. Но математики с умным видом меняют в этом числе цифры местами.!!! И это всё называется классическая перестановка в математике.
0
Я не совсем Вас понимаю. Каким образом, десятичное число превращается в имя по Вашему мнению?
Вы можете больше примеров привести в числовом виде?
У вас проблемы с десятиричной системой?
Попробуйте привести примеры для шестнадцатеричной, ну или любой какой хотите где таких проблем не наблюдается.
Также можете оперировать собачками, кошечками, спичками, если вам так удобнее, математики используют числа.

Вы смирится не можете, я вообще проблемы не наблюдаю.

Судя по тому что Вы написали 9=6.
То можно и 1+1=3 (купи 2 баночки пива 3 получи бесплатно), но это уже не математика — это маркетинг.
Можно и 9=54 (потому что цифру 9 можно составить из 5 спичек, а можно и из 4), что тоже не математика.(для записи)
-1
Вы можете больше примеров привести в числовом виде?

Зачем далеко ходить — вторая картинка темы. Её уже несколько раз повторили, но там она статична.
0

А где вы там видите число? Я там вижу просто набор цифр. Можете 1 2 3 заменить на x y z или на a1 a2 a3 — от этого ничего не поменяется.

0
Даже последовательности де Брёйна, которые в чём-то схожи с суперперестановками, имеют свои приложения в нейробилогии, робототехнике, для упрощения поиска и брутфорса и т.д.
Мы часто даже предположить не можем, какое приложение может иметь какая-то, казалось бы, оторванная от реальности задача.
0
Фундаментальная наука на то и фундаментальная, что от неё не ждут мгновенного практического применения. Например, теорией чисел занимались несколько тысяч лет без какого-либо практического применения, а сейчас на ней криптография построена.
0
В последней строке первые три перестановки 123, 231, 313. При этом 123 и 231 встречаются далее. Только 313 не встречается. Значит если сократить первые 2 символа сначала, то мы ничего не потеряем.

Ну или я что-то не так понял.
0
Он и в этой статье есть :)
Однако существует и более эффективный способ склейки: 123121321

Я только не понимаю почему народ здесь высчитавать начал без чтения статьи.
Видимо себя проверить.)

Для 4 надо проверить, какая там несостыковка. Хотя наверно лучше для 5 сначала, оно нечетное, возможно четность-нечетность имеет значение.

При n=5, возникает цикл. если следовать старому правилу.

image
image
Только полноправные пользователи могут оставлять комментарии. , пожалуйста.