Задача 3 (5 баллов)
--------
На ленте записана последовательность из цифр 0, 1 и 2. Переставить
члены последовательности так, чтобы сначала располагались все нули,
затем все единицы и, наконец, все двойки.

Длина последовательности меньше длины алфавита Корректора. В начальный
момент окошко расположено перед записью.

Пример работы программы:

Начальное состояние                 После работы программы
┬─┬─╦═╦─┬─┬─┬─┬─┬─┬─┐               ┬─┬─╦═╦─┬─┬─┬─┬─┬─┬─┐
│░│░║░║1│0│1│2│1│░│░│    ─────>     │░│░║░║0│1│1│1│2│░│░│
┴─┴─╩═╩─┴─┴─┴─┴─┴─┴─┘               ┴─┴─╩═╩─┴─┴─┴─┴─┴─┴─┘

решение куратора
----------------

Для разминки решим более простую задачу. Пусть в записи только нули и
единицы. Будем идти по записи и делать следующее:

-- в ящике считать нули
-- рекурсивной пружинкой считать единицы
-- стирать запись

Как только дойдем до конца записи (она будет при этом уничтожена!),
создадим ее упорядоченный вариант: сначала выпишем все нули, затем все
единицы:

ЭТО вход                 │
 ВПРАВО                  │Шаг по записи вправо
 ЕСЛИ НЕ ПУСТО           │
 ТО                      │
 {                       │
   ЕСЛИ 0 ТО             │Если видим ноль, то "увеличиваем"
   {                     │ящик на 1, стираем символ и продолжаем рекурсию.
     ОБМЕН ПЛЮС ОБМЕН    │
     ПИШИ ПУСТО          │
     вход                │
   }                     │
   ИНАЧЕ                 │Если видим единицу, то стираем символ,
   {                     │продолжаем рекурсию и "откладываем"
     ПИШИ ПУСТО          │команду записи единицы.
     вход                │
     ПИШИ 1 ВПРАВО       │
   }                     │
 }                       │
 ИНАЧЕ { ОБМЕН запись0 } │Запись кончилась (она стерта) -- переходим
КОНЕЦ                    │к созданию ее упорядоченного варианта.
                         │Процедура "запись 0" -- выбросит на ленту нули,
ЭТО запись0              │а единицы запишутся сами рекурсивной пружинкой.
 ПОКА НЕ ПУСТО           │
 {                       │
   МИНУС                 │
   ОБМЕН                 │
   ПИШИ 0                │
   ВПРАВО                │
   ОБМЕН                 │
 }                       │
КОНЕЦ                    │


Как видите, нам не понадобились алгоритмы классической сортировки
для решения этой задачи. Задача решается за один проход записи!

Вариант, когда в записи есть еще и двойки легко решить за два прохода:

ЭТО вход                              │
 ПИШИ |                               │Ставим флаг для старта второго прохода.
 проход1                              │В первом проходе записываем 0 и 1
                                      │в правильном порядке.
 ВЛЕВО                                │Выводим окно на начало записи
 ПОКА НЕ | ВЛЕВО                      │и приступаем ко второму проходу.
 проход2                              │
КОНЕЦ                                 │
                                      │
ЭТО проход1                           │Проход 1 работает как и раньше,
 ВПРАВО                               │только мы не стираем двойки.
 ЕСЛИ НЕ ПУСТО                        │
 ТО                                   │
 {                                    │
   ЕСЛИ 0 ТО                          │
   {                                  │
     ОБМЕН ПЛЮС ОБМЕН                 │
     ПИШИ ПУСТО                       │
     проход1                          │
   }                                  │
   ИНАЧЕ ЕСЛИ 1 ТО                    │
   {                                  │
     ПИШИ ПУСТО                       │
     проход1                          │
     ПИШИ 1 ВПРАВО                    │
   }                                  │
   ИНАЧЕ проход1                      │
 }                                    │Выставляем флаг "*" для пометки
 ИНАЧЕ { ПИШИ * ВПРАВО ЖБМЕН запись0 }│начала упорядоченной записи.
КОНЕЦ                                 │
                                      │
