1.                  
                      

    .  ࠧ  ⮨   ᭮
⮢: ᨬ,   ᫮, ᫮⠭  ।. ⬨-
᪨  ᮤন  , ⮫쪮 ᫮ 뢠 -
묨 ﬨ, ᫮⠭-ࠦﬨ, ।--
ࠬ.  ,    樨,  ࠦ   
⠢  ,  ᪮  -
樨 ࠧ  ᫥⥫쭮 ᨬ, ࠦ- ᫥-
⥫쭮  権  ᨬ,   -᫥-
⥫쭮 ࠦ,  権  ᨬ.
      ᠭ   ⮢. ᠭ
ᨬ 砥    ᫥ ⨬ ᨬ 몠.  
ᠭ  権  ࠢ    ࠧ.
ᠭ ࠦ-  ࠢ ࠧ  ࠦ,  
   몥.  ᠭ ஢  ⮨    ᬮ७
 ⨯ ஢,  ⨬  몥. ᠭ  
몠     . ⠪᪨ ।-
 ⠭ ࠢ ஥ ⮢ 몠. ⨪ -
   ࠢ ᯮ짮  ⮢ 몠,  
뫨  ᨭ⠪᪨ ।.
    몠- ᭮  ,  ନ  -
  ⥪  몥.
      -   몠,  騥
ᠬ⥫ .  ࠧ  ᭮ ᨬ 몠.
     ⬨᪮ 몥 ⮨      -
権   ᨬ,    ࠢ ᫥ ண -
.
      ᠭ ண ⢨, ஥ -
室 믮.   ᠭ ᫮ ⢨  ॡ
㯯 ஢.    ⮬ 砥  ꥤ  
  .
   ⢨,  ࠬ, 믮  . ।-
 ⬨᪮ 몠,    ᢥ  ⨯ ,
뢠   ᯮ塞묨 ࠬ.
   ꥤ  ⬮ ᮢ㯭 ᠭ   ஢
ࠧ   ⬨᪮ 몥.
     祭 ⬨᪮ 몠 室 ⫨ -
⬨᪨    ⮣ 몠,    ண ⢫
ᠭ 砥 ⬨᪮ 몠. 筮 砥  -
뢠    몮,   ,   ନ ண  ᠭ
砥 몠 - .
   ⠪᪨ ।      ଠ묨  -
ଠ ᯮᮡ.   ଠ ᯮᮡ:
   -⠫᪠ ᨬ, 뢠 - 㫠;
   -ᨭ⠪᪨ ࠬ;
   -᪮ 樨.
     ᫥饬  㤥 짮 ଠ  ᯮ-
.


2.                   

   ᭮ ᨬ 몠-㪢,    ᯥ樠 ᨬ-⠢-
    䠢.     砥 ᫥騩  ᭮
ᨬ:
   1) 26 ⨭᪨   26 ⨭᪨ ய 㪢:
     A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
     a b c d e f g h i j k l m n o p q r s t u v w x y z
   2) _ ન
   3) 10 :
     0 1 2 3 4 5 6 7 8 9
   4)  権:
     +   -   *   /   =   <>   <   >   <=   >=   :=  @
   5) ࠭⥫:
     .   ,   '   (   )   [   ]   (.  .)   {  }  (*  *)   ..   :   ;
   6) ᯥ䨪:
     ^  #  $
   7) 㦥 (१ࢨ஢) ᫮:

ABSOLUTE          EXPORTS           LIBRARY           SET
ASSEMBLER         EXTERNAL          MOD               SHL
AND               FAR               NAME              SHR
ARRAY             FILE              NIL               STRING
ASM               FOR               NEAR              THEN
ASSEMBLER         FORWARD           NOT               TO
BEGIN             FUNCTION          OBJECT            TYPE
CASE              GOTO              OF                UNIT
CONST             IF                OR                UNTIL
CONSTRUCTOR       IMPLEMENTATION    PACKED            USES
DESTRUCTOR        IN                PRIVATE           VAR
DIV               INDEX             PROCEDURE         VIRTUAL
DO                INHERITED         PROGRAM           WHILE
DOWNTO            INLINE            PUBLIC            WITH
ELSE              INTERFACE         RECORD            XOR
END               INTERRUPT         REPEAT
EXPORT            LABEL             RESIDENT

   ஬ ᫥,   ᭮ ᨬ 室 ஡. -
  ᯮ짮  ᤢ ᨬ   १ࢨ஢-
 ᫮.
    
3.                           
    
    樨 몠    ᥡ , -
  ப.
    (䨪) 뢠  몠 - ⠭, ⪨,
⨯, ६, 楤, 㭪樨, 㫨, ꥪ.  -  -
⥫쭮 㪢  , 稭  㪢.    -
짮 ᨬ _ ન.   ᮤঠ ந쭮
⢮ ᨬ,  騬  63 ᨬ.
    ࠧ蠥    몥  ᯮ짮  ⢥  -
 ᫮  ⠭ ,  묨  ⠭ -
⠭, ⨯, 楤, 㭪樨  䠩.
    襭 來 ணࠬ    ⠢ ஡-
.     ࠩ      ஡  ॡ ⠢  
᫥⥫묨 , ᫠  㦥묨  ⠭묨 -
. ஡  ᯮ짮    ᥫ.
     ਬ  몠 :

    A    b12    r1m    SIGMA    gamma    I80_86

   ᫠  몥  筮  뢠    筮  ⥬
᫥.       楫묨  ⢨⥫묨.  ⥫
 ᫠   饭.   ᫠ 뢠   ଥ  
筮 窨, ਬ:

     217    -45     8954   +483

   ⢨⥫ ᫠  뢠  ଥ  筮 窮 
 ଥ  ᯮ짮  筮 浪,    ࠦ
㪢 :

    28.6     0.65     -0.018   4.0   512   -1.729   73.1-16
    
    ᪠    楫 ᥫ  ࠣ⮢ ⢨⥫
ᥫ  ଥ  浪  ⭠筮 ⥬ ᫥:
    
    $7F     $40      $ABC0

   ப  몥  -  ᫥⥫쭮 ᨬ, ᠭ-
  䠬.  ᫨  ப  ⢥ ᮤঠ⥫쭮 ᨬ-
 室 㯮ॡ ᠬ ,     ᫥    
