Задача b (8 баллов)

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


До выполнения программы

  ┼─┼─┼─┼─┼─┼─┼─┼─┼─┼   ┼─┼─┼─┼─┼─┼─┼─┼─┼─┼   ┼─┼─┼─┼─┼─┼─┼─┼─┼─┼
 1│ │ │ │ │ │ │ │ │ │   │ │ │ │ │ │ │ │ │ │   │ │ │ │ │ │ │ │ │ │
  ┼─┼─┼─┼─┼─┼─┼─┼─┼─┼   ┼─┼─┼─┼─┼─┼─┼─┼─┼─┼   ┼─┼─┼─┼─┼─┼─┼─┼─┼─┼
 2│ │ │ │ │ │ │ │ │ │   │ │ │ │ │ │ │ │ │ │   │ │ │ │ │ │ │ │ │ │
  ┼─┼─┼─┼─┼─┼─┼─┼─┼─┼   ┼─┼─┼─┼─┼─┼─┼─┼─┼─┼   ┼─┼─┼─┼─┼─┼─┼─┼─┼─┼
 3│ │¤│*│ │ │ │ │ │ │   │ │¤│*│*│ │ │ │ │ │   │ │¤│*│*│*│ │ │ │ │
  ┼─┼─┼─┼─┼─┼─┼─┼─┼─┼   ┼─┼─┼─┼─┼─┼─┼─┼─┼─┼   ┼─┼─┼─┼─┼─┼─┼─┼─┼─┼
 4│ │ │ │ │ │ │ │ │ │   │ │ │ │ │ │ │ │ │ │   │ │ │ │ │ │ │ │ │ │
  ┼─┼─┼─┼─┼─┼─┼─┼─┼─┼   ┼─┼─┼─┼─┼─┼─┼─┼─┼─┼   ┼─┼─┼─┼─┼─┼─┼─┼─┼─┼

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

  ┼─┼─┼─┼─┼─┼─┼─┼─┼─┼   ┼─┼─┼─┼─┼─┼─┼─┼─┼─┼   ┼─┼─┼─┼─┼─┼─┼─┼─┼─┼
 1│ │ │ │ │ │ │ │ │ │   │ │ │ │ │ │ │ │ │ │   │ │ │ │ │ │ │ │ │ │
  ┼─┼─┼─┼─┼─┼─┼─┼─┼─┼   ┼─┼─┼─┼─┼─┼─┼─┼─┼─┼   ┼─┼─┼─┼─┼─┼─┼─┼─┼─┼
 2│ │ │ │ │ │ │ │ │ │   │ │ │ │ │ │ │ │ │ │   │ │ │ │ │ │ │ │ │ │
  ┼─┼─┼─┼─┼─┼─┼─┼─┼─┼   ┼─┼─┼─┼─┼─┼─┼─┼─┼─┼   ┼─┼─┼─┼─┼─┼─┼─┼─┼─┼
 3│ │ │ │ │ │ │ │ │ │   │ │ │ │ │ │ │ │ │ │   │ │ │ │ │ │ │ │ │ │
  ┼─┼─┼─┼─┼─┼─┼─┼─┼─┼   ┼─┼─┼─┼─┼─┼─┼─┼─┼─┼   ┼─┼─┼─┼─┼─┼─┼─┼─┼─┼
 4│ │ │*│ │ │ │ │ │ │   │ │ │ │ │ │ │ │ │ │   │ │ │ │ │ │ │ │ │ │
  ┼─┼─┼─┼─┼─┼─┼─┼─┼─┼   ┼─┼─┼─┼─┼─┼─┼─┼─┼─┼   ┼─┼─┼─┼─┼─┼─┼─┼─┼─┼
 5│ │ │ │ │ │ │ │ │ │   │ │ │*│*│ │ │ │ │ │   │ │ │ │ │ │ │ │ │ │
  ┼─┼─┼─┼─┼─┼─┼─┼─┼─┼   ┼─┼─┼─┼─┼─┼─┼─┼─┼─┼   ┼─┼─┼─┼─┼─┼─┼─┼─┼─┼
 6│ │ │ │ │ │ │ │ │ │   │ │ │ │ │ │ │ │ │ │   │ │ │*│*│*│ │ │ │ │
  ┼─┼─┼─┼─┼─┼─┼─┼─┼─┼   ┼─┼─┼─┼─┼─┼─┼─┼─┼─┼   ┼─┼─┼─┼─┼─┼─┼─┼─┼─┼


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

