Видео: корень из 2


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


Принцип:

Вообще, квадратный корень считается легко. Из формулы суммы членов арифметической прогрессии получается, что сумма первых n нечётных чисел = n^2. Из чего следует

Откуда достаточно легко выводится алгоритм вычисления квадратного корня, использовавшийся с начала 1950-х годов арифмометрами с автоматическим вычислением квадратных корней фирмы Friden. Вот тут про него можно прочитать подробнее.

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

 


Псевдокод:

1. Получить число.
2. Расчитать степень десятки (сколько раз можно убрать пару нулей)
3. Вычислить корень после сдвига.
4. Распечатать корень и сдвиг

begin:
Read kbd*5, I // тут будет исходное число.
goto around_answer;
answer: print II, IV; goto begin;
around_answer;
III=5
II=IV=0
next: K=III<<2;
if(I>=K) 
  {
  III=K;
  IV++;
  if (I!=K) goto next; 
  //II=1; goto answer; //Мы наткнулись на степень сотни! Для простоты игнорируем этот случай. 
  }


//в этом месте в III у нас 5, сдвинутое на нужную степень, а в IV - степень десятки ответа (она не понадобится до самой печати)
II=III; //записываем исходную (сдвинутую) пятёрку

I-=II; //вычитаем первый член. Оно получается - иначе бы мы сдвинулись ещё на один разряд.
next_step:
  II+=III;
  II+=III;
next_digit:
  I-=II;
  if (I==0) //мы нашли точный ответ
    {
    II+=III;
    goto answer;
    }
if (I>0) goto next_step;
I+=II;//прибавляем последнее число, которое вычли.
II-=III;//убираем пятёрку в конце

I<<=2; if (overflow) goto answer;
II<=1;
II+=III;//добавляем пятёрку в конце - но уже в следующий разряд.
goto next_digit; // одну пятёрку мы добавили, ещё две пока не нужны - поэтому next _digit находится после next_step;

 


Программа:


Переменные:
В начале: в II вычисляемое, в I - 5, сдвинутое на несколько пар разрядов влево.
В конце:
I - вычисляемое (исходно, число*5)
II - результат. 
10,20- временные переменные
K - шаг (5*100^х).
41 - степень десятки результата
При первом запуске 10, 20, I, II, надо обнулить.

Константы:
01 - 9Е9
11 - 1
31 - 5

1: read K; clr;
1: read 10; clr;
1: read 41; clr;

//Read kbd*5, II // тут будет исходное число.
//goto around_answer;
//answer: print II, 41; goto begin;
//around_answer;

1: stop; read kbd; II+=; prn();
1: read kbd; II+=; 10+; //*2 *1
1: read kbd; II+=; 10+ clr; //*3 *2
1: read 10; II+=; clr; //*5
2: read II; prn(); clr;
2: read 41; prn(); clr; newline; goto prog1; goto backward1;

1: read 31; K+=;  //в 31 - 5
1: read 11; II+=; goto prog2; // увеличим II на единицу - чтобы порядок в "100 ровно" превратилось в "порядок 101" - и ответ читался бы не как 10Е0, а как 1Е1

//I=K<<2
2: backward2: read K; 10+=; 20+=; I+=; // 1  1  1
2: read K; 10+=; 20+=; I+=; // 2  2  2
12: forward1: read 10; 20+=; I+=; //      2  4  4
12: read 20; 10+=; I+=; //      6  4  8
12: read I; 10+=; 20+=; //      14 12 8
12: read 10; 20+=; I+=; clr;//  0  26 22 !!!newline
12: read 20; I+=;//             0  26 48
12: read 20; I+=;//             0  26 74
12: read 20; I+=; clr;//        0  0  100

//if(II>I) 
//  {
//  K=r30;
//  r41++;
//  goto next; 
//  }

2: read II; I-=; wait; goto prog1; goto forward1;// стопс задержки ставим здесь, а не на следующем шаге! Чтобы он анализировал ЭТО значение I

1: read II; 10+=; 20+=; goto prog2; goto forward2;//1 1 1 // первая строка сдвига II<<=1; из конца программы.

1: forward1: read II; I+=; goto forward1;
1: if (I>=0) read I; clr; goto forward1;// то есть, II<I. С этого места начинаем считать корень.
1: forward1: read K; clr; //технически, он находится на шаг раньше, поэтому по условному оператору переход не осуществляется.
1: read I; K+=; clr;
1: read 11; 41+=; goto backward2;//в r11 - 1



