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

a  = 110 (например)
 1
a  = 11001
 2
a  = 1100110
 3
...

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

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

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


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

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

Решение

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

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

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

Команда 3106
------------
.\06\06.txt
Оценка: 3.8
Автор решения: Докадин Иван

Алгоритм
--------
Идея:Помещаем номер члена, который нужно написать, в ЯЩИК.Переме-
щаем курсор до конца записи (до первой пустой клетки). Затем сохраняем
номер текущего элемента, отступив 2 клетки от записи.При этом содер-
жимое ЯЩИКа уменьшаем на 1.Находим нужную цифру в записи( она распола-
гается за 4 и 3 клетки от клетки с номером), инвертируем и записываем
цифру в нужном месте.

ЭТО Вход
 ОБМЕН     //Помещаем номер искомого члена в ЯЩИК
 ВПРАВО
 ПОКА НЕ ПУСТО
      {
       ВПРАВО    //Ищем конец записи
        }
 Работа
 ПОВТОРИ 2 ВЛЕВО
 КОНЕЦ

ЭТО Работа
  ПОВТОРИ 2 ВПРАВО
  ОБМЕН
  МИНУС
  ЕСЛИ НЕ 0 ТО
       {
       ПОВТОРИ 2 ВЛЕВО
       ПОВТОРИ 2 Шаг
       ОБМЕН
       Работа
        }
           ИНАЧЕ ПИШИ ПУСТО
КОНЕЦ

ЭТО Шаг
 ПОВТОРИ 2 ВЛЕВО
 ЯЩИК+
 ЕСЛИ 1 ТО ПИШИ 0 ИНАЧЕ ПИШИ 1
 ОБМЕН
 ПОВТОРИ 2 ВПРАВО
 ОБМЕН
 ВПРАВО
КОНЕЦ

к о м м е н т а р и й  к у р а т о р а
Правильные алгоритм и программа. Оценка снижена за неэффективную
работу с ящиком.

Команда 3107
------------
.\07\07.txt
.\07\tur4.kor
Оценка: 1.5
//-------------------------------------
// Задача 4
// Последующий член - инверсия двух    
// предыдущих
// Авторы решения: Повалишин Е.,
// Чиков С.                            
//                                     
ЭТО вход                               
//  Алгоритм: уменьшение счетчика      
// сопровождаем записью двух цифр      
// путем копирования последней и       
// предпоследней цифр с изменением     
// порядка. Счетчик - на ленте         
 ПОКА НЕ 1                             
  работа     // в конце - окно на
             // счетчике               
 ПИШИ ПУСТО  // Стирание счетчика с    
             // ленты                  
 КОНЕЦ                                 
//--------------------------------     
ЭТО работа                             
 МИНУС      // уменьшаем счетчик на 1  
 ПОКА НЕ ПУСТО                         
  ВПРАВО     // встаем на первый       
        // пустой символ после записи  
 ВЛЕВО //встаем на последний символ
       // записи
 ЯЩИК+  // копируем символ в ящик      
 ВПРАВО  //передвигаем окно на         
         // пустую соседнюю клетку     
 ЯЩИК-   // копируем последний символ  
 ПОВТОРИ 2 ВЛЕВО // на предпоследний   
                 // символ             
 ЯЩИК+     // копируем предпоследний   
 ПОВТОРИ 3 ВПРАВО  // символ           
 ЯЩИК-             //                  
 ПОКА НЕ ПУСТО ВЛЕВО // идем к
 ВПРАВО              // счетчику       
КОНЕЦ                                  

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

Для 200 получает 0000 (должно быть 0011)
Для 211 получает 1111 (должно быть 1100)
Для 300 получает 000000 (должно быть 001100)
....


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

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

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

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

к о м м е н т а р и й  к у р а т о р а
Неоптимальный алгоритм: исполнитель постоянно бегает в начало записи
посмотреть на счетчик.


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