ЭТО запись0                           │Пишем нули, единицы запишутся следом
 ПОКА НЕ ПУСТО                        │сами рекурсивной пружинкой.
 {                                    │
   МИНУС                              │
   ОБМЕН                              │
   ПИШИ 0                             │
   ВПРАВО                             │
   ОБМЕН                              │
 }                                    │
КОНЕЦ                                 │
                                      │
ЭТО проход2                           │Во втором проходе идем по записи,
 ПИШИ ПУСТО                           │считаем двойки и стираем их с ленты.
 ОБМЕН                                │
 ПОКА НЕ *                            │
 {                                    │
   ЕСЛИ 2 ТО { ОБМЕН ПЛЮС ОБМЕН }     │
   ПИШИ ПУСТО                         │
   ВПРАВО                             │
 }                                    │
                                      │
 ПИШИ ПУСТО                           │Стираем флаг "*" и выставляем
 ВПРАВО                               │окно на конец упорядоченной записи.
 ПОКА НЕ ПУСТО ВПРАВО                 │
                                      │
 ОБМЕН                                │Рисуем на ленту двойки.
 ПОКА НЕ ПУСТО                        │
 {                                    │
   МИНУС                              │
   ОБМЕН                              │
   ПИШИ 2                             │
   ВПРАВО                             │
   ОБМЕН                              │
 }                                    │
КОНЕЦ                                 │
                                      │


Можно ли решить задачу за один проход?

Скажем, в ящике считать единицы, а для построения нулей и двоек
откладывать соответствующие команды.

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

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

ПОКА НЕ ПУСТО ВЛЕВО               (0)
ПИШИ 0

когда в окошке 0 и

ПОКА НЕ ПУСТО ВПРАВО              (2)
ПИШИ 2

когда в окошке 2.

Что же получается? Единицы подсчитываются в ящике и откладываются
на ленту обычным способом. А каждый отложенная на нуле "зверость" (0)
заставляет Корректора шагать к началу записи и дописывать там 0. А каждая
отложенная "наглость"  (2) заставляет Корректора бежать на правый конец
и дописывать в ее конец 2.

Красиво? Ужасно!

Оптимально? Сомнительно. Здесь оценивать оптимальность надо уже более
тонко.

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

А в снежинском алгоритме? Исходная запись проходится один раз, а вот
при построении новой, Корректор будет мотаться из конца в конец
возможно очень долго. Его мытарства существенно зависят от числа нулей
и двоек в исходной записи и их расположения в записи. Скажем группа
двоек идущая подряд в исходной записи заставит Корректора выписать их
в результирующую "скопом", без беготни. А вот тяжелый случай:

02020202011111

Здесь каждый ноль и каждая двойка - дает дополнительный проход по
строющейся записи.

Однако, владение рекурсией и собственной головой, показано на высшем
уровне. Вот этот "танцующий" снежинский код:

ЭТО Сортировка
 ПИШИ 0
 ОБМЕН
 Работа                                
 ПОКА НЕ ПУСТО ВЛЕВО                   
КОНЕЦ

ЭТО Работа
  ПИШИ ПУСТО
  ВПРАВО
  ЕСЛИ 1                               
   ТО                                  
   { ОБМЕН
     ПЛЮС                              
     ОБМЕН                             
     Работа                            
   }                                   
  ИНАЧЕ ЕСЛИ 0
  ТО                                   
  {                                    
   Работа
   ПОКА НЕ ПУСТО ВЛЕВО                 
   ПИШИ 0                              
  }                                    
  ИНАЧЕ ЕСЛИ 2
  ТО                                   
  {                                    
   Работа
   ПОКА НЕ ПУСТО ВПРАВО
   ПИШИ 2
  }                                    
  ИНАЧЕ ЕСЛИ ПУСТО                     
  ТО                                   
  {                                    
   ЯЩИК-
   ПОКА НЕ 0                           
   {                                   
    МИНУС                              
    ЯЩИК+                              
    ПИШИ 1
    ВПРАВО                             
    ЯЩИК-                              
   }                                   
  ПИШИ ПУСТО                           
  ВЛЕВО                                
  }                                    
