JPH0749652A - Language learning device - Google Patents

Abstract

PURPOSE:To add the variation to a question for learning roman letters and to increase a learning effect by providing an input device, a display device, a word leaning means and learning data storage means and further a means for learning the roman letters. CONSTITUTION:A sub routine for gaining a learning data number is called by a key board 1, and the input request picture of the learning data number is displayed, and the learning data number is inputted. Then, the sub routine for calling out the learning data of the learning data number from the learning data storage means 5 to respective variables, tables is called, and the learning data of the learning data number are called out to respective variables, tables. The sub routine for displaying the called learning data is called, and a learning picture is displayed on the display device 2. Then, a function type sub routine for learning the Roman letters and returning the result is called, and the learning of the roman letters are performed, and the result is stored in a variable CLEAR. By the function type sub routine, zero is returned when the learning is ended, and one is returned when the learning is reexecuted, and the learning is re-executed or ended by judging the CLEAR value.

Description

Detailed Description of the Invention

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a language learning device in a personal computer, a document editing device, an information device or the like.

[0002]

2. Description of the Related Art A conventional language learning device is disclosed in Japanese Patent Application No. 4-139.
No. 111 publication.

[0003]

With the above-mentioned conventional technique, it is impossible to learn Roman characters. Moreover, since the problem is only the array of the stored data, learning was very monotonous. An object of the present invention is to improve the learning effect by changing the problem of learning Romaji.

[0004]

The above object can be achieved by providing a means for learning Romaji in a word learning device having an input device, a display device, a language learning means and a learning data storage means.

[0005]

The data stored in the learning data storage means is displayed on the display device, the Romaji learning means is performed using the input device, and the result is stored in the learning data storage means. Language learning is performed as a problem of the learning means. .

[0006]

Embodiments will be described in detail below with reference to embodiments of the present invention.

FIG. 1 is a block diagram of a word learning device showing an embodiment of the present invention, which comprises an input device such as a keyboard 1, a display device 2, means for learning Roman letters 3, and known word learning means 4. It

As shown in FIG. 2, the keyboard 1 is composed of a cursor key 11 for moving a character, a function key 12 for executing re-execution by a language learning device, and the like.

The Romaji learning means will be described below with reference to the flowchart of FIG.

First, a subroutine GET ¥ LN for obtaining a learning data number is called, a learning data number input request screen is displayed as shown in FIG. 21, and the learning data number is input (70).

Next, a subroutine SET \ DATA for calling the learning data of the learning data number LN from the learning data storage means 5 to each variable and table is called, and the learning data of the learning data number is called to each variable and table (71). The learning data is composed of a cursor “♀”, an obstacle “black square”, and English letters. The obstacle "black square" is placed to limit the operation of moving the alphabet with the cursor and to enhance the game.

Call the subroutine INIT \ DSP for displaying the read learning data,
As shown in FIG. 22, the learning screen is displayed on the display device 2 (72).

Next, a romanized alphabet is learned and a function type subroutine GAME for returning the result is called to learn the romanized alphabet and the result is stored in a variable CLEAR (7).
3). As a result, this functional subroutine returns a value 0 when learning is completed and a value 1 when the same learning is re-executed.

Next, the value of CLEAR is determined, and if the value is 1, the same learning is performed again from the beginning. If the value is 0,
Romaji learning ends (74).

The individual subroutines will be described in detail below.

Subroutine G for acquiring learning data number
ET \ LN is shown in FIG.

In this subroutine, first, the learning data number input request screen shown in FIG. 21 is displayed, the learning data number is input, and the learning data number is stored in the variable LN. FIG. 5 shows a subroutine SET \ DATA for calling the learning data of the learning subroutine number LN from the learning data storage means 5 into each variable and table.

