Задача 1. (5 баллов)

   Текстовая строка  - это последовательность из нескольких сим-
волов. Будем считать концом строки символ пробела. Для обобщения
наших рассмотрений  введем  понятие пустой строки. Пустая строка
-- это пустое место, отсутствие каких-либо символов.
   Операция соединения двух текстовых строк в  одну строку назы-
вается операцией  конкатенации.  Обычно  эта  операция  в языках
программирования обозначается  так  же,  как и операция сложения
знаком "+".

   Примеры выполнения операции конкатенации.
1) каша+лот  = кашалот
   Соединяются две непустые строки.
2) каша++лот = кашалот
   Соединяются две непустые строки и одна пустая -- она распола-
   гается "между" двумя знаками "+".
3) + =
   Соединяются две пустые строки. Результат -- пустая строка.

4) +по+беда+ = победа
   Соединяются 4  строки. Первая и последняя, соединяемые строки
   -- пустые.

   Замечание.  Предполагается,  что  среди символов, входящих  в
состав строк, знака "+" нет.

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

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

До выполнения                 После работы программы

   1 2 3 4 5 6 7 8 9 0           1 2 3 4 5 6 7 8 9 0
  ┌─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬       ┌─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬
1 │ │ │ │ │ │ │ │ │ │ │ │     1 │ │л│и│с│и│ц│а│¤│ │ │ │
  ├─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼       ├─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼
2 │¤│л│и│+│с│и│+│ц│а│ │ │     2 │ │ │ │ │ │ │ │ │ │ │ │
  ├─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼       ├─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼


   1 2 3 4 5 6 7 8 9 0           1 2 3 4 5 6 7 8 9 0
  ┌─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬       ┌─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬
1 │ │ │ │ │ │ │ │ │ │ │ │     1 │ │к│о│ш│к│а│¤│ │ │ │ │
  ├─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼       ├─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼
2 │¤│к│о│+│ш│+│+│к│а│+│ │     2 │ │ │ │ │ │ │ │ │ │ │ │
  ├─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼       ├─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼

   И так далее.

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

ЭТО вход                             │ Шаг по записи и проверка.
  шаг                                │ Если "+", то удаление,
  ЕСЛИ + ТО { ВВЕРХ ВНИЗ вход ВЛЕВО }│              рекурсия и сжатие пружины.
  ИНАЧЕ ЕСЛИ НЕ ПУСТО ТО вход        │ Если не ПУСТО, то  просто рекурсия.
  ИНАЧЕ ВВЕРХ                        │ Если ПУСТО, то  вверх и работа пружины.
КОНЕЦ                                │
                                     │
ЭТО шаг                              │
  ВНИЗ                               │
  ВПРАВО                             │
  ВВЕРХ                              │
КОНЕЦ                                │

                      * * *

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

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

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

Понятно, что однопроходной алгоритм более эффективен.

За многопроходность алгоритма я ставил 4 балла, если не было других
погрешностей.

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


Команда 3101
------------
.\01\01.txt
Оценка: 5
Автор решения Гуреев Денис

описание  алгоритма
- - - - - - - - - -
КУКАРАЧА ищет "+". Если он найдет его, то выбросит кубик c "+"
за пределы своей среды и запомнит отложенную команду ВЛЕВО.
После того, как КУКАРАЧА дойдет до пустой клетки, он сходит
вверх, вспомнит отложенные команды ВЛЕВО и тем самым
сдвинет слово.

программа
- - - - -

ЭТО Вход                               
    ВНИЗ ВПРАВО ВВЕРХ                  
    ЕСЛИ +
     ТО {                              
         ВВЕРХ ВНИЗ
         Вход                          
         ВЛЕВО
        }                              
     ИНАЧЕ ЕСЛИ ПУСТО
            ТО ВВЕРХ
            ИНАЧЕ Вход                 
КОНЕЦ //Вход                           