Первое решение 1041.kor
--------------
ЭТО вход
ОБМЕН                                  
поиск_последней_цифры                  
//необходим для последующего           
//инвертирования                       
запись_цифр                            
КОНЕЦ                                  
ЭТО поиск_последней_цифры              
ВПРАВО
ЕСЛИ НЕ ПУСТО ТО поиск_последней_цифры 
КОНЕЦ
ЭТО запись_цифр                        
ЯЩИК-                                  
ВЛЕВО                                  
ЯЩИК+                                  
ВПРАВО                                 
ОБМЕН                                  
ВПРАВО
ЯЩИК-                                  
ПОВТОРИ 3 ВЛЕВО                        
ЯЩИК+
ПОВТОРИ 3 ВПРАВО
ОБМЕН
вычитание                              
КОНЕЦ                                  
ЭТО вычитание                          
//нужно для того чтобы узнать, когда   
//необходимо прекратить запись         
//инвертируемых чисел                  
поиск_последней_цифры                  
ПИШИ 0
ОБМЕН                                  
МИНУС
ЕСЛИ Я=Л ТО СТОЯТЬ                     
ИНАЧЕ                                  
{                                      
ОБМЕН                                  
запись_цифр                            
}                                      
ПИШИ ПРОБЕЛ
КОНЕЦ

Второе решение 1042.kor
--------------
ЭТО вход
ЯЩИК+                                  
ПИШИ ПУСТО                             
ВПРАВО                                 
инвертирование                         
КОНЕЦ                                  
ЭТО инвертирование //переставляет      
//последние две цифры                  
//последовательности
{                                      
ПОКА НЕ ПУСТО ВПРАВО
ОБМЕН                                  
МИНУС                                  
запись                                 
}                                      
КОНЕЦ                                  
ЭТО запись //производит инвертироавние 
//нужное количество раз                
ЕСЛИ НЕ 0 ТО
{                                      
ОБМЕН
ПОВТОРИ 2 ВПРАВО
ОБМЕН                                  
ПОВТОРИ 4 ВЛЕВО                        
ЯЩИК+                                  
ПОВТОРИ 3 ВПРАВО                       
ОБМЕН                                  
ПОВТОРИ 2 ВЛЕВО                        
ЯЩИК+                                  
ВПРАВО                                 
ОБМЕН
запись_1                               
}
ИНАЧЕ ПИШИ ПУСТО                       
КОНЕЦ                                  
ЭТО запись_1 //уменьшает значение      
//в ящике на 1                         
ПОВТОРИ 2 ВПРАВО                       
ЕСЛИ НЕ ПУСТО ТО                       
{                                      
МИНУС
ЕСЛИ НЕ 0 ТО                           
запись
ИНАЧЕ ПИШИ ПУСТО
}                                      
КОНЕЦ

к о м м е н т а р и й  к у р а т о р а
Оба решения работают неверно.

Первое решение:
100 преобразует в 0000ПРОБЕЛ (должно быть 00)
111 преобразует в 1111ПРОБЕЛ (должно быть 11)
110 преобразует в 1001 (должно быть 10)
210 преобразует в 100110 (должно быть 1001)
...

Второе решение:
211 преобразует в 1111 (должно быть 1100)
200 преобразует в 0000 (должно быть 0011)
...

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

Автор решения  
Белокопытов Артем, Пащенко Василий.

к о м м е н т а р и й  к у р а т о р а
Ошибка прежняя -- нет алгоритма, есть утомительный линейный
переключатель, который работает неверно:

Для 211 выдает 11ПУСТОПУСТО1 (нужно 1100)
Для 200 выдает 00ПУСТОПУСТО0 (нужно 0011)
Для 210 выдает 10ПУСТОПУСТО0 (нужно 1001)
...


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

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

к о м м е н т а р и й  к у р а т о р а
Программа работает неверно.

100 преобразует в 1001 (нужно 00)
111 преобразует в 1001 (нужно 11)
201 преобразует в 100110 (нужно 0110)
...

Команда 3115
------------
.\15\15.txt
Оценка: 4
Автор решения Колесников Данил
Описание алгоритма:
   С помощью процедуры Вход мы запускаем главную процедуру Работа.
 В ней мы проверяем в окошке 1. Если ее там нет, то рекурсивно от-
 кладываем процедуру "Следующий" 2 раза, иначе он пишет на этом 
 месте пусто, и идет в конец записи, на предпоследнюю цифру.
 Теперь начинает выполняться отложенная строка
                ПОВТОРИ 2 Следующий.
 Процедура "Следующий" инвертирует эту цифру, записывает её в конец
 записи и снова  устанавливает окно на предпоследнюю цифру получившейся
 записи.

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

к о м м е н т а р и й  к у р а т о р а
Красивое решение без замечаний.