КОНЕЦ

                       * * *

Наконец, можно решить эту задачу совсем без всякой хитрости: считаем
число 0 в старой записи и столько раз пишем нули в новую запись, затем
аналогично записываем единицы и двойки. Затем стираем старую запись.
Всего нужно 4 прохода (хотя вполне можно обойтись и тремя). Но даже
при 4 проходах этот алгоритм эффективнее общего алгоритма сортировки.


Решение
-------

ЭТО вход                    │
 ВЛЕВО                      │Поставим слева от записи метку-флаг.
 ПИШИ #                     │┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┐
                            ││░│#│░│1│0│1│2│1│░│░│
                            │┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┘
                            │Этот флаг будем использовать для
                            │возврата окошка к началу записи.
                            │
 запись0                    │Запись нулей в новую последовательность.
 возврат                    │Возврат на флаг.
                            │
 запись1                    │Запись единиц в новую последовательность.
 возврат                    │Возврат на флаг.
                            │
 запись2                    │Запись двоек в новую последовательность.
 возврат                    │Возврат на флаг.
                            │
 удалить_старую             │Удаление старой последовательности
КОНЕЦ                       │
                            │
                            │Запись нулей в новую последовательность
ЭТО запись0                 │
 ВПРАВО                     │Шаг вправо от флага.
 ОБМЕН                      │Запись ПУСТО в ящик (счетчик нулей).
                            │
 ВПРАВО                     │Подсчет нулей.
 ПОКА НЕ ПУСТО              │
 {                          │Каждый раз когда обнаружен ноль
   ЕСЛИ 0                   │к ящику-счетчику "добавляется" 1.
    ТО { ОБМЕН ПЛЮС ОБМЕН } │
   ВПРАВО                   │
 }                          │
                            │
 конец_новой                │Установить окошко на первую пустую клетку
                            │за новой последовательностью.
                            │
 ОБМЕН                      │Запись нужного количества нулей.
 ПОКА НЕ ПУСТО              │Записываем нули и "уменьшаем" содержимое
 {                          │ящика на 1 пока в ящике не окажется ПУСТО.
   МИНУС                    │
   ОБМЕН                    │
   ПИШИ 0                   │
   ВПРАВО                   │
   ОБМЕН                    │
 }                          │
КОНЕЦ                       │
                            │
ЭТО запись1                 │Запись единиц в новую последовательность
 ВПРАВО                     │
 ОБМЕН                      │
                            │
 ВПРАВО                     │
 ПОКА НЕ ПУСТО              │
 {                          │
   ЕСЛИ 1                   │
    ТО { ОБМЕН ПЛЮС ОБМЕН } │
   ВПРАВО                   │
 }                          │
                            │
 конец_новой                │
                            │
 ОБМЕН                      │
 ПОКА НЕ ПУСТО              │
 s                          │
   МИНУС                    │
   ОБМЕН                    │
   ПИШИ 1                   │
   ВПРАВО                   │
   ОБМЕН                    │
 }                          │
КОНЕЦ                       │
                            │
ЭТО запись2                 │Запись двоек в новую последовательность
 ВПРАВО                     │
 ОБМЕН                      │
                            │
 ВПРАВО                     │
 ПОКА НЕ ПУСТО              │
 {                          │
   ЕСЛИ 2                   │
    ТО { ОБМЕН ПЛЮС ОБМЕН } │
   ВПРАВО                   │
 }                          │
                            │
 конец_новой                │
                            │
 ОБМЕН                      │
 ПОКА НЕ ПУСТО              │
 {                          │
   МИНУС                    │
   ОБМЕН                    │
   ПИШИ 2                   │
   ВПРАВО                   │
   ОБМЕН                    │
 }                          │
КОНЕЦ                       │
                            │
ЭТО конец_новой             │Установить окошко на первую пустую клетку
 ВПРАВО                     │за новой последовательностью.
 ПОКА НЕ ПУСТО ВПРАВО       │
КОНЕЦ                       │
                            │
ЭТО возврат                 │Возврат на флаг.
 ПОКА НЕ # ВЛЕВО            │
