Вычисление квадратного корня. Упрощённый вариант, менее требовательный к состоянию машины.



Принцип:

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

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

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

 


Псевдокод:


begin:
Clear I, II, III, IV
Read kbd*5->I, III, IV 
goto around_answer;
answer: print II; goto begin;
around_answer:
read III; // В III записываем 5*(100^N), такое, что 100^N - количество пар разрядов в исходном числе. Например, для вычисления корня из 2 или 20 мы записываем в III 5, для корня из 200 или 2000 - записываем в III 500.
read IV; // В IV записываем 10^M, где M - требуемое количество разрядов результата.

II=III; //записываем исходную (сдвинутую) пятёрку
I-=II; //вычитаем первый член. Оно получается - по условию ввода III

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

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

 


Программа:


Переменные:
I - исходное число, из которого считаем корень (умноженное на 5)
II - корень
III - 5*100^N - вычитаемая пятёрка
IV - 10^M, где M - требуемое количество разрядов результата.
10, 20, 30 - временные переменные

// Clear I, II, III, IV
1: read I; clr;
1: read II; clr;
1: read III; clr;
1: read IV; clr;
1: read 10; clr;
1: read 20; clr;
1: read 30; clr;

//Read kbd*5->I
//goto around_answer;

1: stop; read kbd; I+=; prn();
1: read kbd; I+=; 10+; //*2 *1
1: read kbd; I+=; 10+ clr; //*3 *2
1: read 10; I+=; clr; //*5

// read III; // В III записываем 5*(100^N), такое, что 100^N - количество пар разрядов в исходном числе. Например, для вычисления корня из 2 или 20 мы записываем в III 5, для корня из 200 или 2000 - записываем в III 500.
//II=III; //записываем исходную (сдвинутую) пятёрку
//I-=II; //вычитаем первый член. Оно получается - по условию ввода III

1: stop; read kbd; II+=; III+=; I-=; clr;

//read IV; // В IV записываем 10^M, где M - требуемое количество разрядов результата.
1: stop; read kbd; IV+=;

//answer: print II; goto begin;
2: read II; prn(); clr; newline; goto prog1; goto backward1;
//around_answer;


//next_step:
//  II+=III;
//  II+=III;

backward2:
1: read III; II+=;
1: read III; II+=; goto prog2;


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

2: read II; I-=; goto prog1; goto forward;
1: if (I>0) goto backward2;
forward: 
1: read II; I+=; 
1: read III; II-=;

// II<=1;
1: read II;  10+=; 20+=;      // II-1; 10-1; 20-1; 
1: read II;  10+=; 20+=; clr; // II-0; 10-2; 20-2; 
1: read 10; II+=;  20+=; clr; // II-2; 10-0; 20-4; 
1: read 20; II+=;             // II-6; 10-0; 20-4; 
1: read 20; II+=;        clr; // II-10; 10-0; 20-0; 


// I<<=2;

1: read I;  10+=; 20+=;      // I-1; 10-1; 20-1; 
1: read I;  10+=; 20+=; clr; // I-0; 10-2; 20-2; 
1: read 10; I+=;  20+=; clr; // I-2; 10-0; 20-4; 
1: read 20; I+=;  10+=;      // I-6; 10-4; 20-4; 
1: read I;  10+=; 20+=; clr; // I-0; 10-10; 20-10; 
1: read 10; I+=; 20+=;       // I-10; 10-10; 20-20;
1: read 20; I+=; 10+=;       // I-30; 10-30; 20-20;
1: read 20; I+=; 10+=;  clr; // I-50; 10-50; 20-0;
1: read 10; I+=;        clr; // I-100; 10-0; 20-0;
 

//if (II>IV) goto answer;
1: read IV; II-=; goto forward;
1: if (II>0) read IV; II+=; goto prog2; // goto backward1; не нужен, он автоматически получится.
forward: 
1: read IV; II+=; 

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

 


Код установки стопсов:
Стопсы приведены для версии, которая печатает всю таблицу рассчётов.


    # 0/0
01. 1 10/4            14/3 15/6                                                     // 1: read I; clr;
02. 1 10/4 12/3            15/6                                                     // 1: read II; clr;
03. 1 10/4                 15/6                                      41/3           // 1: read III; clr;
04. 1 10/4                 15/6                    35/3              41/3           // 1: read IV; clr;
05. 1 10/4                 15/6                                  39/3               // 1: read 10; clr;
06. 1 10/4                 15/6                             38/3                    // 1: read 20; clr;
07. 1 10/4                 15/6                        37/3                         // 1: read 30; clr;
08. 1 10/3            14/4                                                          // 1: stop; read kbd; I+=; prn();
09. 1 10/3            14/4 15/6                                  39/4               // 1: read kbd; I+=; 10+; //*2 *1
10. 1                 14/4 15/6                                  39/4               // 1: read kbd; I+=; 10+ clr; //*3 *2
11. 1                 14/4 15/6                                  39/3               // 1: read 10; I+=; clr; //*5
12. 1       12/4 13/3 14/4                                           41/4           // 1: stop; read kbd; II+=; III+=; I-=; clr;
13. 1                                              35/3              41/4           // 1: stop; read kbd; IV+=;
14.(1) 10/4 12/3           15/6      17/3 19/3 33/4                                 // 2: read II; prn(); clr; newline; goto prog1; goto backward1;
15. #                                                                          44/7 // backward2:
	# 0/0
16. 1       12/4           15/6                                      41/3            // 1: read III; II+=;
17. 1       12/4           15/6           19/4                       41/3            // 1: read III; II+=; goto prog2;
18.(1)      12/3 13/3 14/4 15/6 16/3      19/3                                       // 2: read II; I-=; goto prog1; goto forward;
	# 1/4
	# 1/5
19. 1                      15/6                 33/6L                                 // 1: if (I>0) goto backward2;
20. #                                        20/5      // forward: 
21. 1       12/3      14/4 15/6                                                       // 1: read II; I+=; 
22. 1  11/3 12/4           15/6                                      41/3             // 1: read III; II-=;
23.        // 1: read II;  10+=; 20+=;      // II-1; 10-1; 20-1; 
24.        // 1: read II;  10+=; 20+=; clr; // II-0; 10-2; 20-2; 
25.        // 1: read 10; II+=;  20+=; clr; // II-2; 10-0; 20-4; 
26.        // 1: read 20; II+=;             // II-6; 10-0; 20-4; 
27.        // 1: read 20; II+=;        clr; // II-10; 10-0; 20-0; 
28.        // 1: read I;  10+=; 20+=;      // I-1; 10-1; 20-1; 
29.        // 1: read I;  10+=; 20+=; clr; // I-0; 10-2; 20-2; 
30.        // 1: read 10; I+=;  20+=; clr; // I-2; 10-0; 20-4; 
31.        // 1: read 20; I+=;  10+=;      // I-6; 10-4; 20-4; 
32.        // 1: read I;  10+=; 20+=; clr; // I-0; 10-10; 20-10; 
33.        // 1: read 10; I+=; 20+=;       // I-10; 10-10; 20-20;
34.        // 1: read 20; I+=; 10+=;       // I-30; 10-30; 20-20;
35.        // 1: read 20; I+=; 10+=;  clr; // I-50; 10-50; 20-0;
36.        // 1: read 10; I+=;        clr; // I-100; 10-0; 20-0;
37.        // 1: read IV; II-=; goto forward;
38.        // 1: if (II>0) read IV; II+=; goto prog2;
39.        // forward: 
40.        // 1: read IV; II+=; 
41.        // 1: read III; II+=; goto prog2; goto backward2;