2017年3月1日 星期三

 ·
Daily using of ABC Forth


Ching-Tang Tseng
 Hamilton, New Zealand
1 March 2017

ilikeforth@gmail.com

http://forthfortnight.blogspot.com

This article shows a few examples to you. Let you know how to purify a little bit confused question by ABC Forth system? Questions are coming from other people's posting on my Face Book website. I owned ABC Forth for many years, could be applied to solve these kinds of question.

Many years ago, I had ever struggled for a long period of time, try to set up some questions by myself, would like to use them to evaluate my ABC Forth system. Recently, on Face Book, I found many current questions are good to be used to show the special performance of my ABC Forth. I implement these programs on 64 bits ABC Forth system under ubuntu 16.04 OS. I am sure all high school students are able to understand the following demonstration by themselves directly.


All questions are analyzable problem. You are able to inference out their answers by hand. I prefer to solve them with computer program. ABC Forth has been emphasized on purpose. 

(1). This question is showing clear enough in mathematic expression.


BRILLIANT.ORG


\ ABC FORTH demo code
\ Author   : Ching-Tang Tseng, Hamilton NZ
\ Date      : 1 March 2017
\ Contact  : ilikeforth@gmail.com
\ Website  : http://forthfortnight.blogspot.com
4 integers i j x y
: x+y=?  ( -- )
basic
10 for i = -100 to 100
20 for j = -100 to 100
30 let x = i
40 let y = j
50 if     ( abs ( x ) + x + y = 8 )
     and ( x + abs ( y ) - y = 14 ) then 70
60 goto 80
70 print " x = " ; i , " , y = " ; j , " , x + y = " ; i + j
80 next j
90 next i
100 end ;

\ execution result:
\ x+y=?
\ x = 6 , y = -4 , x + y = 2 ok

The most special part in this program is the logic branch expression almost the same as the question described.


(2)

2.1 QuestionHow many squares are in the 20th figure?



 2.2 Description

  According to increase a fixed amount of squares each time, appending them all together, to form an extensible figure.
   How many squares are present in figure number i?
    Figure shows that increased fixed amount is 4, suppose i-th step gets k squares.
    While i = 1 , k(1) = 1
    While i = 2,3,...n,n+1,  k(n+1) = k(n) + 4

2.3 Program

2 integers i k
: test ( -- )
basic
10 let k = 1
20 print " i = 1 k = 1 "
30 for i = 1 to 20 - 1
40 let k = k + 4
50 print " i = " ; i + 1 , " k = " ; k
60 next i
70 end ;

2.4 Execution results

test
i = 1 k = 1
i = 2 k = 5
i = 3 k = 9
i = 4 k = 13
i = 5 k = 17
i = 6 k = 21
i = 7 k = 25
i = 8 k = 29
i = 9 k = 33
i = 10 k = 37
i = 11 k = 41
i = 12 k = 45
i = 13 k = 49
i = 14 k = 53
i = 15 k = 57
i = 16 k = 61
i = 17 k = 65
i = 18 k = 69
i = 19 k = 73
i = 20 k = 77  ok
Then, answer is 77.

2.5 Discussion

    There is always a formula existed if a mathematical question is an analytic problem.
    A very simple regulation is very easy to be find out from the figure above.
    This is its corresponding mathematical expression formula:
    k = ( i - 1 ) * 4 + 1 , i = 1, 2, 3, ........, n
    If we are insisted to have pure FORTH style program only. It will be more simpler as following:
    : test ( i -- k )
      1- 4 * 1+ ;
    Execute 20 test, you are getting 77.


(3)

3.1 QuestionWhat does this simplify to?