КОНЕЦ                       │
                            │
ЭТО удалить_старую          │Удаление флага и старой последовательности
 ПИШИ ПУСТО                 │
 ВПРАВО ВПРАВО              │
 ПОКА НЕ ПУСТО              │
 {                          │
   ПИШИ ПУСТО               │
   ВПРАВО                   │
 }                          │
КОНЕЦ                       │


                          * * *

Высшая оценка за эту задачу получилась 3.5. За два прохода задачу
никто не решил. Все решения можно разделить на три категории:

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

                          * * *

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

Метод пузырька здесь -- стрельба по воробьям из пушки. Хотя, конечно,
знать универсальные методы всегда хорошо и полезно. Жаль, что все
приведенные пузырьковые решения оказались далеки от настоящей
пузырьковой оптимальности.


Рассмотрим "лобовой" (неоптимальный) пузырьковый метод. Идея его
такова. Просматриваем массив, сравнивая два соседних элемента. Если
сравниваемые элементы не упорядочены между собой, переставляем их
местами. Делаем проходы до тех пор, пока в массиве не будет ни одной
перестановки.

Рассмотрим программу на Си.
Пусть надо упорядочить числовой массив set по возрастанию (нумерация
элементов массива в Си идет с нуля).

// Прямодушный неоптимальный пузырек
// На вход функции поступает ссылка на массив и его длина.
void function sort(int *set, int len)
{
  int flag=1; // 1 -- были ли перестановки в массиве
              // 0 -- перестановок не было

  int i;      // индекс цикла
  int x;      // рабочая переменная

  while(flag) // напоминаю, что 1 в Си дает true, а 0 -- false
  {           // Значит while работает пока flag равен 1.
    flag = 0;
    for(i=0; i<len-1; i++)
      if (set[i] > set[i+1]) // если порядок не тот
      {
        // перестановка в правильном порядке
        // соседних элементов
        x        = set[i];
        set[i]   = set[i+1];
        set[i+1] = x;
        flag     = 1;
      }
  }
}

Работает это так.

Просматривает массив, сравнивая соседние элементы. Если элементы стоят
неправильно, они обмениваются местами.

После первого просмотра наступает второй, третий и так до тех пор,
пока в массиве не будет сделано ни одной перестановки. В алгоритме
переменная flag устанавливается в 1, если происходит перестановка.
Вот цикл while и работает пока flag есть 1.

Прокрутим алгоритм для массива (26,71,9,1) при упорядочивании по
возрастанию.


первый просмотр
26,71,9,1
26,9,71,1
26,9,1,71     выплыл на свое место элемент-пузырек 71

второй просмотр
26,9,1,71
9,26,1,71
9,1,26,71     выплыл на свое место элемент-пузырек 26

третий просмотр
1,9,26,71
1,9,26,71
1,9,26,71     выплыл на свое место элемент-пузырек 9

четвертый просмотр
1,9,26,71
1,9,26,71
1,9,26,71

При последнем просмотре не было сделано ни одной перестановки, поэтому
flag остается равным 0 и просмотры заканчиваются.

Каждый просмотр заставляет один элемент всплывать на свое место.
Поэтому метод и называется: "метод пузырька".

В силу этого ясно, что при каждом новом просмотре можно длину
просматриваемой части сокращать на 1.

Ясно, также, что какая-то часть массива уже может стоять в правильном
порядке и пузырьки могут всплывать на свое место, которое не
обязательно отличается на 1 от предыдущего всплытия. То есть, это
означает что, длину просматриваемой части в оптимальном алгоритме
нужно сокращать не на 1 с конца, а всегда до места всплытия последнего
пузырька, что может оказаться существенно больше, чем сокращение
строго на 1.

Поясню на примере массива (2, 5, 1, 6, 7)

первый просмотр (смотрим 5 элементов)
2, 5, 1, 6, 7
2, 1, 5, 6, 7
2, 1, 5, 6, 7 выплыл на свое место элемент-пузырек 5

Понятно, что при следующем просмотре не нужно смотреть элементы
массива за элементом 5 -- они уже в полном порядке.

второй просмотр  (смотрим два элемента)
2, 1
1, 2