комментарий  куратора
- - - - - - - - - - -
Замечание, пожалуй, только одно: с выделенным в отдельную процедуру
кодом "ВНИЗ ВПРАВО ВВЕРХ" программа становится еще понятнее.
Признаюсь, даже не запускал программу -- уверен работает на пять.

Команда 3102
------------
.\02\02.txt
Оценка: 4

Автор решения - Богатырев Гена

программа
- - - - -
ЭТО СЛОЖЕНИЕ
 ПРОВЕРКА                              
 ПОКА ПУСТО ИЩИ //Ограничитель поиска -
              // кубик без буквы.
КОНЕЦ                                  
                                       
// Проверяет первый символ.            
ЭТО ПРОВЕРКА
 ВВЕРХ ВПРАВО ВНИЗ                     
 ЕСЛИ ПУСТО ТО // Проверяет, есть ли
               // на кубике символ.    
              {                        
               ВНИЗ ВЛЕВО
               }                       
            ИНАЧЕ ПРОВЕРЬ_+
КОНЕЦ                                  

ЭТО ПРОВЕРЬ_+ // Определяет, есть на   
              // на кубике + или нет.
 ЕСЛИ НЕ + ТО ПРОВЕРКА //Рекурсия.
  ИНАЧЕ
       {                               
        ПОВТОРИ 8 ВНИЗ  // Выталкивает
        ПОВТОРИ 7 ВВЕРХ // с поля +.   
        }
 ВНИЗ ВЛЕВО ВВЕРХ //Отложенные команды
    //рекурсии по условию есть ли +.   
    //Возвращают буквы на строку вверх
КОНЕЦ                                  

ЭТО ИЩИ // Возвращает исполнителя в    
        // строку со словом.
 ВВЕРХ                                 
 ВПРАВО // Уплотняет строку.           
 ПРОВЕРКА
КОНЕЦ                                  

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

1) Запись смотрится громоздко.

2) Цепочка косвенной рекурсии затрудняет понимание.

3) Убирание знаков "+" через нижний обрез поля долог. Правда это
позволяет в ответе показать запись в той строке, где она была. Но возникает
дополнительный негативный момент: а вдруг высота поля не 10, а 20 или 30
строк? Тогда придется программу переделывать!

4) Алгоритм не описан как одно целое, а построчные комментарии не дают
цельного представления, так как описывают тактику, а не стратегию. А
общая идея алгоритма в том, что он придерживается тактики "один выброс
-- один сдвиг", в отличие от алгоритма команды 3101 "сначала все
выбросы -- потом один большой сдвиг пружинкой". В силу чего Ваш
алгоритм менее оптимальный. Кукараче приходится больше работать!

Команда 3104
------------
.\04\04.txt
Оценка: 2


Вариант 1
Оценка: 1

программа                                            ║
- - - - -                                            ║1.Распределение_работы -
ЭТО Распределение_Работы                             ║главная процедура ,
ВПРАВО                                               ║в которой таракан
ЕСЛИ ПУСТО ТО УБРАТЬ_++ ─1──────────────────────────┐║проверяет на наличие
ЕСЛИ НЕ ПУСТО ТО КОНКАТЕНАЦИЯ ─┐                    │║знака квадрат (1;1)
КОНЕЦ                          2                    │║стрелка 1 - если
ЭТО КОНКАТЕНАЦИЯ    ──────┬───┘                    │║знака нет , стреклка
ВНИЗ                       │                        │║2 если знак есть .
ВПРАВО                     │                        │║2.КОНКАТЕНАЦИЯ - проце-
ВВЕРХ                      │                        │║дура в которой Кукарача
ЕСЛИ НЕ ПУСТО ТО           │                        │║ставит себе условия
{                          │                        │║работы . Если + то
 ЕСЛИ НЕ + ТО ИДИ_ДАЛЬШЕ ─4╫──────────────┐         │║он его удаляет (стрел-
 ЕСЛИ + ТО УБРАТЬ_+ ─5─────╫──────────────╫┐        │║ка 5),если не + то
 КОНКАТЕНАЦИЯ ──3──────────┘              ││        │║исполнитель ищет дальше,
}                                         ││        │║когда после поисков он
 ИНАЧЕ ПЕРЕХОД ──6────────────────────────╪╪────┐   │║видит пустое место то
