Задача 2 (3 балла)
--------
Первый член последовательности равен 1. Каждый следующий член
получается приписыванием справа 0, если последний символ записи
предыдущего члена равен 1, или приписыванием справа 1 в противном
случае.

a  = 1
 1
a  = 10
 2
a  = 101
 3
...

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

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

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

п р о в е р к а  к у р а т о р а

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

Автор: Бельков Игорь

Решение.
Идея та же. Номер члена последовательности используется в качестве
счетчика цикла. Перед тем, как приписать цифру, анализируется 
последняя в записи.

ЭТО вход                               
зпчсл //запись_числа
оформление                             
КОНЕЦ
//-------------------------------------

// Вход:окно на номере члена           
//последовательности                   
// Выход: окно на номере члена         
//последовательности                   
// На ленте - запись n-го члена данной 
//последовательности                   
                                       
ЭТО зпчсл                              
ПОКА НЕ 0
  {                                    
на_конец_записи                        
//После записи цифры уменьшаем
//номер члена последовательности
// на 1                                
МИНУС
  }
КОНЕЦ                                  
//-------------------------------------
// Рекурсивная процедура для
//определения конца записи, анализа
//последнй цифры в записи и возврата на
//номер члена последовательности
                                       
ЭТО на_конец_записи                    
ВПРАВО                                 
ЕСЛИ НЕ ПУСТО                          
  ТО    на_конец_записи                
  ИНАЧЕ                                
  {                                    
   ВЛЕВО                               
     ЕСЛИ 1
      ТО                               
        {                              
         ВПРАВО
         ПИШИ 0
         }                             
      ИНАЧЕ
        {
         ВПРАВО                        
         ПИШИ 1
        }
  }
ВЛЕВО // отложенная команда для        
      //возврата на номер члена
      // последовательности            
КОНЕЦ                                  
//-------------------------------------
// Процедура устанавливает окно после  
//записи числа                         
                                       
ЭТО оформление                         
ПИШИ ПУСТО                             
ВПРАВО
ПОКА НЕ ПУСТО ВПРАВО                   
КОНЕЦ                                  

к о м м е н т а р и й  к у р а т о р а
При n=1 программа выдает ответ "0", что неверно.
Алгоритм так же как и у задачи 1 нерациональный, так как Корректору
приходится для построения каждого нового знака возвращаться к началу
записи.

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

Автор: Романюк Артем
Алгоритм
--------
Идея решения: Фиксируем номер нужного элемента в ЯЩИКе, а на его
месте на ленте пишем 1 или 0 в зависимости от цифры, написанной
слева.Если в ЯЩИКе останется 0, то в клетке на ленте пишем ПУСТО.

Программа
---------
ЭТО Старт
ПОКА НЕ ПУСТО
{
ЯЩИК+
ВЛЕВО //Проверка символа слева
ЕСЛИ 1 ТО
    {
     ВПРАВО
     ПИШИ 0   //если слева 1,
          }   //то пишем 0
       ИНАЧЕ
    {
     ВПРАВО   //если 0-то 1
     ПИШИ 1
           }
Ход
}
КОНЕЦ

//------------------------------
//Проверка содержимого ящика
//Если там не 0, то вычитаем 1
//В противном случае очищаем
//ячейку и заканчиваем выполнение
//программы.


ЭТО Ход
  ВПРАВО
  ЯЩИК-
  ЕСЛИ НЕ 1 ТО МИНУС ИНАЧЕ ПИШИ ПУСТО
  Старт
КОНЕЦ

к о м м е н т а р и й  к у р а т о р а
Правильное решение. Можно немного сократить движение окна, если
устроить "качели" и не проверять последний знак текущей записи
(смотрите решение куратора).

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

// Авторы решения: Якубович К.
// и Ларкин Д.
//                                     
ЭТО вход                               
 МИНУС     // уменьшаем счетчик на 1   
 ВПРАВО    // вставляем пробел после   
 ПИШИ ПРОБЕЛ    // счетчика
 ВПРАВО
 ПИШИ 1         // записываем первую   
          // цифру последовательности  
 ПОВТОРИ 2 ВЛЕВО      // переходим на  
                      //счетчик        
 ПОКА НЕ 0                             
   {                                   
   МИНУС     // вычитаем единицу из    
             // счетчика
   ПОКА НЕ ПУСТО ВПРАВО  //встаем на   
         // пустую клетку после цифры  
   ВЛЕВО // встаем на последнюю цифру  
   ЕСЛИ 1 ТО    //                     
       {        // если последняя      
     ВПРАВО     // цифра 0, то         
     ПИШИ 0     // следующая 0
       }
   ИНАЧЕ                               
       {         // если последняя     
     ВПРАВО      // цифра 1, то        
     ПИШИ 1      // следующая 0        
       }
  ПОКА НЕ ПУСТО // перемещаем окно
   ВЛЕВО        // перед счетчиком     
  ВПРАВО      // встали на счетчике    
   }             // конец ПОКА НЕ 0    
//   Уборка территории.                
//  Стираем счетчик и пробел с ленты   
//                                     
  ПИШИ ПУСТО  // ститраем счетчик      
  ВПРАВО
  ПИШИ ПУСТО  //стираем пробел         
КОНЕЦ                                  

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

