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

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

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

  ┼─┼─┼─┼─┼─┼─┼─┼─┼─┼   ┼─┼─┼─┼─┼─┼─┼─┼─┼─┼   ┼─┼─┼─┼─┼─┼─┼─┼─┼─┼
  │ │ │ │ │ │ │ │ │ │   │ │ │ │ │ │ │ │ │ │   │ │ │ │ │ │ │ │ │ │
  ┼─┼─┼─┼─┼─┼─┼─┼─┼─┼   ┼─┼─┼─┼─┼─┼─┼─┼─┼─┼   ┼─┼─┼─┼─┼─┼─┼─┼─┼─┼
  │ │ │ │ │ │ │ │ │ │   │ │ │ │ │ │ │ │ │ │   │ │ │ │ │ │ │ │ │ │
  ┼─┼─┼─┼─┼─┼─┼─┼─┼─┼   ┼─┼─┼─┼─┼─┼─┼─┼─┼─┼   ┼─┼─┼─┼─┼─┼─┼─┼─┼─┼
  │ │ │ │ │ │ │ │ │ │   │ │ │ │ │ │ │ │ │ │   │ │ │ │ │ │ │ │ │ │
  ┼─┼─┼─┼─┼─┼─┼─┼─┼─┼   ┼─┼─┼─┼─┼─┼─┼─┼─┼─┼   ┼─┼─┼─┼─┼─┼─┼─┼─┼─┼
  │ │ │ │ │ │ │ │ │ │   │ │ │ │ │ │ │ │ │ │   │ │ │ │ │ │ │ │ │ │
  ┼─┼─┼─┼─┼─┼─┼─┼─┼─┼   ┼─┼─┼─┼─┼─┼─┼─┼─┼─┼   ┼─┼─┼─┼─┼─┼─┼─┼─┼─┼
  │ │¤│*│ │ │ │ │ │ │   │ │¤│*│*│ │ │ │ │ │   │ │¤│*│*│*│ │ │ │ │
  ┼─┼─┼─┼─┼─┼─┼─┼─┼─┼   ┼─┼─┼─┼─┼─┼─┼─┼─┼─┼   ┼─┼─┼─┼─┼─┼─┼─┼─┼─┼

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

  ┼─┼─┼─┼─┼─┼─┼─┼─┼─┼   ┼─┼─┼─┼─┼─┼─┼─┼─┼─┼   ┼─┼─┼─┼─┼─┼─┼─┼─┼─┼
  │ │ │ │ │ │ │ │ │ │   │ │ │ │ │ │ │ │ │ │   │ │ │ │ │ │¤│ │ │ │
  ┼─┼─┼─┼─┼─┼─┼─┼─┼─┼   ┼─┼─┼─┼─┼─┼─┼─┼─┼─┼   ┼─┼─┼─┼─┼─┼─┼─┼─┼─┼
  │ │ │ │ │ │ │ │ │ │   │ │ │ │ │ │ │ │ │ │   │ │ │ │ │ │ │ │ │ │
  ┼─┼─┼─┼─┼─┼─┼─┼─┼─┼   ┼─┼─┼─┼─┼─┼─┼─┼─┼─┼   ┼─┼─┼─┼─┼─┼─┼─┼─┼─┼
  │ │ │ │ │ │ │ │ │ │   │ │ │ │ │ │ │ │ │ │   │ │ │ │ │ │ │ │ │ │
  ┼─┼─┼─┼─┼─┼─┼─┼─┼─┼   ┼─┼─┼─┼─┼─┼─┼─┼─┼─┼   ┼─┼─┼─┼─┼─┼─┼─┼─┼─┼
  │ │ │ │ │ │ │ │ │ │   │ │ │ │ │¤│ │ │ │ │   │ │ │ │ │*│ │ │ │ │
  ┼─┼─┼─┼─┼─┼─┼─┼─┼─┼   ┼─┼─┼─┼─┼─┼─┼─┼─┼─┼   ┼─┼─┼─┼─┼─┼─┼─┼─┼─┼
  │ │ │ │ │ │ │ │ │ │   │ │ │ │ │ │ │ │ │ │   │ │ │ │ │ │ │ │ │ │
  ┼─┼─┼─┼─┼─┼─┼─┼─┼─┼   ┼─┼─┼─┼─┼─┼─┼─┼─┼─┼   ┼─┼─┼─┼─┼─┼─┼─┼─┼─┼
  │ │ │ │¤│ │ │ │ │ │   │ │ │ │*│ │ │ │ │ │   │ │ │ │*│ │ │ │ │ │
  ┼─┼─┼─┼─┼─┼─┼─┼─┼─┼   ┼─┼─┼─┼─┼─┼─┼─┼─┼─┼   ┼─┼─┼─┼─┼─┼─┼─┼─┼─┼
  │ │ │ │ │ │ │ │ │ │   │ │ │ │ │ │ │ │ │ │   │ │ │ │ │ │ │ │ │ │
  ┼─┼─┼─┼─┼─┼─┼─┼─┼─┼   ┼─┼─┼─┼─┼─┼─┼─┼─┼─┼   ┼─┼─┼─┼─┼─┼─┼─┼─┼─┼
  │ │ │*│ │ │ │ │ │ │   │ │ │*│ │ │ │ │ │ │   │ │ │*│ │ │ │ │ │ │
  ┼─┼─┼─┼─┼─┼─┼─┼─┼─┼   ┼─┼─┼─┼─┼─┼─┼─┼─┼─┼   ┼─┼─┼─┼─┼─┼─┼─┼─┼─┼
  │ │ │ │ │ │ │ │ │ │   │ │ │ │ │ │ │ │ │ │   │ │ │ │ │ │ │ │ │ │
  ┼─┼─┼─┼─┼─┼─┼─┼─┼─┼   ┼─┼─┼─┼─┼─┼─┼─┼─┼─┼   ┼─┼─┼─┼─┼─┼─┼─┼─┼─┼

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