СДВИГ ────7───────────────────────────────╪╪────┼┐  │║он уплотняет буквы
КОНЕЦ                                     ││    ││  │║(стрелка 7).
//2. Процедура переход в другой столбец   ││    ││  │║
ЭТО ИДИ_ДАЛЬШЕ  ─────────────────────────┘│    ││  │║
ВНИЗ                                       │    ││  │║
ВПРАВО                                     │    ││  │║
ВВЕРХ                                      │    ││  │║
КОНЕЦ                                      │    ││  │║
//3. Процедура уборки с поля +             │    ││  │║
ЭТО УБРАТЬ_+  ────────────────────────────┴─┐  ││  │║
ВВЕРХ                                        │  ││  │║
ВНИЗ                                         │  ││  │║
ИДИ_ДАЛЬШЕ                                   │  ││  │║
КОНЕЦ                                        │  ││  │║
//4. Переход в другую строку                 │  ││  │║
ЭТО ПЕРЕХОД  ───────────────────────────────╫──┘│  │║
ВВЕРХ                                        │   │  │║
ПОВТОРИ 2 ВПРАВО                             │   │  │║
КОНЕЦ                                        │   │  │║
//5. Процедура уплотнения слова              │   │  │║
ЭТО СДВИГ  ─────────────────────────────────╫───┘  │║
ВЛЕВО                                        │      │║
КОНЕЦ                                        └─┐    │║
//Процедура проверки только на + без уплотнения│    │║
                                             ┌─┘    │║
ЭТО УБРАТЬ_++  ────────┬────────────────────╫──────┘║
ИДИ_ДАЛЬШЕ              │                    │       ║
ЕСЛИ + ТО УБРАТЬ_+ ──8──╫────────────────────┘       ║
УБРАТЬ_++ ─9────────────┘                            ║
КОНЕЦ                                                ║

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

1) Программа не имеет структурных отступов.

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

3) Програма зря толкает запись вправо по строке (первой же командой).

4) Да, самое главное: программа не работает. Программа не работает уже
на простейшем тесте "у+с" -- запись не уплотняется. Еще пример: запись
"к++к" превращается в запись "к +к". На самом деле, таких тестов
бесконечно много. Плохо ребята протестировали свою программу!

Вариант 2
Оценка: 2

программа
- - - - -

//Процедура перхода в другой столбец           ║ Задача1 - главная программа.
ЭТО Смещение┬─────────────────────────────┐   ║
  ВНИЗ       └─────────────────────────┐   │   ║
  ВПРАВО                               │   │   ║
  ВВЕРХ                                │   │   ║
  ЕСЛИ ПУСТО                           │   │   ║
  ТО ВВЕРХ                             │   │   ║
                                       │   │   ║
КОНЕЦ                                  │   │   ║
//Процедура убирани  с поля +             │   ║
ЭТО Плюс────┬────────────────────────┼─┐ │   ║
 ВВЕРХ       │                         │ │ │   ║
 ВНИЗ                                 │ │ │   ║
 Смещение  ──┼─5──────────────────────┘ │ │   ║
  {          │                           │ │   ║
   ЕСЛИ +    │                           │ │   ║
   ТО Плюс  6┘                           │ │   ║
   ЕСЛИ НЕ ПУСТО                         │ │   ║
   ТО Задача1 ────4────────────────────┐ │ │   ║
  }                                    │ │ │   ║
 ВЛЕВО                                 │ │ │   ║