3.2 Description

    This question is been used to let the student practice how to simplify a mathematical expression. It is not for calculation practice.
    ABC Forth deal with the operation precedence systematically. So long as the user didn't violate the writing regulation of traditional mathematical requirement, system output certainly should be correct.
    In ABC FORTH system, you are permitted to use infix style only to design your program. There is no restriction on must to be BASIC style. Which style you are preferred is fully up to you.
    ABC Forth divided the using environment between integer number and floating point number rigorously. You are not allowed to mix both of them together, but indexes in array or in matrix should be integer.
    Then, this question list above, we are able to prove its result by two kinds of number format. Original mathematical expression has exponent, square root, multiplication operations. According to the question, it must be written as the following format. This format is almost the same as the traditional fundamental hand writing format. It is apt to write, apt to check, apt to remember and apt to understand.
    Executed the final program to get the answer, we found out the first one of 4 options is our answer, all others are wrong. This special application is one kind of ABC Forth application.
   
3.3 Program
2 reals x y
:  RTest  ( f -- )
  {{ x }} f! {{ y = 0 }}
  {{ y = sqrt ( 2 ^ ( sqrt ( 4 * x * x ) ) ) }}
  y f. ;
2 integers a b
: ITest ( n -- )
  [[ a ]] !
  [[ b = sqrt ( 2 ^ ( sqrt ( 4 * a * a ) ) ) ]]
  b . ;

3.4 Execution results
3.e0 RTest 8.00000  ok
3 ITest 8  ok
When X = 3, 2 ^ X = 2 ^ 3  = 8, question to be proved.

3.5 Discussion

    In programming phase, if you are unable to make sure that your operation precedence arrangement are exactly right, the simplest solving method is to use many pairs of ( ... ) in your expression. Parentheses' mark own the top most precedence in ABC Forth system.



(4)

4.1 QuestionCan you solve for x?



4.2 Description

    In general, traditional programming language did not supply factorial operator ( ! ) to user. There are two reasons:
    First reason, it is available in positive integer only, using range are very narrow. For a 32 bits system, the maximum integer should be less than 13. You have to take care these factors, if using it in your program.
    The following program tells you this restriction directly, beware the output results beyond integer 13.

2 integers i j   
: test ( -- )
basic
10 let j = 1 
20 for i = 1 to 20
30 let j = j * i
40 print i , j
50 next i
60 end ;  ok
test
               1                1
               2                2
               3                6
               4               24
               5              120
               6              720
               7             5040
               8            40320
               9           362880
              10          3628800
              11         39916800
              12        479001600     <--- upper limit is 12
              13       1932053504
              14       1278945280 
              15       2004310016
              16       2004189184
              17       -288522240
              18       -898433024
              19        109641728
              20      -2102132736  ok
-1 1 rshift . 2147483647  ok

    Secondary  reason, if we consider factorial operator ! is a mathematical function as well, his writing position is totally different from all other operators. Four arithmetical notations +,-,*,/ are infix operators. General functions, for examples, sin, cos, tan, exp, ln ... etc, are prefix operators. Only factorial notation ! is a postfix operator. In expression, it is to be written as 7 ! such a format.
    FORTH is a standard postfix programming language. To design such a function into FORTH is very easy. In BASIC style environment, we must consider the problem of how to mix a single postfix operator with all other non-postfix operators. In ABC Forth, this problem is resolved by precedence arrangement. You are permitted to write factorial operator in your program totally the same as in your arithmetical book.
    Then, the program for this question could be designed almost the same as what the question is asking?
       
4.3 Program

\ ABC FORTH can implement this code out directly.
\ If rewrite 20 let x = 14, it will tell you that system is running out of range.
\ It means that solution is exited and x = 12 is an unique solution.
integer x
: test ( -- )
basic
10 let x = 0
20 let x = x + 1
30 if ( x ! + 11 ! + 10 ! ) / ( 7 ! * 5 ! * 3 ! ) = x * x then 50
40 goto -20
50 print " x = " ; x
60 end ;

4.4 Execution results

test
x = 12 ok

4.5 Discussion


    Owing to FORTH language is a natural integer programming language. It means that FORTH is good for solving all integer problem. In 64 bits FORTH, there are 19 digits integer range could be used. Factorial values from 1 to 30 are showing here.