Перестановка была, но теперь надо смотреть только один элемент, а чего
его смотреть? Один элемент всегда в порядке. Значит цикл можно
закончить.

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

// Оптимальный алгоритм пузырька
// На вход функции поступает ссылка на массив и его длина.
void function sort(int *set, int len)
{
  int j=1; // Это индекс места, на которое всплыл "пузырек"
           // или 0, если перестановок не было.
           // Присваиваем 1 для первого входа в цикл while

  int bound=len-1; // верхняя граница просмотра

  int i;           // индекс цикла
  int x;           // рабочая переменная

  while(j) // пока j не равен нулю
  {
    j = 0;
    for(var i=0; i<bound; i++)
      if (set[i] > set[i+1])    // если порядок не тот
      {
        // перестановка в правильном порядке
        // соседних элементов
        x        = set[i];
        set[i]   = set[i+1];
        set[i+1] = x;
        j        = i;
      }
    bound = j; // новая граница просмотра
  }
}

                           * * *

Команда 3101
------------
.\01\01.txt
Оценка: 3.5

Решение 1
Автор - Гуреев Денис                
Оценка: 3.5

описание алгоритма
------------------
Эту задачу я решал в три прохода. В первом проходе с помощью процедуры
"Считай_0" корректор считает количество нулей с помощью своего ящика.
Затем процедура "Пиши_0" пишет на ленту столько нулей, сколько
означает символ в ящике. Затем корректор возвращает окно в начало
записи и происходит следующий проход, но корректор считает единицы с
помощью процедуры "Считай_1", а после этого пишет столько единиц,
cколько означает символ в ящике. Затем все это повторяется, но уже с
2.

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

Решение 2
Автор - Первушин Данила
Оценка: 3.5

описание алгоритма
------------------
Задача решена в 3 прохода, количество цифр 0,1,2 запоминается
с помощью трёх рекурсивных процедур с отложенными командами

комментарий куратора
---------------------

Алгоритм более понятен из заглавной процедуры:

ЭТО Порядок
 Нули                      "Перетащить" нули            
 ПОКА НЕ ПУСТО ВЛЕВО       Вернуться к началу записи            
 Единица                               
 ВЛЕВО
 ПОКА НЕ ПУСТО ВЛЕВО                   
 Двойки                                
 ПОКА НЕ ПРОБЕЛ ВЛЕВО                  
 ПОКА НЕ ПУСТО
             { ПИШИ ПУСТО ВЛЕВО }  Убрать с ленты
 ПОКА ПУСТО ВПРАВО                 исходную запись    
КОНЕЦ

Три прохода вместо возможных двух со стиранием старой записи.
Вместо счетчика-ящика использована пружинка-рекурсия. Это, конечно,
красиво, но один проход лишний.


Команда 3102
------------
.\02\02.txt
Авторы решения: Богатырев Геннадий
Оценка: 3.5

описание алгоритма
------------------
1) Организация цикла (условие выхода - конец записи):
- поиск 0, если найден, осуществляется обмен с содержимым ящика 
- рекурсивный возврат к исходному символу и обмен с содержимым ящика
- рекурсивный возврат к месту, где раннее находился 0
- обмен содержимого ящика с содержимым окна ленты
2) Установить окно на символ следующий за последним 0
3) Организация цикла (условие выхода - конец записи) - аналогично первому
   для 1

комментарий куратора
--------------------
Описание алгоритма я не понял. Из программы следует, что работа
производится в рамках исходной записи путем перестановок элементов.
Некоторая вариация классической сортировки с учетом специфики данных
на ленте. Может быть и два прохода и четыре.

Команда 3104
------------
.\04\04.txt
Коллективное решение
Оценка: 3.5

описание алгоритма
------------------
Отсутствует.

комментарий куратора
--------------------
Алгоритм тот же самый, что и у команды 3102. То есть сначала нули
путем перестановок записываются в начало, потом единицы.


Команда 3105
------------
.\05\05.txt
Оценка: 3.5

I вариант
Автор Вязьмин Антон
Оценка: 3.5

