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

a  = 10
 1
a  = 1001
 2
a  = 100110
 3
...

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

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

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


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

Команда 3104
------------
.\04\04.txt
Оценка: 2
Автор: Бельков Игорь

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

ЭТО Инверсия_1                         
ВПРАВО                                 
ПИШИ 0                                 
КОНЕЦ                                  
//-------------------------------------
                                       
ЭТО Инверсия_0                         
ВПРАВО                                 
ПИШИ 1                                 
КОНЕЦ                                  

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

Команда 3106
------------
.\06\06.txt
Оценка: 2.8
Автор решения: Топчий Ксения

Алгоритм
--------
Идея:Помещаем номер искомого элемента в ЯЩИК, вычитая из него
по 1 при написании очередного элемента. Т.к. к каждому преды-
дущему добавляется две цифры,то сохраняем текущий номер на
расстоянии 2 клеток от предыдущего элемента. При написании
последнего, клетку с номером делаем ПУСТОй.


ЭТО ВХОД   //Записываем цифры
 ОБМЕН     //первого элемента
 ПИШИ 1
 ВПРАВО
 ПИШИ 0
 ВПРАВО
 ОБМЕН
 ПОКА НЕ ПУСТО
{
 Ход
}
КОНЕЦ

//--------------------

ЭТО Ход
ЕСЛИ НЕ 1 ТО     //Проверяем значение
        {       //счетчика и, если оно
        МИНУС   //не 1, уменьшаем на 1
        ОБМЕН
        ПОВТОРИ 2 ВПРАВО //Фиксируем
        ОБМЕН            //значение
                         //счетчика

        ПОВТОРИ 2 ВЛЕВО  //Возвращаем
//курсор к концу предыдущего элемента

        ПОВТОРИ 2 След
          }
           ИНАЧЕ
                ПИШИ ПУСТО
КОНЕЦ

//--------------------

ЭТО След
  ПОВТОРИ 2 ВЛЕВО
  ЕСЛИ 1 ТО      //Инверсия соответ-
     {          //ствующей цифры
      ОБМЕН
      ПИШИ 0
          }
        ИНАЧЕ
          {
          ОБМЕН
          ПИШИ 1
           }
  ОБМЕН
  ПОВТОРИ 2 ВПРАВО //Запись цифры
  ОБМЕН     //на нужном месте
  ВПРАВО
КОНЕЦ

к о м м е н т а р и й  к у р а т о р а
Однопроходное хорошее решение. Только одно небольшое замечание: совсем
не надо отступать две клетки для проверки ящика. Ящик можно проверить
в любом месте записи (по команде ОБМЕН).


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

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

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

Команда 3108
------------
.\08\08.txt
Оценка: 1.5
Автор решения: Шарапов Андрей

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

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

ЭТО Лента_3
ЕСЛИ НЕ 1 ТО
{
ПОКА НЕ ПУСТО ВПРАВО
ВЛЕВО
ЕСЛИ 0 ТО
{
ВПРАВО
ПИШИ 0
ВПРАВО
ПИШИ 1
}
ИНАЧЕ
{
ВПРАВО
ПИШИ 1
ВПРАВО
ПИШИ 0
}
ПОКА НЕ ПУСТО ВЛЕВО
ВПРАВО
МИНУС
Лента_3
}
ИНАЧЕ ПИШИ ПУСТО
КОНЕЦ

к о м м е н т а р и й  к у р а т о р а
Алгоритм многопроходной (не оптимальный), а программа неверная, так
как выдает для:

n=1 ПУСТО (нужно "10")
n=2 10    (нужно "1001")
n=3 1001  (нужно "100110")
...

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

Команда 3113
------------
.\13\13.txt
.\13\1321.kor
Оценка: 1
Автор решения  
Белокопытов Артем, Васильев Максим.

к о м м е н т а р и й  к у р а т о р а
Решение основано на переключении по возможным значениям n, то есть, не
является универсальным. Можно сказать, что решении основано на
непродуктивном перечисляющим все случаи алгоритме. Такие алгоритмы
никогда не используют в практике программирования (за очень редкими не
интересными исключениями).
Кроме того, решение содержит ошибки:
для n=3 строит "10010" (должно быть "100110").


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

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

к о м м е н т а р и й  к у р а т о р а
Хороший однопроходной алгоритм. Программа, к сожалению неверная.

Для n=1 получает 1001 (нужно 10)
Для n=2 получает 100110 (нужно 1001)
....

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

Оценка: 3
---------
Решение 1531
Автор решения Данил Колесников

Описание алгоритма:  
Для 2-го и последующих членов с помощью рекурсии откладывается
процедура Следующий, которая дописывает или 01 или 10,
смотря на предыдущий символ.

Программа, описание программы

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

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

Программа

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

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

к о м м е н т а р и й  к у р а т о р а
Молодцы! Никаких замечаний кроме восхищений красотой и точностью
обоих решений.