Сознаюсь, что решение, которое написано ниже, стало мне очевидно
только после запуска программы Кудрявцева Артёма (команда 3101).

Я написал эти коды, потом сравнил их с кодами Артема -- получилось
почти один в один.

Меня, как и многих других ребят, подвел стереотип рекурсивных пружин.
Мы забыли про старый добрый цикл ПОКА. Или терминальную рекурсию без
всяких пружин. Цикл ПОКА, конечно, предпочтительнее.

Нетерминальная рекурсия в программе, правда, есть, но не ключевая --
обычная пружинка для возврата исполнителя в исходное положение перед
новым оборотом цикла ПОКА.

Мое прежнее, чисто пружинное решение, показалось мне совершенно
ужасным!

Что касается, следующей задачи d, то по моему пружинному алгоритму,
она оказалось более сложной, в то время как с циклом ПОКА (или
анологичной циклу ПОКА рекурсией) решение получается даже проще по
записи, а по алгоритму абсолютно ничем не отличается.

Отличился в решении этой задачи не только Артем. Решение с циклом ПОКА
предложила и команда 3106 и Кисилев Слава из команды 3111.

Как хорошо, что подростает талантливая смена и уже есть у кого
поучиться!


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

Алгоритм очень прост: перемещаем ряд за рядом кубики, сдвигаясь на
один столбец вправо перед каждым новым сдвигом.

Здесь более важна аккуратная техника записи кода. Не забыть толкнуть
кубик перед вход в цикл ПОКА и перед новым оборотом цикла:


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


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

Приведенное выше решение можно переписать, заменив цикл ПОКА на
терминальную рекурсию, но цикл ПОКА, конечно, предпочтительнее:

ЭТО вход
 ВНИЗ ВПРАВО ВПРАВО
 ВВЕРХ ВВЕРХ
 ряды
 ВВЕРХ
КОНЕЦ

ЭТО ряды
 вверх
 ВВЕРХ ВВЕРХ
 ЕСЛИ НЕ ПУСТО ТО ряды
КОНЕЦ

ЭТО вверх
 ЕСЛИ НЕ ПУСТО
   ТО
   {
     ВНИЗ ВНИЗ ВПРАВО
     ВВЕРХ ВВЕРХ
     вверх
     ВЛЕВО
   }
   ИНАЧЕ ВПРАВО
КОНЕЦ


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

описание  алгоритма
- - - - - - - - - -
                         Процедура Лесенка
Сначала исполнитель проверяет, есть ли второй кубик.
Если есть, то Кукарача исполняет процедуру Ряд_вверх
до тех пор, пока не кончатся кубики.
Когда кончатся кубики (или когда второго кубика нет),
Кукарача становится на место еще одной ступеньки.

                       Процедура Ряд_вверх
В процедуре Ряд_вверх Кукарача сдвигает оставшиеся справа кубики
на две строки вверх и с помощью рекурсии возвращается в начало ряда.