\ 64 bits factorial !
2 integers i j   
: test ( -- )
basic
10 let j = 1 
20 for i = 1 to 30
30 let j = j * i
40 print i , j
50 next i
60 end ;  ok
test
                   1                    1
                   2                    2
                   3                    6
                   4                   24
                   5                  120
                   6                  720
                   7                 5040
                   8                40320
                   9               362880
                  10              3628800
                  11             39916800
                  12            479001600
                  13           6227020800
                  14          87178291200
                  15        1307674368000
                  16       20922789888000
                  17      355687428096000
                  18     6402373705728000
                  19   121645100408832000
                  20  2432902008176640000
                  21 -4249290049419214848      <--- out of 64 bits integer range
                  22 -1250660718674968576
                  23  8128291617894825984
                  24 -7835185981329244160
                  25  7034535277573963776
                  26 -1569523520172457984
                  27 -5483646897237262336
                  28 -5968160532966932480
                  29 -7055958792655077376
                  30 -8764578968847253504  OK
-1 1 rshift .
9223372036854775807  OK


(5)   

5.1 QuestionHow do you solve this problem without a calculator?




5.2 Description

    Ok, let's don't use calculator, let's divert to use computer. The difference of using between these two devices are:
    Calculator doesn't need too much thinking, needs pushing down its keys many times.
    Computer needs some thinking and must find out general expressions before you are coding the program.
    This question is asking you to deal with summation of one set of series. Before coding, we need to sort out so called general expression. They are combined with two simple terms.
     n ^ 2 - ( n - 1 ) ^ 2
    Then, the program could be coded out directly. This is the procedure what I did.
  
5.3 Program

2 integers y i
: Answer ( -- )
basic
10 let y = 0
20 for i = 100 to 1 step -2
30 let y = y + i * i - ( i - 1 ) * ( i - 1 )
40 next i
50 print " Sum = " ; y
60 end ;

5.4 Execution Results

Answer
Sum = 5050 ok

5.5 Discussion


    Overflow is always the most serious nightmare to all programmer. According to the general expression above, we could checked it out, one term is addition, another one term is subtraction. They are compensated each other, so we are able to ignore the overflow problem.

(6)


6.1 Question: Can you find n?




6.2 Description

    Questions above talked a lot already. No more comment here.

6.3 Program

integer n
: FindN ( -- )
basic
10 let n = 0
20 let n = n + 1
30 if  n + n ^ 2 + n ^ 3 + n ^ 4 = ( n + 2 ) !  then 50
40 goto -20
50 print " n = " ; n
60 end ;

6.4 Execution results

FindN
n = 3

6.5 Discussion

    Iteration incremental amount in program is no upper limit. I let it begin from 0, owing to the answer is impossible to be a negative number. You are unable to get the answer intuitively, so I wrote this program.


(7)

7. 1 Question: Your calculator probably won't help you here...


    My suggestion: ABC FORTH can help you some.



7. 2 Description

Yes, general calculator indeed won't help you to solve this question. Even more remarkable, a 64 bits general FORTH system won't help you as well.
Big number operation functions had been built in ABC FORTH system. You are able to code the big number in the program. Let the system tell you the result.
Besides, we are able to solve this problem by using floating number operation, convert numbers back and forth by two logarithmic functions Log and ALog.
So long as you are able to get two values in your program,  compare both of them is simple and directly.

7.3 Program

16 bigvariable a 20 allot
17 bigvariable b 20 allot
: test1 ( -- )
basic
10 let B{ a = a ^ 17 }B
20 let B{ b = b ^ 16 }B
30 if B{ a > b }B then 60
40 print  " 17 ^ 16 > 16 ^ 17 "
50 goto 70
60 print  " 16 ^ 17 > 17 ^ 16 "
70 run cr ." 16 ^ 17 = " a big.
80 run cr ." 17 ^ 16 = " b big.
90 end ;
2  reals  x  y
: test2 ( -- )
basic
10 let { x = alog ( 17 * log ( 16 ) ) }
20 let { y = alog ( 16 * log ( 17 ) ) }
30 if { x > y } then 60
40 print  " 17 ^ 16 > 16 ^ 17 "
50 goto 70
60 print " 16 ^ 17 > 17 ^ 16 "
70 print  " 16 ^ 17 = " , { x }
80 print  " 17 ^ 16 = " , { y }
90 end ;