//в этом месте в K у нас 5, сдвинутое на нужную степень, а в r41 - степень десятки ответа (она не понадобится до самой печати)

// II--; //мы увеличивали число на единицу, надо это исправить.
// I=II; //переносим изучаемое число в I
// II=K; //записываем исходную (сдвинутую) пятёрку
//I-=II; //вычитаем первый член. Оно получается - иначе бы мы сдвинулись ещё на один разряд.
//next_step:
//  II+=K;
//  II+=K;
//next_digit:
//  I-=II;


1: forward1: read 11; II-=; 
1: read II; I+=; clr; //I=II; II=0;
1: read K; II+=; //II=K
1: read II; I-=;
1: backward1: read K; II+=;
1: read K; II+=;
1: forward1: read II; I-=; 

//  if (I==0) //мы нашли точный ответ
//    {
//    II+=K;
//    goto answer;
//    }

1: read I; if (!=0) goto forward1; 
1: read K; II+=; clr; goto prog2; goto forward2; //мы сюда попадаем только если I==0, поэтому обнулять его не нужно.


//if (I>0) goto next_step;
1: if(I>=0) goto backward1; 

//I+=II;//прибавляем последнее число, которое вычли.
//II-=K;//убираем пятёрку в конце

1: forward1: read II; I+=;
1: read K; II-=;

// if (II>9E9) goto answer;
1: read 01; II-=; goto forward1;// в 01 - 9Е9
1: if (II>0) read I; clr; goto prog2; goto forward2; //Окей, мы нашли ответ. Обнуляем остаток исходного числа, и идём печатать ответ.
1: forward1: read 01; II+=; // Восстанавливаем I

// I<<=2;   

1: read I; 10+=; 20+=; // 1  1  I1
1: read I; 10+=; 20+=; clr;      // 2  2 I0
1: read 20; I+=; goto forward1;  // 2  2  I2


//II<<=1;
//1: read II; 10+=; 20+=; //1 1 1 это выполняется в предыдущем блоке сдвига 
2: forward2: read II; 10+=; goto prog1; // 2 1 II1
1: read 10; II+=; 20+=; //2 3 II3
1: read 10; II+=; 20+=; clr; //0 5 II5
1: read 20; II+=; clr;//0 0 II10 


//II+=K;//добавляем пятёрку в конце - но уже в следующий разряд.
//goto next_digit; // одну пятёрку мы добавили, ещё две пока не нужны - поэтому next _digit находится после next_step;

1: read K; II+=; goto forward1; goto backward1; 

 


Код установки стопсов:
Наиболее точная версия программы. Стопсы приведены для версии, которая работает в одну строку, распечатывая только исходное число и корень из него.
Если вы хотите получить красивую распечатку таблицы, как на видео, уберите все стопсы 5/3, а на каждую команду goto backward добавьте newline (17/3). Как вариант, можно оставить 5/3 у команд 1,2,4,5,6,7 - тогда исходное число и результат будут печататься аккуратно и понятно, а всё остальное будет красивой табличкой.