In this subroutine, variables NI and NA are
I, NK, NR, CRSX, CRSY, table K (i),
i = 0, 1, ..., 2 + NK, ID (i, j), i = 0,
1, ..., 4, j = 0,1, ..., NAI-1, G (i,
j), i = 0, 1, ..., 13, j = 0, 1, ..., 9, R
Store the following values in (i), i = 0, 1, ..., 2 + NR
(711).

The variable NI is the initial value of the number of Hiragana (Roman characters) created in the displayed English characters (the number of Hiragana (Roman characters) displayed during learning is stored in the variable ENI), N
AI stores the total number of hiragana (Roman characters) that can be configured with the displayed English characters, NR stores the number of displayed English characters, and NK stores the number of Hiragana characters (Roman characters) that can be created with the displayed English characters.
CRSX and CRSY are screen tables G described below.
Stores the cursor position on (i, j). CRSX stores the position in the X direction (horizontal direction), and CRSY stores the position in the Y direction (vertical direction). R (i) is an alphabetic table that stores, in order, an empty pattern, a cursor, an obstacle, and a display pattern of an alphabetic group to be displayed. K (i) is a hiragana table, which stores, in order, an empty pattern, a cursor, an obstacle, and a display pattern of a hiragana group to be displayed. ID
(i, j) is a Roman character table, and ID (i, j), i
The alphabetic table numbers forming the idioms are stored in = 0, ..., 3 and 0 is stored in the empty space to form one Roman character.
G (i, j) is a screen table which stores display data (alphabetic characters / Hiragana table number) to be displayed on the display device. An example of reading the learning data is shown in FIGS. In this example, the initial value NI of the number of Hiragana (Romaji) created in the displayed alphabet is 3, all the Hiragana (Romaji) numbers NAI that can be composed of the letters displayed are 3, and the number of English letters NR displayed is 6 The number of hiragana (romaji) characters NK that can be created in English is 6, and the cursor position (CRSX,
CRSY) is (8,6). English table R (i) is
The empty pattern is "", the cursor pattern is "♀", the obstacle pattern is "black square", the alphabet display pattern is "T", "A", "N", "U", "K",
It is "I". In addition, in the hiragana table K (i), an empty pattern is “”, a cursor pattern is “♀”,
It shows that the pattern of the obstacle is "black square" and the alphabet display pattern is "ta", "nu", "ki", "tsu", "chi", "na" .... Romaji table ID (i, j)
Is a roman alphabet that can be composed of "TA", "NU",
“KI”, “TU” ...

FIG. 6 shows a subroutine INIT \ DSP for displaying the read learning data.

In this subroutine, the screen is first erased (721) and the title is displayed (722) as shown in FIG.

Further, the operation guide is displayed as shown in FIG. 22 (723).

Next, the screen table G (i, j), i = 0,
, ..., 13, j = 0, 1, ..., 9 are displayed using the subroutine DSPL for displaying screen data (72
4). At this time, the upper left position of the Romaji learning screen shown in FIG. 22 is set to (0, 0), and G (i, j), i = 0, 1,
..., 13 in the X direction (horizontal direction), G (i, j), j = 0,
1, ..., 9 are displayed in the Y direction (vertical direction).

For example, the screen table G shown in FIG.
In the case of (i, j), when this subroutine is executed, the screen is displayed as shown in FIG.

FIG. 7 shows a functional subroutine GAME for learning Roman letters and returning the result. This functional subroutine returns a value 0 when learning is completed and a value 1 when the same learning is restarted from the beginning.

First, the initial value NI of the number of hiragana (Roman characters) created in the displayed English characters is stored in the variable ENI (731). Next, it is judged from the variable ENI whether all the hiragana to be created have been created (732), and if there is no hiragana to create, the value 0 is returned to indicate that the learning of Romaji has ended, and the process ends.

If all hiragana have not been created,
Call the functional subroutine GETKEYNO, enter the key,
For the input key, the key table number shown in FIG. 9 is acquired and stored in the variable KEYNO (733).