КОНЕЦ                                  │ │ │   ║
//Главная процедура                    │ │ │   ║
ЭТО Задача1──────────┐───────────────┘  │   ║
  Смещение  ────3─────┼──────────────────┼┘   ║
  ЕСЛИ +                                │     ║
  ТО Плюс  ────2──────┼──────────────────┘     ║
  ИНАЧЕ ЕСЛИ НЕ ПУСТО │                        ║
  ТО Задача1  ───1────┘                        ║
КОНЕЦ                                          ║

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

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

Тесты на которых выдается результат "Не могу!": "у++с", "++с".

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

Автор: Млечка Юля

описание  алгоритма
- - - - - - - - - -
Проверяем каждый символ в  записи, если это + то выбрасываем его и
продолжаем проверку до тех пор, пока не встретим пустой символ, тогда 
поднимаемся вверх и сдвигаем запись влево на столько клеток, сколько раз 
вызывалась процедура УБОРКА (т.е. сколько в записи встретилось символов 
+). 

программа
- - - - -

ЭТО СЛОВО
  БУКВА
  ЕСЛИ +        ТО УБОРКА ИНАЧЕ
  ЕСЛИ НЕ ПУСТО ТО СЛОВО  ИНАЧЕ ВВЕРХ 
КОНЕЦ                                  
                                       
ЭТО БУКВА  //распознаем символы
  ВНИЗ
  ВПРАВО
  ВВЕРХ                                
КОНЕЦ
                                       
ЭТО УБОРКА                             
  ВВЕРХ    //убираем символ +                            
  ВНИЗ                                 
  СЛОВО                                
  ВЛЕВО // пружина для уплотнения записи
КОНЕЦ

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

1) Процедуры лучше записывать маленькими буквами. Так процедуры лучше
выделяются в программе.

2) Так писать переключатель:

  ЕСЛИ +        ТО УБОРКА ИНАЧЕ               
  ЕСЛИ НЕ ПУСТО ТО СЛОВО  ИНАЧЕ ВВЕРХ

не надо! Кажется, что это не переключатель, а две условных команды.
Надо писать так:

  ЕСЛИ       +        ТО УБОРКА
  ИНАЧЕ ЕСЛИ НЕ ПУСТО ТО СЛОВО
  ИНАЧЕ                  ВВЕРХ

Здесь видно, что имеет место переключение на три положения.

3) Использована косвенная рекурсия. Которая менее наглядна, чем
прямая.

4) Программу не запускал -- понятно и так, что работать будет
совершенно правильно!

Команда 3106
------------
.\06\ol00-1.coc
Оценка: 4.8

описание алгоритма
- - - - -- - - - -
Пока не достигли конца записи проверяем символы.
Если обнаружили +, то запоминаем это событие (не забыв вытолкнуть +).
Процедура Дальше_с_+ позволяет отследить несколько + подряд.
В конце разжимаем "пружинку".

программа
- - - - -

ЭТО Слово
 Шаг
 ЕСЛИ НЕ ПУСТО
  ТО ЕСЛИ + ТО    Дальше_с_+           
            ИНАЧЕ Слово                
  ИНАЧЕ ВВЕРХ                          
КОНЕЦ
                                       
ЭТО Дальше_с_+                         
 ВВЕРХ   //Вытолкнем букву             
 ВНИЗ                                  
 Шаг                                   
 ЕСЛИ НЕ ПУСТО
  ТО ЕСЛИ + ТО    Дальше_с_+
            ИНАЧЕ Слово
  ИНАЧЕ ВВЕРХ                          
 ВЛЕВО        //Сжимаем запись         
КОНЕЦ                                  
                                       
ЭТО Шаг                                
 ВНИЗ                                  
 ВПРАВО                                
 ВВЕРХ                                 
КОНЕЦ                                  

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

1) Одинаковые проверки на "+" в разных процедурах. Одна проверка
лишняя.

2) Прямая рекурсия нагляднее косвенной.

3) К работе программы замечаний нет.


Команда 3107
------------
.\07\07.txt
.\07\0711.coc
Оценка: 1
Автор решения Михайлова Ирина.