01 1 0(+2)3/10 5/3                              15/6                                                        // 1: read K; clr;
02 1           5/3     10/4                     15/6                23/3      36/3      39/3                // 1: read 41; clr;
03 1                   10/3      12/4                                                                       // 1: read kbd; II+=;
04 1           5/3     10/3      12/4           15/6                                    39/4                // 1: read kbd; II+=; 10+; //*2 *1
05 1           5/3               12/4           15/6                                    39/4                // 1: read kbd; II+=; 10+ clr; //*3 *2
06 1           5/3     10/4      12/4           15/6                                    39/3                // 1: read 10; II+=; clr; //*5
07(1)          5/3               12/4           15/6                23/3                     40/3           // 2: read 01; II+=; // Восстанавливаем II
08(1)                  10/4      12/3           15/6                                                        // 2: read II; prn(); clr;
09(1)          5/4     10/4                     15/6 17/3 19/3      23/3 33/4 36/3                          // 2: read 41; prn(); clr; newline; goto prog1; goto backward1;
10 1       3/4 5/3                              15/6                23/3      37/3                          // 1: read 31; K+=;  //в 31 - 5
11 1           5/3               12/4           15/6      19/4      23/3                39/3                // 1: read 11; II+=; goto prog2; // увеличим II на единицу - чтобы порядок в "100 ровно" превратилось в "порядок 101" - и ответ читался бы не как 10Е0, а как 1Е1
12(1)0(+2) 3/9 5/3                         14/4 15/6                               38/4 39/4     44/7R(-2)  // 2: backward2: read K; 10+=; 20+=; I+=; // 1  1  1
13(1)      3/9 5/3                         14/4 15/6           20/5                38/4 39/4                // 2: read K; 10+=; 20+=; I+=; // 2  2  2
14 2           5/3                         14/4 15/6                               38/4 39/3                // 12: forward1: read 10; 20+=; I+=; //      2  4  4
15 2           5/3                         14/4 15/6                               38/3 39/4                // 12: read 20; 10+=; I+=; //      6  4  8
16 2           5/3                         14/3 15/6                               38/4 39/4                // 12: read I; 10+=; 20+=; //      14 12 8
17 2           5/3     10/4                14/4 15/6                               38/4 39/3                // 12: read 10; 20+=; I+=; clr;//  0  26 22
18 2           5/3                         14/4 15/6                               38/3                     // 12: read 20; I+=;//             0  26 48
19 2           5/3                         14/4 15/6                               38/3                     // 12: read 20; I+=;//             0  26 74
20 2           5/3     10/4                14/4 15/6                               38/3                     // 12: read 20; I+=; clr;//        0  0  100
21(1)1/4       5/3               12/3 13/3 14/4 15/6 16/3 19/3                                              // 2: read II; I-=; wait; goto prog1; goto forward1; 
22 1           5/3               12/3           15/6 16/3 19/4                     38/4 39/4                // 1: read II; 10+=; 20+=; goto prog2; goto forward2;//1 1 1 // первая строка сдвига II<<=1; из конца программы.
23 1 1/5(-2)   5/3     10/4                14/3 15/6 16/3      20/5                                         // 1: if (I>0) read I; clr; goto forward1; // то есть, II<I. С этого места начинаем считать корень.
24 1           5/3               12/3      14/4 15/6                                                        // 1: forward: read II; I+=;
25 1      3/10 5/3                              15/6                                                        // 1: read K; clr;
26 1       3/4 5/3     10/4                14/3 15/6                                                        // 1: read I; K+=; clr;
27 1           5/3                              15/6      19/4 20/5 23/3 33/6L 36/4     39/3                // 1: read 11; 41+=; goto backward2; goto prog2;//в r11 - 1
28 1           5/3          11/3 12/4           15/6                23/3                39/3                // 1: forward1: read 11; II-=; 
29 1           5/3     10/4      12/3      14/4 15/6                                                        // 1: read II; I+=; clr; //I=II; II=0;
30 1       3/9 5/3               12/4           15/6                                                        // 1: read K; II+=; //II=K
31 1           5/3               12/3 13/3 14/4 15/6                                                        // 1: read II; I-=;
32 1 0(+2) 3/9 5/3               12/4           15/6                                             44/7R(-2)  // 1: backward2: read K; II+=;
33 1       3/9 5/3               12/4           15/6                                                        // 1: read K; II+=;
34 2           5/3               12/3 13/3 14/4 15/6      19/3                                              // 12: read II; I-=; goto prog1;
35 1 1/4       5/3  7/4                    14/3 15/6 16/3                                                   // 1: read I; if (!=0) goto forward1; 
36 1      3/10 5/3               12/4           15/6      19/4           33/4                               // 1: read K; II+=; clr; goto prog2; goto backward1;//мы сюда попадаем только если I==0, поэтому обнулять его не нужно.
37 1 1/5(-2)   5/3                              15/6           20/5      33/6L                              // 1: if(I>=0) goto backward2; 
38 1           5/3               12/3      14/4 15/6                                                        // 1: forward: read II; I+=;
39 1 1/4       5/3          11/3 12/4           15/6                23/3                     40/3           // 1: read 01; II-=; // в 01 - 9Е9
40 1      3/9  5/3          11/3 12/4           15/6 16/3                                                   // 1: read K;  II-=; goto forward1;  
41 1 2/5(-2)   5/3     10/4                14/3 15/6      19/4 20/5      33/4                               // 1: if (II>0) read I; clr; goto prog2; goto backward1; //Окей, мы нашли ответ. Обнуляем остаток исходного числа, и идём печатать ответ. 
42 1           5/3               12/4           15/6                23/3                     40/3           // 1: forward: read 01; II+=; // Восстанавливаем II
43 1           5/3                         14/3 15/6                               38/4 39/4                // 1: read I; 10+=; 20+=; // 1  1  I1
44 1           5/3     10/4                14/3 15/6                               38/4 39/4                // 1: read I; 10+=; 20+=; // 1: read I; 10+=; 20+=; clr;      // 2  2 I0
45 1           5/3                         14/4 15/6 16/3       21/5               38/3                     // 1: read 20; I+=; goto forward1;  // 2  2  I2
46(1)          5/3               12/3           15/6      19/3                          39/4                // 2: forward2: read II; 10+=; goto prog1; // 2 1 II1
47 1           5/3               12/4           15/6                               38/4 39/3                // 1: read 10; II+=; 20+=; //2 3 II3
48 1           5/3     10/4      12/4           15/6                               38/4 39/3                // 1: read 10; II+=; 20+=; clr; //0 5 II5
49 1           5/3     10/4      12/4           15/6                               38/3                     // 1: read 20; II+=; clr;//0 0 II10 
50 1       3/9 5/3               12/4           15/6      19/4           33/6L                              // 1: read K; II+=; goto prog2; goto backward2;

 