The function type subroutine GETKEYNO performs key input as shown in FIG. 8, compares the input key with the key table shown in FIG. 9, and if there is the same key as the input key, the key table number. return it. If not, re-enter the key. The key table number to be returned is 0 when the input key is “→” of the cursor key 11, “1” when the cursor key 11 is “←”, 1 when the cursor key 11 is “↑” 2, and “↓” of the cursor key 11 When 3, "F1"
When it is 12, it is 4.

After the function-type subroutine GETKEYNO is called to obtain the key table number, each process is performed according to the key table number.

When the input key is the cursor key 11, X
Variables MVX and MVY indicating the movement amounts in the direction and the Y direction are set (734). When "→", X direction is 1, Y direction is 0, when "←", X direction is -1, Y direction is 0, and when "↑", X direction is 0, Y direction is -1, "↓" In this case, the X direction is set to 0 and the Y direction is set to 1.

After setting the variable indicating the movement amount, the function type subroutine MOVE is called with the movement amount as a parameter, it is determined whether or not the cursor can be moved, and the result is stored in the variable OK (738). As a result, this functional subroutine returns a value 0 when the cursor cannot be moved, a value 1 when only the cursor can be moved, and a value 2 when an alphabetic character can be moved along with the movement of the cursor.

Next, the OK value is determined. If the value is 0, the cursor cannot be moved, so an abnormal sound is output and the next input is made (7
39).

Next, the OK value is determined. If the value is 1, the cursor is moved only. Therefore, the subroutine MVCRS is called with MVX and MVY as parameters to move the cursor (740).

If the value of OK is not 1 (when it is 2), the letters move as the cursor moves, so MVX, MV
The subroutine MVKCRS is called with Y as a parameter to move the cursor and alphabetic characters (741). After moving, MVX, M
Call the functional subroutine CHKIDM with VY as a parameter to determine whether or not hiragana (romaji) can be constructed by moving the letters, and if hiragana (romaji) can be constructed, erase the letters that compose these hiragana (romaji). The created hiragana is displayed, and the created hiragana (Romaji) number is stored in the variable CNI (742).
This functional subroutine returns the number of hiragana (romaji) created. A value of 0 is returned if the Hiragana (Roman alphabet) cannot be constructed.

Next, the Hiragana (Roman character) number CNI created is subtracted from the Hiragana (Roman character) number ENI created in the displayed English characters (743), and the next input is performed.

When the input key is "F1" 12, the value 1 is returned to indicate that the same learning is restarted from the beginning, and the processing is ended (735).

FIG. 10 shows a functional subroutine MOVE for determining whether or not the cursor can be moved. This functional subroutine has MVX and MVY indicating the movement amount in the X direction and the Y direction as parameters, and as a result, the value 0 when the cursor cannot be moved, the value 1 when only the cursor can be moved, and the character (alphabetic / hiragana) ) Also returns a value of 2 when it can move.

First, a variable OK for storing the value returned from this functional subroutine is initialized to 0 (7381).