программа

ЭТО Лесенка
  ВНИЗ
  ПОВТОРИ 2 ВПРАВО                     
  ПОВТОРИ 2 ВВЕРХ
  ПОКА НЕ ПУСТО
  { Ряд_вверх
    ПОВТОРИ 2 ВВЕРХ
  }                                    
  ВВЕРХ
КОНЕЦ // Лесенка
//-------------------------------------
ЭТО Ряд_вверх
  ПОВТОРИ 2 ВНИЗ                       
  ВПРАВО
  ПОВТОРИ 2 ВВЕРХ                      
  ЕСЛИ НЕ ПУСТО                        
   ТО { Ряд_вверх                      
        ВЛЕВО
      }
КОНЕЦ // Ряд_вверх                     

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

Просто отлично! Красиво, элегантно! Лучше не бывает!


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

программа
- - - - -
ЭТО ЛЕСЕНКА
 ПОВТОРИ 2                             
          {                            
          ВВЕРХ ВПРАВО ВНИЗ            
          }
 ЕСЛИ * ТО СЧЕТ
 // Установка последней ступеньки.     
 // Исполнитель на место               
 // дополнительной ступеньки           
 ВВЕРХ ВЛЕВО                           
 ПОВТОРИ 5 ВНИЗ
 ВПРАВО
 ВВЕРХ
КОНЕЦ
                                       
ЭТО СЧЕТ
 // Подсчет количества * минус одна    
 ВВЕРХ ВПРАВО ВНИЗ
 ЕСЛИ * ТО СЧЕТ
  ИНАЧЕ ВНИЗ                           
 УСТАНОВКА_СТУПЕНЕК                    
КОНЕЦ                                  

ЭТО УСТАНОВКА_ОДНОЙ_СТУПЕНЬКИ          
 // Передвижение к крайней левой *     
 // ряда                               
 ВВЕРХ ВЛЕВО ВНИЗ
 ЕСЛИ * ТО УСТАНОВКА_ОДНОЙ_СТУПЕНЬКИ
  // Установка исполнителя             
  // над крайней левой *               
  ИНАЧЕ ВПРАВО                         
 // Отложенная команда будет выполнена 
 // столько раз, сколько команды
 // ВВЕРХ, ВЛЕВО, ВНИЗ (сколько *
 // в ряде)
 ПОВТОРИ 2 ВНИЗ
КОНЕЦ                                  

ЭТО УСТАНОВКА_СТУПЕНЕК                 
 УСТАНОВКА_ОДНОЙ_СТУПЕНЬКИ
 // Установка исполнителя под
 // крайней левой * ряда               
 ВПРАВО ВВЕРХ                          
 ПОКА ПУСТО ВВЕРХ
 РЯД_НА_МЕСТО
 ВВЕРХ
КОНЕЦ                                  
                                       
ЭТО РЯД_НА_МЕСТО
 ВНИЗ ВПРАВО ВВЕРХ
 ЕСЛИ * ТО РЯД_НА_МЕСТО                
КОНЕЦ                                  

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

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

2) Программа работает правильно и, если бы не решение команды 3101, ее
можно было бы оценить гораздо выше.

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

Команда 3105
------------
Оценка: 6
.\05\05.txt
Автор: Галушко Марина

описание  алгоритма
- - - - - - - - - -
     Считаем количество символов. Двигаем второй по счету вверх,
потом опять считаем количество оставшихся символов. Алгоритм повторяем
сначала.

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

ЭТО ОДИН
ПОВТОРИ 2 СИМВОЛ                       
ЕСЛИ НЕ ПУСТО ТО ПРОВЕРКА              
ПОВТОРИ 3 ВВЕРХ
КОНЕЦ                                  

ЭТО ПРОВЕРКА                          
СИМВОЛ                                 
ЕСЛИ НЕ ПУСТО ТО ПРОВЕРКА              
ВВЕРХ                                  
ВВЕРХ                                  
СТУПЕНЬ
КОНЕЦ
                                       
ЭТО СТУПЕНЬ                            
ВНИЗ                                   
ВНИЗ                                   
ВЛЕВО
ВВЕРХ
ВВЕРХ
ЕСЛИ НЕ ПУСТО ТО СТУПЕНЬ               
ИНАЧЕ                                  
     {
      ВВЕРХ                            
      ВВЕРХ                            
      ВПРАВО
      ВНИЗ                             
      ВНИЗ                             
      ВЛЕВО                            
     }                                 