Общая идея: "считаем" кубики и закручиваем пружину.
Под сжатую пружину подставляем процедуру, которая смещает
кубики на одну строку вниз.

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

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


Короткая программа, правда?

Однако, как, доказали ребята из команды 3105 и Виталий Бурляй (команда
3101) -- не оптимальная.

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

В результате пружина закручивается на два оборота меньше числа кубиков
в записи + ПУСТО. Что вместе со смещением, выполняемом при "подсчете"
дает правильное результирующее число сдвигов вниз.

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

Идельным решением этой задачи можно считать решение Виталия.



Команда 3101
------------
Оценка: 8
.\01\01.txt
Автор решения: Виталий Бурляй

описание  алгоритма
- - - - - - - - - -
     В процедуре Начало Кукарача проверяет, есть ли справа
от него два кубика. Если второй кубик есть, то таракан переходит
к выполнению процедуры Дальше.
Это сделано для того, чтобы сосчитать все кубики кроме первого.
     В процедуре Дальше Кукарача сдвигает кубики на строку вниз,
пока не находит пустую клетку, одновременно считая их.
Сосчитав кубики, исполнитель выполняет отложенную
процедуру Сдвиг сосчитанное количество раз.
     В процедуре Сдвиг таракан сдвигает все кубики
на одну строку вниз.

программа
- - - - -
ЭТО Начало
 ПОВТОРИ 2 { ВВЕРХ ВПРАВО ВНИЗ }
 ЕСЛИ НЕ ПУСТО ТО Дальше               
КОНЕЦ

ЭТО Дальше
 ВВЕРХ ВПРАВО ВНИЗ                     
 ЕСЛИ НЕ ПУСТО                         
  ТО Дальше
  ИНАЧЕ ВЛЕВО
 Сдвиг
КОНЕЦ                                  
                                       
ЭТО Сдвиг
 ВНИЗ
 ЕСЛИ НЕ ПУСТО
 ТО
 {
  ВВЕРХ ВЛЕВО
  Сдвиг
  ВПРАВО
 }                                     
КОНЕЦ                                  

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

Очень хорошее решение.


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

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

ЭТО СДВИГ
 ВВЕРХ ВПРАВО ВНИЗ                     
 СЧЕТ
КОНЕЦ

ЭТО СЧЕТ                               
 // Поиск конца ряда                   
 ВВЕРХ ВПРАВО ВНИЗ                     
 ЕСЛИ * ТО СЧЕТ
  ИНАЧЕ                                
        {                              
        ВНИЗ                           
        ИСХОДНОЕ_ПОЛОЖЕНИЕ_РЯДА
         }                             
 // Отложенные команды будут выполнены
 // столько раз, сколько команды
 // ВВЕРХ, ВПРАВО, ВНИЗ                
 ВВЕРХ
 СДВИГ_РЯДА                            
КОНЕЦ

ЭТО ИСХОДНОЕ_ПОЛОЖЕНИЕ_РЯДА            
 // Устанавливается исходное положение
 // ряда звездочек                     
 ВНИЗ ВЛЕВО ВВЕРХ
 ЕСЛИ * ТО ИСХОДНОЕ_ПОЛОЖЕНИЕ_РЯДА
КОНЕЦ
                                       
ЭТО СДВИГ_РЯДА
 // Сдвигается ряд звездочек           
 // параллельно вниз на на одну клетку
 ВВЕРХ ВПРАВО ВНИЗ                     
 ЕСЛИ * ТО СДВИГ_РЯДА
  ИНАЧЕ ПОВТОРИ 2 ВНИЗ                 
 ВЛЕВО                                 
КОНЕЦ

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

1) Нет описания алгоритма

2) Программа работает правильно, но нельзя сказать,
что оптимально.

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

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


программа
- - - - -
ЭТО ОДИН
ПРОВЕРКА
ПРОВЕРКА                               
ЕСЛИ НЕ ПУСТО ТО СДВИГ                 
КОНЕЦ
                                       
ЭТО СДВИГ                              
ПРОВЕРКА                           
ЕСЛИ НЕ ПУСТО ТО СДВИГ
ВНИЗ                               
ПОЛОСА                                 
КОНЕЦ

ЭТО ПОЛОСА
СДВИГ-                                 
КОНЕЦ
                                       
ЭТО СДВИГ-                             
ПРОВЕРКА-
ЕСЛИ НЕ ПУСТО ТО СДВИГ-                
ВПРАВО
КОНЕЦ                                  