Next, the current cursor position (CRSX, C
The movement amount (MVX, MVY) is added to (RSY) to obtain a new cursor position (TX, TY) (7382).

It is determined whether or not the new cursor position (TX, TY) is an obstacle, and if the obstacle is an obstacle, the value cannot be moved.
Is returned and the process ends (7383).

It is determined whether or not there is nothing at the new cursor position (TX, TY). If there is nothing, only the cursor is moved, so the value 1 is returned and the processing is terminated (7384).

If the judgments of 7383 and 7384 are not established, it means that there is a character next to the cursor in the movement direction.

It is judged whether or not there is anything at the destination of the character while moving in the X direction. If there is nothing, it is possible to move with both the cursor and the character. Similarly,
It is determined whether or not there is anything at the destination of the character while moving in the Y direction. If there is nothing, the cursor and the character can both be moved, so the value of 2 is returned and the process ends (7386). 7385 and 7386
If the determination is not satisfied, it corresponds to the case where the cursor and the character cannot be moved. Therefore, the value 0 is returned and the process ends.

Subroutine MVCR for moving cursor
S is shown in FIG. This subroutine has MVX and MVY indicating the movement amounts in the X and Y directions as parameters.

First, the cursor positions CRSX, CRSY
Is called as a parameter, the subroutine CLRL is called, the cursor is erased, and the screen table G (CRS
The alphabetic table number 0 (no pattern) is stored in (X, CRSY) (7411). Next, the movement amounts in the X and Y directions are added to the cursor position to obtain a new cursor position (7412).

New cursor positions CRSX, CRSY,
Call the subroutine DSPL with the alphanumeric table number 1 (indicating the cursor) and MODE "0" (alphanumeric display "0", hiragana display "1") indicating the alphabet / hiragana display type as parameters and displaying the cursor The screen table G (CRSX, CRS at the new cursor position)
The value of (Y) is set as a cursor (7413).

FIG. 12 shows a subroutine MVKCRS for moving both the cursor and the character. This subroutine is a parameter MVX, MV indicating the amount of movement in the X and Y directions.
Have Y.

In this subroutine, the subroutine MVKNJ is called with MVX and MVY as parameters to move the character. Next, the subroutine MVCRS is called by using MVX and MVY as parameters, and the cursor is moved.

FIG. 13 shows a subroutine MVKNJ for moving characters. This subroutine uses X as a parameter
It has MVX and MVY indicating the movement amount in the Y direction.

First, the character positions TX and TY to be moved from the cursor position and the movement amount are moved from the screen table G (TX, TY) at the position of the moving character to the character (alphabetic / hiragana) table number TL. Seeking (742)
1).

The value stored in the screen table G (TX, TY) stores the value obtained by adding 1000H to the table number for distinguishing the alphabet / hiragana table number.

Next, the subroutine CLRL is called with the positions TX and TY of the moving characters as parameters, the moving characters are erased, and the alphabet table number 0 (no pattern) is stored in the screen table G (TX, TY). Yes (7422).

New positions TX and TY of the moving character are obtained from the position of the moving character and the moving amount (7423).

Next, the character to be moved is determined (742)
4) If the character to be moved is hiragana, a new position TX, TY of the moving hiragana, the hiragana table number TL of the moving hiragana, and the hiragana movement mode 1 are used as parameters to call the subroutine DSPL, and the hiragana is moved to the new position. Is displayed (7425). If the moving character is an alphabetic character, the new position of the moving alphabetic character TX, TY,
Alphabet table number of moving alphabet (TL-1000
H), the subroutine DSPL is called by using the alphabet movement mode 0 as a parameter, and the alphabet is displayed at a new position (7426).

Next, the character table number TL of the character is stored in the screen table G (TX, TY) (7427).

It is determined whether or not a hiragana (Roman character) can be constructed by moving an English character, and if a Hiragana (Roman character) is constructed, the English characters that compose these Hiragana (Roman characters) are deleted and the number of Hiragana (Roman alphabet) created is returned. The functional subroutine CHKIDM is shown in FIGS. This function-type subroutine has MVX and MVY indicating the movement amounts in the X and Y directions as parameters.

First, the created hiragana (Romaji) number CNI is initialized (7431), and the cursor position CRS is set.
The positions TX and TY of the letters moved from X, CRSY and the movement amounts MVX and MVY are obtained (7432).

Next, it is determined whether or not a hiragana (Roman character) cannot be formed in the X and Y directions. Judgment is made from left to right in the X direction and from top to bottom in the Y direction.

In order to determine whether or not a Hiragana (Roman character) cannot be constructed in the X direction, the position obtained by subtracting 1 from the aerosol position CRSX is set as the first Hiragana (Roman character) determination position X in the X direction (7433). In this case, the Y direction is TY fixed.

Next, based on this position, hiragana (Romaji) judgment is performed.

It is judged whether or not X is less than or equal to the position TX of the moved English character in the X direction (step 7434).