Фотография собранной доски (без стопсов 5/3, со стопсами 17/3):

Кликните для увеличения.

 


Что должно распечатываться при вычислении корня из 400:


       Переменные:
       В начале: в II вычисляемое, в I - 5, сдвинутое на несколько пар разрядов влево.
       В конце:
       I - вычисляемое (исходно, число*5)
       II - результат. 
       10,20- временные переменные
       K - шаг (5*100^х).
       41 - степень десятки результата
       При первом запуске 20, I, II, надо обнулить.
       
       Константы:
       01 - 9Е9
       11 - 1
       31 - 5
       
???    1: read K; clr;
???    1: read 10; clr;
???    1: read 41; clr;
       
       //Read kbd*5, II // тут будет исходное число.
       //goto around_answer;
       //answer: print II, 41; goto begin;
       //around_answer;
       
400    1: stop; read kbd; II+=; prn();
400    1: read kbd; II+=; 10+; //*2 *1
400    1: read kbd; II+=; 10+ clr; //*3 *2
800    1: read 10; II+=; clr; //*5
       2: read II; prn(); clr;
       2: read 41; prn(); clr; newline; goto prog1; goto backward;
       
5      1: read 31; K+=;  //в 31 - 5
1      1: read 11; II+=; goto prog2; // увеличим II на единицу - чтобы порядок в "100 ровно" превратилось в "порядок 101" - и ответ читался бы не как 10Е0, а как 1Е1
       
       //I=K<<2
5      2: backward2: read K; 10+=; 20+=; I+=; // 1  1  1
5      2: read K; 10+=; 20+=; I+=; // 2  2  2
10     12: forward1: read 10; 20+=; I+=; //      2  4  4
20     12: read 20; 10+=; I+=; //      6  4  8
40     12: read I; 10+=; 20+=; //      14 12 8
70     12: read 10; 20+=; I+=; clr;//  0  26 22 
130    12: read 20; I+=;//             0  26 48
130    12: read 20; I+=;//             0  26 74
130    12: read 20; I+=; clr;//        0  0  100
       
       //if(II>I) 
       //  {
       //  K=r30;
       //  r41++;
       //  goto next; 
       //  }
       
2001   2: read II; I-=; wait; goto prog1; goto forward1;// стопс задержки ставим здесь, а не на следующем шаге! Чтобы он анализировал ЭТО значение I
       
       1: read II; 10+=; 20+=; goto prog2; goto forward2;//1 1 1 // первая строка сдвига II<<=1; из конца программы.
       
2001   1: forward1: read II; I+=; goto forward1;
       1: if (I>=0) read I; clr; goto forward1;// то есть, II<I. С этого места начинаем считать корень.