7.4 Execution Results

test1
16 ^ 17 =
21 digits
295147905179352825856
17 ^ 16 =
20 digits
48661191875666868481
test2
16 ^ 17 > 17 ^ 16
16 ^ 17 =     2.95148E20 
17 ^ 16 =     4.86612E19   ok

7.5 Discussion

There are two purposes to list this big number program here:
First, it demos out the big number operation performance that general system is not so easy to possess. Second, it could  print out the absolute value of a big number.
16 to the power of 17 is a 21 digits value. In 64 bits forth system, a maximum single integer number is a 19 digits number only. In this question above, we have got this hint already.
Owing to the big number coding format does not have a programming standard. ABC FORTH built a few fundamental functions inside independently. There are some restrictions for  using. You are rarely able to find this kind of program from other places. My personal programming style is served to you for reference only.
Stack variation indication can tell you how does big** function  worked in the system.
big** ( addr1 n -- addr2 )
addr1 is the initial address of a base big number, n is its integer power, addr2 is the initial address of the calculation result big number.
To claim out a structure for a big number, please use this format:
n1 bigvariable <name> n2 allot
stack variation indication of a bigvariable  is as following:
bigvariable  ( n -- )         compiling time
                                   ( -- addr )  interpreting time
n1 is the initial value of a big number. It must be a reasonable integer,. <name> is an up to you given name of this big number.  n2 is the needed memory amount to ALLOT.
Usage principle of n2 is depended on how many digits does  this big number required? Then, ALLOTs out the same amount bytes for it. In fact, we need 80% bytes memory amount only. Here we use 20 in the program.
Specification of a big number output instruction is Big.
Big. ( addr -- )
addr is the initial address of a big number.

Direct operate the intrinsic words in this big number included system, you are able to get the calculation result by a big number operation as following:
big 16 17 big** big.
21 digits
295147905179352825856  ok
The difference between direct operation mode and programming mode is that the former direct operation mode is eating memory each time or say that it is a memory hungry operation mode.
The latter programming mode has no memory hungry problem. After you compile a big number program, no matter how many times you have done to execute it, ABC FORTH system is always keeping the memory consuming amount 0.

A few  big number  words  are introduced  here only.

   
(8)

8.1 How many times does the digit 9 appear?


8.2 Description

Obviously, It is not an intelligent idea to solve this question by computer program. But versatility of a program has its advantage relative to other methods. Appropriate program could be applied to all conditions by adjusting parameters. 
Number to be thought as characters is one dealing with method. Number to be thought as value is another method to deal with. We are using ABC FORTH mathematical calculation system, so the latter method are preferred. We think number as a value.
In all FORTH system, there is a special instruction named MOD existed. MOD can help us to get the remainder after a division operation. To get value 9 by division is the key procedure in the program.

There is a trick in the following program line label 20. Owing to the FOR instruction in ABC FORTH system is formed by LET instruction. Both instruction's position could be replaced by each other. I would like to show you this performance only. Base on the fundamental principle, to let you apt to maintain your program in future. My suggestion is still don't ignore FOR from system. FOR ... NEXT pair makes reading of program more clear.
 
8.3 Program

2 integers  count  i
: test ( -- )
basic
10 let count = 0
20 let i = 1 to 100
30 if i mod 10 = 9 then 50
40 goto 60
50 let count = count + 1
60 if i / 10 = 9 then 80
70 goto 90
80 let count = count + 1
90 next i
999 print count
1000 end ;

8.4 Execution Results

test
20 ok

8.5 Discussion