If it exceeds TX, the hiragana (romaji) determination process in the X direction is ended, and the hiragana (romaji) determination process in the Y direction is performed.

In case of TX or less, hiragana (romaji)
Judgment position X, TY, hiragana (romaji) The function type subroutine CMPIDM is called with the value 0 indicating that the judgment is in the X direction as a parameter, it is judged whether or not hiragana (romaji) cannot be constructed, and the result is stored in the variable CMP. (7435). This functional subroutine returns a value 1 when a Hiragana (Roman character) can be constructed and a value 0 when a Hiragana (Roman character) cannot be constructed.

As a result of the hiragana (Romaji) determination, it is determined whether CMP is 0 or not. If it is not 0, the start position X, TY of the hiragana (Roman character), the direction 0 (indicating the X direction) of the Hiragana (Roman character) is converted to the Hiragana conversion table CG (CNI, 0), CG (CNI, 1), CG (CN).
I, 2) Hiragana (Romaji) number CN stored and worked
Count up I (7436).

Hiragana (Romaji) judgment position X in the X direction
Is counted up (7437) and hiragana (Romaji) judgment is performed at the next position.

Hiragana (Romaji) judgment in the Y direction is similarly performed.

In order to determine whether or not a Hiragana (Roman character) cannot be constructed in the Y direction, the position obtained by subtracting 1 from the cursor position CRSY is set as the first Hiragana (Roman character) determination position X in the X direction (7438). In this case, the X direction is fixed to TX.

Next, based on this position, hiragana (romaji) is judged.

It is determined whether Y is equal to or less than the position TY of the moved English character in the Y direction (7439).

If it exceeds TY, the hiragana (romaji) determination processing in the Y direction is ended, and the conversion processing of the constructed hiragana (romaji) is performed.

If it is less than TY, hiragana (romaji)
Judgment position TX, Y, hiragana (romaji) The function type subroutine CMPIDM is called with the value 1 indicating that the judgment is in the Y direction as a parameter, it is judged whether or not hiragana (romaji) cannot be constructed, and the result is stored in the variable CMP. (7440).

As a result of the hiragana (Romaji) determination, it is determined whether CMP is 0 or not. If not 0, the start position TX, Y of the hiragana (Roman character) and the direction 1 (indicating the Y direction) of the Hiragana (Roman character) are shown in FIG. 22. The Hiragana conversion table CG (0, CNI), CG (1, CNI) , C
Stored in G (2, CNI) and created Hiragana (Romaji)
The number CNI is counted up (7441).

Hiragana (Romaji) judgment position Y in the Y direction
Is counted up (7442), and hiragana (Romaji) determination at the next position is performed.

After the hiragana (romaji) in the X and Y directions is determined, the conversion processing of the created hiragana (romaji) is performed.

A variable I indicating a hiragana (Roman character) to be converted is initialized (7443).

Hiragana (Romaji) number CN for which I was created
It is determined whether it is less than I (7444). If it is equal to or more than CNI, there is no hiragana to be converted, so the created hiragana (Romaji) CNI is returned as the value of this functional subroutine, and the processing ends.

If it is less than CNI, the start position CG (CNI, 0), CG (CNI, 1) of the hiragana (Roman character) stored in the hiragana conversion table is stored in the hiragana display position X, Y ( 7445).

In addition, the direction CG of the hiragana (romaji)
It is determined whether or not (CNI, 2) is 0, and if it is 0, it is stored in the X-direction movement amount IX 1 and 0 in the Y-direction movement amount IY when converting to Hiragana (Roman characters). To do. If it is other than 0, it is Hiragana (Roman character) in the Y direction, so 0 is stored in IX and 1 is stored in IY (744).
6). Next, the hiragana conversion processing when the hiragana (romaji) is formed is performed.

A variable J indicating the position of an alphabetic character to be converted is initialized (7447).