описание алгоритма
------------------
Используется условие, что лента бесконечная, и не может возникнуть
ошибка, когда длина записи превышает половину длины ленты. Помещаем в
ящик нуль. Считаем количество нулей в записи (увеличиваем содержимое
ящика на единицу, если на ленте встречаем нуль) и формируем новую
запись через пробел от данной. Для этого пишем нуль на ленте и
уменьшаем содержимое ящика на единицу, пока в ящике не окажется нуль.
С помощью отложенной команды возвращаемся на начало первой записи.
Аналогично считаем и записываем число цифр 1 и 2. Затем первую запись
удаляем.

комментарий куратора
--------------------
Описание алгоритма очень понятно. Из заглавной процедуры:

ЭТО Сортировка
ПИШИ 0
ОБМЕН                                  
Цифра_0
Цифра_1                                
ВПРАВО
Цифра_2                                
ВПРАВО                                 
Уборка                                 
КОНЕЦ
                                       
видно, что проходов - четыре.

II вариант
Автор Галушко Марина
Оценка: 3.5

Описание алгоритма
Находим в записи первый нуль, помещаем его в ящик, возвращаемся на
начало записи (сработает условие Я>Л, это же условие сработает, когда
нужно поставить нуль за нулем, или единицу за нулем, или единицу за
единицей), меняем первый символ и символ в ящике местами. С помощью
отложенной команды, возвращаемся на то место, где нашли первый нуль и
меняем содержимое ящика и ячейки местами. Движемся до конца записи и
выбираем нули. С помощью процедуры Запись меняем местами первый символ
записи и первый нуль в этой записи, второй символ записи и второй нуль
в этой записи и т.д. Затем возвращаемся на начало записи и аналогично
выбираем все единицы, одновременно все двойки выстроятся за единицами.

комментарий куратора
--------------------
Здесь описание алгоритма более туманное, но понятно, что работа
происходит в исходной записи путем перестановок элементов.

Команда 3106
------------
Оценка: 3
Вариация на тему классического "пузырька".



Команда 3107
------------
.\07\07.txt
Автор Кондратюк Лена
Оценка: 3

описание алгоритма
------------------
1 поиск 0
2 установка 0 в нужную позицию
3 возврат на начало записи
4 поиск 1
5 установка 1 в нужную позицию
6 возврат на начало записи
7 поиск 2
8 установка в позицию после 1

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


Команда 3108
------------
.\08\08.txt
Автор:  Екатерина Витальевна Мороз.
Оценка: 3.5

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

комментарий куратора
--------------------
Алгоритм как у куратора, только подсчитывает не ящик, а рекурсивная
пружинка (что эффективнее), но  четыре прохода.

Команда 3110
------------
.\10\10.txt
Автор: Щукин М. 7 класс)
Оценка: 3

описание алгоритма
------------------
1-ый способ сортировка методом "пузырька"
- подсчитываем количество символов в цепочке( в дальнейшем столько 
  раз будем совершать обход)
- возвращаемся
 процедура ОБХОД, идея следующая:
    сравниваем два соседних символа, будем считать если левый
    меньше правого-это порядок и мы ничего не делаем
    если же левый больше правого, то это беспорядок и надо поменять
    символы местами.
- процедура ОБХОД выполниться столько раз, чему равно кол-во
  символов в цепочке
Этот алгоритм может быть оптимизирован: количество ОБХОДов
может быть сокращено, если ниодной перестановки не было то поставить
 флажок и на этом обходы закончить.

комментарий куратора
--------------------
Даже с установкой флажка алгоритм не является оптимальным.

Команда 3112
------------
.\12\12.txt
Авторы: Табашина Ольга и Толкачев Александр.
Оценка: 3

описание алгоритма
------------------
Алгоритм сортировки известен под названием "Метод пузырька"

комментарий куратора
--------------------
Для данного частного случая данных на ленте алгоритм не является
оптимальным.

Команда 3114
------------
.\14\14.txt
Авторы решения: не указаны
Оценка: 3.5

описание алгоритма
------------------
Отсутствует.

комментарий куратора
--------------------
Перестановка элементов внутри исходной записи.