ВПРАВО                                 
КОНЕЦ                                  
                                       
ЭТО СИМВОЛ
ВНИЗ
ВПРАВО                                 
ВВЕРХ
КОНЕЦ

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

Алгоритм описан не слишком понятно, но решение не так уж и плохо!

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

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

алгоритм  решения
- - - - - - - - -
1. Поднять первый символ текущего ряда на 1 клетку вверх.

2. Оставшийся (не пустой) ряд поднять на 2 клетки вверх и вернуться
под первый символ этого ряда и поставить его на ступеньку в 2 шага.

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

4. Поставить Кукарачу на последнюю ступеньку.

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

ЭТО Работа
 Маленький_Шаг
 ПОКА НЕ ПУСТО { Поднять_ряд ВВЕРХ }
 ВВЕРХ
КОНЕЦ

ЭТО Поднять_ряд
 Шаг_вперед        //Поднять на 2 шага вверх
 ЕСЛИ НЕ ПУСТО                         
  ТО  {
       ВНИЗ        //Опуститься к следующему символу
       Поднять_ряд
       ВЛЕВО       //Вернуться к первому символу вышестоящей строки
      }                                
КОНЕЦ                                  

ЭТО Шаг_вперед                         
 ВНИЗ                                  
 ВПРАВО
 ПОВТОРИ 2 ВВЕРХ                       
КОНЕЦ                                  
                                       
ЭТО Маленький_Шаг
 ВНИЗ                                  
 ВПРАВО
 ВВЕРХ                                 
КОНЕЦ                                  
                                       
комментарий  куратора
- - - - - - - - - - -

  Отличное, оптимальное решение.

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

     Автор решения Марченко Юля
     Программа 1 вариант

     ЭТО ступень
     ВНИЗ
     ПОВТОРИ 3 ВПРАВО
     ВВЕРХ
     ЕСЛИ ПУСТО ТО ступ1
     ИНАЧЕ ступ2
     КОНЕЦ

     ЭТО ступ1
     ВНИЗ
     ВЛЕВО
     ВВЕРХ
     ЕСЛИ ПУСТО ТО ПОВТОРИ 2 ВВЕРХ
     ИНАЧЕ ступ3
     КОНЕЦ

     ЭТО ступ3
     ВВЕРХ
     ВНИЗ
     ВПРАВО
     ПОВТОРИ 4 ВВЕРХ
     КОНЕЦ

     ЭТО ступ2
     ПОВТОРИ 3 ВВЕРХ
     ПОВТОРИ 4 ВНИЗ
     ступ1
     ПОВТОРИ 2 ВПРАВО
     ПОВТОРИ 5 ВВЕРХ
     КОНЕЦ

     Авторы решения - Васильева Таня, Близнюк Юля
     Программа 2 вариант

     ЭТО лесенка
     ВНИЗ
     ВПРАВО
     л1
     КОНЕЦ

     ЭТО л1
     ВПРАВО
     ВВЕРХ
     ЕСЛИ ПУСТО ТО ПОВТОРИ 2 ВВЕРХ
     ИНАЧЕ р
     КОНЕЦ

     ЭТО р
     ВВЕРХ
     ВПРАВО
     ВНИЗ
     ЕСЛИ ПУСТО ТО ПОВТОРИ 4 ВВЕРХ
     ИНАЧЕ л2
     КОНЕЦ

     ЭТО л2
     ВЛЕВО
     ПОВТОРИ 2 ВНИЗ
     ВПРАВО
     ПОВТОРИ 5 ВВЕРХ
     ВПРАВО
     ПОВТОРИ 3 ВВЕРХ
     КОНЕЦ

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

  Программы обслуживают частные начальные состояния среды.

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

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

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

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

описание  алгоритма
- - - - - - - - - -
1.Встать под вторым символом.

2.Поднять 1 ряд символов, и встать под следующий символ ряда

3.Поднять так 2-ой, 3-й и следующие ряды, пока не станет пусто при
помощи рекурсивного алгоритма "Ступень".

3.Встать на две клетки выше.


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

комментарий  куратора
- - - - - - - - - - -
Отличное решение, которое можно сделать немного пооптимальнее.

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

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

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

Хотя в этой программе и использован цикл ПОКА, но решение по
траектории движения исполнителя почти такое же, как было у куратора,
то есть не оптимальное.

Но тем не менее, программа работает! А для программ это качество очень
важное! Так, что Оля все отлично для первого раза!