It is determined whether J is less than 3 characters forming the hiragana (Roman character) (7448).

When it is 3 or more, I is incremented (7453) and the next hiragana conversion process is performed.

If it is less than 3, it is determined whether the variable J is the Hiragana conversion start position (7449). In the case of the hiragana conversion start position, the X direction hiragana display position variable X, the Y direction hiragana display position variable Y, the variable ROMA indicating the hiragana table number, and the MOD indicating the alphabet / hiragana display type.
The subroutine DSPL is called with E "1" as a parameter, and the converted hiragana table number is stored in the screen table G (CRSX, CRSY) (7450). If it is other than the Hiragana conversion start position, the Hiragana conversion position X,
The subroutine CLRL is called with Y as a parameter to erase the letters at the positions X and Y, and the screen table G at that position is displayed.
The Kanji table number 0 (no pattern) is stored in (X, Y) (7451).

Moving amounts IX, I at the hiragana conversion positions X, Y
Y is added and J is incremented to perform the next hiragana conversion process (7452).

A functional subroutine CMPI that determines whether or not the hiragana (romaji) is not converted and returns the result.
DM is shown in FIG. This function-type subroutine uses, as parameters, the start position X, Y, for hiragana (romaji) determination.
It has Hiragana (Romaji) direction D (0 in X direction, 1 in Y direction). Further, as a result, a value 1 is returned when a hiragana (Roman character) can be constructed, and a value 0 is returned when a hiragana character cannot be constructed.

First, the judgment result CMP is initialized (8
011).

It is determined whether the screen table G (X, Y) at the start position of the hiragana (romaji) determination is an alphabetic table number 1002H or less (in the case of hiragana table number, no pattern, cursor, obstacle) (8012). . 1
In the case of 002H or less, since hiragana (Roman characters) cannot be constructed, the value 0 is returned and the process is terminated. If it exceeds 1002H, since it is an alphabetic character, the process of hiragana (romaji) determination is continued.

The direction of the hiragana (Roman character) is judged and 0
In the case of, since the hiragana (Roman character) in the X direction is 1, the movement amount IX in the X direction is 1 when the comparison is performed, and the movement amount IY in the Y direction.
0 is stored in. If it is other than 0, it is Hiragana (Roman character) in the Y direction, so 0 is stored in IX and 1 is stored in IY (8
013).

A variable I indicating the Romaji table number to be compared is initialized (8014).

It is judged whether or not I is less than the number NAI of all the hiragana (Roman characters) that can be composed of the displayed alphabetic characters (80
15). In the case of NAI or more, there is no Romaji table to be compared, and since Hiragana (Romaji) is not configured, the value 0 is returned and the process ends. If it is less than NAI, it is compared with the Romaji table.

In order to make a comparison with the Romaji table,
Initialize a variable J indicating the position of an alphabetic character to be compared (801
6).

It is determined whether J is less than 3 characters forming one hiragana (Roman character) (8017).

In the case of 3 or more, the alphabetic character string to be judged is the Roman character table ID (I). Since Romaji can be constructed corresponding to C (J), J = 0, ..., 2, the value 1 is returned (801
8), ID to the variable ROMA indicating the hiragana table
(I). The value of N is stored (8019) and the process ends.

When the number is less than 3, the comparison target screen table G (X + IX × J, Y + IX × J) and the Roman character table I
D (I). It is determined whether C (J) is not equal (802
0), if not equal, I is incremented and compared with the next Romaji table (8021).

If they are equal, J is counted up and the next alphabetic character is compared (8020).

FIG. 16 shows a subroutine DSPL for displaying character (alphabet / hiragana) table data. This subroutine has display positions X and Y as parameters, a character table number LNO of the data to be displayed, and a MODE indicating the type of data to be displayed (alphabetic / hiragana).

The processing judges the value of the variable MODE,
When the value of DE is 0, the alphabetic table data R (LNO) designated at the designated positions X and Y is displayed. Also,
When the value of MODE is 1, the hiragana table data K (LNO) designated at the designated positions X and Y are displayed.

