·

**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 ;

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

\ 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 Description

(2)

2.1 Question： How many squares are in
the 20th figure?

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 Question：What 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 Question：Can 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.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.

My daily thinking today:

(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.

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

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.