программа
- - - - -
 ЭТО поиск
 ВНИЗ                                  
 ВПРАВО
 ВВЕРХ                                 
 ЕСЛИ НЕ + ТО поиск                    
 ИНАЧЕ { ВВЕРХ ВВЕРХ ВНИЗ ВНИЗ поиск1 }
КОНЕЦ                                  
ЭТО поиск1                             
 ВНИЗ
 ВПРАВО                                
 ВВЕРХ                                 
 ЕСЛИ НЕ ПУСТО ТО поиск1
 ИНАЧЕ { ВВЕРХ ВЛЕВО }
КОНЕЦ                                  

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

1) Нет описания алгоритма.
2) Структурные отступы маловаты (еще бы один пробел!)
3) Код "ВНИЗ ВПРАВО ВВЕРХ" лучше оформить отдельной процедурой.
4) Запись должна по условию быть во второй строке.
5) А главное -- программа неверная. Опровергающий тест "у++с". И любые
другие, где несколько знаков "+", например, "л+и+с". В программе нет
рекурсивной пружинки!

Команда 3108
------------
.\08\08.txt
Оценка: 5
Автор решения: Катя Мороз

Вариант 1
- - - - -
Оценка: 5

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

программа
- - - - -

ЭТО Из_2х_1-о
  { ВНИЗ ВПРАВО ВВЕРХ }                
 ЕСЛИ + ТО                             
  { ВВЕРХ ВНИЗ Из_2х_1-о ВЛЕВО }
 ИНАЧЕ                                 
 ЕСЛИ НЕ ПУСТО ТО Из_2х_1-о            
 ИНАЧЕ ВВЕРХ                           
КОНЕЦ                                  

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

1) Оформление кода "ВНИЗ ВПРАВО ВВЕРХ" в составную команду -- лишнее.
Вполне можно писать без {...}. Лучше было бы этот код оформить отдельной
процедурой "шаг".

2) Имя процедуры слишком сложное.

3) В остальном программа почти буквально повторяет решение куратора и,
конечно, работает идеально, можно даже не проверять!


Вариант 2
- - - - -
Оценка: 5

ЭТО Поехали                            
  { ВНИЗ ВПРАВО ВВЕРХ }                
 ЕСЛИ + ТО Имя                         
 ИНАЧЕ                                 
 ЕСЛИ НЕ ПУСТО ТО Поехали              
 ИНАЧЕ ВВЕРХ
КОНЕЦ // Поехали
                                       
ЭТО Имя                                
 ЕСЛИ + ТО
  { ВВЕРХ ВНИЗ Поехали  }              
 ИНАЧЕ Поехали                         
 ВЛЕВО                                 
КОНЕЦ                          
                                       
комментарий  куратора
- - - - - - - - - - -

Этот вариант немного хуже из-за косвенной рекурсии.
Но, в принципе, алгоритм тот же самый.


Команда 3109
------------
.\09\09.txt
Оценка: 4

Автор решения: Журавлев Дима

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

Кукарача последовательно проверяет кубики пока не дойдет до конца
записи. Если на пути Кука (как мы его ласково назвали) попадается
кубик с +, он его выкидывает с поля (для этого мы использовали второй
слой), возвращается в начало записи и сдвигает все символы вправо.
Затем путь Кука продолжается.

программа
- - - - -
ЭТО Сложение
ВВЕРХ        //узнаем какой кубик
ВПРАВО
ВНИЗ
ПОКА  НЕ  ПУСТО
{
ЕСЛИ + ТО
{
Удаление    //убираем кубик с поля
Уплотнение  //сдвигаем все предыдущие символы вправо
}
Сложение
КОНЕЦ

ЭТО Удаление
ВПЕРЕД
ВНИЗ
НАЗАД
КОНЕЦ

ЭТО Уплотнение
ПОКА НЕ ПУСТО
{
ВНИЗ
ВЛЕВО
ВВЕРХ
}
ВВЕРХ
ВПРАВО
КОНЕЦ

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

1) В программе нет структурных отступов.
2) Алгоритм многопроходной, то есть не оптимальный. Многопроходность
означает, что Кукарача "ремонтирует" запись не за один ее просмотр, а
за несколько, причем число просмотров существенно зависит от числа
знаков "+" в ней.