Here is another program to be implemented by GOSUB ... RETURN pair. Function of this program is thoroughly the same as the program listed above. But in fact, in ABC FORTH system, there is another very powerful special instruction, named RUN, able to execute any one word or words out of a defining word's range. GOSUB ... RETURN could be fully ignored under such a situation. We keep GOSUB ... RETURN pair in the system for convenience. 
: test ( -- )
basic
10 let count = 0
20 let i = 1 to 100
30 if i / 10 <> 9 then 50
40 gosub 500
50 if i mod 10 <> 9 then 70
60 gosub 500
70 next i
80 goto 999
500 let count = count + 1
501 return
999 print count
1000 end ;
test
20 ok

(9)

9.1 Question: What is the limit?



9.2 Description

L'Hopital's rule should be the formal application for such a question. You are able to learn this rule from an elementary calculus course.
Here, I submit another flavor of solving method. Let the computer program tells you the limit by numerical analysis method.
Analytic method is given by this procedure: execute differential operation once for both of numerator expression and denominator expression, substituted 1 into x, then get answer = 15 / 10 = 3 / 2 = 1.5.
Programming method has no differential treatment inside. We substitute into x with a few real values directly. Values are from a little bit bigger than 1 converged to 1 step by step. Then print out a series of numerical calculation results in sequence. You are able to see the last value in this output listing will be the same answer value as talked above in analytic method.       

9.3 Program

4 reals x y f1 f2
: test ( -- )
basic
10 let { y = 1 }
20 let { y = y / 10 }
30 let { x = 1 + y }
40 if  { x <= 1 } then 90
50 let { f1 = x ^ 15 - 1 }
60 let { f2 = x ^ 10 - 1 }
70 print { x , f1 / f2 }
80 goto -20
90 end ;

9.4 Execution Results

test
1.100000000000000 1.993576910297222
1.010000000000000 1.538574701453724
1.001000000000000 1.503760637188892
1.000100000000000 1.500375106262153
1.000010000000000 1.500037501059981
1.000001000000000 1.500003749983436
1.000000100000000 1.500000374700102
1.000000010000000 1.500000037747582
1.000000001000000 1.500000000000000
1.000000000100000 1.500000000000000
1.000000000010000 1.500000000000000
1.000000000001000 1.500000000000000
1.000000000000100 1.500000000000000
1.000000000000010 1.500000000000000
1.000000000000001 1.500000000000000  ok

9.5 Discussion

Implementation is the best proof for testing of a theory.


(10)


10.1 Question: How big can N be?
  



10.2 Description

this is a question of inequality equation. Replace greater than mark > by equal sign =, we are able to compute out what is the maximum value of this equation.
In the expression, a standard floating point number function of logarithm has been used. If N is to b restricted should be an integer, then mixing operation of integer number and floating point number must to work together effectively in the program. ABC FORTH permits you to do these kinds of arithmetical operation.

10.3 Program

integer n
: test1 ( -- )
basic
10 let n = 0
20 let n = n + 1
30 if { ( log 10 + log 20 ) > ( 2 * log ( i>r ( n ) ) ) } then -20
40 print " max n = " , n - 1
50 end ;

: test2 ( -- )
basic
10 print " max n = " ; {  alog ( ( log 10 + log 20 ) / 2 ) }
20 end ;

10.4 Execution Results

test1 test2
max n =               14
max n =        14.14213562373095   ok

10.5 Discussion

Except integral index of an array or of a matrix, any one integer number should be converted into a floating point number format first, before it can be used in the floating point algebraic expression programming environment. Converting instruction I>R is working totally the same as a general mathematical function do.
Program are translating arithmetical expression into the domain of logical branch condition only. Flowing stream line of program will be guided by this logical branch.
We are going to get the maximum value. Let program started by guess from the smallest value 0. Let value keep going to increase 1 each time while the logical condition is true, until it is failed, that value minus 1 will be the answer.
The same meaning, equal equation with maximum value, expressed as in program test2, will give you the real number answer.

Submit such a topic has another purpose. Logarithmic formulas such as following

Log A*B = Log A + Log B Log A/B = Log A - Log B ...etc.

are not so easy to remember all of them. Even me, especially when I am getting old gradually, it is more difficult to remember as well.  