5      1: read K; clr;
500    1: read I; K+=; clr;
1      1: read 11; 41+=; goto backward2;//в r11 - 1
       
       
       
       //в этом месте в K у нас 5, сдвинутое на нужную степень, а в r41 - степень десятки ответа (она не понадобится до самой печати)
       
       // II--; //мы увеличивали число на единицу, надо это исправить.
       // I=II; //переносим изучаемое число в I
       // II=K; //записываем исходную (сдвинутую) пятёрку
       //I-=II; //вычитаем первый член. Оно получается - иначе бы мы сдвинулись ещё на один разряд.
       //next_step:
       //  II+=K;
       //  II+=K;
       //next_digit:
       //  I-=II;
       
       
       1: forward1: read 11; II-=; 
       1: read II; I+=; clr; //I=II; II=0;
       1: read K; II+=; //II=K
       1: read II; I-=;
       1: backward2: read K; II+=;
       1: read K; II+=;
       12: read II; I-=; goto prog1;
       
       //  if (I==0) //мы нашли точный ответ
       //    {
       //    II+=K;
       //    goto answer;
       //    }
       
       1: read I; if (!=0) goto forward1; 
       1: read K; II+=; clr; goto prog2; goto backward1; //мы сюда попадаем только если I==0, поэтому обнулять его не нужно.
       
       
       //if (I>0) goto next_step;
       1: if(I>=0) goto backward2; 
       
       //I+=II;//прибавляем последнее число, которое вычли.
       //II-=K;//убираем пятёрку в конце
       
       1: read II; I+=;
       
       // if (II>9E9) goto answer;
       1: read 01; II-=; // в 01 - 9Е9
       1: read K; II-=; goto forward1;
       1: if (II>0) read I; clr; goto prog2; goto backward1; //Окей, мы нашли ответ. Обнуляем остаток исходного числа, и идём печатать ответ.
       1: read 01; II+=; // Восстанавливаем I
       
       // I<<=2;   
       
       1: read I; 10+=; 20+=; // 1  1  I1
       1: read I; 10+=; 20+=; clr;      // 2  2 I0
       1: read 20; I+=; goto forward1;  // 2  2  I2
       
       
       //II<<=1;
       //1: read II; 10+=; 20+=; //1 1 1 это выполняется в предыдущем блоке сдвига 
       2: forward2: read II; 10+=; goto prog1; // 2 1 II1
       1: read 10; II+=; 20+=; //2 3 II3
       1: read 10; II+=; 20+=; clr; //0 5 II5
       1: read 20; II+=; clr;//0 0 II10 
       
       
       //II+=K;//добавляем пятёрку в конце - но уже в следующий разряд.
       //goto next_digit; // одну пятёрку мы добавили, ещё две пока не нужны - поэтому next _digit находится после next_step;
       
       1: read K; II+=; goto backward2; goto prog2;
       

 


Что должно распечатываться при вычислении корня из 2:


        Переменные:
        В начале: в II вычисляемое, в I - 5, сдвинутое на несколько пар разрядов влево.
        В конце:
        I - вычисляемое (исходно, число*5)
        II - результат. 
        10,20- временные переменные
        K - шаг (5*100^х).
        41 - степень десятки результата
        При первом запуске 20, I, II, надо обнулить.
        
        Константы:
        01 - 9Е9
        11 - 1
        31 - 5
        
???     1: read K; clr;
???     1: read 10; clr;
???     1: read 41; clr;
        
        //Read kbd*5, II // тут будет исходное число.
        //goto around_answer;
        //answer: print II, 41; goto begin;
        //around_answer;
        
2       1: stop; read kbd; II+=; prn();
2       1: read kbd; II+=; 10+; //*2 *1
2       1: read kbd; II+=; 10+ clr; //*3 *2
4       1: read 10; II+=; clr; //*5
        2: read II; prn(); clr;
        2: read 41; prn(); clr; newline; goto prog1; goto backward;
        
5       1: read 31; K+=;  //в 31 - 5
1       1: read 11; II+=; goto prog2; // увеличим II на единицу - чтобы порядок в "100 ровно" превратилось в "порядок 101" - и ответ читался бы не как 10Е0, а как 1Е1
        
        //I=K<<2