Команда 3110
------------
.\10\10.txt
Оценка: 4.8

Вариант 1
- - - - -
Оценка: 2
.\10\1011.coc
Автор: Колмаков Ваня, 7 класс

описание  алгоритма
- - - - - - - - - -
Программа проходит не все тесты

Идея: проверка символа толканием снизу, если + то следующую цепочку до+
сдвигать влево.

Работает для ЛИ+СИ+ЦА

Если в текстовой строке идут подряд два и более +, то операция
конкатенации не срабатывает.

программа
- - - - -
ЭТО ПР
ШАГ
ПОКА НЕ +                              
   ШАГ
ВВЕРХ                                  
ВНИЗ
КОН
КОНЕЦ                                  
ЭТО КОН
ШАГ
ЕСЛИ НЕ ПУСТО ТО                       
     {                                 
      ЕСЛИ + ТО ПЕТЛЯ                  
      КОН                              
     }
  ИНАЧЕ  конец                         
КОНЕЦ                                  
ЭТО ШАГ                                
ВНИЗ                                   
ВПРАВО
ВВЕРХ                                  
КОНЕЦ                                  
ЭТО ПЕТЛЯ
ВВЕРХ
ВЛЕВО                                  
ВНИЗ
ВПРАВО                                 
КОНЕЦ
ЭТО ПЕТЛЯ2
ВНИЗ                                   
КОНЕЦ

ЭТО конец                              
ВВЕРХ                                  
ВЛЕВО                                  
ВЛЕВО                                  
КОНЕЦ

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

1) Программа не имеет структурных отступов и пустых строк между
процедурами.

2) Программа не получилась потому, что не был продуман до конца
алгоритм и решение, вероятно, подбирались за компьютером. Отсюда такие
длинные и запутанные тексты.

Вариант 2
- - - - -
Оценка: 2
.\10\1012.coc
Автор Чернышов Дима 7, класс

Описание  алгоритма
- - - - - - - - - -
Идея: проверка символа толканием вправо, и если символ не +
устанавливаем его выше, а если +, то его выталкиваем из поля.
Выполняется это до пусто, так как используется рекурсия, то можно
применить в конце пружину(ВЛЕВО), которая склеит текст.

Работает для случаев когда знак + один.
Для ЛИ++СИ+ЦА работает не правильно.

программа
- - - - -
ЭТО КОН
 ВПРАВО
 ЕСЛИ НЕ ПУСТО ТО                      
   ЕСЛИ НЕ + ТО МЕСТО                  
     ИНАЧЕ УБР                         
 ИНАЧЕ конец
ВЛЕВО                                  
КОНЕЦ                                  
ЭТО МЕСТО
ШАГ
КОН
КОНЕЦ                                  
ЭТО УБР
ШАГ                                    
ВВЕРХ
ВНИЗ                                   
КОН                                    
КОНЕЦ                                  
ЭТО ШАГ
ВНИЗ                                   
ВПРАВО                                 
ВВЕРХ
КОНЕЦ                                  
ЭТО конец
ВВЕРХ                                  
КОНЕЦ                                  

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

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

Вариант 3
- - - - -
Оценка: 4.8
.\10\1013.coc
Идея Чернышова Димы, дорабатанная вместе с руководителем.

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

Идея та же что и во 2-ом варианте.
Работает для всех тестов.

программа
- - - - -
ЭТО ЛИСИЦА
ВПРАВО                                 
ШАГ                                    
ПР
КОНЕЦ                                  
// пр- пружина                         
                                       