ЭТО ПРОВЕРКА
ВВЕРХ                                  
ВПРАВО                                 
ВНИЗ
КОНЕЦ                                  
                                       
ЭТО ПРОВЕРКА-                          
ВВЕРХ
ВЛЕВО                                  
ВНИЗ
КОНЕЦ

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

1) Нет описания алгоритма.
2) Программа не структурирована по записи.

3) Программа оптимальна в целом, но можно ее еще улучшить, убрав
лишние движения на правом конце записи (см.решение команды 3101).

Команда 3106
------------
Оценка: 6
.\06\06.txt

описание  алгоритма
- - - - - - - - - -
1.Пока не дойдем до пусто сжимаем рекурсивную пружину На_один_ряд_вниз

2.Когда пружина расжимается мы на каждом шаге расжимания толкаем
строчку на один ряд вниз и сжимаем еще одну пружину (для возврата
Кукарачи обратно).

3.Коррекция нам нужна, так как первое смещение не учитывается
(Кукарача "считает", а не сдвигает).


ЭТО Прога
  Лестница
  На_один_ряд_вверх   //КОРРЕКЦИЯ      
КОНЕЦ

ЭТО Лестница
 Шаг
 ЕСЛИ НЕ ПУСТО                         
  ТО  {                                
       Лестница                        
       На_один_ряд_вниз
       ВНИЗ                            
      }                                
  ИНАЧЕ ВНИЗ                           
КОНЕЦ                                  
                                       
ЭТО Шаг                                
 ВВЕРХ                                 
 ВПРАВО                                
 ВНИЗ                                  
КОНЕЦ                                  

ЭТО На_один_ряд_вниз                   
 Шаг_назад
 ЕСЛИ НЕ ПУСТО                         
  ТО    На_один_ряд_вниз               
 ВПРАВО  //ВСТАТЬ НА МЕСТО             
КОНЕЦ

ЭТО Шаг_назад                          
 ВВЕРХ                                 
 ВЛЕВО
 ВНИЗ
КОНЕЦ
                                       
ЭТО На_один_ряд_вверх                  
 Шаг_снизу                             
 ПОКА НЕ ПУСТО Шаг_снизу               
 ВВЕРХ                                 
КОНЕЦ                                  
                                       
ЭТО Шаг_снизу                          
 ВНИЗ ВЛЕВО ВВЕРХ                      
КОНЕЦ

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

Ваше решение, как и решение куратора, оказалось недогадливое!


Команда 3107
------------
Оценка: 2
.\07\07.txt
Автор решения: Смирнова Лена

программа
- - - - -
     ЭТО работа
     ВВЕРХ ВПРАВО ВНИЗ
     ЕСЛИ ¤ ТО звезда1
     ИНАЧЕ СТОЯТЬ
     ВВЕРХ ВПРАВО ВНИЗ
     ЕСЛИ ¤ ТО звезда2
     ИНАЧЕ СТОЯТЬ
     ВВЕРХ ВВЕРХ ВПРАВО ВПРАВО ВНИЗ
     ЕСЛИ ¤ ТО звезда3
     ИНАЧЕ СТОЯТЬ
     КОНЕЦ

     ЭТО звезда1
     СТОЯТЬ
     КОНЕЦ

     ЭТО звезда2
     ВНИЗ ВВЕРХ ВЛЕВО ВНИЗ
     КОНЕЦ

     ЭТО звезда3
     ВНИЗ ВНИЗ ВВЕРХ ВЛЕВО ВНИЗ ВВЕРХ ВЛЕВО ВНИЗ
     КОНЕЦ

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

1) Нет описания алгоритма.
2) Программа обрабатывает только частные случаи.


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

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

Команда 3110
------------
Оценка: 6
.\10\10.txt
.\10\109b1.coc
Автор: Орешин Олег

описание автора
- - - - - - - -
Решение интересно тем что одна пружина находится в другой.
Недостаток: пружина закручивается на 1 больше, чем надо,
поэтому приходится делать "разбег", а это лишние движения
исполнителя. Было бы больше времени можно эту программу
доработать.
Тесты проходят.

программа
- - - - -
ЭТО СМЕЩ
  ВВЕРХ
  ВПРАВО                               
  ПР1                                  