Solving such a question can help us to remember Logarithmic formulas.

Similarly, if the base of a Logarithm is not 10, for example to be  changed to 2, expressed as following

Ln(2) 8 = n, or  Ln_2 8 = n, or Lb 8 = n

Its directed meaning is 

2 ^ n = 8

Remember this relationship with such an expression can help you everywhere to operate Logarithm function more convenient.

(11)

11.1 Which one do you think is bigger?


11.2 Description

It is impossible to get the exact value of 300 ! in a general FORTH system, except you added big number instructions to it. It has been told that for a 32 bits system, the cover range of a single integer should be less than 12 !. Even though you are able to use floating point function, for an 8 Bytes/Float condition, value of 300 ! is still overflow out of the upper limit 10 to the power of 308, system will warning you: it is 'infinite!'. 10 Bytes/Float format floating point number functions are able to cover the value of 300 !.
ABC FORTH possesses 10 Bytes/Float performance to compute 300 ! directly. Owing to the accumulated error in 300 times computation and inevitable number formats convert, the result value will be last 2 digits inaccuracy. You are able to find it out by compare. please refer to the listing of this big number value in 11.5

11.3 Program

INTEGER I
2 REALS X Y
: TEST ( -- )
BASIC
10 LET { X = 300 ! }
20 LET { Y = 1. E 0 }
30 FOR  I = 1 TO 300
40 LET { Y = Y * 1. E 2 }
50 NEXT I
60 IF { X > Y } THEN 90
70 PRINT " 100^300 > 300! "
80 GOTO 100
90 PRINT " 300! > 100^300 "
100 PRINT { " 300! = " ; X }
110 PRINT { " 100^300 = " ; Y }
120 END ;

11.4 Execution Results

TEST
300! > 100^300
300! = 3.0605751221644063616 E 614
100^300 = 1. E 600 OK

11.5 Discussion

Two programs compute out the value of 300 ! directly. All big number operations are running continuously in the program.

2 INTEGERS I N
0 BIGVARIABLE X
0 BIGVARIABLE Y 40000 ALLOT
: BIG!. ( n -- )
[[ N ]] !
BASIC
10 LET B{ X = BIG0 }B
10 LET B{ Y = BIG1 }B
20 FOR I = 1 TO N
30 LET B{ X = X + BIG1 }B
40 LET B{ Y = Y * X }B
50 NEXT I
60 RUN Y BIG.
70 END ;
or
: BIG! ( n -- addr )
[[ N ]] !
BASIC
10 LET B{ X = BIG0 }B
10 LET B{ Y = BIG1 }B
20 FOR I = 1 TO N
30 LET B{ X = X + BIG1 }B
40 LET B{ Y = Y * X }B
50 NEXT I
70 END
B{{ Y }}B ;

Execute 300 BIG!.  get
615 digits
30605751221644063603537046129726862938858880417357
69994167767412594765331767168674655152914224775733
49939147888701726368864263907759003154226842927906
97455984122547693027195460400801221577625217685425
59653569035067887252643218962642993652045764488303
88909753943489625436053225980776521270822437639449
12012867867536830571229368194364995646049816645022
77165001851765464693401122260347297240663332585835
06870150169794168850353752137554910289126407157154
83028228493795263658014523523315693648223343679925
45940952768206080622328123873838808170496000000000
00000000000000000000000000000000000000000000000000
000000000000000  ok

Simple floating point number computational result is listed here again, please compare it with the listing above.

300! = 3.0605751221644063616 E 614

There are two closed words named BIG!. and BIG! to be used as the name of each program.  Differences are to be arranged on output interface places only. Latter one program could be cited by other advanced using in this  system. This is an intrinsic characteristic of FORTH.  


(12)

12.1 Question: Find the last digit.


12.2  Description

This is another question it results overflow problem in 32 bits system. Let us print out the square value of each integer in sequence first.
   