ЭТО ПР                                 
ЕСЛИ + ТО                              
        {                              
        ВВЕРХ
        ВНИЗ                           
        ШАГ                            
        ПР                             
        }
ИНАЧЕ ЕСЛИ НЕ ПУСТО ТО ЛИСИЦА
ИНАЧЕ ВВЕРХ                            
// отложенная команда
ВЛЕВО                                  
КОНЕЦ                                  
ЭТО ШАГ
ВНИЗ                                   
ВПРАВО                                 
ВВЕРХ                                  
КОНЕЦ                                  

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

1) Вот здесь уже сделана попытка писать структурно текст программы. И
результат сразу лучше! Дима, надо доводить запись до идеальной формы.
Посмотри, как записана программа куратора. Ведь ее легко читать и
понимать, верно?

2) Имена процедур лучше записывать маленькими буквами. Так они лучше
будут выделяться на фоне команд и ключевых слов, которые -- большие.

3) Самое интересное, что несмотря на некоторую сложность алгоритма,
программа работает правильно!


Команда 3111
------------
.\11\11.txt
Оценка: 5
Автор: Гарипова Лиана

описание  алгоритма
- - - - - - - - - -
1.Исполнитель "Кукарача" проверяет все символы выражения.

2.Если встретится "плюс", то исполнитель выталкивает этот знак и
запоминает команду "влево".

3.Затем, если становится пусто, исполнитель встает в конец выражения и
уплотняет его отложенной командой "влево"

программа
- - - - -

ЭТО Склеивание
  Шаг
  ЕСЛИ НЕ ПУСТО                        
     ТО                                
      { ЕСЛИ +
          ТО { Столкнуть_букву
               Склеивание              
              ВЛЕВО     //Отложенная   
             }          // команда
          ИНАЧЕ Склеивание
       }                               
      ИНАЧЕ ВВЕРХ    //Встать в конец
КОНЕЦ // Склеивание  //слова           
//-------------------------------------
// По процедуре "Шаг"  исполнитель     
// переходит к следующему символу.     
ЭТО Шаг                                
  ВНИЗ                                 
  ВПРАВО                               
  ВВЕРХ                                
КОНЕЦ // Шаг                           
//-------------------------------------
// Исполнитель сталкивает"плюс"с поля. 
ЭТО Столкнуть_букву                    
  ВВЕРХ                                
  ВНИЗ
КОНЕЦ // Столкнуть_букву

комментарий  куратора
- - - - - - - - - - -
1) Верный алгоритм -- залог здоровья Кукарачи!

2) Не буду, Лиана, запускать твою программу. Итак видно, что она
совершенно правильная и работать будет как часы!

Сказал так, а потом все таки взял, да запустил. Вернее хотел запустить
-- не запускается! Там в файле за программой такое -- на 50 килобайт.
Конечно, после вырезания программы из остального массива, она
заработала как и предполагалось.


Команда 3112
------------
.\12\12.txt
Оценка: 5


Вариант 1
- - - - -
Оценка: 5
Автор решения: Громков Сергей

программа
- - - - -

//  задача 1211-------------------------
// Устанавливает КУКАРАЧУ в нужное
// положение (в клетку под неизвестным
// кубиком)
ЭТО ЛИСИЦА         <─────────────────────────────┐
  ВНИЗ ВПРАВО                                    │
  ПРОВЕРКА     ────────────────────────────┐     │
КОНЕЦ                                      │     │
//-------------------------------------    │     │
// Определяет какой кубик находится        │     │
// на клетку выше КУКАРАЧИ                 │     │
ЭТО ПРОВЕРКА     <─────────────────────────┘     │
 ВВЕРХ                                           │
 ЕСЛИ +                                          │
  ТО  ШАГ1        ────────────────────────┐      │
  ИНАЧЕ ШАГ2      ────────────────────────┼─┐    │