Subroutine CL for deleting display data
The RL is shown in FIG. This subroutine has erase positions X and Y as parameters.

In the processing, "" is displayed at the designated position X, Y and the displayed data is erased.

As described above, in the Roman character learning apparatus of this embodiment, the displayed English characters are moved by using the cursor to arrange the English characters in the vertical direction (from the top to the bottom) or in the horizontal direction (from the left to the right) to read the hiragana characters. Make up (Roman alphabet). As shown in FIG. 24, when a hiragana (Roman character) is constructed, it is converted into hiragana which is indicated by a combination of the constituent English characters and displayed.

According to the present embodiment, the Romaji can be learned like a game, so that the learning can be done without getting tired and the learning effect is improved. Further, as shown in the table example in FIG. 20, the position where the hiragana is combined in the Roman alphabet learning is
Since it becomes the display pattern of the language learning that is continuously performed, the variation of the language learning problem increases.

[0101]

According to the present invention, it is possible to learn Roman letters as if playing a game. Also, if you move the displayed letters to form hiragana (romaji), the letters of the letters will be converted to hiragana, and you can learn the following words based on those words, so there will be more variations in the language learning problem. .

[Brief description of drawings]

FIG. 1 is a configuration diagram showing an embodiment of the present invention.

FIG. 2 is a diagram showing a configuration example of a keyboard.

FIG. 3 is a flowchart showing a process of the Roman character learning device according to the embodiment of the present invention.

FIG. 4 is a flowchart showing a process of a subroutine GET ¥ LN.

FIG. 5 is a flowchart showing the processing of a subroutine SET ¥ DATA.

FIG. 6 is a flowchart showing the processing of a subroutine INIT \ DSP.

FIG. 7 is a flowchart showing a process of a functional subroutine GAME.

FIG. 8 is a flowchart showing the processing of a functional subroutine GETKEYNO.

FIG. 9 is a diagram showing allocation of key tables.

FIG. 10 is a flowchart showing the processing of a functional subroutine MOVE.

FIG. 11 is a flowchart showing a process of a subroutine MVCRS.

FIG. 12 is a flowchart showing a process of a subroutine MVRCRS.

FIG. 13 is a flowchart showing a process of a subroutine MVRNJ.

FIG. 14 is a flowchart showing a process of a subroutine CHKIDM.

FIG. 15 is a flowchart showing a process of a subroutine CHKIDM.

FIG. 16 is a flowchart showing the processing of a functional subroutine CMPIDM.

FIG. 17 is a flowchart showing processing of a functional subroutine DSPL.

FIG. 18 is a flowchart showing the processing of a subroutine CLRL.

FIG. 19 shows variables NI, NAI, NR, NK, CRSX,
It is a figure which shows the allocation example of CRSY, an English character table, a Roman character table, and a Hiragana table.

FIG. 20 is a diagram showing an example of screen table allocation.

FIG. 21 is a diagram showing an example of a learning data number input request screen.

FIG. 22 is a diagram showing an output example of a Romaji learning screen.

FIG. 23 is a diagram showing an example of a hiragana variable table.

FIG. 24 is a diagram showing an example of a training screen for learning Romaji.

[Explanation of symbols]

1 ... Input device, 2 ... Display device, 3 ... Romaji learning means,
4 ... Word learning means, 5 ... Learning data storage means.

 ─────────────────────────────────────────────────── ─── Continuation of the front page (72) Inventor Toshio Kushida 1-1-1, Higashitaga-cho, Hitachi-shi, Ibaraki Hitachi Ltd. Information & Video Media Division

Claims (2)

[Claims] 1. A word learning device comprising a input device, a display device, a word learning means, and a learning data storage means, and a means for learning Romaji. 2. The word learning device according to claim 1, wherein the learning result of the means for learning Romaji is used as learning data of the word learning device.