6 integers i j k l p s
: demo             ( n -- )   \ maximum < 11
[[ j ]] !
basic
10 let k = 0
20 for i = 1 to j
30 print " " ; i ; " ^ " ; i ; " = " , i ^ i
40 let k = k + i ^ i
50 next i
60 print " Sum( " ; j ; " ) = " , k
70 end
;
10   demo1
1 ^ 1 =                1
2 ^ 2 =                4
3 ^ 3 =               27
4 ^ 4 =              256
5 ^ 5 =             3125
6 ^ 6 =            46656
7 ^ 7 =           823543
8 ^ 8 =         16777216
9 ^ 9 =        387420489
10 ^ 10 =     1410065408  <== overflow
Sum( 10 ) =   1815136725  ok

32 bits integer is not much enough to cover 10 to the power of 10. If you don't care overflow factor to write the program as following directly, the answer will be incorrect.  

: test basic
10 let j = 1
20 for i = 2 to 10
30 let j = j + ( ( i ^ i ) mod 10 )
40 next i
50 let j = j mod 10
60 print j
70 end ;  ok
test
             5  ok

Correct answer is 7 is not 5.
10 to the power of 10 is out of the able to represent range in 32 bits integer system. This incorrect result must happened.
Another possible option we can deal with is let the program do the maximum square up to 9 only. Because no matter how many power of 10, the last digit is always to be 0. We don't have to add it. This is not a formal option. If the last power index is far more bigger than 10, trouble is still coming to this kind of program.
Formal option is to do analysis first. Question is asking you what is the last digit? We are able to concentrate our attention on last digit only.
Chinese are familiar with 9 times 9 table and used to do continuous multiplication operation in mind for all single digital number. According to this habit, we know that the result of continuous multiplication for an one digital number itself will be a always fixed number or a sequence of numbers with cycled variation. Result is depended on the multiplication times.
Similarly,  program could followed such a deduction to design. No matter how many times multiplication it did. Let us just reserve the last digital number only, then keep going to do the rest self multiplication. At last, our program is just accumulated all the last digits, it is able to prevent overflow problem.

12.3 Program
  
: test   ( n -- )               \ maximum can up to very huge
[[ j ]] !                         \  highest power is j
basic
10 let s = 0
20 for k = 1 to j           \  for k terms
30 let l = 1
40 for i = 1 to k
50 let l = ( l * k ) mod 10     \ reserve only one last digit, after do multiplication each time
60 next i
80 let s = s + l              \  summation of all last digits
90 next k
100 let s = s mod 10     \ get the last digit of total summation
110 run s .
120 end
;
\ Program main shows out all results for the maximum power from 0 to 20
: main ( -- )
basic
10 for p = 0 to 20
20 print " Last power = " ; p ; " last digit is "
30 run p test
40 next p
50 end ;

12.5 Execution Results

main
Last power = 0 last digit is 1
Last power = 1 last digit is 1
Last power = 2 last digit is 5
Last power = 3 last digit is 2
Last power = 4 last digit is 8
Last power = 5 last digit is 3
Last power = 6 last digit is 9
Last power = 7 last digit is 2
Last power = 8 last digit is 8
Last power = 9 last digit is 7
Last power = 10 last digit is 7    <== the answer of this question is here.
Last power = 11 last digit is 8
Last power = 12 last digit is 4
Last power = 13 last digit is 7
Last power = 14 last digit is 3
Last power = 15 last digit is 8
Last power = 16 last digit is 4
Last power = 17 last digit is 1
Last power = 18 last digit is 5
Last power = 19 last digit is 4
Last power = 20 last digit is 4  ok


12.5 discussion

To replace 20 with many other vales in program main, showed that all digits from 0 to 9 are possible to come out at the last digit position. Such a program is still effective while power is huge.

A special instruction RUN is coming out in both of these 2 programs. RUN has some meanings.

Originally, printing output ability of all traditional BASIC language are limited. You are unable to print out a tied together message of a number and some characters. When you are facing to such a difficult condition, in ABC FORTH, RUN instruction can help you some. This performance has been showed above.

I invented RUN instruction. Features include the inherent spirit of FORTH. Let programs are able to grow up by RUN other words in FORTH.