5       2: backward2: read K; 10+=; 20+=; I+=; // 1  1  1
5       2: read K; 10+=; 20+=; I+=; // 2  2  2
10  40  12: forward1: read 10; 20+=; I+=; //      2  4  4
20  80  12: read 20; 10+=; I+=; //      6  4  8
40  160 12: read I; 10+=; 20+=; //      14 12 8
70  280 12: read 10; 20+=; I+=; clr;//  0  26 22 
130 520 12: read 20; I+=;//             0  26 48
130 520 12: read 20; I+=;//             0  26 74
130 520 12: read 20; I+=; clr;//        0  0  100
        
        //if(II>I) 
        //  {
        //  K=r30;
        //  r41++;
        //  goto next; 
        //  }
        
11      2: read II; I-=; wait; goto prog1; goto forward1;// стопс задержки ставим здесь, а не на следующем шаге! Чтобы он анализировал ЭТО значение I
        
 10 140 1: read II; 10+=; 20+=; goto prog2; goto forward2;//1 1 1 // первая строка сдвига II<<=1; из конца программы.
        
11A     1: forward1: read II; I+=; goto forward1;
500 A   1: if (I>=0) read I; clr; goto forward1;// то есть, II<I. С этого места начинаем считать корень.
        1: read K; clr;
        1: read I; K+=; clr;
        1: read 11; 41+=; goto backward2;//в r11 - 1
        
        
        
        //в этом месте в K у нас 5, сдвинутое на нужную степень, а в r41 - степень десятки ответа (она не понадобится до самой печати)
        
        // II--; //мы увеличивали число на единицу, надо это исправить.
        // I=II; //переносим изучаемое число в I
        // II=K; //записываем исходную (сдвинутую) пятёрку
        //I-=II; //вычитаем первый член. Оно получается - иначе бы мы сдвинулись ещё на один разряд.
        //next_step:
        //  II+=K;
        //  II+=K;
        //next_digit:
        //  I-=II;
        
        
1       1: forward1: read 11; II-=; 
10      1: read II; I+=; clr; //I=II; II=0;
5       1: read K; II+=; //II=K
5       1: read II; I-=;

5      5   5   5 5                       1: backward2: read K; II+=;
5      5   5   5 5                       1: read K; II+=;
15 105 115 125 135 145                   12: read II; I-=; goto prog1;
        
                                         //  if (I==0) //мы нашли точный ответ
                                         //    {
                                         //    II+=K;
                                         //    goto answer;
                                         //    }
        
-10 395 280 155 20 -125                  1: read I; if (!=0) goto forward1; 
                                         1: read K; II+=; clr; goto prog2; goto backward1; //мы сюда попадаем только если I==0, поэтому обнулять его не нужно.
        
        
                                         //if (I>0) goto next_step;
                                         1: if(I>=0) goto backward2; 
        
                                         //I+=II;//прибавляем последнее число, которое вычли.
                                         //II-=K;//убираем пятёрку в конце
        
15               145                     1: read II; I+=;
        
                                                // if (II>9E9) goto answer;
-00              -00                     1: read 01; II-=; // в 01 - 9Е9
5                  5                     1: read K; II-=; goto forward1;
                                         1: if (II>0) read I; clr; goto prog2; goto backward1; //Окей, мы нашли ответ. Обнуляем остаток исходного числа, и идём печатать ответ.
00                 00                    1: read 01; II+=; // Восстанавливаем I
        
                                         // I<<=2;   
        
5   20                                   1: read I; 10+=; 20+=; // 1  1  I1
5   20                                   1: read I; 10+=; 20+=; clr;      // 2  2 I0
10  40                                   1: read 20; I+=; goto forward1;  // 2  2  I2
        
        
                                         //II<<=1;
                                         //1: read II; 10+=; 20+=; //1 1 1 это выполняется в предыдущем блоке сдвига 
   10  140                               2: forward2: read II; 10+=; goto prog1; // 2 1 II1
   20  280                               1: read 10; II+=; 20+=; //2 3 II3
   20  280                               1: read 10; II+=; 20+=; clr; //0 5 II5
   50  700                               1: read 20; II+=; clr;//0 0 II10 
        
        
                                         //II+=K;//добавляем пятёрку в конце - но уже в следующий разряд.
                                         //goto next_digit; // одну пятёрку мы добавили, ещё две пока не нужны - поэтому next _digit находится после next_step;
        
   5  5                                  1: read K; II+=; goto backward2; goto prog2;
        


:

1

.