Команда 3108
------------
.\08\08.txt
Оценка: 1.5
Авторы: Каменев Артем, Кичемасов Миша

Описание алгоритма: имеется счетчик циклов. В каждом цикле проверяется
последняя цифра числа, следом записывается ее инвертированное значение.
Счетчик уменьшается на единицу и проверяется на 1.

Описание программы:
В качестве счетчика используется ячейка, содержащая значение n,
находящаяся перед первой цифрой числа. Перед началом работы
ее значение сравнивают с 1. Если в ней 1, работа заканчивается.
Содержимое ячейки-счетчика стирается. Если в ней не 1, то
начинается работа.  Окно перемещается вправо и
анализируется последняя цифра числа. Если она 1, то в следующей ячейке
будет записан 0, а если последняя цифра 0, следующей будет записана 1.
Окно перемещается к началу строки, от числа на ленте отнимается 1,
содержимое ячейки сравнивается с 1. Если не 1, осуществляется рекурсивный
вызов процедуры.


ЭТО Цеп_2
ЕСЛИ НЕ 1 //счетчик циклов остается на ленте,
//в первой позиции числа
ТО
{
ПОКА НЕ ПУСТО ВПРАВО
ВЛЕВО
ЕСЛИ 1 ТО //анализ последней цифры числа
{
ВПРАВО
ПИШИ 0
}
ИНАЧЕ
{
ВПРАВО
ПИШИ 1
}
ПОКА НЕ ПУСТО ВЛЕВО //к ячейке-счетчику
ВПРАВО
МИНУС               //уменьшить содержимое счетчика
Цеп_2               //рекурсивный вызов процедуры
}
ИНАЧЕ ПИШИ ПУСТО    //стереть ячейку-счетчик
КОНЕЦ

к о м м е н т а р и й  к у р а т о р а
Нерациональное решение. Исполнитель, прежде чем поставить новый знак,
бегает на другой конец записи к счетчику.
К тому же решение неверное. Оно для
n=1 дает пусто (нужно "1")
n=2 строит "1"(нужно "10")
n=3 строит "10"(нужно "101")
....

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

Команда 3113
------------
.\13\13.txt
.\13\1321.kor
Оценка: 0

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

// Задача решена с применением косвен-
// ной рекурсии. Главная процедура     
// "вход".
                                       
ЭТО ставим_символ                      
ЕСЛИ НЕ ПУСТО ТО
                { ЯЩИК+                
// скопировать содержимое оконной      
// ячейки ленты в ящик
                  ПИШИ 1 }
// записать в оконную ячейку ленты     
// символ из алфавита                  
ВПРАВО  // переход в следующую ячейку  
        // ленты
ЯЩИК-   // скопировать в оконную       
        // ячейку ленты символ из      
        // ящика
МИНУС   // заменить символ в оконной   
        // ячейке на предыдущий в
        // смысле алфавита исполнителя 
ЕСЛИ НЕ ПУСТО ТО // проверка наличия   
                 // символа в ячейке   
                 // ленты              
                { ЯЩИК+                
// скопировать содержимое оконной
// ячейки ленты в ящик
                  ПИШИ 0 }             
// записать в оконную ячейку ленты
// символ из алфавита                  
ВПРАВО  // переход в следующую ячейку  
        // ленты
ЯЩИК-   // скопировать в оконную ячей-
        // ку ленты сивол из ящика     
МИНУС   // заменить символ в оконной
        // ячейке на предидущий в      
        // смысле алфавита исполнителя
вход                                   
КОНЕЦ
ЭТО вход
ЕСЛИ НЕ ПУСТО ТО // проверка наличия   
                 // символа в ячейке
                 // ленты
ставим_символ                          
КОНЕЦ

к о м м е н т а р и й  к у р а т о р а
Ребята пытались соорудить "качели", описанные куратором, они почти
получились, но, к сожалению, программа работает неверно при любом n:

при n=1 дает "10" (нужно "1")
при n=2 дает "101" (нужно "10")
при n=3 дает "1010" (нужно "101")
...

"Качели" не получились потому, что сделаны на уровне одной процедуры
(смотрите  решение куратора).

Команда 3115
------------
.\15\15.txt
.\15\1511.kor

Оценка: 3
Решение 1521.
Автор: Казанцев Лев
Описание алгоритма: Исполнитель уменьшает до нуля число на ленте,
рекурсивно запуская процедуру Вход. Последовательность нулей и единиц
появляется благодаря отложенной процедуре Цифры.

Программа 

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

Оценка: 2.8
Решение 1522.
Задачу решал: Филиппов Василий.
Описание алгоритма:
Сначала мы проверяем цифру на ленте. Если эта цифра не 1, то
мы начинаем выполнять задачу.      
Запоминая в ящике число, стоящее на ленте, мы на его место пишем 1,
а затем идем вправо. После этого выкладываем число из ящика.
Затем пока в ящике у нас не останется 1, мы выполняем
программу "Работа". При этом мы ходим влево и смотрим, если
у нас получилась 1, то мы ходим вправо и пишем 0, иначе мы
ходим вправо и пишем 1.

Программа

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

к о м м е н т а р и й  к у р а т о р а
Рекусивное решение как всегда -- термоядерное!
Во втором решении можно немного сократить движение окна, если
устроить "качели" и не проверять последний знак текущей записи
(смотрите решение куратора).