КОНЕЦ // Имя                              │ │    │
//-------------------------------------   │ │    │
// Если на кубике "+", то КУКАРАЧА        │ │    │
//его выкидывает, в рекурсивную пружину   │ │    │
// заносит одну команду ВЛЕВО для того,   │ │    │
// чтобы после проверки сдвинуть слово    │ │    │
ЭТО ШАГ1           <──────────────────────┘ │    │
 ВВЕРХ ВНИЗ ЛИСИЦА ВЛЕВО                    │    │
КОНЕЦ // Имя                                │    │
//-------------------------------------     │    │
// Если кубик не пустой, то КУКАРАЧА        │    │
// переходит к проверке следующего          │    │
// кубика, иначе (если пустой)              │    │
// обращается в рекурсивную пружину и       │    │
// сдвигает слово                           │    │
ЭТО ШАГ2     <──────────────────────────────┘    │
 ЕСЛИ ПУСТО                                      │
  ТО    ВВЕРХ                                    │
  ИНАЧЕ ЛИСИЦА  ─────────────────────────────────┘
КОНЕЦ // Имя

комментарий  куратора
- - - - - - - - - - -
1) Однопроходной алгоритм, такой же как и у куратора, но
с разветвленной косвенной рекурсией.

2) Программа хорошо структирирована.

Вариант 2
- - - - -
Оценка: 4
Авторы: Александр Целиков и Толкачев Саша

программа
- - - - -

// КУКАРАЧА проверяет есть ли справа
// от него кубик
ЭТО КАН-КАН             <────────────────────────┐
  ВПРАВО                                         │
  ЕСЛИ ПУСТО ТО НА_МЕСТО    ──────────────┐      │
ИНАЧЕ                                     │      │
// если кубик непустой то КУКАРАЧА        │      │
// осуществляет проверку                  │      │
  {                                       │      │
  ПОКА НЕ ПУСТО ШАГ        ─────────────┐ │      │
  СДВИГ                     ────────────┼─┼──┐   │
  КАН-КАН                  ─────────────┼─┼──┼───┘
  }                                     │ │  │
КОНЕЦ                                   │ │  │
// КУКАРАЧА становится под кубик и      │ │  │
// проверяет его. Если + то выкидывает  │ │  │
// кубик ,иначе переходит к проверке    │ │  │
// следуещего                           │ │  │
ЭТО ШАГ                    <────────────┘ │  │
 ВНИЗ ВПРАВО ВВЕРХ                        │  │
  ЕСЛИ + ТО ВЫБРОС         ────────────┐  │  │
КОНЕЦ                                  │  │  │
ЭТО ВЫБРОС                 <───────────┘  │  │
  ВВЕРХ ВНИЗ                              │  │
КОНЕЦ                                     │  │
// После того как КУКАРАЧА выбрасывает    │  │
// "+" идет в конец слова и сдвигает      │  │
// оставшуюся часть влево.Затем           │  │
// поднимает оставшуюся часть на строку   │  │
// вверх и снова выполняет проверку       │  │
ЭТО СДВИГ                <────────────────┼──┘
  ХОД1                    ───────┐        │
  ПОКА НЕ ПУСТО ХОД1             │        │
  ВНИЗ     ВЛЕВО ВЛЕВО           │        │
  ХОД2                     ──────┼───┐    │
  ПОКА НЕ ПУСТО ХОД2             │   │    │
  ВВЕРХ                          │   │    │
КОНЕЦ                            │   │    │
ЭТО ХОД1                  <──────┘   │    │
  ВВЕРХ ВПРАВО ВНИЗ                  │    │
КОНЕЦ                                │    │
ЭТО ХОД2                  <──────────┘    │
  ВНИЗ ВЛЕВО ВВЕРХ                        │
КОНЕЦ                                     │
ЭТО НА_МЕСТО               <──────────────┘
  ВПРАВО ВВЕРХ ВЛЕВО
КОНЕЦ

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

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

Смотреть на танец, конечно, забавно.

Команда 3114
------------
Оценка: 0
.\14\14.txt