КОНЕЦ                                  
ЭТО ПР1                                
  ВНИЗ                                 
  ЕСЛИ * ТО                            
         {
          ВВЕРХ                        
          ВПРАВО                       
          ПР1                          
         }                             
     ИНАЧЕ ОБР                         
ВДОЛЬ                                  
КОНЕЦ
ЭТО ВДОЛЬ
  ВЛЕВО                                
  ВНИЗ                                 
  ЕСЛИ * ТО
         {                             
          ВВЕРХ
          ВДОЛЬ                        
         }
  ВПРАВО                               
КОНЕЦ                                  
ЭТО ОБР                                
  ПОВТОРИ 2 ВНИЗ                       
  ВЛЕВО                                
  ПОВТОРИ 2 ВВЕРХ                      
  ЕСЛИ * ТО ОБР
    ИНАЧЕ ПОВТОРИ 2 ВВЕРХ              
  ВПРАВО                               
КОНЕЦ                                  

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

Не оптимальное решение. Олег, посмотри решение команды 3101. Там
"разбега" нет!

Команда 3111
------------
Оценка: 6
.\11\11.txt
Автор:  Килеев Слава

описание  алгоритма
- - - - - - - - - -
1.Считает символы, и откладывает процедуру смещения строки на один
ряд.

2.Закончилась строка и работает отложенная процедура.

3.Поднимает эту строку на клетку вверх для коррекции положения.

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

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

ЭТО Строка                             
 Символ                                
 ЕСЛИ НЕ ПУСТО                         
  ТО    Строка                         
 ВПРАВО  //Отложенная команда, ставит  
         // исполнителя в конец строки 
КОНЕЦ // Строка                        
//-------------------------------------
// Толкнуть предыдущий символ вниз     
ЭТО Символ
 ВВЕРХ                                 
 ВЛЕВО                                 
 ВНИЗ                                  
КОНЕЦ // Символ
//-------------------------------------
// Поднимает строку на ряд вверх.      
                                       
ЭТО Корекция                           
 Подъем        // Поднимает один символ
 ЕСЛИ НЕ ПУСТО                         
  ТО    Корекция
  ВПРАВО        // Отложенная команда.
КОНЕЦ // Корекция                      
//-------------------------------------
// Поднимает предыдущий символ         
ЭТО Подъем                             
 ВНИЗ                                  
 ВЛЕВО                                 
 ВВЕРХ                                 
КОНЕЦ // Подъем                        

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

Слава, нам надо с тобой поучиться у команды 3101 писать оптимальные
программы!

Команда 3112
------------
Оценка: 7
.\12\12.txt
Автор Громков Сергей задача 12b1

//-------------------------------------
// УСТанавливает КУКАРАЧУ снизу под
// первый кубик "*", выполняет
// проверку. После каждой проверки
// заносит в рекурсивную пружину
// "СПУСК"
ЭТО УСТ               <──────────────────────┐
 ВВЕРХ ВПРАВО                                │
 ПРОВЕРКА             ──────────────────┐    │
 ВЛЕВО                                  │    │
 СПУСК                ──────────────────┼──┐ │
КОНЕЦ // Имя                            │  │ │
//------------------------------------- │  │ │
// КУКАРАЧА двигает кубик вверх, если   │  │ │
// пустой то выполняет { ВВЕРХ ВВЕРХ }  │  │ │
ЭТО ПРОВЕРКА           <────────────────┘  │ │
 ВНИЗ                                      │ │
 ЕСЛИ * ТО УСТ     ────────────────────────┼─┘
 ИНАЧЕ                                     │
  {                                        │
 ВВЕРХ ВВЕРХ                               │
  }                                        │
КОНЕЦ // Имя                               │
//-------------------------------------    │
// Опускает строчку из "*" вниз на         │
// одну строку                             │
ЭТО СПУСК                <─────────────────┘
 ВНИЗ
 ЕСЛИ *
  ТО    СПУСК1           ─────────────────┐
  ВПРАВО                                  │
КОНЕЦ // Имя                              │
//-------------------------------------   │
// описание                               │
ЭТО СПУСК1               <────────────────┘
 ВВЕРХ ВЛЕВО СПУСК
КОНЕЦ // Имя

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

Кубики не перемещаются на поле лишний раз. Это достигается лишними
движениями на поле самого исполнителя под воздействием хитросплетений
косвенных рекурсий и отложенных команд.

Решение хитрое, но его слабое место именно в хитрости (по сравнению с
изящной находкой команд 3101 и 3105) и кроме того, решение все равно
не оптимальное.

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