Conclusion

All questions in all square blocks are copied from BRILLIANT.ORG website:
https://brilliant.org/practice/
Many question examples had been posted over there by many team workers. You are welcome to visit. Smart enough answers for each question are appended to each thread for reference for everybody. I must say thanks to them for citing their materials here.

This article took me more than 12 days to prepare. I posted draft day by day, question by question. Inevitable modification from time to time are always.

To add ABC FORTH on a traditional bare FORTH system is not difficult. It made me daily using FORTH, sometimes as this article described.




My daily thinking today:


Every year, close to 28th February, the current Taiwan government is always sly to cheat all people with something about 228 affairs.

What does '228 affairs' mean?

After world war II, Japan surrender to China, but China government had never asked all Japanese to depart out from Taiwan. Roughly said, over that time, there were about 800 thousand Japanese resident in Taiwan still.
Kindly attitude from Chinese to Japanese had never been fed back any make sense response from Japanese all the time. Instead of such a Chinese kindness to Japanese, many terrible things happened to us in Taiwan after the time of Japan surrender to China.

It was a terrible affair occurred in Taiwan on 28th February 1947. Many successor of Japanese and their stupid follower, communists, and a lot of rubbish people made a comprehensive turmoil in Taiwan.
During the turmoil period of time, there were many people, they are come from Mainland China later, had been killed randomly. Turmoil people robbed weapons from army, occupied government's building as well.
Under such a situation, China government had no choice, military suppress happened, about 600 Taiwanese turmoil people were killed on site in those turmoil affairs, and more than thousand uncountable people come from Mainland China later were killed by turmoil Taiwanese.
The current Taiwan government are organized by folks pigs of Japanese. They used cheating method in national election took over the government. For the present in Taiwan, talking about the people come from Mainland China had been killed in 228 affairs in public site are  prohibited. But those 600+Taiwanese victim family of 228 affairs had got huge compensation money from government already. Some of them are pseudo victims.

This is the true fact of 228 affairs in Taiwan.

Let's tell one true thing had ever happened in 228 affairs.

One person name Liu Chin San. In 1947, he was one of the people come from Mainland China later in Taiwan.
Before 228 affairs, he was one staff worked for a government company to manage exclusive cigarette and liquor.
After 228 affairs happened, one day, he had been hurt under a horrible condition, and had been sent to hospital in Taichung city.
The following day, those hurt Liu's turmoil Taiwanese heard that Liu didn't died and still alive in the hospital. Those turmoil Taiwanese rushed to the hospital immediately and killed Liu in the ward with more terrible actions, cut his ears down and dug his eyes out.
This terrible thing had ever been reported on many newspaper. And there was still a government file recorded that government company had ever arranged Liu's funeral ceremony.
The current Taiwan government would like to cheat everybody with something about 228 affairs. I'd like to tell something of the truth to all of the world.

228 affairs was an interior affairs of China government dealt with Taiwan turmoil. It was not a terrorists attacked events.


二二八真相
二二八期間,台中瘋狂打殺外省人,公賣局專员劉青山被打成重傷住院。第二天暴徒聽說劉青山没死,他们衝到病床前把劉青山打死。割掉耳鼻,挖掉双眼。
劉青山案相關挡案很多,许多报纸报導外,挡案中还有公卖局替劉青山辨公祭的资料。
三月二十五号,台湾已經平静,但是不少外省人夜宿碼頭急着逃離台湾,可見外省人惊恐到什麽程度
民進党天天吵着要真相,现在我㑹不停地告訴你們真相



Announcement to all of the world:



Everybody should know the real historical fact. The territory of Japan should be shrunken to three islands as the following map displayed.





In historical fact, more than 36 sequential islands of Okinawa was Chinese territory originally,
American did the bad arrangement on purpose, let it occupied by Japanese after World War II.

There was a nation organized by the aboriginal people named Ar-yi-nu kingdom on whole Hokkaido island.
Japanese killed almost all aboriginals on this island and occupied it.