. ਬ ப:

  ''   'STRING'    ''    ''''
              

4.                 
          

    ⥬⨪  ਭ ஢ ६  ᮮ⢥⢨ 
묨 묨 ࠪ⨪. ந ண ࠧ࠭-
  ⢥묨, 묨  ᪨ ६묨, -
 ६묨, ।⠢騬 ⤥ 祭  ⢮ -
  ⠪ .
    ࠡ⪥    ⠪ 䨪   . 
 ⬨᪮ 몥  ⠭,  ६,  ࠦ
 㭪 뢠 । ⨯.
    몥    ࠢ:  ⨯    ᠭ
६  㭪樨,  ஥ ।  ᯮ짮.  -
楯 ⨯ 몠   ᫥騥 ᭮ ᢮⢠:
   - ⨯  । ⢮ 祭,   ஬  -
 ⠭,   ਭ ६  ࠦ,
 ࠡ뢠   㭪;
   -⨯ 祭,   ⠭⮩, ६  ࠦ,
 ।     ᠭ;
   -   㭪 ॡ 㬥⮢ 䨪஢ -
  뤠 १ 䨪஢ ⨯.
    ᫥,  ࠭  ᯮ짮 ଠ  -
  ஢ન ᫨  ࠢ쭮 ࠧ 権.
    ।:
   - 祭 ६, ⠭, 㭪権, ࠦ, -
   ⨯;
   -७  ।⠢   ;
   -樨   㭪樨,      믮  稭,
ਭ騬   ⨯.
   易⥫쭮 ᠭ ⨯ ਢ  筮  ⥪ ண-
ࠬ,    ⠪ 筮   ᯮ⥫ ।-
⢮ ࠧࠡ⪨ ணࠬ  ᬠਢ  室  ᢮⢮
ᮢ६ ⬨᪨ 몮 ᮪ ஢.   몥 
 ᪠  ஢ ⨯ .
     c ⨯ ⭮ ⠭ ⨯  ⨯, ।-
 짮⥫.
   ⠭ ⨯    楫,   ⢨⥫,   ᨬ,
᪨   ⨯. , ।塞 짮⥫, - -
塞  ࢠ.
   ஢ ⨯   ࠧ:  ᨢ,  -
⢠,   䠩.
   ஬ ᫥,  TURBO PASCAL  砥   ⨯ - -
  ꥪ.
    㯯 ᪠ ⨯  뤥  浪  ⨯,
 ࠪਧ ᫥騬 ᢮⢠:
   -  祭 浪 ⨯ ।⠢ ᮡ
࠭祭 㯮冷祭 ⢮;
   -  浪 ⨯   ਬ ⠭⭠
㭪 Ord,   ⢥ १ 頥 浪-
  ⭮ 祭   ⨯;
   -  浪 ⨯   ਬ ⠭
㭪樨 Pred  Succ,   ।饥  ᫥-
饥 祭 ᮮ⢥⢥;
   -  浪 ⨯   ਬ ⠭ 㭪-
樨 Low  High,    襥  襥 祭
稭  ⨯.
    몥    ⭮  ᮢ⨬ ⨯.
    ⨯ 1  2  묨 (묨),  ᫨ 믮
   ᫮:
   -1  2 ।⠢ ᮡ      ⨯;
   -⨯ 2  ᠭ   ᯮ짮 ⨯ 1   ࠢ⢠ 
᫥⥫쭮 ࠢ. ਬ:

   type
      T1 = Integer;
      T2 = T1;
      T3 = T2;

    ண ࠭祭 । ᮢ⨬ ⨯. -
, ⨯  ᮢ⨬묨, ᫨:
   - ;
   -   楫묨,  ⢨⥫묨;
   - ⨯ - ࢠ, 㣮 -  ;
   - ࢠ  騬 ;
    ⨯ - ப, 㣮 - ᨬ.
      ࠭祭  ᮢ⨬ ⨯   
 ਢ  ⨯.  ਢ ⨯  ᬠਢ
    稭     ਭ  ࠧ  ⨯.
 ⮣ ᯮ 

   _(६  祭).

   ଥ,

    Integer('Z')

।⠢ ᮡ 祭  ᨬ 'Z'  塠⭮ ।⠢-
 楫 ᫠, 

    Byte(534)

 祭 22, ᪮ 楫 ᫮ 534  ⨯ Word  -
  ,  ⨯ Byte   ,    ਢ
訩  㤥 襭.


5.                   
     

    ⠭  ⭮  楫,    ⢨⥫,    ᪨,
ᨬ   ⨯.

    ⨯  । ⠭,  ६  㭪樨,  祭
 ॠ ⢮ 楫 ᥫ,  ⨬   .

 ⨯             祭       ॡ㥬 
__________________________________________________________
Shortint            -128 .. 127           1 
Integer           -32768 .. 32767         2 
Longint      -2147483648 .. 2147483647    4 
Byte                   0 .. 255           1 
Word                   0 .. 65535         2 
__________________________________________________________
    
    楫묨 ࠭    믮  ᫥騥  䬥᪨
樨: ᫮,  ⠭, 㬭, , 祭 ⪠
 .   権:
   
        +      -     *     div     mod
    
    䬥᪮ 樨  楫묨 ࠭  -
稭 楫 ⨯.  믮 樨  楫 稭
 楫  ⭮.   믮  樨  祭
⪠   - ⮪   楫. ਬ:
   
        17 div 2 = 8,   3 div 5 = 0.
        17 mod 2 = 1,   3 mod 5 = 3.
   
   樨 ⭮襭,  ਬ  楫 ࠭,  १
᪮ ⨯ TRUE  FALSE ( ⨭     ).
    몥   ᫥騥 樨 ⭮襭: ࠢ⢮ =,
ࠢ⢮ <>,   ࠢ >=,    ࠢ <=,   >,
 < .
    㬥⠬ 楫 ⨯ ਬ ᫥騥 ⠭ (஥-
) 㭪樨, १ 믮   楫 ⨯:
   
        Abs(X),   Sqr(X),   Succ(X),   Pred(X),
   
  । ᮮ⢥⢥ ᮫⭮ 祭 ,    -
, +1, -1.
    㯯 ⠭ 㭪権  㬥 楫 ⨯ -
 ⢨⥫ १:
   
        Sin(X), Cos(X), ArcTan(X), Ln(X), Exp(X), Sqrt(X).
   
    㭪樨  ᨭ,  ᨭ  ⠭ 㣫, 
 ࠤ,   ࠫ, ᯮ  ७  -
⢥⢥.
    믮 㭪樨 ஢ન 楫 稭  ⭮
Odd(X)     祭 ⨭,  ᫨ 㬥 ,   祭
, ᫨ 㬥 :
   
        X=5    Odd(X)=TRUE ,    X=4    Odd(X)=FALSE.
   
    ன ࠡ  楫묨 ᫠ । 楤:
   
    Inc(X)     X:=X+1
    Inc(X,N)   X:=X+N
    Dec(X)     X:=X-1
    Dec(X,N)   X:=X-N

    ⨯  ।    ,    ॠ
⢮ ⢨⥫ ᥫ, ⨬   .
   
                      ⢮      ॡ㥬
                 祭                   ()
---------------------------------------------------------------
Real         2.9e-39 .. 1.7e+38        11                6
Single       1.5e-45 .. 3.4e+38         7                4
Double      5.0e-324 .. 1.7e+308       15                8
Extended   3.4e-4932 .. 1.1e+4932      19               10
Comp        -9.2e+18 .. 9.2e+18        19                8
---------------------------------------------------------------
   
    Real ।  ⠭⭮    ⥬᪨  ᮯ-
஬  ন.
   ⠫ ⢨⥫ ⨯ । ⠭⮬ IEEE 457  -
   ᮢ६ .
     ᯮ짮  稨 ᮯ     ࠡ  
 ⨯ 80486 室 ஢ ணࠬ  箬 {$ N+},  
 ⢨ ᮯ -  砬 {$N-,E+}.
    Comp     ⭮  ⢨⥫ ⨯,  ࠭ ⮫쪮
 楫 祭.
    ⢨⥫묨 ࠭  믮 ᫥騥 䬥-
᪨ 樨, 騥 ⢨⥫ १:
   
    ᫮ + ,  ⠭ - ,  㬭 * ,   / .
   
    稭 ⢨⥫쭮 ⨯ ਬ  樨 ⭮襭,
騥 㫥᪨ १.
     ࠭,    ,   楫.
    ⢨⥫ 㬥⠬ ਬ 㭪樨, 騥 ⢨⥫-
 १:
    
     Abs(X), Sqr(X), Sin(X), Cos(X),  ArcTan(X),  Ln(X),  Exp(X),
Sqrt(X), Frac(X), Int(X), Pi.
    
   㭪 Frac(X) 頥 ஡  X, 㭪 Int(X) - 楫
 X.
   㬥⭠ 㭪  Pi  頥  祭 ᫠  ⢨-
⥫쭮 ⨯.
    㬥⠬ ⢨⥫쭮 ⨯ ਬ ⠪ 㭪樨
    
     Trunc(X)  Round(X),
    
騥 楫  १.  ࢠ   뤥 楫  ⢨-
⥫쭮  㬥  ⥬  祭 ஡ ,  㣫
㬥  襣 楫.

    ⨯ (Boolean)  ।  ,   -
 ᪨ 祭 TRUE  FALSE.
    㫥᪨ ࠭ ਬ ᫥騥 ᪨ 樨:
    
     not     and      or     xor.
    
   ᪨ ⨯ । ⠪ ࠧ,  FALSE < TRUE.  -
 ਬ  㫥᪨ ࠭  樨 ⭮襭.
        ࠧ ᪮ ⨯:
ByteBool, WordBool  LongBool,      , 
   ᮮ⢥⢥.

    ⨯ (Char) । 㯮冷祭 ᮢ㯭 ᨬ-
, ⨬       .  祭 ᨬ쭮 ६ 
⠭ -   ᨬ  ⨬ .
   쭠 ⠭    뢠  ⥪ ணࠬ ६
ᯮᮡ:
    -  ᨬ, 祭  , ਬ:
    
      'A'   'a'   ''  '';
    
   -  樨  #K,  K -  ᮮ⢥饣 ᨬ-
,  ⮬ 祭 K  室  । 0..255;
   -  樨  ^C,  C -  ᮮ⢥饣 ࠢ-
饣  ᨬ,  ⮬  祭  C    64 
 ࠢ饣 ᨬ.
    稭 ᨬ쭮 ⨯ ਬ  樨 ⭮襭.
    稭 ᨬ쭮 ⨯ ।  㭪樨 ८ࠧ
      
        Ord(C)     Chr(K).
   
   ࢠ 㭪 । 浪  ᨬ    ᨬ-
,    ।  浪   ᨬ, 騩 
-    ᨬ. 浪   楫 ⨯.
    㬥⠬ ᨬ쭮 ⨯ ਬ 㭪樨,  ।-
 ।騩  ᫥騩 ᨬ:
    
      Pred(C)    Succ(C).   Pred('F') = 'E' ; Succ('Y') = 'Z' .
    
    ⢨  ।饣  ᫥饣 ᨬ 祭 -
⢥ 㭪権  ।.
      ࢠ 'a'..'z' ਬ 㭪 UpCase(C), -
 ॢ    孨 ॣ 'A'..'Z'.
    
    ⨯ (Pointer) । ६,   ᮤ-
 祭  ᮢ   ࠣ⮢ ணࠬ.   ࠭
 ॡ  ᫮ (4 ),    । ᥣ,
஥ - ᬥ饭.
     묨 ६묨  (㪠⥫ﬨ)   㤥  ᬮ७
, ᥩ  ⬥⨬,    祭 祭  -
६  㭠ୠ  @.
 
   
6.           
    
    ⠭    몥  ।   :  ⠭
楫 ⨯ -  楫 ᫠,   ᮤঠ騥 筮 窨, -
⠭ ⢨⥫쭮  ⨯ - ⢨⥫ ᫠,  ᪨ -
⠭ - ᪨ 祭 TRUE  FALSE, ᨬ ⠭ - 
ப    ᨬ,  樨  #K  ^K.
     ᪠ ᯮ짮 ᨭ  祭 -
⠭,     ⮬  砥  ⥪  ணࠬ  ᮤন  ࠧ  ᠭ
⠭, ਬ: {}

7.            .
                       

    ६ । 짮⥫  ࠧ ᠭ -
:{}
    饥  ६    ᨮ쭮  ணࠬ஢  ਭ
뢠   ६  ᯮ짮 ⠪ 뢠 -
 樨.
   ᪠   -   ᮣ襭   ६ 
㭪権.  襭 ப ᯮ  ணࠬ஢  -
 PASCAL, C   । WINDOWS.
   ᪠  ᭮뢠  ᫥ ਭ樯:
   - ६  㭪権  ᮤঠ 䨪,  뢠騩
 ⨯;
   - ६   㭪権 뢠 묨 ᫮  ᫮-
⠭ﬨ   ᮪饭ﬨ,   ⠪, ⮡    뫮
 祭 ६  ⢨, 믮塞 㭪樥.
   䨪 뢠 묨 㪢, ࢠ 㪢  ᫮ -
, 䨪  ᫮ 뢠  ᫨⭮,  १ ᨬ-
 _ (ન).
    몠  PASCAL    ४ ᫥騥 䨪 
᪠ ६  㭪権:

䨪     
---------------------
by        Byte
sh        Shortint
i         Integer
w         Word
l         Longint
r         Real
si        Single
d         Double
e         Extended
c         Comp
ch        Char
b         Boolean
p         Pointer
x,       न ᨬ  窨  ࠭

    稭 ஢ ⨯   ᯮ짮 ᫥-
騥 䨪:

a         Array
s         String
sz        Stringz
se        Set
re        Record
f         File
t         Text

   ਬ:

    rV, arVector[1..20], sName, iCount.

    ⪮஢ ணࠬ   ६ ⢥  
,  ᥬ ६ ᢮ 㫥 祭.
     砫 祭 ६ (樠樨  ६-
) TURBO PASCAL  ᢠ 砫 祭 ६
६   ᠭ.  ⮣ ᯮ 

     ६: ⨯ = 祭;

   ࠧ饭  ࠧ ᠭ ⠭, ਬ:

    const rWeight: Real = 0.4;


8.           

   ࠦ ⮨    ⠭,  ६,  㪠⥫ 㭪権,
 権  ᪮. ࠦ  ࠢ ᫥ -
ண 祭.  冷 ᫥ । 設⢮ (ਮ-
⮬) ᮤঠ    権.  몥  ਭ ᫥騩
ਮ 権:

  1. 㭠ୠ   not, 㭠   -, ⨥   @
  2. 樨 ⨯ 㬭  *  /  div  mod  and  shl  shr
  3. 樨 ⨯ ᫮  +  -  or  xor
  4. 樨 ⭮襭  =   <>   <    >   <=    >=  in
  {}
   ࠦ 室  ⠢  ஢ 몠 ,  ⠪
  㬥⠬ ஥ 㭪権.


9.                        

    ६  ⨯ ࠦ  ᮢ ஬ , -
 ࠦ ⭮  楫 ⨯,  ६ -  ⢨⥫쭮-
.     ⮬  ந室  ८ࠧ  祭   ࠦ   
⢨⥫쭮 ⨯.{}
10.                  
        

   ᬮਬ ࣠    뢮   ନ쭮 -
ன⢠. ନ쭮 ன⢮ -  ன⢮,   ࠡ⠥
짮⥫, 筮  ࠭ (ᯫ)  .
      뢮  ᯮ ⠭ 楤 
 뢮 Read  Write, 騥 ⠭묨 ᫥⥫묨 䠩
INPUT  OUTPUT.
    䠩 ࠧ  ப ६ ,  ⤥塞 
 㣠 ਧ  ப.   ப  ⨥ -
 ENTER.
     室  ᯮ  楤 :

         Read(A1,A2,...AK);
         ReadLn(A1,A2,...AK);
         ReadLn;

      ॠ ⥭  祭 室    -
  祭 ६ 1,  2,  ...,  . ன 
ॠ ⥭  祭 室 , ய ⠫ -
  砫 ᫥饩 ப, ᢠ ⠭ 祭 -
 1,  2, ..., . ⨩  ॠ ய ப -
室 .
     室   ந室  ८ࠧ    譥
 ।⠢  ७, ।塞 ⨯ ६. -
६, ࠧ騥  ᯨ᮪ ,  ਭ   楫,
    ⢨⥫쭮,    ᨬ쭮 ⨯.  ⥭ 室
 ᪮ ⨯  몥  ⨬.
       ⥭ 祭 ६ 楫 
⢨⥫쭮 ⨯ ய᪠ ஡,  ।騥 .   
 ६    ய᪠ ஡,  । -
 ᨬ ६,  ⠪  ஡    ࠢࠢ묨
ᨬ ப. ਬ  ஢ :

         var rV, rS: Real;
             iW, iJ: Integer;
             chC, chD: Char;
         ................
         Read(rV, rS, iW, iJ);
         Read(chC, chD);

   祭 室   ⤥   㣠  ஡
 ⨥  ⠡樨  Enter.
    뢮 १⮢ ࠡ ணࠬ  ࠭ ᯮ
:

         Write(A1,A2,...AK);
         WriteLn(A1,A2,...AK);
         WriteLn;

      ஢ ॠ 뢮 祭 ६  1,
2,...,    ப ࠭.  ன  ॠ 뢮
祭 ६ 1,  2,  ...,    室   砫  ᫥饩
ப. ⨩    ॠ ய ப  室  砫
᫥饩 ப.
   ६, ⠢騥 ᯨ᮪ 뢮,  ⭮  楫,
⢨⥫쭮, ᨬ쭮  㫥᪮ ⨯.  ⢥ -
 ᯨ᪠ 뢮 ஬  ६  ᯮ짮 ࠦ
 ப.
   뢮   祭  ப ࠭ ந室  ᮮ-
⢨  ਭ  뢮,  ।塞 ⭮  ॠ樥
몠.
   ଠ ।⠢ 祭   뢮 ᮮ⢥ ⨯  -
६  ࠦ:  稭 楫 ⨯ 뢮  楫 -
 ᫠,  ⢨⥫쭮 ⨯ -   ⢨⥫  
᫠   浪,  ᨬ쭮 ⨯  ப -   ᨬ-
, ᪮ ⨯ -   ᪨ ⠭ TRUE  FALSE.
    뢮      ਭ  뢮  
 ᯨ᪠ 뢮.   ⮬ 砥
 ᯨ᪠ 뢮   :, 
 - ࠦ  ப,   - ࠦ  ⠭ 楫  ⨯.
᫨ 뢮 祭    뢮  権, 祬 ,
 । ⨬ 祭 ᯮ ஡.  ᫨ 뢮 -
  頥  ਭ  ,    ⮣ 祭 㤥 ⢥-
 室 ⢮ 権.  稭 ⢨⥫쭮 ⨯
 ᯨ᪠ 뢮    ::,   - ६  ࠦ-
 ⢨⥫쭮 ⨯,   - ਭ  뢮,    -  ᫮  
஡    뢮 祭.     - ࠦ  ⠭
楫 ⨯.   ⮬ 砥 ⢨⥫ 祭 뢮  ଥ
筮 ᫠  䨪஢ 窮.
    ਬ  ஢ 뢮:
        . . . . . . . . . . . .
        var rA, rB: Real;       iP,iQ:Integer;
            bR, bS: Boolean;    chT, chV, chU, chW: Char;
        . . . . . . . . . . . .
        WriteLn(rA, rB:10:2);
        WriteLn(iP, iQ:8);
        WriteLn(bR, bS:8);
        WriteLn(chT, chV, chU, chW);


11.                      

   ணࠬ  몥  ⮨  , ࠧ ᠭ
 ࠧ ஢.
    ணࠬ ᮤন  ணࠬ, ਬ:

      Program PRIM;

   ᠭ     ᥡ ࠧ 砥 ⥪ (-
㫥), ࠧ  ᠭ ⮪, ࠧ ᠭ ⠭, ࠧ -
ᠭ ⨯,  ࠧ ᠭ ६,  ࠧ ᠭ 楤 
㭪権.
    ᠭ  㫥  । 㦥 ᫮ USES  -
ন  砥 㫥 (⥪)   室   ⠢
⥬ TURBO PASCAL, ⠪  ᠭ 짮⥫.  ᠭ
㫥    । ࠧ ᠭ.  㫥 -
   㣠 묨:

    uses  CRT, Graph;

       ணࠬ   祭 ⪮.   ⢥
⪨ ᯮ ந 楫  ,  ᮤঠ騥  
 ,  . ⪠ ⠢ । ஬  ⤥-
   稥.   ⪨,  ᯮ㥬  ணࠬ,  
 ᫥  ࠧ ᠭ ⮪, ਬ:

      label 3, 471, 29, Quit;

   ᠭ ⠭   ᯮ짮   ᨭ -
⠭,  室 ।  ࠧ ᠭ ⠭:

      const K= 1024;   MAX= 16384;

    ࠧ ᠭ ६ 室 । ⨯  -
, ᯮ㥬  ணࠬ:

      var P,Q,R: Integer;
          A,B:   Char;
          F1,F2: Boolean;

   ᠭ ⨯,  楤  㭪権 㤥 ᬮ७ . ⤥-
 ࠧ ᠭ  ⢮,   ᫥ ,   
 - ணࠬ      易⥫쭮 ᠭ  
ணࠬ.
    ஢  ।⠢ ᮡ ⠢ ,  
ᮤন  㦥묨 ᫮

         begin.......end

᫥⥫쭮  ஢.    ⤥    㣠
ᨬ ;.
    ணࠬ 稢 ᨬ 窠.
   ஬ ᠭ    ஢   - ணࠬ  ᮤঠ
ਨ,   ।⠢ ᮡ ந  ᫥⥫-
 ᨬ,  ᯮ  뢠饩 ᪮ ਥ
{  뢠饩 ᪮ ਥ }.
     - ணࠬ  ᮤঠ  樨,  -
  ࠢ ० 樨.  ⠪᪨  -
樨 뢠  ਨ.  樨 ᮤন ᨬ
$  㪢-  ᫥騬  + ( ०)   - (몫-
 ०). ਬ:

   {$E+} - 㫨஢ ⥬᪨ ᮯ;
   {$F+} - ନ஢ 쭨 ⨯ 맮 楤  㭪権;
   {$N+} - ᯮ짮 ⥬᪨ ᮯ;
   {$R+} - ஢ 室  ࠭ .

     樨  ᮤঠ ࠬ, ਬ:

   {$I  䠩} -   ⥪ 㥬 ணࠬ  -
 䠩.

    ਬ  ⮩ ணࠬ:

         Program TRIANG;
          var A, B, C, S, P: Real;
          begin
           Read(A,B,C);
           WriteLn(A,B,C);
            P:=(A+B+C)/2;
            S:=Sqrt(P*(P-A)*(P-B)*(P-C));
           WriteLn('S=',S:8:3)
          end.


12.                     

   ⮢  ࠧ來 䬥⨪      TURBO  PASCAL  
ᯥ祭  ࠡ  묨 ࠧ鸞 (⠬). -
樨 ⮢ 䬥⨪ ਬ ⮫쪮  楫 ⨯.
   ࢠ 㯯 権 - ᪨ 樨 not, and, or  xor.
    not  ⭮,      楫
᫠  .
   樨 and, or  xor - 㬥, ࠭  権 - 楫
稭    .   樨 믮 ୮  ᥬ
묨 ࠧ鸞 ࠭.
    㯯  権  -   樨 ᤢ  shl  ᤢ
ࠢ shr:
    
    I shl N
    I shr N.
   
    樨 ᤢ  ᫥⥫쭮 祭 I 
 ࠢ  N  ࠧ冷.  ⮬ , 室騥  ।
ࠧ來 ⪨, ,  ᢮訥  ࠧ -
 ﬨ.   ᤢ ࠢ ⥫ 祭 ᢮訥
ࠧ  栬.
    
    

13.                    

   筮     ணࠬ 믮  ⮬ 浪,   
 ᠭ.  室 뢠 ⢥ 冷 믮-
 ணࠬ  㪠뢠,   쭩襥 믮  த-
, 稭  , 祭 ⪮, 㪠  -
 室. ਬ   室:

        goto 218;


14.                        
               

   ਧ ணࠬ  (  ணࠬ)  -  ணࠬ,
⠢  䨪஢ ⢠  権.   -
ਬ ᭮  ।  ᯮᮡ ࠧ  権 
奬 ⬮.
{}
    権, ࠧ  ᫨ﭨ   樨: ᫥-
, ⢫,  横. ਬ ⮫쪮   樨, 
ॠ  襭  .
   , ।⠢ ᮡ ᫥⥫쭮 믮 
  権, 뢠 ᫥.
   ,   ࠧ,  権  ᫨ﭨ, -
 ⢫.   権  ⢮.
   ,   ࠢ, 騥  ।騬 -
  ࠧ, 뢠 横.
   樨 ᫥,   ⢫    横  ।⠢ 
樨, ⠪     ⢥ 室  ⢥  室.
ந ᫥⥫쭮   権  ।⠢  
.
        ॠ    ஬ 몠 
(  ⠢),  㯯 ஢,  ᪫祭 -
 室 GOTO.
    몥  ⢮  権 㢥祭  ,
:
       -᫥;
       -⢫;
       -横  ।᫮;
       -横  ᫮;
       -横  ࠬ஬;
       -ਠ.
    ᬮਬ,     樨 ॠ  몥
.


15.                    
 {}
   ᫮    ⪮ ଥ ࠡ⠥  ࠢ:  ᫨ -
᪮ ࠦ B ⨭,   믮  1,   -
 , ᫥騩  ᫮. ᫨ 㫥᪮ ࠦ B
,  㤥 믮 , ᫥騩  ⨬ ᫮ -
஬.

16.                       {}
17.                       {}
18.                     {}
19.                             

     ஢ 横 室  横 ⢫ 
᫥⢨ ⢥  砭  横,  ⠪  
 ஢ 室   室.
    ᨨ   7.0 । ⠭ 楤 Break 
Continue. 楤 Break 믮 ᫮ 室  横. -
 Continue ᯥ稢 室  砫  樨 横.


20.                    {}
21.                            

   塞 ⨯ ।⠢  ᮡ  ࠭祭  㯮冷祭
᫥⥫쭮 ᪠ ⠭,  ⠢  ⨯. -
祭  ⠭   .   ⤥  ⠭
⤥   㣠 묨,    ᮢ㯭 ⠭, -
⠢  塞 ⨯, 砥  㣫 ᪮.
   ணࠬ ꥤ   㯯  ᮮ⢥⢨   - 
ਧ  ᮢ㯭 祭,  ⠢ 塞 ⨯.
ਬ, 塞    ⨯  Rainbow()  ꥤ ᪠ 祭
RED, ORANGE, YELLOW, GREEN, LIGHT_BLUE, BLUE, VIOLET (,
,  , , , , ). -
塞 ⨯ Traffic_Light () ꥤ ᪠
祭 RED, YELLOW, GREEN (,  , ).
   塞 ⨯  뢠   ࠧ ᠭ ⨯,  
稭  㦥 ᫮ type, ਬ:

type
  Rainbow = (RED, ORANGE, YELLOW, GREEN, LIGHT_BLUE, BLUE, VIOLET);

    祭   ⠭⮩ ᢮ ⨯   ਭ-
 ⮫쪮   塞 ⨯,   ணࠬ. -
ਬ, 塞    ⨯  Traffic_Light    ।  
ணࠬ  ⨯ Rainbow,  ⠪   ⨯ ᮤঠ  -
⠭.
   ᠭ ६, ਭ  ᪠ ⨯,  -
   ࠧ ᠭ ⨯,  ந    ⨯.
ਬ:

        type  Traffic_Light= (RED, YELLOW, GREEN);
        var   Section: Traffic_Light;

    砥,  ६ Section  ਭ 祭 RED,
YELLOW  GREEN.
   ६ 塞 ⨯   ᠭ  ࠧ -
 ६, ਬ:

        var  Section: (RED, YELLOW, GREEN);

    ⮬  ⨯ ,   ६ । ᮢ-
㯭 祭, ⠢  塞 ⨯.
    ६ 塞  ⨯      ਬ  
ᢠ:

          Section:= YELLOW;

   冷祭 ᫥⥫쭮 祭, ⠢ -
 ⨯, ⮬᪨ 㬥, 稭     १ -
.  ᫥,   塞 ६  ⠭⠬ -
  ਬ 樨 ⭮襭    ⠭  㭪樨  Pred,
Succ, Ord.
   ६  ⠭ 塞 ⨯    -
 ᯨ᪠   뢮.

22.                           

   १  浪 ⨯
    ।  ࢠ  ࠭祭
⨯. १      쭮    ᨬ쭮
祭 ⠭, ࠧ  窠.  ⢥ ⠭ -
  ᯮ짮 ⠭, ਭ騥  楫, ᨬ쭮,
᪮  塞 ⨯.  ⨯,  ஬ -
 १, 뢠  ⨯.
   쭮   ᨬ쭮  祭 ⠭ 뢠  
孥 ࠭栬 १,  ।饣 ࢠ  ⨯.   
࠭    孥.
 {}
    ६묨,  ⭮騬  ࢠ쭮 ⨯,   믮-
  樨  ਬ  ⠭  㭪樨,   
⨬  ᮮ⢥饣  ⨯.
    ᯮ짮  ணࠬ ࢠ ⨯    -
 ஫     ⥬,  ⮡ 祭 ६  室 
࠭,    ६  ᠭ ࢠ쭮 ⨯.
23.         

   ᨢ ।⠢ ᮡ ࠭祭 㯮冷祭 ᮢ㯭
⨯ 稭.   ⤥쭠 稭 뢠 ⮩
ᨢ.       ,  ਭ  몥 ,
஬ 䠩 ⨯.   뢠  ⨯.
    ᮢ㯭  ।  .   -
祭 ⤥  ᯮ ,  뢠 -
  ᮬ   ᠬ:

          A[5]     S[k+1]     B[3,5].

    ⢥    ᯮ짮 ࠦ.  ᮢ
  ⮫쪮 ࢠ  塞.   ⢨⥫  
楫 ⨯ ⨬.   ࢠ쭮 ⨯,  ண -
  楫 ⨯,   ਭ ⥫,  㫥  
⥫ 祭.{}
   ୮ 
ணࠬ  ᨢ   ᢮ 㣮, ᫨  ⨯ -
, ਬ:

         R1:=Z.

       뢮 ᨢ  ᯨ᮪   뢮 頥
६  ᮬ,       뢮  믮  
横.
{}
      ।    ப,  ன -  ⮫.
㬥 ᨢ ࠭     ப.
   樠 ᨢ (᢮ 砫 祭 ᥬ  -
⠬ ᨢ) ⢫  ᯮᮡ.
    ᯮᮡ -  ᯮ짮 ⨯஢ ⠭,   -
:

   type Dim10= Array[1..10] of Real;

   const
    raM10: Dim10 = ( 0, 2.1, 4, 5.65, 6.1, 6.7, 7.2, 8, 8.7, 9.3 );

    樠樨 㬥 ᨢ 祭   
室    ᨢ 뢠  ᪮:

   type Dim3x2= Array[1..3,1..2] of Integer;

   const
    iaM3x2: Dim3x2= ( (1, 2)
                      (3, 4)
                      (5, 6) );

   ன ᯮᮡ 樠樨 - ᯮ짮 ࠧ 楤-
 FillChar:

   FillChar( var V; NBytes: Word; B: Byte );

 楤  ⮪  ⮢ 祭. -
,  㫥 ᨢ A[1..10] of Real  :

   FillChar(A, 40, 0);



   FillChar(A, SizeOf(A), 0);

{}
24.        

   ᮡ   몥   ᨢ ᨬ.  ⠭-
  ᪠  ᯮᮡ ࠭ ᨬ ᨢ   -
 : ᯠ  㯠. ᯠ ᨢ ᨬ
࠭      ᨬ  設 ᫮, 㯠
-   ᨬ  .  ᠭ 㯠 ᨢ ᨬ-
 ᯮ 㦥 ᫮ PACKED, ਬ:

            var   MAS: Packed Array[1..20] of Char;

ᠭ ᯠ ᨢ ᨬ  :

            var   M: Array[1..20] of char;

    ८ࠧ ᨬ쭮 ᨢ   ᯠ    
㯠  ,   㯠  ᯠ,    -
   ⠭ 㭪樨 Pack, UnPack.
    ᨢ ᨬ ࠧ ᨬ ப. 쭠
ப    ப ⠭⮩,  ப  ६-
. ப ⠭,  ப, ।⠢ ᮡ ᮢ㯭
ᨬ, 祭   .  ப -  ୠ  -
 몠 . ப ⠭  室  ⠢ -
ࠦ.    ᫮ ⠭,     ᠭ  ࠧ
ᠭ ⠭.
   ப ६ -   㯠  ᨢ  ᨬ-
,  ᠭ   TURBO PASCAL  ⨯ String.
   ਬ, ᫨ ப ᮤন  30 ᨬ,   ⨯ 㤥 -
 

    type   s= String[30];

    ப   ᮤঠ , 祬 255 ᨬ.
    TURBO PASCAL । ⨥ ப ६ ,   ⮬
砥  ᠭ  

    type  s= String;

    String  㪠  ᮢ⨬  ᥬ ⨯ ப.
   ᮡ ப ६  ,     -
   ᪠ ६, ⠪   ᨢ.  ஬ -
砥 ਬ  "६  ᮬ",  ᯥ稢
    ⤥ ᨬ ப.   ⮬  ࠭ 
ࠢ 1. ⤥ ᨬ ப ᮢ⨬  ⨯ Char.
      ப  ⢮ ⮢,   襥
 . 㫥  ப ᮤন  .
    ப । 樨 ᢠ, ᫨ﭨ (⥭樨)
 ࠢ.

    ࠢ ப ਬ  樨 ⭮襭.  ࠢ
ப ந室 ᨬ쭮,  稭  ࢮ ᨬ. ப ࠢ-
, ᫨     ᨬ쭮 .
   ப   ⠬ ᯨ᪠  - 뢮,  ⮬ -
뢠  ப  .
      ப ६ ⢮  ᨬ 
 ,  祬  ப.  ⮬ 砥  ᨬ ࠧ-
  砫 ப,  ⠢訥   ஡. -
 ⢮    ᨬ  ॢ蠥    ப,   譨
ᨬ 뢠.
   樠 ப  ந    ⨯஢-
 ⠭:

   const sName: String[9]= 'IBM PC/AT';

⠪   ᯮ짮 ன ࠧ 㭪樨 FillChar:

   FillChar( var V; NBytes: Word; C: Char );

ਬ:

   FillChar(A, SizeOf(A), '0');

    ࠡ    ப  TURBO PASCAL 祭 楤  㭪-
樨,  ᯥ稢 ।஢  ८ࠧ ப.
{}
25.                       

    襭   ஥ ⥬ 樨 ᥩ -
  ⤥ . 筮  ॠ   -
ணࠬ.
   ணࠬ -  ᫥⥫쭮 ஢,   ।-
    ᠭ  ⮫쪮      ணࠬ,    
맢  믮    ᪮쪨 祪 ணࠬ.  -
 ணࠬ । 㭨 .   몥  -
  ⨯ ணࠬ - 楤  㭪樨.
   楤   㭪 -   ᫥⥫쭮 ᠭ
 ஢.   ᯮ짮 楤  㭪権  - ண-
ࠬ  ᮤঠ ⥪ 楤  㭪樨  饭  -
楤  㭪樨.   楤  㭪権      ࠧ
ᠭ 楤  㭪権.
{}
   楤  ᮤঠ ⠪ -  ࠧ ᠭ,    -
 - ணࠬ,   :  ࠧ ᠭ 㫥,  ⮪, -
⠭, ⨯, ६, 楤  㭪権.
{}
          .   
, ᮡ   ᫨⥫쭮 ⥬⨪, 室 -
।  楤  㭪権  ⢥ ࠬ஢.   ⮣ 
TURBO PASCAL     ⨯  - 楤  㭪樮-
,  ᨬ  ⮣,  뢠.
   ᠭ 楤  㭪樮 ⨯ ந  ࠧ
ᠭ ⨯:
   type
         FuncType = Function(z: Real): Real;
         ProcType = Procedure (a,b: Real; var x,y: Real);

   㭪樮  楤 ⨯ ।   -
  㭪樨  ᯨ᪮ ଠ ࠬ஢,    . 
। 㭪樮  楤 ⨯  ࠬ஢,  -
:
   type
         Proc = Procedure;

   ᫥  楤୮  㭪樮쭮 ⨯    
ᯮ짮   ᠭ  ଠ  ࠬ஢  -  楤 
㭪権.
   ஬ ⮣, 室   ॠ 楤  㭪樨,
   ।  䠪᪨ ࠬ.   -
楤   㭪樨  ஢  ० 쭥 樨 
箬 {$F+}.


   ਬ. ⠢ ணࠬ  ᫥ । ⥣ࠫ
                tk
                       2t
             I= S--------------- dt
                   sqrt(1-sin2t)
                tn
 ⮤ ᮭ. ᫥  ⥣ࠫ쭮 㭪樨 ॠ 
 㭪樨,  ன ।  ࠬ.  祭 -
 ⥣ࠫ  㫥 ᮭ   㫥:

      ISimps=2*h/3*(0.5*F(A)+2*F(A+h)+F(A+2*h)+2*F(A+3*h)+...
                                                +2*F(B-h)+0.5*F(B))

 A  B -    ࠭ ࢠ ⥣஢,
    N - ᫮ ࠧ ࢠ ⥣஢,
    h=(B-A)/N, 祬 N   .

Program INTEGRAL;
 type
    Func= function(x: Real): Real;
 var
    I,TN,TK:Real;
    N:Integer;
{$F+}
 Function Q(t: Real): Real;
   begin
     Q:=2*t/Sqrt(1-Sin(2*t));
   end;
{$F-}
 Procedure Simps(F:Func; a,b:Real; N:Integer; var INT:Real);
   var
      sum, h: Real;
      j:Integer;
   begin
     if Odd(N) then N:=N+1;
     h:=(b-a)/N;
     sum:=0.5*(F(a)+F(b));
     for j:=1 to N-1 do
       sum:=sum+(j mod 2+1)*F(a+j*h);
       INT:=2*h*sum/3
   end;
 begin
   WriteLn('  TN,TK,N');
   Read(TN,TK,N);
   Simps(Q,TN,TK,N,I);
   WriteLn('I=',I:8:3)
 end.

{}
26.                    

    襭  ࠡ ணࠬ,  楤  㭪権  ।-
⥫쭮 室  ⪠  뢠饬 end  TURBO PASCAL 
楤 Exit  Halt.
   맮 Exit 蠥 ࠡ ᢮ ணࠬ     ।
ࠢ 뢠饩 ணࠬ.  ᫨ Exit 믮  ணࠬ-
,  믮 ⮩ ணࠬ ४,   㤥 믮-
 ᫥騩  맮 ⮩ ணࠬ . ᫨ Exit -
  ᭮ ணࠬ,  室   㤥  ⥭  
ଠ쭮 襭.
   맮 楤 Halt,      室,  蠥 ࠡ
ணࠬ  । ࠢ 樮 ⥬.
   楤 Halt   Halt(n),   n -  , -
    ஠஢ 樮 ⥬   -
 IF ERRORLEVEL.  祭 n=0 ᮮ⢥ ଠ쭮 -
 ࠡ ணࠬ. 맮 楤 Halt  ࠬ ⥭
맮 Halt(0).

27.        

    (UNIT)  TURBO PASCAL -  ᮡ ࠧ ଫ -
⥪ ணࠬ.    ⫨稥  ணࠬ    -
饭  믮 ᠬ⥫쭮,     ⮫쪮  ⢮  
஥ ணࠬ  㣨 㫥.
   㫨  ᮧ  ⥪ 楤  㭪権  
ந ணࠬ ࠪ᪨  ࠧ.
     TURBO PASCAL ।⠢ ᮡ ⤥쭮 ࠭  -
ᨬ 㥬 ணࠬ .
    饬 砥  -    ᮢ㯭  ணࠬ  ᮢ,
।祭  ᯮ짮 㣨 ணࠬ.   ணࠬ-
묨 ᠬ    몠 TURBO PASCAL: ⠭-
, ⨯,  ६,  ணࠬ.   ᠬ  ᥡ  
믮塞 ணࠬ,   ᯮ 㣨 ணࠬ-
 栬.
    ணࠬ    ࠧ   :
   - ணࠬ ,  ।祭  ᯮ짮 㣨
ணࠬ  ﬨ,  ⠪  뢠 묨  -
;
   - ணࠬ , 室 ⮫쪮  ࠡ ᠬ -
,  뢠 묨  묨.
    ᮮ⢥⢨  ⨬ , ஬ , ᮤন  ᭮-
 , 뢠 䥩ᮬ  ॠ樥.
    饬 砥   ᫥ :

   unit < >;         { }

    interface
     { ᠭ  ணࠬ ⮢  }

     { ᠭ  ணࠬ ⮢  }

    begin
     {  樠樨 ⮢  }
    end.

    ⭮ 砥    ᮤঠ  ॠ樨  -
 樠樨, ⮣   㤥 ⠪:

   unit < >;         { }

    interface
     { ᠭ  ணࠬ ⮢  }

    implementation

    end.

   ᯮ짮   楤  㭪権  ᢮ ᮡ.
 ணࠬ ᮤন  ᢥ,  室   -
: , 祭  ⨯ ࠬ஢, ⨯ १  㭪権, 
ଠ   㯭  㣨 ணࠬ  㫥.  -
 ஭,   ⥪ ணࠬ,  ॠ騩  ,  㣨
ணࠬ  ﬨ    ᯮ짮.  ⮬  
楤  㭪権   䥩  ,   ⥪ - 
 ॠ樨.
   䥩᭠     ᮤন ⮫쪮  (㯭 
㣨 ணࠬ  㫥)   楤  㭪権 ( 㦥-
 ᫮   forward).   ⥪ 楤  㭪樨  
 ॠ樨, 祬    ᮤঠ ᯨ᮪ ଠ-
 ࠬ஢.
   室 ⥪    ⪮஢    ४-
⨢ Make   Compile  ᠭ  .  ⮬ 樨
  䠩  ७ .TPU (Turbo Pascal Unit). ᭮
     .
    祭      ணࠬ 室 㪠   
ࠧ ᠭ 㫥, ਬ:

           uses  CRT, Graph;

    ⮬ 砥,  ᫨  ६  䥩᭮   
 ணࠬ,   ᯮ饩  ,  ᮢ,  饭 㤥
ந室  ६,  ᠭ  ணࠬ.  饭  -
६, ᠭ    㫥,   室 ਬ ⠢ ,
饥      ६, ࠧ 窮.
   ਬ,   ,  ஬ ᠭ ६ :

   unit M;
    interface
     var K: Integer;
    implementation
   .................
    end.

    ணࠬ, ᯮ  , ⠪ ᮤন ६-
 :

   Program P;
    uses M;
    var K: Char;
    begin
   .............
    end.

    ⮣, ⮡  ணࠬ P    ६ K  -
 M, 室  ⠢  M.K.
   ᯮ짮 ⠢  ਬ  ⮫쪮    -
,   ᥬ , ᠭ  䥩᭮  .
   ᨢ ᯮ짮 㫥 饭.
   ᫨  㫥  ࠧ 樠樨,     ⮣
ࠧ  믮 । 砫 믮 ணࠬ,  ன
ᯮ  .

28.           

   ⨥ ⢠  몥  ᭮뢠    ⥬᪮
।⠢   ⢠:   ࠭祭 ᮢ㯭 ࠧ
⮢.  ஥ ⭮ ⢥ ⨯ ᯮ-
 塞  ࢠ ⨯ .   ⮢, ⠢-
 ⢮, 뢠  ⨯.
   ⢥ ⨯  뢠      㦥 ᫮ Set of,
ਬ:

         type  M= Set of B;

  - ⢥ ⨯,  -  ⨯.
   ਬ ᠭ ६ ⢥ ⨯:

         type
             M= Set of 'A'..'D';
         var
            MS: M;

   ਭ ६  ⢥ ⨯   ।-
 אַ  ࠧ ᠭ ६:

         var
            C: Set of 0..7;

   ⠭ ⢥  ⨯  뢠    祭 
 ᪮ ᫥⥫쭮 ⮢  ࢠ -
 ⨯, ࠧ 묨, ਬ:

         ['A', 'C']    [0, 2, 7]    [3, 7, 11..14].

⠭ 

         [ ]

砥 ⮥ ⢮.
   ⢮ 砥  ᥡ  ⮢  ⨯,  -
⢠  ⢠,  ⠪ ⮥ ⢮. ᫨ 
⨯,  ஬ ந ⢮,   ⮢,  ᫮ -
, 室   ⢮, ࠢ 2  ⥯ .  
६  ࢠ쭮 ⨯:

         var P: 1..3;

    ६  ਭ  ࠧ 祭  -    1,
 2,  3. ६  ⢥ ⨯

         var T: Set of 1..3;

 ਭ ᥬ ࠧ 祭:

         [ ]        [1,2]
         [1]        [1,3]
         [2]        [2,3]
         [3]        [1,2,3]

   冷 ᫥ ⮢  ⨯  ⠭  ࠧ-
祭.
   祭 ६  ⢥  ⨯     -
樥  [T],  T - ६  ⨯.
    ६  ⠭⠬ ⢥ ⨯  ਬ  樨
ᢠ(:=), ꥤ(+), 祭(*)  ⠭(-):

         ['A','B'] + ['A','D']        ['A','B','D']
         ['A'] * ['A','B','C']        ['A']
         ['A','B','C'] - ['A','B']    ['C'].

    믮    権   稭 ⢥
⨯.
    ⢥ 稭 ਬ 樨: ⮦⢥ (=),
⮦⢥ (<>), ᮤন   (<=), ᮤন (>=).  
믮  権  ᪨ ⨯, ਬ:

         ['A','B'] = ['A','C']   FALSE
         ['A','B'] <> ['A','C']  TRUE
         ['B'] <= ['B','C']      TRUE
         ['C','D'] >= ['A']      FALSE.

   ஬  権  ࠡ  稭 ⢥ ⨯  
몥  ᯮ 

         in

஢  ਭ     ⨯,  饣 ᫥
  樨,  , 饬 ࠢ   樨. -
 믮 ⮩ 樨 - 㫥᪨.   ஢ન -
    ᯮ  権 -
襭, ਬ:

         A in ['A', 'B']   TRUE,
         2 in [1, 3, 6]    FALSE.
   
    ᯮ짮     ணࠬ      ⢥   ⨯
믮 権 ந室  ⮢묨 ப .  
祭 ⢥ ⨯    ᮮ⢥  
ࠧ. ਬ, ⢮

         ['A','B','C','D']

।⠢    ⮢ ப

         1 1 1 1.

⢠ ⮣ ⢠ ।⠢ ப:

         ['A','B','D']   1 1 0 1
         ['B','C']       0 1 1 0
         ['D']           0 0 0 1

   稭  ⢥ ⨯    ⠬ ᯨ᪠ -
 - 뢮.
      ⭮  ॠ樨 ࠭  몠  -
⢮ ⮢  ⨯,   ஬ ந ⢮, -
祭.   TURBO PASCAL ⢮  ⮢   ॢ-
 256.
   樠 稭  ⢥  ⨯ ந  
⨯஢ ⠭:
   
   const  seLit: Set of 'A'..'D'= [];
   
   ந㥬 ਬ   ⢥ ⨯  ਬ.
   ਬ. ⠢ ணࠬ,  ࠡ뢠  뢮  -
࠭ ᯫ  砩 ᥫ    "⫮ 5  36".
      窨 ᯮ⫮ 室  
  ᥢ砩 ᥫ.  ⨬ ᫠ ।  ॡ-
:
    -᫠  室   1..36;
    -᫠   .
   
    Program Lotto;
     var
         nb, k: Set of 1..36;
         kol, l, i, n: Integer;
     begin
        Randomize;
        WriteLn(' kol');
        ReadLn(kol);
        nb:=[1..36];
        for i:=1 to kol do
          begin
           k:=[];
           for l:=1 to 5 do
             begin
               repeat
                 n:=Random(36)
               until (n in nb) and not (n in k);
               k:=k+[n];
               Write(n:4)
             end;
           WriteLn
          end
         end.

    
29.        

    ।⠢ ᮡ ᮢ㯭 ࠭祭  ᫠  -
᪨ 易 ,  ਭ  ࠧ ⨯.  
 뢠 ﬨ,    । . 
 ᮤন  , ᫥   १ 稥 㪠뢠-
 ⨯ ⮣ .    ⭮   ⨯, -
⨬  몥 ᪠,  ᪫祭 䠩 ⨯.
   ᠭ       몥      ⢫    
㦥 ᫮ RECORD,  ᫥   뢠  -
. 蠥 ᠭ  㦥 ᫮ END.
   ਬ, ᭠  ᮤন 䠬,  樠   -
䮭, ⮬ ⤥ ப  ᭮  㤮 ।⠢
  ᫥饩 :
   
         type   Row=Record
                     FIO: String[20];
                     TEL: String[7]
                    end;
         var    str: Row;

   ᠭ ᥩ    ᯮ짮  ⨯,   -
:
         var  str: Record
                    FIO: String[20];
                    TEL: String[7]
                   end;

   饭    楫 ᪠ ⮫쪮   ᢠ-
,   ᫥  ࠢ   ᢠ ᯮ  
ᥩ  ⨯.   ⠫   ⤥-
묨 ﬨ ᥩ.  ⮡   ⤥쭮  ,
室      १  㪠  㦭 ,
ਬ:
   
         str.FIO,   str.TEL

     뢠 ⠢. ⮩    ⠪-
 ,     ⠪ 砥 ⠢  㤥 ᮤঠ  ,  
襥 ⢮ .
   饭   ⠬ ᥩ  ,  ᫨ ᯮ짮-
 ஬ ᮥ with.
      ⠢ ,  ࠪਧ騥  -
,    ,    ।   -
:
   
         with M do OP;

      -    ,     - ,  ⮩  ⠢.
  ।⠢ ᮡ  ⢨  ᮥ-
,  । ன   ᯮ짮 ⠢ .
    ᮤন ⤥쭮    祭    
 .   몥  ᪠ ᠭ ,  饩 
饩  ਠ⭮ ⥩.  ਠ⭠     -
樨
         case P of,

  -     饩    .  祭, ਭ-
 ⨬ ,   ⠪ ,     ਠ.
  㪠 믮塞 ⢨,     -
 ਠ,    㪠뢠  ਠ,  祭  㣫
᪮. ᠭ ਠ⭮  蠥 㦥 ᫮ end.
       㪠   ਠ⭮ , ਬ:
   
         case P: Integer of
   
   樠 ᥩ  ⢫       ⨯஢
⠭:
   
   type
     RecType= Record
               x,y: Word;
               ch: Char;
               dim: Array[1..3] of Byte
              end;
   
   const
     Rec: RecType= ( x: 127; y: 255;
                     ch: 'A';
                     dim: (2, 4, 8) );

{}
30.       

    䠩 ⨯        맢  室
ᯥ  ࠡ  ਩묨 (譨) ன⢠
, ।祭묨  , 뢮  ࠭ .
    ⨯   䠩 । 㯮冷祭 ᮢ㯭
ந쭮 ᫠ ⨯ .
   饥 ᢮⢮ ᨢ,  ⢠   砥  ⮬, 
⢮   ।  ⠯ ᠭ ணࠬ, ⮣-
   ⢮  䠩  ⥪ ணࠬ  ।
   ந.
   ⨥ 䠩  筮  ப.      䠩 
᪥, 㭨樮  ,  ன⢮ ,   
㣨 ன⢠.
    ࠡ  䠩 믮 樨  - 뢮. 
 砥   ९     譥 ன⢠ ( 室
䠩)   ᭮  ,  뢮 -  뫪 
 ᭮   譥 ன⢮ ( 室 䠩).
     譨 ன⢠  뢠  䨧᪨  䠩.
   ।  樮 ⥬.   ணࠬ  몥
᪠  䠩    ப. ਬ,  䠩 
᪥   :
   
   'A:LAB1.DAT'
   'c:\ABC150\pr.pas'
   'lab3.pas'.
   
   樮 ⥬  MS-DOS   ᮡ ࠧ  䠩-
  ᪠    ன⢠   ⠬ 㭨権.  
TURBO PASCAL   ᯮ짮  ன  ⮢,  ।-
  MS-DOS, ਬ:
   
   'CON',  'LPT1',  'PRN',  'COM1',  'AUX',  'NUL'.
   
    䠩 ⥬ TURBO PASCAL 易 ⨥      -
뢮.    뢮  ⢫ १ .   - 
  ,   뤥   䠩.   
䠩   ଠ ᭠砫 ࠢ    ⠬ 
  ,    ꥬ   㤥 .  쪮  ᫥
⮣  ᫥ ᯥ樠쭮   ந室 । 
 譥 ன⢮.  ⥭  䠩  砫 뢠
 , 祬  뢠  ⮫쪮, ᪮쪮 訢,
 ᪮쪮   .
   堭 ਧ樨       䥪⨢ -
 ଠ樥  譨 ன⢠.
    ࠡ    䠩   ணࠬ 室 । 䠩
६. TURBO  PASCAL ন  䠩 ⨯:   ⥪⮢
䠩,  䠩, ⨯ 䠩.
   ᠭ 䠩 ६ ⥪⮢ ⨯  ந    -
 㦥 ᫮ Text, ਬ:
   
   var tStory: Text;
   
   ᠭ  䠩  :
   
   var fComp: File of T;
   
 T  -  ⨯   䠩. ਬ ᠭ 䠩 ६
⭮ ⨯:
                           
   type M= array[1..500] of Longint;
   
   var f1: File of Real;
       f2: File of Integer;
       fLi: File of M;
   
   ⨯ 䠩 뢠   㦥 ᫮ File:
   
   var f: File;
   
    ६,   ᠭ  ணࠬ,  뢠 -
᪨ 䠩.     ᭮ 楤  㭪樨,  ᯥ稢騥
 - 뢮 ,  ࠡ ⮫쪮  ᪨ 䠩. -
 䠩    易  ᪨  믮 楤 -
 䠩.
   TURBO PASCAL   楤  㭪権,  ਬ   
⨯ 䠩:  Assign,  Reset,  Rewrite,  Close,  Rename, Erase, Eof,
IOResult.
   楤 Assign(  var  f; FileName: String ) 뢠 ᪨
䠩 f  䨧᪨ 䠩,      ண      ப
FileName.
   楤 Reset( var f ) 뢠 ᪨ 䠩 f  ᫥-
饣 ⥭  ,   ,  뢠 室 䠩.  ᫥
ᯥ譮 믮 楤 Reset 䠩 ⮢  ⥭   -
 .
   楤 Rewrite( var f )  뢠 ᪨ 䠩 f  ᫥-
饩    (뢠 室 䠩).  ᫥ ᯥ譮 -
 ⮩ 楤 䠩 ⮢     ࢮ  .
   楤 Close( var  f )  뢠    ⮣ ᪨
䠩. 맮 楤 Close 室  襭 ࠡ  䠩.
᫨    -  稭  楤 Close  㤥 믮, 䠩
-  㤥 ᮧ  譥 ன⢥,   ᮤন ᫥
     㤥 ७ᥭ.   室 䠩 ᯮ짮
  䠩 易⥫쭮.
   ᪠ 㭪 EOF( var f ): Boolean 頥 祭 TRUE,
  ⥭ ⨣  䠩.   砥,  㦥 -
⠭ ᫥   䠩  䠩 ᫥   .
   楤 Rename( var f; NewName: String )  २
䨧᪨ 䠩  ᪥, 易  ᪨ 䠩 f. २-
  ᫥  䠩.
   楤 Erase( var f )  㭨⮦ 䨧᪨ 䠩  ᪥, -
  易  䠩 ६ f.     맮 -
楤 Erase   .
   㭪  IOResult: Integer 頥 楫 ᫮, ᮮ⢥饥
 ᫥ 訡  - 뢮.   ଠ쭮 襭 -
樨 㭪 ୥ 祭 0. 祭 㭪樨 IOResult 室
ᢠ  -  ६,  ⠪    맮 㭪-
  ᢮ 祭. 㭪 IOResult ࠡ⠥ ⮫쪮  -
祭 ० ஢ப 訡  - 뢮   箬  -
樨 {$I-}.
   
   
31.                  
   
   ᮡ   몥   ⥪⮢ 䠩,  
  ᨬ ⨯.   ᠭ ⥪⮢ 䠩   몥
। ⠭ ⨯ ext:

         var    TF1, TF2: Text;

   ⮢ 䠩  ।⠢  ᮡ  ᫥⥫쭮 ப,  
ப - ᫥⥫쭮 ᨬ.  ப  ६ ,
 ப 蠥 ਧ  ப.
    ਧ  ப 易 㭪 EOLn(var T:Text):Boolean,
  -   ⥪⮢  䠩.   㭪 ਭ 祭 TRUE,
᫨ ⨣  ப,  祭  FALSE, ᫨   ப 
⨣.
    権  ⥪⮢묨 䠩,  ஬ ᫥, ।-
 ⠪  饭  楤ࠬ:

   ReadLn(T) - ய᪠ ப  砫 ᫥饩;

   WriteLn(T) -  蠥  ப 䠩,    ந -
, ਧ  ப  室  砫 ᫥饩.
    ࠡ  ⥪⮢묨 䠩  ७ ଠ -
஢   뢮. 

    Read(T,X1,X2,...XK)

 ⥭ 㯯 ஢

    begin
      Read(T,X1);
      Read(T,X2);
      ...........
      Read(T,XK)
    end;

     - ⥪⮢ 䠩,  ६ 1, 2,...   -
  ६묨  楫, ⢨⥫쭮  ᨬ쭮  ⨯,  
ப.  ⥭ 祭 ६  䠩  ८ࠧ 
⥪⮢ ।⠢  設.
   

    Write(T,X1,X2,...XK)

⥭ 㯯 ஢

    begin
      Write(T,X1);
      Write(T,X2);
      ...........
      Write(T,XK)
    end;

      -  ⠪ ⥪⮢ 䠩,   ६ 1,2,... 
 楫, ⢨⥫쭮, ᨬ쭮, ᪮ ⨯  -
.   祭 ६  䠩  ८ࠧ  -
७ ।⠢  ⥪⮢.
    ⥪⮢ 䠩 ⭮ ⠭ 䠩 INPUT, OUTPUT.
   ᬮ७ ࠭   - 뢮   -
砥 ஢   ⥪⮢묨 䠩,  ᯮ ⠭-
 䠩  - 뢮 INPUT, OUTPUT.
     ⨬ 䠩  ᮡ:
   -  䠩  ᯨ᪠  - 뢮  㪠뢠;
   -ਬ 楤  Reset,  Rewrite  Close  ⠭ 䠩
 - 뢮 饭;
   - ࠡ  䠩 INPUT,  OUTPUT  ࠧ 㭪樨
EOLn  ࠬ஢.
   TURBO PASCAL  ⥫ 楤  㭪樨, ਬ
⮫쪮  ⥪⮢ 䠩,   SetTextBuf,  Append, Flush, SeekEOLn,
SeekEOF.
   楤 SetTextBuf( var f: Text; var Buf; BufSize: Word ) 㦨
 㢥祭   㬥襭   - 뢮 ⥪⮢ 䠩
f. 祭  ࠧ   ⥪⮢ 䠩   㬮砭  ࠢ
128 ⠬.  祭 ࠧ  ᮪頥 ⢮ 饭
 .    ࠧ    䠩. -
 䠩 筥  ࢮ  ६ Buf.    -
  易⥫쭮 ࠬ BufSize,   ᫨  ࠬ  -
, ࠧ  ।  ६ Buf.
   楤 Append( var f:  Text )  㦨  ᯥ樠쭮 
室 䠩.  ਬ  㦥 騬 䨧᪨ 䠩 
뢠      䠩.
   楤 Flush(  var  f: Text )  ਬ    室
䠩.   ਭ㤨⥫쭮 뢠     䠩 -
ᨬ  ⥯  .
   㭪 SeekEOLn( var f: Text ): Boolean 頥 祭 True,
᫨   ப ⠫ ⮫쪮 ஡.
   㭪 SeekEOF( var f:  Text ): Boolean 頥 祭 True,
᫨   䠩 ⠫ ப,  ஡.
   
   
32.                     
                                      
     ⨯஢ 䠩 -  䠩    -
  .  䠩   設 ।⠢-
 祭 ६,   ࠭   ⮬  ,    -
 .
   ᠭ 稭 䠩 ⨯  :

         type M= File Of T;

  -  䠩 ⨯,  - ⨯ . ਬ:

         type
           FIO= String[20];
           SPISOK=File of FIO;
         var
           STUD, PREP: SPISOK;

    STUD,   PREP  -  䠩,  ⠬  
ப.
   ᠭ 䠩    ࠧ ᠭ ६:

         var
            fsimv: File of Char;
            fr: File of Real;

   ⠬ 䠩    ᪠ ⨯,    -
஢ - ᨢ, ⢠, . ࠪ᪨   
ॠ 몠   "䠩 䠩" ⨬.
    樨    묨  䠩  ந   
⠭ 楤:

   Reset, Rewrite, Read, Write, Close.

      - 뢮 ᯮ 楤:

     Read(f,X);
     Write(f,X);

    f -  ᪮ 䠩,   -  ६,   ᨢ,
 ப,   ⢮,    ⠪  ᠭ, 
  䠩.
    믮 楤  Read(f,X)  ⮨  ⥭  譥 -
ன⢠   䠩     X.  ୮ ਬ
楤 Read(f,X) ᯥ ⥭ ᫥饩  䠩  -
   X.
   믮 楤 Write(f,X) ⮨   X  譥 -
ன⢮      .  ୮ ਬ ⮩ 楤
ᯥ  X  ᫥饩  䠩.
    ࠡ   묨 䠩  ७ ଠ -
஢   뢮:

    Read(f,X1,X2,...XK)

    Write(f,X1,X2,...XK)
   
    f -  䠩,  ६ 1, 2,... 
 - ⨯,    ⨯  䠩 f.
                                
   
33.                   

   ⨯ 䠩  뢠   ந ⪨
   뢠   ᪠  .  樨   -
묨   䠩   ⢫       楤  BlokRead  
BlockWrite. ஬  ⮣,   ७ ଠ 楤 Reset 
Rewrite.  ⠫쭮 ਭ樯 ࠡ  ⠪ ,    -
묨 䠩.
   । ᯮ짮 ᪨ 䠩
   
   var  f: File;
   
   易    䨧᪨   楤 Assign.  
䠩     ⥭      楤ன  Reset
 Rewrite,  ᫥ 砭 ࠡ  楤ன Close.
    ⨨ 䠩   ⠭  㬮砭  128
. TURBO  PASCAL    ࠧ   - 뢮,
 祣 ᫥ 뢠 䠩 ७  楤
   
   Reset(var f: File; BufSize: Word )
   

   
   Rewrite(var f: File; BufSize: Word )

   ࠬ BufSize  ᫮ ⮢, 뢠  䠩  -
뢠     饭. 쭮 祭 BufSize - 1
, ᨬ쭮 - 64  .
   ⥭   ⨯ 䠩 ⢫ 楤ன
   
  BlockRead( var f: File; var X; Count: Word; var QuantBlock: Word );
   
    楤 ⢫   饭 ⥭  ६ X
⢠ ,   ࠬ஬ Count,   ⮬   
ࠢ   .  祭 Count     1.   
饭   , 祬 64  ⮢.
   易⥫ ࠬ  QuantBlock 頥 ᫮  (-
஢), ⠭ ⥪饩 樥 BlockRead.  砥 ᯥ譮 -
襭 樨 ⥭ QuantBlock = Count,  砥 ਩ -
樨 ࠬ QuantBlock 㤥  ᮤঠ  ᫮  㤠筮  ⠭
.   ᫥,        ࠬ QuantBlock 
஫஢ ࠢ쭮 믮 樨 ⥭.
      ⨯ 䠩 믮 楤ன
   
   BlockWrite( var f: File; var X; Count: Word; var QuantBlock: Word );
   
 ⢫     饭   ६ X -
⢠ ,   ࠬ஬ Count,  ⮬   ࠢ
 .
   易⥫ ࠬ  QuantBlock 頥 ᫮  (-
஢), ᠭ ᯥ譮 ⥪饩 樥 BlockWrite.
                                                                    
   
34.                            
     
   
    ᫥⥫쭮  㯠  砥  ⮬,    
 ६ 㯭      ᥩ  ᫥⥫-
.   ⮣,  ⮡  ( )    
஬ ,  室 ᬮ  砫 䠩 -1 ।
. ᫥ 饭    ஬   
   ஬ +1.  ᫥,   ନ஢
()    䠩  ᬮ (⥭)    ந쭮
।.   ࠧ, 䠩 砫 ந   ᫥-
⥫쭮     ,   ⥬  ᫥-
⥫쭮 ᬠਢ  砫  .
   ᬮ७ ࠭  ।⢠ ࠡ  䠩 ᯥ稢 ᫥-
⥫ .
   TURBO PASCAL   ਬ    ⨯ 䠩-
, ᠭ   , ᯮᮡ אַ 㯠. אַ  -
砥    ࠭ ।  䠩 ,   ஬ 㤥
ਬ   - 뢮.   砥 ⨯  䠩  
ࠢ ࠧ ,    䠩  -   -
 䠩.
   אַ   ।,   䠩 ।⠢ ᮡ 
᫥⥫쭮 .  ᫨ 䠩 ᮤন n ,   㬥-
  1 १ 1  n.  ஬ ⮣,  ⨥ ᫮ -
  ,  ⮬ ᫮ ࠭  ஬ 0 ᯮ
।   ஬ 1,  ࠭  ஬ 1 ᯮ । -
  ஬ 2 ,  ,  ᫮ ࠭  ஬ n  室
᫥   ஬ n.
    אַ 㯠 ⢫   㭪権  -
楤 FileSize, FilePos, Seek  Truncate.
   㭪 FileSize( var f ):  Longint 頥 ⢮  
⮬ 䠩 f.
   㭪 FilePos( var f ):  Longint 頥  ⥪    
䠩 f.   䠩 -   ᫮ ࠭.  ⮫쪮 
⮣ 䠩 ⥪饩 樥 㤥 ࠭  ஬ 0.   -
,         ஬ 1.  ᫥ ⥭
  ࢮ  ⥪  ६    ࠭  
஬ 1,    㤥   쫮  ஬ 2. ᫥ -
⥭ ᫥  祭 FilePos ࠢ 祭 FileSize.
   楤 Seek( var f; N: Longint) ᯥ稢 祭 ⥪饩
樨  䠩 (樮஢).   ࠬ N    
 ᫮ ࠭, ।饩 ,  ஬ 㤥 ந-
 ᫥饥 饭.  ਬ, ⮡ ࠡ   4,
室  祭 N, ࠢ 3. 楤 Seek ࠡ⠥  -
묨 䠩.
   楤 Truncate( var f )  ⠭  ⥪饩 樨 ਧ-
  䠩  㤠 (ࠥ)  ᫥騥 .
   
   ਬ.     ⥪⮢ 䠩 ID.DAT,  ᮤ-
 ᫮   祭  ⢨⥫쭮  ⨯    ᫠  
ப - 祭 㬥  㭪樨 ᮮ⢥⢥.  ⢮ 
ᥫ   200.  ⠢ ணࠬ,  ⠥ 䠩, -
 㬥  㭪樨 뢠   ᨢ, 뢠
 ⢮,    뢮  ࠭ ᯫ  뢠  䠩 -
⭮ ⨯ RD.DAT.

   Program F;
    var
     rArg, rF: Array[1..200] of Real;
       inf: Text;
       outf: File of Real;
       n, l: Integer;
    begin
      Assign(inf,'ID.DAT');
      Assign(outf,'RD.DAT');
      Reset(inf);
      Rewrite(outf);
      n:=0;
      while not EOF(inf) do
        begin
          n:=n+1;
          ReadLn(inf,rArg[n],rF[n])
        end;
      for l:=1 to n do
       begin
        WriteLn(l:2,rArg[l]:8:2,rF[l]:8:2);
        Write(outf,rArg[l], rF[l]);
       end;
      close(outf)
    end.
                                               
   
35.           .
   
   樮 ⥬ MS - DOS  㥬 ࠭⢮  
ᥣ.  -  ⮪  ࠧ஬ 64  .   -
  室 ।  砫 ᥣ  ᬥ饭 -
⥫쭮 砫 ᥣ.
    TURBO  PASCAL ।  ⨯ Pointer - 㪠⥫.  -
 ⨯ Pointer

   var p: Pointer;
   
ᮤঠ   -   ணࠬ    4  ,
 ⮬    ࠭   ᫮,     । ᥣ-
, ஥ - ᬥ饭.
   ६ ⨯ 㪠⥫   㣨 ᯮᮡ.
   
  type NameType= ^T;
   
  var p: NameType;
    
    p - ६ ⨯ 㪠⥫, 易  ⨯   
 ⨯ NameType.   ६ ⨯ 㪠⥫   -
।⢥  ࠧ ᠭ ६:
  
   var p: ^T;
   
   室 ࠧ  ६  ⨯ 㪠⥫  ६,  
  㪠⥫ 뫠.  ਬ ᫨ p - 뫪   -
 ⨯ ,  p^ - 祭 ⮩ ᠬ ६.
    ६  ⨯  㪠⥫   ⠭⭮ 祭 NIL,
஥ 砥,   㪠⥫  뫠       ꥪ.
⠭ NIL ᯮ   㪠⥫.
    㪠⥫ﬨ  ।  権,  ஬ ஢ન 
ࠢ⢮  ࠢ⢮.
   ६ ⨯ 㪠⥫   ᠭ    -
 ᢠ,   ⮬  ࠢ      室  
㭪 ।  Addr(X),  ࠦ @ X,  @ - 㭠-
   ,  X -  ६  ⨯,     ⮬
᫥ 楤୮.
   ६ ⨯ 㪠⥫    ⠬ ᯨ᪠   -
뢮.
                                                
   
36.                          

   ᪮ ६ (᪨ ࠧ饭) 뢠 ᠭ-
  ࠧ  ணࠬ ६, 饭   ⢫-
  .      ࠧ饭 ᪨  ६
।  樨 ணࠬ.
    ⫨稥  ⠪ ᪨ ६  ணࠬ, ᠭ
 몥 ,    ᮧ ᪨ ६. ᭮-
 ᢮⢮ ᪨ ६ 砥  ⮬,    ᮧ-
         뤥  ६ 믮 ணࠬ.
 ᪨ ६    ᪮    
(heap - ).
   ᪠ ६  㪠뢠   ᠭ ६
        .    ⠪ ६ -
⢫   㪠⥫  뫮.
     ᪮    TURBO PASCAL ॠ 
 楤  㭪権 New,  Dispose,  GetMem,   FreeMem,   Mark,
Release, MaxAvail, MemAvail, SizeOf.
   楤 New( var p:  Pointer ) 뤥   ᪮ -
      ࠧ饭  ᪮ ६ p^   
ᢠ 㪠⥫ p.
   楤 Dispose(  var p:  Pointer )  ᢮ ⮪ ,
뤥  ࠧ饭 ᪮ ६ 楤ன  New,  
祭 㪠⥫ p ⠭ ।.
   㥤 GetMem( var p:  Pointer; size:  Word )  뤥 ⮪
    heap - ,  ᢠ   砫 㪠⥫ p,
ࠧ ⪠    ࠬ஬ size.
   楤 FreeMem( var p:  Pointer; size: Word ) ᢮ -
⮪ ,   砫 ண । 㪠⥫ p,  ࠧ -
ࠬ஬ size. 祭 㪠⥫ p ⠭ ।.
   楤 Mark( var p:  Pointer )  뢠  㪠⥫ p  
砫 ⪠ ᢮ ᪮     맮.
   楤 Release( var p: Pointer ) ᢮ ⮪ -
 ,   稭  ,  ᠭ  㪠⥫ p 楤ன
Mark,  -,  頥   ,   뫠 
᫥ 맮 楤 Mark.
   㭪 MaxAvail: Longint 頥    ᠬ -
 ᢮ ⪠ ᪮ .
   㭪 MemAvail:  Longint  ꥬ ᢮ ᪮ -
  .
   ᯮ⥫쭠 㭪 SizeOf( X ):  Word 頥 ꥬ  -
,   X, 祬 X     ६ 
⨯,   ⨯.
   ᬮਬ  ਬ ࠡ  㪠⥫ﬨ.
    
    var
     p1, p2: ^Integer;
   
    p1  p2 - 㪠⥫  ६ 뫮筮 ⨯.
    
    p1:=NIL;  p2:=NIL;

   ᫥ 믮  ஢ ᢠ 㪠⥫ p1  p2 
 뫠     ꥪ.
    
    New(p1);  New(p2);

   楤 New(p1) 믮 ᫥騥 ⢨:
   -   뤥 ⮪   ࠧ饭  稭  楫
⨯;
   - ⮣ ⪠ ᢠ ६ p1:

                ͻ          ͻ
                  *ĺ>     
                ͼ          ͼ
                  p1               p1^

   筮, 楤 New(p2)  ᯥ 뤥 ⪠ ,
 ண 㤥 ᠭ  p2:
   
                ͻ          ͻ
                  *ĺ>     
                ͼ          ͼ
                  p2               p2^

   ᫥ 믮 ஢ ᢠ
    
        p1^:=2;   p2^:=4;
    
 뤥  ⪨     ᠭ 祭 2  4 ᮮ⢥-
⢥:
    
                ͻ          ͻ
                  *ĺ>  2  
                ͼ          ͼ
                  p1               p1^

                ͻ          ͻ
                  *ĺ>  4  
                ͼ          ͼ
                  p2               p2^
    
    १ 믮  ᢠ
    
       p1^:=p2^;

  ⮪ ,    뫠 㪠⥫ p1, 㤥 ᠭ
祭 4:
    
    
                ͻ          ͻ
                  *ĺ>  4  
                ͼ          ͼ
                  p1               p1^

                ͻ          ͻ
                  *ĺ>  4  
                ͼ          ͼ
                  p2               p2^

   ᫥ 믮  ᢠ
    
      p2:=p1;

 㪠⥫  ᮤঠ  ࢮ ⪠ :
    
                ͻ          ͻ
                  *ĺ>  4  
                ͼ      >ͼ
                  p1            p1^ p2^
                             
                ͻ      
                  *ĺ
                ͼ
                  p2
                                                                   
    
   ६ p1^, p2^  ᪨, ⠪    
뤥   믮 ணࠬ   楤 New.
   ᪨ ६   室  ⠢ ࠦ,  -
:
    
      p1^:=p1^+8;    Write('p1^=',p1^:3);
    
    
    ਬ.  १ 믮 ணࠬ:
    
 Program DemoPointer;
  var p1,p2,p3:^Integer;
  begin
   p1:=NIL;  p2:=NIL;  p3:=NIL;
   New(p1);  New(p2);  New(p3);
   p1^:=2;  p2^:=4;
   p3^:=p1^+Sqr(p2^);
   writeln('p1^=',p1^:3,'  p2^=',p2^:3,'  p3^=',p3^:3);
   p1:=p2;
   writeln('p1^=',p1^:3,'  p2^=',p2^:3)
  end.
    
 ࠭ ᯫ  뢥 १:
    
p1^=  2  p2^=  4  p3^= 18
p1^=  4  p2^=  4
                                           


37.                          
     

   ஢ ⨯ ,  ⠪,  ᨢ, ⢠, -
, ।⠢   ᮡ ᪨ ,  ⠪   ࠧ
  祭 ᥣ ६ 믮 ணࠬ.
    ॡ, ⮡   﫨 ᢮ ࠧ  室
襭 .      뢠 ᪨,  
 ⭮ ⥪,  ।, ᯨ᪨, ॢ  㣨. ᠭ -
᪨     ᨢ,  ᥩ  䠩 ਢ 
 ᯮ짮    㢥稢 ६ 襭 -
.
      ᪮  ।⠢  ᮡ
, ᮤঠ    ࠩ   :    ⨯ 㪠-
⥫,   ஥ -  ࠧ饭 .   饬 砥  
ᮤঠ    ,   ᪮쪮 㪧⥫  ᪮쪮  .
    ६,  ᨢ, ⢮  .
    쭥襣 ᬮ७ ।⠢ ⤥   -
:
                               ͻ
                                 D  
                               ͺ
                                 p  
                               ͼ
  p - 㪠⥫;
     D - .
   ᠭ ⮩   ᫥騬 ࠧ:

   type
    Pointer = ^Comp;
    Comp = record
            D:T;
            pNext:Pointer
         end;

 T - ⨯ .
   ᬮਬ ᭮ ࠢ  ࠡ    ᪨  ࠬ
 ⨯ ⥪, ।  ᯨ᮪,   ਢ ᠭ
.
    
38.       
    
   ⥪ 뢠 ᪠  ,  -
    ᪫祭    ன  ந  
 , 뢠 設 ⥪. ⥪ ࠡ⠥  ਭ樯

      LIFO (Last-In, First-Out) -

㯨訩 ᫥, 㦨 .
   筮  ⥪ 믮  樨:
    -砫쭮 ନ஢ ⥪ ( ࢮ );
    -   ⥪;
    -롮ઠ  (㤠).
    ନ஢ ⥪  ࠡ   室     -
 ⨯ 㪠⥫,  ࢠ   । 設 ⥪, 
 - ᯮ⥫쭠.  ᠭ  ६  :

    var pTop, pAux: Pointer;

 pTop - 㪠⥫ 設 ⥪;
    pAux - ᯮ⥫ 㪠⥫.
   砫쭮 ନ஢ ⥪ 믮 ᫥騬 ࠬ:

                     ͻ       ͻ
  New(pTop);           *ĺĿ        
                     ͼ      ͺ
                      pTop     >     
                                   ͼ

                     ͻ       ͻ
  pTop^.pNext:=NIL;    *ĺĿ        
                     ͼ      ͺ
                      pTop     > NIL 
                                   ͼ

                     ͻ       ͻ
  pTop^.D:=D1;         *ĺĿ    D1  
                     ͼ      ͺ
                      pTop     > NIL 
                                   ͼ

    ᫥   㯯 ஢ 뢠  ᮤন
  ࢮ .
       ⥪ ਧ  ᯮ짮 ᯮ-
⥫쭮 㪠⥫:
    
                     ͻ       ͻ       ͻ
  New(pAux);           *ĺĿ           ĺ*  
                     ͼ      ͺ      ͼ
                      pTop             <    pAux
                                  ͼ
                               
                                  ͻ
                                   D1  
                                  ͺ
                               > NIL 
                                   ͼ


                     ͻ       ͻ       ͻ
  pAux^.pNext:=pTop;   *ĺĿ           ĺ*  
                     ͼ      ͺ<   ͼ
                      pTop          *ĺĿ      pAux
                                  ͼ 
                                          
                                  ͻ 
                                   D1   
                                  ͺ 
                               > NIL <
                                   ͼ


                     ͻ       ͻ       ͻ
  pTop:=pAux;          *ĺĿ           ĺ*  
                     ͼ      ͺ<   ͼ
                      pTop     >  *ĺĿ      pAux
                                   ͼ 
                                           
                                   ͻ 
                                    D1   
                                   ͺ 
                                    NIL <
                                   ͼ

                     ͻ       ͻ
  pTop^.D:=D2;         *ĺĿ    D2  
                     ͼ      ͺ
                      pTop     >  *ĺĿ
                                   ͼ 
                                           
                                   ͻ 
                                    D1   
                                   ͺ 
                                    NIL <
                                   ͼ

    ᫥  ந 筮.
   ᬮਬ  롮ન   ⥪.    -
砫 롮ન ⥪ ᮤন  :
                     ͻ       ͻ
                       *ĺĿ    D3  
                     ͼ      ͺ
                      pTop     >  *--Ŀ
                                   ͼ 
                                           
                                   ͻ 
                                    D2   
                                   ͺ 
                                 ĺ*  <
                                  ͼ
                                 
                                  ͻ
                                   D1  
                                  ͺ
                                 > NIL 
                                   ͼ

      㯯 ஢ ⢫  ⥭  
  - 設 ⥪. ன   祭 㪠-
⥫ 設 ⥪:

                         ͻ       ͻ
  D3:=pTop^.D;             *ĺĿ    D3  
  pTop:=pTop^.pNext;     ͼ      ͺ
                          pTop             
                                      ͼ
                                   
                                      ͻ
                                       D2  
                                      ͺ
                                   >  *ĺĿ
                                       ͼ 
                                               
                                       ͻ 
                                        D1   
                                       ͺ 
                                        NIL <
                                       ͼ

      㭪,  ⥭  㤠  ⥪.

   ਬ. ⠢ ணࠬ,   ନ ⥪,   
 ந쭮 ⢮ ,  ⥬ ⠥  
 뢮   ࠭ ᯫ,   ⢥   ப ᨬ-
.   -   ᯫ, ਧ   - ப
ᨬ END.
    
 Program STACK;
  uses Crt;
  type
   Alfa= String[10];
   PComp= ^Comp;
   Comp= Record
           sD: Alfa;
           pNext: PComp
          end;
  var
   pTop: PComp;
   sC: Alfa;
  Procedure CreateStack(var pTop: PComp; var sC: Alfa);
   begin
    New(pTop);
    pTop^.pNext:=NIL;
    pTop^.sD:=sC
   end;
  Procedure AddComp(var pTop: PComp; var sC: Alfa);
   var pAux: PComp;
   begin
    NEW(pAux);
    pAux^.pNext:=pTop;
    pTop:=pAux;
    pTop^.sD:=sC
   end;
  Procedure DelComp(var pTop: PComp; var sC:ALFA);
   begin
    sC:=pTop^.sD;
    pTop:=pTop^.pNext
   end;
  begin
   Clrscr;
   writeln('    ');
   readln(sC);
   CreateStack(pTop,sC);
   repeat
    writeln('    ');
    readln(sC);
    AddComp(pTop,sC)
   until sC='END';
   writeln('******    ******');
   repeat
    DelComp(pTop,sC);
    writeln(sC);
   until pTop = NIL
  end.
                                     
39.         
    
   । 뢠 ᪠  ,  -
   ந   ,  롮ઠ ⢫
 㣮 . । ࠡ⠥  ਭ樯:

        FIFO (First-In, First-Out) -

㯨訩 , 㦨 .
    ନ஢ ।  ࠡ   室   -
 ⨯ 㪠⥫,  ࢠ   । 砫  ।,
 -  ।,  - ᯮ⥫쭠.
   ᠭ  ।  ६ ⨯ 㪠⥫  ᫥-
騬 ࠧ:
    
  type
   PComp=^Comp;
   Comp=record
         D:T;
         pNext:PComp
        end;
  var
   pBegin, pEnd, pAux: PComp;

 pBegin - 㪠⥫ 砫 ।, pEnd - 㪠⥫   -
, pAux - ᯮ⥫ 㪠⥫.
     । ⨯   ।.
   砫쭮 ନ஢ । 믮 ᫥騬 ࠬ:


                       ͻ       ͻ       ͻ
 New(pBegin);            *ĺĿ                    
                       ͼ      ͺ       ͼ
                       pBegin    >              pEnd
                                     ͼ


                       ͻ       ͻ       ͻ
 pBegin^.pNext:=NIL;     *ĺĿ                    
                       ͼ      ͺ       ͼ
                       pBegin    > NIL          pEnd
                                     ͼ


                       ͻ       ͻ       ͻ
 pBegin^.D:=D1;          *ĺĿ    D1              
                       ͼ      ͺ       ͼ
                       pBegin    > NIL          pEnd
                                     ͼ


                       ͻ       ͻ       ͻ
 pEnd:=pBegin;           *ĺĿ    D1     ĺ*  
                       ͼ      ͺ      ͼ
                       pBegin    > NIL <     pEnd
                                     ͼ


      । ந   ।:

 New(pAux);
    
ͻ       ͻ       ͻ       ͻ       ͻ
  *ĺĿ    D1     ĺ*                 ĺ*  
ͼ      ͺ      ͼ       ͺ      ͼ
pBegin    > NIL <    pEnd              <     pAux
              ͼ                     ͼ

 pAux^.pNext:=NIL;
    
ͻ       ͻ       ͻ       ͻ       ͻ
  *ĺĿ    D1     ĺ*                 ĺ*  
ͼ      ͺ      ͼ       ͺ      ͼ
pBegin    > NIL <    pEnd          NIL <     pAux
              ͼ                     ͼ
 pBegin^.pNext:=pAux;
    
ͻ       ͻ       ͻ       ͻ       ͻ
  *ĺĿ    D1     ĺ*                 ĺ*  
ͼ      ͺ      ͼ       ͺ      ͼ
pBegin    >  *  <    pEnd          NIL <     pAux
              ͼ                     ͼ
                                            ^
                                            
                 
 pEnd:=pAux;

ͻ       ͻ       ͻ       ͻ       ͻ
  *ĺĿ    D1           *ĺĿ           ĺ*  
ͼ      ͺ       ͼ      ͺ      ͼ
pBegin    >  *          pEnd     > NIL <     pAux
              ͼ                     ͼ
                                            ^
                                            
                 

 pEnd^.D:=D2;
    
ͻ       ͻ                     ͻ       ͻ
  *ĺĿ    D1                        D2     ĺ*  
ͼ      ͺ                     ͺ      ͼ
pBegin    >  *ĺ> NIL <    pEnd
              ͼ                     ͼ
                                              
                                              


    ᫥  ந 筮.
    
   롮ઠ     ।  ⢫  砫 ।,
६  ᪫砥  ।.       
ନ஢ ।,    ⮢:


ͻ       ͻ       ͻ       ͻ       ͻ
  *ĺĿ    D1          D2          D3     ĺ*  
ͼ      ͺ       ͺ       ͺ      ͼ
pBegin    >  *ĺ>  *ĺ> NIL <     pEnd
              ͼ       ͼ       ͼ
                                                                                                                                                                                                                                                               

   롮ઠ  믮 ᫥騬 ࠬ:

 D1:=pBegin^.D;
 pBegin:=pBegin^.pNext;
    
ͻ       ͻ       ͻ       ͻ       ͻ
  *ĺĿ    D1          D2          D3     ĺ*  
ͼ      ͺ       ͺ       ͺ      ͼ
pBegin               >  *ĺ> NIL <     pEnd
             ͼ      ͼ       ͼ
                       
          
    
   ਬ. ⠢ ணࠬ,   ନ ।, 
  ந쭮 ⢮ ,  ⥬ ⠥  -
  뢮   ࠭ ᯫ.  ⢥   ப ᨬ-
.       -   ᯫ,  ਧ   -
ப ᨬ END.

  Program QUEUE;
  uses Crt;
  type
   Alfa= String[10];
   PComp= ^Comp;
   Comp= record
          sD:Alfa;
          pNext:PComp
         end;
  var
   pBegin, pEnd: PComp;
   sC: Alfa;
  Procedure CreateQueue(var pBegin,pEnd: PComp; var sC: Alfa);
   begin
    New(pBegin);
    pBegin^.pNext:=NIL;
    pBegin^.sD:=sC;
    pEnd:=pBegin
   end;
  Procedure AddQueue(var pEnd:PComp; var sC:Alfa);
   var pAux: PComp;
   begin
    New(pAux);
    pAux^.pNext:=NIL;
    pEnd^.pNext:=pAux;
    pEnd:=pAux;
    pEnd^.sD:=sC
   end;
  Procedure DelQueue(var pBegin: PComp; var sC: Alfa);
   begin
    sC:=pBegin^.sD;
    pBegin:=pBegin^.pNext
   end;
  begin
   Clrscr;
   writeln('   ');
   readln(sC);
   CreateQueue(pBegin,pEnd,sC);
   repeat
    writeln('   ');
    readln(sC);
    AddQueue(pEnd,sC)
   until sC='END';
   writeln(' *****   *****');
   repeat
    DelQueue(pBegin,sC);
    writeln(sC);
   until pBegin=NIL
  end.
    
    
40.                  
    
    ⥪  ।    ⮫쪮      -
    ,  ⭮   祭 -
.
   吝 () ᯨ᮪  ன ,  ந-
 ࠭  ண   ,  ⠪ 묠-
 㤠.
     ᯨ᪠ । 箬.  筮  -  
᫮,   ப ᨬ.  ᯮ    -
,     ⤥쭮  , ⠪   
 .
   ᭮ ⫨ 吝 ᯨ᪠  ⥪  । ᫥騥:
   - ⥭ 㯭   ᯨ᪠;
   -       ᯨ᪠;
   - ⥭   㤠  ᯨ᪠.
    ᯨ᪠ 믮 ᫥騥 樨:
   -砫쭮 ନ஢ ᯨ᪠ ( ࢮ );
   -    ᯨ᪠;
   -⥭    箬;
   -⠢     ᯨ᪠ (筮  ᫥  -
   箬);
   -᪫祭    箬  ᯨ᪠.
    ନ஢ ᯨ᪠  ࠡ   室   -
 ⨯ 㪠⥫,  ࢠ   ।  砫  ᯨ᪠,
 -  ᯨ᪠, ⠫- ᯮ⥫.
   ᠭ  ᯨ᪠  ६ ⨯ 㪠⥫   ᫥-
騬 ࠧ:

   type
    PComp= ^Comp;
    Comp= record
           D:T;
           pNext:PComp
          end;
   var
    pBegin, pEnd, pCKey, pPreComp, pAux: PComp;

 pBegin - 㪠⥫ 砫 ᯨ᪠, pEnd - 㪠⥫   ᯨ᪠,
pCKey, pPreComp, pAux - ᯮ⥫ 㪠⥫.
   砫쭮 ନ஢ ᯨ᪠,     ᯨ᪠
믮 ⠪ ,    ନ஢ ।.

ͻ     ͻ    ͻ       ͻ    ͻ    ͻ
  *ĺĿ    D1       D2          DN1      DN    ĺ*  
ͼ    ͺ    ͺ       ͺ    ͺ   ͼ
pBegin  >  *ĺ>  *ĺ....>  *ĺ> NIL <   pEnd
            ͼ    ͼ       ͼ    ͼ
                                                                                                                                                                                                                                                               
    ⥭   ⠢    室 믮 -
    箬:
    
  pCKey:=pBegin;
  while (pCKey<>NIL) and (Key<>pCKey^.D) DO
   pCKey:=pCKey^.pNext;
   
 Key - , ⨯ ண ᮢ  ⨯  .
   ᫥ 믮   ஢ 㪠⥫ pKey 㤥 ।
   箬  ⠪   㤥 .
    pCKey ।    箬. ⠢ 
 믮 ᫥騬 ࠬ:
    
 New(pAux);               ͻ
 pAux^.D:= DK1;        ĺ* 
                         ͼ
                         pCKey
                       
ͻ     ͻ      ͻ     ͻ      ͻ     ͻ
 *ĺĿ  D1       Key     KK1      DN   ĺ* 
ͼ    ͺ      ͺ     ͺ      ͺ    ͼ
pBegin > *ĺ...> *ĺ> *ĺ...>NIL<  pEnd
          ͼ      ͼ     ͼ      ͼ
                                                                                                                                                                                                                                                               
    
                                           ͻ     ͻ
                                           DK1  ĺ* 
                                           ͺ    ͼ
                                              <   pAux
                                           ͼ
    
 pAux^.pNext:=pCKey^.pNext;
 pCKey^.pNext:=pAux;
                                         
                          ͻ
                       ĺ* 
                         ͼ
                         pCKey
                       
ͻ     ͻ      ͻ     ͻ      ͻ     ͻ
 *ĺĿ  D1       Key     KK1      DN   ĺ* 
ͼ    ͺ      ͺ     ͺ      ͺ    ͼ
pBegin > *ĺ...> *       *ĺ...>NIL<  pEnd
          ͼ      ͼ     ͼ      ͼ
                                ^
                                          ͻ     ͻ
                                          DK1  ĺ-* 
                                ĺͺ    ͼ
                       >* <   pAux
                                            ͼ
    
     㤠    箬 室  ᪥
㦭    ।饩:

  pCKey:=pBegin;
  while (pCKey<>NIL) and (Key<>pCKey^.D) do
   begin
    pPreComp:=pCKey;
    pCKey:=pCKey^.pNext
   end;
    
 㪠⥫ pCKey ।    箬, 㪠-
⥫ pPreComp ᮤন  ।饩 .
    
      箬 Key 믮 ஬:

 pPreComp^.pNext:=pCKey^.pNext;
    
                    pPreComp   pCKey
                     ͻ     ͻ
                      *       * 
                     ͼ     ͼ
                                
                                
                                
ͻ     ͻ      ͻ     ͻ    ͻ      ͻ     ͻ
 *ĺĿ  D1       KK1     Key    KK2      DN   ĺ* 
ͼ    ͺ      ͺ     ͺ    ͺ      ͺ    ͼ
pBegin > *ĺ...> *ĺĿ    *ĺ> *ĺ...>NIL<   pEnd
          ͼ      ͼ    ͼ    ͼ      ͼ
                                         ^
                                         
                           
                                                                                                                                                                                                                                                               
   ਬ. ⠢ ணࠬ,  ନ ᯨ᮪,  
 ந쭮 ⢮ ,  믮 ⠢  㤠
  ,   ⥬ ⠥  뢮  ᯨ᮪    ࠭
ᯫ.     ⢥   ப ᨬ.    - 
 ᯫ, ਧ   - ப ᨬ END.

 Program LISTLINKED;
  uses Crt;
  type
   Alfa= String[10];
   PComp= ^Comp;
   Comp= record
          sD:Alfa;
          pNext:PComp
         end;
  var
   pBegin, pEnd, pAux, pCKey, pPreComp: PComp;
   sC, sKey: Alfa;
   bCond: Boolean;
  Procedure CreateLL(var pBegin,pEnd: PComp; var sC: Alfa);
   begin
    New(pBegin);
    pBegin^.pNext:=NIL;
    pBegin^.sD:=sC;
    pEnd:=pBegin
   end;
  Procedure AddLL(var pEnd: PComp; var sC: Alfa);
   var pAux: PComp;
   begin
    New(pAux);
    pAux^.pNext:=NIL;
    pEnd^.pNext:=pAux;
    pEnd:=pAux;
    pEnd^.sD:=sC
   end;
  Procedure Find(var sKey: Alfa; var pBegin,pCKey,pPreComp: PComp;
                 var bCond: Boolean);
   begin
    pCKey:=pBegin;
    while (pCKey <> NIL) and (sKey <> pCKey^.D) do
     begin
      pPreComp:=pCKey;
      pCKey:=pCKey^.pNext
     end;
    if (pCKey = NIL) and (sKey <> pCKey^.sD) then bCond:=FALSE
                                             else bCond:=TRUE
   end;
  Procedure InsComp(var sKey,sC: Alfa);
   var pAux:PComp;
   begin
    Find(sKey,pBegin,pCKey,pPreComp,bCond);
    New(pAux);
    pAux^.sD:=sC;
    pAux^.pNext:=pCKey^.pNext;
    pCKey^.pNext:=pAux
   end;
  Procedure DelComp(var sKey: Alfa; var pBegin: PComp);
   begin
    Find(sKey,pBegin,pCKey,pPreComp,bCond);
    pPreComp^.pNext:=pCKey^.pNext
   end;
  begin
   ClrScr;
   writeln('    ');
   readln(sC);
   CreateLL(pBegin,pEnd,sC);
   repeat
    writeln('  ');
    readln(sC);
    AddLL(pEnd,sC)
   until sC='END';
   writeln(' *****    *****');
   pAux:=pBegin;
   repeat
    writeln(pAux^.sD);
    pAux:=pAux^.pNext;
   until pAux=NIL;
   writeln;
   writeln('    ');
   readln(sKey);
   writeln('  ');
   readln(sC);
   InsComp(sKey,sC);
   writeln;
   writeln('   ');
   readln(sKey);
   DelComp(sKey,pBegin);
   writeln;
   writeln(' *****    *****');
    pAux:=pBegin;
    repeat
     writeln(pAux^.sD);
     pAux:=pAux^.pNext;
    until pAux=NIL
  end.

