
          ⢮ 饣  ᨮ쭮 ࠧ
                         ᨩ᪮ 樨

                 ࠫ᪨ 㤠⢥ 㭨
                           . .. 쪮




                      ⨭ .., ᪠ ..

                 모  孮 ணࠬ஢.
                            砫 .

                            祡 ᮡ









                             ਭ
                                 1998






 ⨭  ..,  ᪠  ..  모   孮  ணࠬ஢.
砫 . 祡. ᮡ. ਭ, 1998.

   祡 ᮡ ।⠢ ᮡ    
樮 ,  ⠥ 㤥⠬ ⥬⨪-堭᪮
  1 ᥬ.
 砫   饭  ᭮ ᮧ ணࠬ. 
     ᯮ짮  몠  ணࠬ஢  ࡮   ᪠.
ᬠਢ  ᪨ .  ਢ  ਬ
襭 ⨯ .
 ᮡ   ।祭    㤥⮢  ⠭⭮     祭
ᯥ樠쭮   "ଠ樮   ⥬",      ⠪      
ᯮ짮      㤥⮢        祭      ⮩
ᯥ樠쭮.









                                     .. ⨭, .. ᪠, 1998.
                              
                                       5
                                    5
                                      5
                                   5
                             6
                                     7
   ⨯                                   7
  ⢥ ⨯                            8
  ᪨ ⨯                               9
   ⨯                               9
                                      9
                      10
                             11
                     11
                          11
                          11
                      12
                              12
                              13
                                13
                          14
   .                          14
   .                            16
                    17
                              17
 -                                 17
                                       17
                                        17
                              17
                             17
  ࠬ-祭                          17
  ࠬ-६                        17
  ࠬ-⠭                         17
  -                   17
                           17
                               17
                                      17
                       17
                                        17
                               17
                                 17
                                17
  ()                     17
                           17
                             17
   (⮤ "쪠")      17
                           17
                          17
                               17
      17
 CRT (᭮ )             17
                                    17



     ࢠ   몠 ᪠ 뫠 ࠧࠡ⠭ 袥᪨  祭
ᮬ  ⮬  1968 . ࢮ砫쭮   ।砫  
楫  祭,  ᪮   筮  ନ஢,
..   稭 । ࠢ, ᪫祭    
⠪  . ᭮ ࠪ⨪: ⭮⥫쭮 讥 ⢮
  ⨩, ⮩ ᨭ⠪,      ॢ
室 ⥪⮢  設 .
       1992  .  ଠ  Borland International ⨫    ,
᭮   몥 ᪠: Borland Pascal 7.0  Turbo  Pascal  7.0.
  ࠡ   ० - 筮  饭 ० MS
DOS      ⥬ Windows.   室 浪  30    
⪮  ᪥   2  ⨢ . ࡮  ᪠  7.0
ࠡ⠥  ⮫쪮    筮  ० MS DOS      ॡ⥫  
ࠪ⨪ . ᪮ ᭮ ,   
㤥  ᬠਢ   襬 , ᮢ     த,  
쭥襬 㤥 ᯮ짮  ࡮ ᪠.
       砥    ᥡ  ⬨᪨    ணࠬ஢
᮪  ஢,  ஥ ।   ।,  ।祭  
⫠   ᪠ ணࠬ. ஬ ⮣,  ᮤন 让  ꥬ
ࠢ筮    ଠ樨   (筮).       ⭮,    모
ணࠬ஢     ⨯:     .
࡮ ᪠ ⭮   몠.

                              

                               

     ⬮   뢠   ᠭ   ᫥⥫쭮   ⢨,
室        襭    ।    .     ᭮묨
ࠪ⨪   ⬠    ᫨⥫쭠   ᫮   
⭠  ᫮. ᫨⥫쭠 , ,  ६  ᫮
⬠  -    ⢮   権      
믮.  ᫨⥫ ᫮  ।      襬
砥. ⭠ ᫮ ⬠ -  ꥬ ᯮ㥬 ,
  ⠪  ꥬ    ᠬ ணࠬ.  ᮧ  ⬠  楫
 ᮪饭   ᫨⥫쭮, ⠪  ⭮ ᫮.
        뢠 ࠧ묨 ᯮᮡ,  ਬ,  
  -奬      ணࠬ. ணࠬ      㪠
ᯮ⥫, ..  襬 砥   .

                              

      䠢⮬ 몠  ᮢ㯭 ⨬ ᨬ.  
몥   ࡮   ᪠   ᯮ  ᨬ  ASCII   (ਪ᪨
⠭     ଠ樥).  뤥   ᭮
㯯 ᨬ: ᨬ, ᯮ㥬  䨪, ࠧ⥫,
ᯥ樠 ᨬ  ᯮ㥬 ᨬ.
     䨪  -    ꥪ 몠.    
  ⨭᪨  㪢 (a...z),  (0...9)   ન    
   稭      .  ய         㪢   
䨪  १ࢨ஢ ᫮  묨,  
ࠧ      ப ⠭.    䨪  
࠭祭,  稬묨    63 ᨬ.
     ⥫   ᯮ      ⤥          㣠
䨪஢,  ᥫ    १ࢨ஢  ᫮.     ࠧ⥫
⭮,  ਬ, ஡  ਩.      ணࠬ,
 ࠧ蠥  ஡,   ⠢  ⢮.
     ਨ    䨣 ᪮ { ਩ 1 },
    ᨬ (* ਩ 2 *)     ⢮
ப. ᫥⥫쭮   ᨬ (*) 稭 ਩ 
 ப.     樨, ᫨  
 ४⨢ ,    {$ }.
 :
(*⨬ {{{  (* ணࠬ} ਩*).
(*⨬ {{{  (* ணࠬ*) ਩*).
      ᯥ樠  ⭮  㭪樨 (. () [] .. : ;),
  権  १ࢨ஢ ᫮.  権    
  ᨬ  (+,-,*,/  ..), ⠪  㪢묨 (mod,  div,  not).
१ࢨ஢  ᫮    㦥묨            
८।  짮⥫, ..   ᯮ짮    
짮⥫᪨ ꥪ⮢. ᯮ㥬 ᨬ -      ASCII,
 ᯮ ⮫쪮    ᨬ ப,  
  몥.   ⭮  ᪨ 㪢,  ⠪ ᨬ %, &, ! 
..

                           

      ணࠬ, ᠭ  ࡮ ᪠,   ᫥騥
ࠧ:

Program   ... ;   {  ணࠬ }
Uses      ... ;   { 祭 㫥 }
Label     ... ;   {   ⮪ }
Const     ... ;   {   ⠭ }
Type      ... ;   {    ⨯ }
Var       ... ;   {   ६ }
Procedure ... ;   { ᠭ ᢮ 楤 }
Function  ... ;   { ᠭ ᢮ 㭪権 }
Begin             { 砫 ᭮ ணࠬ }
 ...;
 {  }
 ...;
End.

     易⥫쭮         ⥫  ணࠬ,   ஥
稭  ᫮  begin,    稢  ᫮  end     窮.
    ᪠ ࠧ 窮 ⮩.   ணࠬ
   易⥫,  ⥫ ⮬  ⮨  
१ࢨ஢ ᫮ program  䨪 -    ணࠬ,
  ஬ ᫥ 窠  ⮩. 冷   ᠭ  
ॣ.

 : ⥩ ணࠬ.
program prim_1; {   ணࠬ}
{ ணࠬ  ॡ    ᠭ}
begin
 write('ਢ!    砫.') (*  ப ⥪  
࠭ *)
end.

                               

     ⨥ ⨯   祢  몥 ᪠.  
ࠪਧ ७ ।⠢, ⢮ ⨬  祭
   ,  ⠪ ᮢ㯭 権  . ।  ⨯
 ࠧ ⠭ (।। ࠧࠡ稪 몠) 
짮⥫᪨  (।塞 ணࠬ⮬  ᢮  ணࠬ).  
㤥   ᬠਢ  ᫥騥  ⠭   ⨯:   楫   ᫠,
⢥  ᫠,  ᪨ ⨯,  ᨬ    ப  ⨯.
ணࠬ    ᢮ ⨯  ᭮      ࠧ
ᠭ ⨯,  稭 ᫮ Type. ⥬   ⨯
᫥  :

                䨪 ⨯ = । ⨯;

     ᬮਬ  ᭠砫    ⨯  ,       
।  㯮冷祭 ⢮ 祭: 楫  ⨯,  ᪨
⨯,   ᨬ  ⨯,  ⢥  ⨯.       ⨯,   ஬
⢥   浪묨.  祭  浪  ⨯
㭪 Ord ⠢  ᮮ⢥⢨ ࠫ쭮 ᫮ - 浪 
  祭  ⢥ ⨬ 祭.    浪
⨯  ⠪    ਬ 㭪樨 Pred  -  頥  ।饥
祭    Succ - ᫥饥 祭.  ⭮   㯮冷祭
᫨    ६    ࠦ  ⮣  ⨯  ।  樨
⭮襭    ࠢ: =, <>, <, >, <=, >=.   浪  ⨯
  㯮冷祭,   .  ⢥ ⨯    ⨯
string 㯮冷祭,   浪.

                               ⨯

 몥 ࡮ ᪠ । 5 楫 ⨯:

     Shortint (-128 ... 127, 1 ),
     Integer (-32767 ... 32768, 2 ),
     Longint (-2147483648 ... 2147483647, 4 ),
     Byte (0 ... 255, 1 ),
     Word (0 ... 65535, 2 ).

        楫  ᥫ  ।  ⠪  樨.  :   +,-.
: ᫮, ⠭, 㬭, 祭 ⭮  (div)  
⪠  (mod)  楫᫥    㣨.    
楫묨 ᫠  ந 樨, १   楫
᫠.   筮   樨 ⭮襭. ஬ ⮣,  
讥  ⢮ ஥ 㭪権  ࠡ    楫묨  ᫠:
abs, sqr, sqrt, sin, cos, exp, ln  .

                           ⢥ ⨯

      ࡮ ᪠  5 ⢥ ⨯.

   * Real     ( 6 ,     2.9E-39    1.7E+38  
              , 筮 11-12  )
   * Single   (  4 ,   1.5E-45    3.4E+38  
              , 筮 7-8  )
   * Double   ( 8 ,   5.0-324    1.7+308  
              , 筮 15-16  )
   * Extended ( 10 ,   3.4E-4932  1.1E+4932 
              , 筮19-20  ).
   * Comp     ( 8  ,      -9.2E-18    9.2E+18,
              ࠭ 筮, ᪮  楫 ᫠)

     ⢥  ⨯   㯮冷祭묨,     浪묨.
樨    ⢥묨 ᫠: ᫮ ,⠭,  㬭,
    樨 ⭮襭. ஬ ⮣,  讥 ⢮
஥  㭪権  ࠡ  ᫠: abs, sqr, sqrt, sin,  cos  
..
     ⢥   ᫠  ࠭  筮.        
⢥    ⨯   ࠭   ࠢ쭮    ࠭    ⮫쪮
। ⢠  ,  뢠 묨 ࠬ. 
⥬᪮   窨   ७,        ᮡ⥩   ७
।⠢    ⭮⥫쭮 譮.
     筮  ࠭ ⢥ ᥫ  ਢ    ⮬,
  ⠭  ᥫ  ந  稬. 
  , 祬 ᫥  ࠢ ⢥  稭
 筮 ࠢ⢮.

:  ⨯ Single - ࠭ 7-8  ᫥ 筮 窨,  ⨯
Double - 15-16, ⨯ Extended - 19-20.
program sravnenie;
var  x : single;    y : double;    z : extended;
begin
 x := 1/3;    y := 1/3;
 z := abs(x-y);
 writeln('z=',z);
end.
         ணࠬ  뤠  १ ᫮  z=9.93410748106882E-
0009. 筮 ਭ ,  a=b, ᫨ 믮 ᫮ abs(a-
b)<eps.    ᫮    eps       ।    ᫥騬    ࠧ:
min(abs(a),abs(b))*10^(-m),    m -  室  ᫮  ᮢ
 ࠧ冷.

                            ᪨ ⨯

     ६ ᪮ ⨯ Boolean      
  ਭ     祭 False  -      True  -
⨭.  ⨯  浪 (Ord(False) = 0, Ord(True) = 1)
,  ᫥⥫쭮,  㯮冷祭.   権  ࠢ
 ᪨ ⨯    ᢮ ᪮ ६.  
࠭ ⨯ boolean । ᫥騥 ᪨ 樨: NOT -
栭  (ॢ頥 false  true,  true  false), AND - ᪮
㬭  "", OR   ᪮ ᫮ "", XOR - ᪫饥  
(true  ᫨  ࠭  ࠧ). ਭ樯 ⢨   権  
ந஢ ⠪ 奬:

     AND     false  true
     
     false   false  false
     true    false  true

     OR      false  true
     
     false   false  true
     true    true   true

     XOR     false  true
     
     false   false  true
     true    true  false


                             ⨯

       ⨯  Char  ⠪  뢠  .     
ࠡ     ᨬ,    뢠    ᯮᮡ:   
 窠    , ਬ 'a', 'B', '*' ,   
  ᠬ,  #97, #130, #42.  ⫨稥  ⥪ ணࠬ   ᪠,
ᨬ,  ᮮ⢥騥       㪢  ࠧ.
⢮ 祭 ⨯ Char ।⠢ ᮡ    ASCII  -
ᨬ  (ਪ᪠ ⠭⭠ ஢).    ࠭
⭠   ᨬ (1 ),     ᯮ  
    ⭮襭   (ࠢ).   㭪   Ord    뤠    
ᮮ⢥饣  ᨬ,     0    255.  ⭮
㭪樥,       뤠 ᮮ⢥騩  ᨬ,  
㭪 Chr.

                               

       ࠦ  -      몠,    ।  ᯮᮡ
᫥  ண  祭. ࠦ ନ    ⠭,
६,  㭪権,  権  㣫 ᪮  ।
ᨭ⠪᪨ ࠢ.
     ⠭⠬ 뢠 ࠬ ணࠬ, 祭    
            믮.          
।⢥   祭,    䨪 ⠭,
ᠭ    ࠧ,  稭饬    ᫮  Const.     
⠭  ࠧ 㪠뢠  :

                  䨪 ⠭ = 祭;

  ⠭  ᮤঠ    : -214,  23,  ⢥
 ᮤঠ ⠪  , ⥫ ⥯  ᨬ e,
   ᭮ 10   ᫠: -0.5,  -1e-5,  7.2e+15.
᪨  ⠭  -    祭  False    True.  쭠
⠭  ।⠢ ᮡ ᨬ ASCII, 祭    .
᫨  ᨬ    䨧᪮ ࠦ,      #  
冷 ASCII- ᨬ  䮢.
     ६묨 뢠 ࠬ ணࠬ,    
᢮  祭    믮.   ᪫祭 ६
   ᠭ  ࠧ ணࠬ, 稭饬   ᫮  VAR.
⥬ ᫥ 樨 :

               ᯨ᮪ 䨪஢ ६ : ⨯1;
               ᯨ᮪ 䨪஢ ६ : ⨯2;

       ᯨ᪥    ६  १  .  ஬
  ⨯  ࡮  ᪠      ᯮ짮  ᢮  ⨯
(ᠭ  ࠭    ࠧ Type).  ࡮ ᪠    讥
⢮ ஥ 㭪権  ࠡ  묨  ⨯. 
(㪠⥫)   㭪権  㬥⮬  㣫 ᪮    ⠪
   ࠦ.  権   ⨯ ᯮ㥬
 ࠦ ࠭  ᬮ७ .
     㣫  ᪮  ᯮ     浪  ᫥
⥩   ࠦ.  ࠦ    ᪮       浪,
ᮮ⢥饬  ਮ  権.  ਮ  ⠢  ⠪
ࠧ:

     ᫥  㣫 ᪮;
     ᫥ 祭 㭪権;
     㭠 樨 ( not,+,- );
     樨 ⨯ 㬭 ( *,/,div,mod,and );
     樨 ⨯ ᫮ ( +,-, or, xor );
     樨 ⭮襭 ( =, <>, <, >, <=, >= ).

       ᪮  ࠦ  2<=4 and  5>3  ᪠  뤠  訡,
᪮    and  㤥 믮 ࠭  権  ࠢ.
ୠ  - (2<=4) and (5>3).

                        

             襩 ணࠬ  
  ࠧ  ⨯,  ⠥    ᮢ⨬.    몥
࡮   ᪠  ⮬    㤥  祭  讥   ,
ࠧࠡ⠭  ண ࠢ, ।騥 筮, ᮢ⨬
 饬 砥  ᮢ⨬  ᢠ ࠧ ⨯.
        砫  筮  ᫥饥. ६  
ࠦ  ⨯   ᮢ⨬묨. 㣨 ⨥
 ᮢ⨬  ᢠ. ᢠ ६ 
⨯  ࠦ  㣮 ⨯ ⨬  ⮬ 砥,   ⢮
祭   ண  ⨯    ⢮  祭   ࢮ.
ਬ, १ ᫮  楫 ६ ⨯ integer  word
  ᢠ  楫 ६, ⨯ ன  ⮫쪮  longint,
᪮  ⮫쪮    楫  ⨯ ᮤন    ᥡ    
  祭   ⨯ integer, ⠪   ⨯  word.  ,
  ᢠ  楫  ࠦ    ⢥  ६  
ᨬ쭮 ࠦ  ப.

                           

     ⬨᪨  ⢨    室묨  묨      ࠡ稬
ꥪ⠬   몠,   室    襭   ⠢   
뢠   ஢ ࡮ ᪠.  ࠧ
窮    ⮩,  ᫥⥫쭮  ⠢ ⥫ ணࠬ.
  ⮩  砩 ।⠢ ᮡ   .  
믮      ⪮   ⬠      믮
᫥⥫쭮      㣮    ⮬  浪,     ஬   
᫥    ணࠬ.    ⮬   ᯮ짮  
ᢠ, 樨   뢮.

                        

       ணࠬ   ਬ ⮩ ,    믮騩
 ⢨.  ।⠢ ᮡ   ⮩.
     ⠢  ஬  ⠥ ᫥⥫쭮  ந
஢, 祭   ᪮ - १ࢨ஢ ᫮
begin  ... end. ᪠ ந쭠 㡨  ⠢
஢.  ⠢  ਬ ⠬,   ᨭ⠪᪨
ࠢ 몠   ⮫쪮  ,    믮
᪮쪮 ⢨.  ⮬ 砥  室   
ଫ     ⠢  .    ,    ⥫   ணࠬ
।⠢ ᮡ  ⠢ .

                          

        ᢠ   ᯮ         祭
६   ᫥騩 ᨭ⠪:

                     _६ := ࠦ;

       ࠦ, 饥  ࠢ   ,  ᫥
祣   祭 뢠  ६,  ன ⮨ ᫥.
  ࠦ  ⨯ ६   ᮢ⨬, .. ⢮
⨬  祭    ⨯  ࠦ  ᮤন     ⢥
⨬ 祭  ⨯ ६.

                           

     ᬮਬ ⥩訥 楤   뢮.  㬮砭 
⢫    ,  뢮  ࠭.    ࠬ  
⭮:
               Read(<ᯨ᮪ ६ १ >);
                     Readln(<ᯨ᮪ ६>);
                               Readln;

     ன  ⫨砥    ࢮ ⥬,   ᫥    ॢ
      ப, 筥,   ᢮  ࠡ  뢠  
      <Enter>. ⨩    ᯮ  
࣠樨    - 믮 ணࠬ த,    ࠢ,
⮫쪮  ᫥        <Enter>.    ࠬ
뢮 ⭮:

                        Write(<ᯨ᮪ 뢮>);
                       Writeln(<ᯨ᮪ 뢮>);
                               Writeln;

       ᯨ᪥  뢮  ஬  ६     ப
⠭  (᫥⥫쭮 ᨬ  )   ࠦ
(뢮   祭). ன  ⫨砥   ࢮ  ⥬,
  ᫥  뢮 ॢ    ப.  ⨩  
 ॢ    ப.
       ⠪  뢠 ଠ஢ 뢮.    
⢮  権, ⢮  ᫮.  楫 - ᫥  ࠦ
  ६  १ 稥 㪠뢠    ⢠
権          뤥  祭.    ⢥   -
⥫쭮 १ 稥  㪠 ⢮    ஡
.  ⮬ ந室 㣫   ஭.

:  ᫥.
program vvod_vyvod;
const     n=1.5;
var  y1,y2:real;    x:byte;
begin
 writeln(' ࠫ쭮 ᫮ <= 255');
 readln(x);
 y1:=cos(n); y2:=cos(x);
 write('祬- ⠫: ');
 writeln('n=',n,' y1=',y1:7:4, cos(Pi/2):8:4);
 {⠥
 祬- ⠫: n= 1.50000000000000E+0000
 y1= 0.0707 1.0000}
 writeln('x=',x:3,' y2=',y2:7:4);
end.

                        

       ࡮  ᪠    室 ணࠬ,
..  믮 ஢   ⮬ 浪,  ஬   ᠭ.
     ।⠢ ࠧ⢫騥  .  
    ॠ       ᯮᮡ:    ᯮ짮
஢ 室, ᫮    롮.

                            

      室  
                             GOTO <⪠>.

          ।  ࠢ  ।⢥    㦭
  ணࠬ. । ⨬ ஬  ᯮ  ⪠
⤥      稥.  ࡮  ᪠    ⢥  ⮪
㯠    楫  ᫠  0  9999,   䨪.  
⪨      ᠭ    ࠧ    ⮪  ᫥騬
ࠧ:

                 label <ᯨ᮪ ⮪ १ > ;

       ⪮    ணࠬ      祭  ⮫쪮   
.  ஢ 室    ⮩   ⪮    
  ⢮. 室, ⮡ ࠧ ᠭ ⪨, ᠬ ⪠
h    室     ᯮ짮 ᯮ    ।
    ணࠬ (. ⥬ 楤  㭪樨).  ஬  ⮣,
   ।  ࠢ    ஢  ஢
(ਬ, if, for, while, repeat  .).

                            

     ᫮  IF   冷 믮 
  ᨬ  ண ᪮ ᫮, ..  ⢫
⢫ ᫨⥫쭮 . ᫮   :
           IF <᫮> THEN <1> [ELSE <2>];
       砥  ⨭ ᪮ ࠦ, 饣    ᫮,
믮  <1>,    <2>  ய᪠.     
祭  ᪮ ࠦ ய᪠ <1>  믮
<2>.
       IF       (    ⢨)  
  (Else-⢨ ,   ᫮ 祣  ).  
ࠢ      ⢥   ᮤঠ      믮塞
,   ᪮쪮, ꥤ  ⠢. 窠    ⮩
। Else ⠥ 訡.

:  楫 ᫮. 뢥 ᮮ⢥騩  ᨬ  ASCII-
⠡,    ᮮ,  ⠪ ᨬ  (0-31  -  ࠢ騥
, ⥬  256 - ⠥ ᨬ).
program ascii_symbol;
var  i:word;
begin
 write(' 楫 ᫮: ');  readln(i);
 if (i>31) and (i<256) then
   writeln('⢥騩 ᨬ - ', Chr(i))
   else writeln(' ᨬ ');
 readln
end.

                             

     ᫨         ਠ 믮  ணࠬ,  
,   ᯮ짮  롮 CASE.   ⮣
  ࡮ ᪠:
                         CASE <_롮> OF
                           C1 : <1>;
                           C2 : <2>;
                                 . . .
                           CN : <N>;
                          [ELSE <0>;]
                                 END;
        <_롮>  -    ࠦ  浪   ⨯,   
ᨬ    祭 ண ਭ  襭;  C1,...,CN  -
祭,    묨 ࠢ 祭 <>; <1>,...,
<N>  -   ( ⠢),    믮
rnr,    ⠭⮩  ண  ந室 ࢮ  ᮢ  祭
<>, <0> 믮, ᫨ 祭   ᮢ  
  ⠭ C1,...,CN.
      Else  易⥫쭠,   ⫨稥   if, । 
  ⠢    ⮩. ᫨  ᪮쪨 祭  <>
⢨  ᮢ,   ⠭  ᫨ १  
। 稥     祭 ( ࠭  ..
 ࠭).

:  楫 ᫮, ᫨  ,  । ⭠ 
 ,  ᫨ ᫮,  ।        10
 100, ᫨ ,  뤠 ᮮ⢥饥 ᮮ饭.
program chislo;
var  i:integer;
begin
 write(' 楫 ᫮: ');
 readln(i);
 case i of
   0,2,4,6,8 : writeln('⭠ ');
   1,3,5,7,9 : writeln('⭠ ');
   10...100,200 : writeln('᫮  10  100  200');
   else writeln('᫮  ⥫쭮,  > 100,   200');
 end;
 readln
end.

                          

     ࡮ ᪠  ᯮ짮  ࠧ   
࣠樨     ᫥⥫쭮⥩   ⢨,   
뢠 横.

                            .

      横 For ࣠ 믮   ࠭
। ᫮ ࠧ.   뢠 横  稪. 
  :
             FOR <ࠬ> := <nz> TO <kz> DO <>;
           FOR <ࠬ> := <nz> DOWNTO <kz> DO <>;
       ࠬ  横  (稪) ।⠢  ᮡ  ६
浪 (न쭮) ⨯; <nz>  <kz> - ࠦ, ।騥
砫쭮    筮 祭 稪; <> -   (
⠢)   ,    뢠  ⥫  横,   塞
। ᫮ ࠧ.
       ࢮ 蠣 横 ࠬ ਭ 祭 nz.     
 ந室 ᫥ kz - 祭 ࠬ  ᫥ 蠣
横.  ᫥   믮 ⥫ 横, ᫨ ࠬ  横  
ࠢ  kz,  ந室   ࠬ  ᫥饥  襥  
襥  祭   ᨬ    for,  ..  
ந室 믮    ஢:

                    <ࠬ> := Succ(<ࠬ>);
                    <ࠬ> := Pred(<ࠬ>);

       砥 nz > kz  ࢮ ଥ   nz < kz   ன
  ଥ 訡  ந室,  横  믮  ࠧ. ᫥
襭 ࠡ 横 祭 ࠬ ⠥ ࠢ kz.
     :   ᯮ짮  横  for    ࠭   ⭮
⢥  ७.      ࠬ    ⥫  横.   
ᯮ짮  () 横 ਬ ࠧ ६ 
⢥ ࠬ஢. ।  横 祭  ᯮ㥬  
 ६.  ⠢   ⮩ ᫥ do.

:      10   ᥫ,     ।      ⢮
⥫.
program cycle_for1;
var  i,kn:byte;     x:real;
begin
 kn:=0;
 for i:=1 to 10 do
 begin
   writeln(' ',i,' ᫮: ');
   readln(x);
   if x>0 then kn:=kn+1 {㢥稢 ⢮  1}
 end;
 writeln('  ',kn,' ⥫ ᥫ.');
 readln
end.

:  㪢  'Z'  'A'.
program cycle_for2;
var  c:char;
begin
 for c:='Z' downto 'A' do write(c);
 readln
end

: ᫨ N- ᫮ . ᫠  
᫥騬 ࠧ: F(0)=F(1)=1; F(i+1)=F(i)+F(i-1);  i>=1. 
ਬ ᫥  ४७ 㫠.
program Fib;
var  a,b,c:word;    i,n:byte;
begin
 write('  ᫠  ');
 readln(N);
 a:=1; {a=F(0), a ᮮ⢥ F(i-2)}
 b:=1; {b=F(1), b ᮮ⢥ F(i-1)}
 for i:=2 to N do
 begin
   c:=a+b; {c ᮮ⢥ F(i)}
   a:=b; b:=c; { ⢥ a  b  ᫥  ᥫ}
 end;
 writeln(N,'- ᫮  =',b); { N>=2 b=c}
 readln
end.

                             .

     ᫨  ࠭  ⭮ ᫮ ७ 横,  ᯮ
横  ᫮.  ᪠   ⨯ ⠪ 横.  While
뢠 横  ।-᫮.   
                WHILE <.ࠦ> DO <>;
       While  ࣠  믮  (  ⠢)
    ⨭  ᪮ ࠦ,  饥    
横.  ᪮ 祭 ᪮ ࠦ ஢   砫
  樨,  ⥫ 横   믮    ࠧ.  
ࠧ,    ⮬ 横 ᪮ ࠦ -  ᫮ த
ࠡ  横.
     㣮  ਠ 横  ᫮ -  横 Repeat.  뢠
横  -᫮.   

                                REPEAT
                     < 1> ... < N>
                        UNTIL <.ࠦ>

       Repeat  ࣠ 饥 믮  ᪮쪨
஢      ⠭ ⨭ ᫮, 饥  Until-
.    横 易⥫쭮 믮      ࠧ.  
ࠧ,    ⮬ 横 ᪮ ࠦ -  ᫮  室  
横.
       ᮧ  横᪨  ⬮  ࡮  ᪠  
ᯮ짮  楤 Continue  Break. 楤 Continue  筮
蠥  ।  蠣  横, ।  ࠢ    .
楤 Break ॠ  室  横.
     :    ⮣, ⮡   横  ணࠬ
室 ᯥ    蠣 横 祭   
  ६, 室饩  ᫮ 横. ᫥ 室  横  
᫮  ᫮ ( ᯮ짮 権 and, or, xor)  ࠢ
室 ஢ઠ ⮣,   ᫮ 横 襭.

:  ⥫ ⢥ ᥫ   .
 ந     㬬  ᥫ.
program cycle_while;
var  x,y,sum:real;  otv:char;
begin
 sum:=0;
 otv='';
 while (otv='') or (otv='') do
 begin
   write(' ᫠ x,y > 0 ');
   readln(x,y);
   writeln(' ந = ',x*y:8:3);
   sum:=sum+x+y;
   write(' ணࠬ (/)? ');
   readln(otv);
 end;
 writeln(' 㬬 = ',sum:8:3);
 readln
end.

:  ⮩    ᯮ짮 㣮 横  ᫮:
program cycle_repeat;
var  x,y,sum:real;  otv:char;
begin
 sum:=0;
 repeat
   write(' ᫠ x,y > 0 ');
   readln(x,y);
   writeln(' ந = ',x*y:8:3);
   sum:=sum+x+y;
   write(' ணࠬ (/)? ');
   readln(otv);
 until (otv='') or (otv='');
 writeln(' 㬬 = ',sum:8:3);
 readln
end.

:  宦  襣 饣 ⥫   楫  ᥫ  
 ⬠ .
program Evklid;
var  a,b,c:integer;
begin
 write('  楫 ᫠ : ');
 readln(a,b);
 while b<>0 do
 begin
   c:=a mod b;
   a:=b;
   b:=c;
 end;
 writeln('訩 騩 ⥫ = ',a);
 readln
end.

                       

       ࡮  ᪠  ।ᬮ७ 堭  ᮧ    ⨯,
  ਭ  뢠 짮⥫᪨   㥬묨.  
  ᮧ    ᭮  ⠭    ࠭  ᮧ  ⨯.
ᠭ   ⨯ ந室  ࠧ TYPE. ᫥ ⮣    
ࠧ  Var  ᮧ  ६   ⨯.  ,    ࠧ
뢠    ⨯  ᮧ ६  ࠧ  Var.    ⮩
  ᬮਬ ᫥騥 짮⥫᪨ ⨯:
       塞 ⨯,
       ⨯-,
       ᨢ,
       .

                            

     塞 ⨯  ᫥  祭,  
   .    祭      䨪஬
(ᬮ   䠢 몠)  ᯮ  㣫 ᪮  १
. ⢮ ⮢  ᫥   65536.  
뢮  ६ 塞 ⨯ 饭.  ᫨  ⨯
  浪 (ᬮ   ), ⮬   ६
⠪  ⨯    ਬ 㭪樨 Ord, Pred,  Succ.  㭪  Ord
頥 浪  祭 稭  .

:  塞 ⨯.
Type Colors = (Red,Green,Blue);
   Numbers = (Zero,One,Two,Three,Four,Five);
var  c:Colors;      n:Numbers;
begin
 c:=Red;      write(Ord(c));      {0}
 n:=Four;          write(Ord(n));      {4}
 c:=Succ(c);  {c=Green}
 for n:=One to Five do  write(Ord(n));      {12345}
end.
      ⬥,  ⠭ ⨯ byte, word, char  boolean
⠪   ਠ⠬ ᫨ ⨯.

                             -

     - ⠪ 뢠 ࠭祭  ࢠ  ⨯.
    ⢮ ᢮  ⨯,  ⢥  ண
  㯠    浪  ⨯  ஬  ⨯-.  -
  ᫥   ᢮⢠ ᢮   ⨯.    
⠭  㭪樨,  ࠡ騥  ⨬  ⨯:  High(x)-  頥
ᨬ쭮   祭   ⨯-,      ஬   ਭ
६ x; Low(x) - 頥 쭮 祭.

:  ⨯-.
type      Numbers = (Zero,One,Two,Three,Four,Five);
   Num = Two .. Four; {   ⨯ Numbers}
   Abc = 'A' .. 'z'; { ᪨ 㪢 :    ⨯
 Char}
   Digits = 0 .. 9; {}
var  n:Num;    c,d:Abc;  x:integer;
begin
 n:=Four;     writeln(Ord(n));    {4     ⨯}
 n:=Succ(n); {  (᫥饥 祭  )}
 read(c,d);
 if c=d then write(' 㪢');
 writeln(Low(c),' .. ',High(c)); { A .. z }
 writeln(Low(x),' .. ',High(x)); { -32768 .. 32767 }
end.
       ⥪  ணࠬ  ࡮ ᪠   ४⨢
,   ⠪  뢠 ﬨ.  樨  {$R+}    {$R-}
   ⪫ ஢ ᮡ ࠭  ࠡ 
.  ஢ઠ 祭,  襭 ࠭  
ந室  ਩  襭 ࠡ ணࠬ.    㣮  砥
⢥⢥   訡   ணࠬ.

                                

     ᨢ  -  㯮冷祭  ⨯ , ࠭
 ᫥⥫쭮.    ᨢ ⢫ १ 
. ᨢ 뢠 ᫥騬 ࠧ:
    ⨯ = ARRAY [  ᮢ ] OF ⨯  ᨢ;
       ⢥  ⨯  ⮢ ᨢ  ᯮ짮  
⨯  ࡮  ᪠  ஬ 䠩.  ᮢ  ।⠢
ᮡ     ᪮쪮 , ᫥ १ .  
⢥   ᮢ  ᯮ짮    
⨯ Longint.

:  ᯮᮡ ᠭ   ⮣  ⨯ ᨢ:
type {1} M1 = array [0..5] of integer;
     M2 = array [char] of M1;
     M3 = array [-2..2] of M2;
 {2} M3 = array [-2..2] of array [char] of array [0..5] of integer;
 {3} M3 = array [-2..2,char,0..5] of integer;
var A:M3;
{  ⠬ ᨢ  ᫥騬 ࠧ:}
begin
 read(A[-1,'a',3]);
 read(A[1]['x'][0]);
 A[1]['c',1]:=100;
end.

     㡨  , .. ⢮ ᮢ,    ।
ᨢ   ࠭祭. ࠥ ஫ ⮫쪮 㬬 ꥬ    
ணࠬ.    ⠭⭮  ० ࠡ  ࡮  ᪠    ꥬ
࠭祭 ࠧࠬ ᥣ, .. 64 .   ᨢ
᪠   ਬ   ⮫쪮   樨   ᢠ   ᨢ
(ᨢ)  ⨯. ⠫ 樨   믮
⭮.

:   ᫥  祭  童  ⥯  N,   樥
ண 室  ᨢ A  窥 X  奬 ୥.
Pn(x) = A[0]*X^n + A[1]*X^(n-1) + ... + A[n-1]*X + A[n] =
= (...((A[0]*X + A[1])*X + A[2])*X + ... + A[n-1])*X + A[n].
program Scheme_Gorner;
type Mas = array[0..100] of integer;
var  A:Mas;    i,j,n:integer;      x,p:real;
begin
 write('⥯ 童 = ');  read(n);
 writeln(' 楫 樥 : ');
 for i:=0 to n do read(A[i]);
 write('祭 X = ');     read(x);
 p:=0;
 for i:=0 to n do p:=p*x+A[i];
 writeln('Pn(X) = ',p);
end.

                                

      -  pp , p  ᮤp p
p  ⨯,  ꥤ   .     
뢠  ﬨ.    䨪p ᫮. ᠭ  ᥩ  
᫥ pp:
                            ⨯ = RECORD
                        ᯨ᮪  1 : ⨯ 1;
                              -    -    -
                        ᯨ᮪  N : ⨯ N;
                       CASE  롮 : ⨯ OF
                    祭 1 : ( 1 : ⨯ 1 )
                                 END;
           묨.  ᢮ p, ⨯  
  ᯮ짮  ᮧ ᨢ    ᥩ.  ⥯
  p祭.
     ᮪           p:  ﭭ  
p⭮  .  ﭭ   p᫥    
(䨪p)   㪠  ⨯. ⠪  ⠪  ,    
p var.

: ਬ  ⨯ .
type Men = Record
        FIO,Adress : string;
        Year : byte;
     End;
var A,B : Men;
       p饭      㪠뢠   p  ⨯
, 窠,  , pp:
begin
 A.FIO:=' ..';
 A.Adress:='p. , . 40, . 10';
 A.Year:=1981;
end.
     ᫥ ᠭ ﭭ   ᫥ p⭠ ,
p   ⮫쪮    
                      CASE  롮p : ⨯   OF
                    祭 1 : (ᯨ᮪  1);
                                 - - -
                    祭 N : (ᯨ᮪  N);

        롮p    ⢮.  ᫨    ,      
p    ﭭ  . ᫨   ,  㪠뢠
⮫쪮  ⨯,  p   p浪,         
⢮ p᫥  祭,   ⨯  祭.
  p  pᯮ    ⮬     ,  p
뤥  ⮫쪮,  ᪮쪮 p  ᨬ쭮    pp
p.   p  ⮬,    p⭮  
뢠  ﭨ      ⠫.    㢥稢  
pp ⨯, :   ਠ⠬.
var R = Record
        rem : string;
        Case byte of
        3   : (n:integer);
        5   : (x,y,z:char);
        'a' : (i,j:byte);
    end;
begin
 R.rem:='  p⠬';
 R.n:=25000;
 write(R.i,R.x,R.j,R.y); {16897a}
 {ord('')=168,  ord('a')=97,  168+97*256=25000}
end.
     祭 롮p  p.     
p묨 , ᫥⥫쭮,  p,  ⮫쪮    p
p, pp:
var Rec:Record
        x : real;
        Sr : Record a : real; x,y : integer; end;
        I : byte;
    end;
       㤮⢠  p饭     ᥩ    ᯮ짮
pp pᮥ
                     WITH p DO pp;
  p  -    ,  p   ᫥  ᯨ᮪
 , pp ᫥騥 p pp :
With Rec,Sr Do a := x / y;
With Rec.Sr Do a := x / y;
Rec.Sr.a := Rec.Sr.x / Rec.Sr.y;

                            

       String  (ப)    ࡮ ᪠ ப  ᯮ  
ࠡ⪨ ⥪⮢.  ⨯  ⠭    宦  
   ᨢ  ᨬ  Array  [0..N]  of  Char.   祭   N
ᮮ⢥  ᨬ  ப       0  
255.  , 室騥  ப,  樨  1  N. 砫
  ப    ᮬ 0 ᮤন ଠ   ,  ..  
ᨬ  , ࠢ  ப.
     ,  ⠪ 뢠 ६ ⨯ String[K],  K -  楫
᫮     255.  । ப       K.
  ⨯  㦥      ⠭.   ᨬ  ப  
ࠡ      ⠬  ᨢ  ᨬ,      ⫨稥  
ᨢ,  ப   楫, ࠢ     㣮  
楯 樥 "+".

:   ப.
var s,x,y,z:string;
begin
 x:='turbo';
 y:='pascal';
 z:=x+' '+y; { z='turbo pascal' }
 s:=''; {  ப }
 for c:='a' to 'z' do s:=s+c; { s='abcd..xyz' }
 writeln(s);
end.

     ࠢ  ப  믮 ᨬ쭮    ᮮ⢥⢨    
    ࢮ  ᮢ. ᫨   ப  稫  
ࢮ  ᮢ,   ⠥ 襩.  ப  
 ப.

: ࠢ ப.
'abcd' > 'abcD' { 'd'>'D' }
'abcd' > 'abc' { 'd'>'' }
'abc' < 'axxc' { 'b'<'x' }
'abcd' = 'abcd'

    ⠭ 㭪権  楤  ࠡ  ப.
     㭪 Length(s) 뤠  ப s.
     㭪 Concat(s1,s2,..,sn) 頥 ப s1+s2+..+sn.
     㭪  Copy(s,p,k)  頥  ࠣ  ப  s,  
     稭  樨 p    k.
     㭪 Pos(s1,s)  ࢮ 宦 ப s1  ப s 
 頥  ࢮ ᨬ s1  ப s  0 ᫨  諨.
      楤  Delete(s,p,k) 㤠  ப s  ࠣ,  
 稭  樨 p    k.
      楤  Insert(s,s1,p) ⠢   ப  s  ப  s1,
 稭   樨 p.
     ࡮   ᪠    ந  ८ࠧ  ᫮
祭    ப    .  ⮣ ᯮ  楤
Str(X:n:d,S)    Val(S,X,e). ࢠ 砥  ᫠  X  ப  S  
ࠦ ⮣ ᫠,  ன   n ᨬ        d
 ᫥ ⮩. ࠬ n  d 易⥫.  楤
砥  ப S ᫮ X.  ᯥ譮 १ e=0.

                            

     ࡮   ᪠     뤥  ࠣ   ணࠬ   
ᯮ⥫      ().           
஢   ணࠬ.  모  ணࠬ஢,      
।ᬮ७      ,     뢠     楤୮-ਥ஢묨.
஢ ணࠬ 筮     ⫠.
     稥      몥 ணࠬ஢  ਬ  
ᮢ襭 ⮤  ࠧࠡ⪥  ஥஢ ᫮ ணࠬ
ᮢ.     ப ਬ塞 室.  
뢠   ⮤  室饣  ணࠬ஢     ࠧࠡ⪮
ணࠬ    ᢥ  -   .    ⮬  ᭠砫  ᮧ   
ணࠬ,  ।  稥  ,    ।
.  ⥬  室    ⠫쭮  ࠧࠡ⪥  㯮   
室 .
     㣨  室  ࠧࠡ⪥ ணࠬ  ⮤ 室饣
ணࠬ஢  ஥஢  ᭨ -  .    ⮬  砥
  稭   ᮧ  ,    ⥬  ᮧ
 ᫮  , , ᭮ ணࠬ.
       ࡮  ᪠    ଫ   楤    㭪権.
      ᮡ⢥  .  맮  楤    믮
⢫ ⤥ ஬    . 맮  㭪樨
      ⠢         ࠦ      ᫮
ᮣᮢ   ⨯.   ᠭ   楤      㭪権    
।⢮    맮    ᯮ  ।  砫  ᭮
ணࠬ.    뢠  믮  ,    ᮤঠ
  㣨 楤  㭪権. ᠭ 楤   ᫥
.
Procedure  (᮪ ଠ ࠬ஢);
 label
 const             ᠭ  ⮪,
 type              ⠭, ⨯  ६
 var
   procedure         ᠭ ७ 楤
   function                㭪権
begin
 
end;
     ᠭ 㭪樨  ᫥ .
Function  (᮪ ଠ ࠬ஢) :  १;
 label
 const             ᠭ  ⮪,
 type              ⠭, ⨯  ६
 var
   procedure         ᠭ ७ 楤
   function                㭪権
begin
 , ।    , 
 ᢠ  㭪樨 祭 १
end.
      १  㭪     ⠭ ⨯
࡮ ᪠ ஬ 䠩 ⨯. ᯮ짮 㥬 ⨯
 ⨬.
          ⮪, ⠭,  ⨯
  ६. ᭨    ਬ ६.  ६,
ᠭ    ᭮ ணࠬ,  묨  ⭮襭  
楤ࠬ     㭪,    ᠭ       ६.
筮,  ६, ᠭ  楤   㭪,  
묨   ⭮襭  ७ 楤ࠬ  㭪,  
ᠭ  . ⠫ ६ 뢠 묨.  
⢨ , .. ࠭祭, ⥬ ,   ᠭ.
     室    ࠡ   । १  
६,    ⠪  १  ࠬ.  ࠬ     맮   
뢠   䠪᪨,    ࠬ        뢠
ଠ묨.
     ଠ   ࠬ    ⠪  ⭮        
६.   ᮧ, ..  뤥 , 
맮 ,  ᢮ ⮩  ந室  襭 ࠡ
.      ⮬  砥,    쭠  ६        
䨪,    쭠,  ࠡ⠥   쭮.  
⮬, 祭 쭮 ६ ࠭  ᯥ樠쭮 
,  뢠 ⥪.
       ᯮᮡ  । ࠬ  ࡮ ᪠      
⨯:
     ࠬ-祭,
     ࠬ-६,
     ࠬ-⠭.

                          ࠬ-祭

       맮  楤   㭪権 ଠ  ࠬࠬ-祭
뤥       ᢠ 祭  䠪᪨
ࠬ஢.    ⮬    䠪᪨ ࠬ஢    
ࠦ.     ⨬    ⨯    ।    ﬨ
ᢠ.   ᫥   믮   ணࠬ      ଠ
ࠬ஢   ᢮.      ଠ   ࠬ஢   
᪠뢠  祭 䠪᪨.  楤  ࠬࠬ-
祭ﬨ  :
       Procedure MyProc1(par1,par2 : type1; par3,par4 : type2);

                         ࠬ-६

       맮  楤   㭪権 ଠ  ࠬ-६
      ᠬ     ,      ᮮ⢥騥  
䠪᪨ ࠬ.  ࠧ, ⥫쭮    
뤥     ଠ쭮 ࠬ ਢ    
䠪᪮.  ࠬ-६,    ࠢ,  ᯮ  
। १⮢  楤  뢠騩 .
        堭  ।    ॡ,  ⮡   䠪᪨
ࠬ  뫨  ६묨, 祬  筮 ⮣   ⨯,    
ଠ  ࠬ.   ᠭ  ।  ࠬࠬ-६묨
  ⢮ ᫮ var.  楤    ࠬࠬ-
६묨  :
   Procedure MyProc2(var par1,par2 : type1; var par3,par4 : type2);

                          ࠬ-⠭

         ଠ묨 ࠬࠬ-⠭⠬    
   묨 묨 ⠭⠬. 쪮  ⠭ ਭ
祭 ࠦ,  室  䠪᪨ ࠬ.   
뤥     ६. 頥 
  祭    ६ 믮 ணࠬ    ஫    ⨬
⢫  ஢ ,    ⠭.
     ᯮ짮   ࠬ-⠭  ४     ।
  讣 ꥬ  ࠭⨥ ࠭  祭.  
楤  ࠬࠬ-⠭⠬  :
 Procedure MyProc3(const par1,par2 : type1; const par3,par4 : type2);

                       -

       ࠬ-ᨢ      ࠬࠬ-祭ﬨ,
ࠬࠬ-६묨   ࠬࠬ-⠭⠬.    ᯮ
 । ᨢ ந쭮 ࠧ୮.  楤  
묨 ࠬࠬ-ᨢ  :
            Procedure OpenArray(Vector : array of MyType);
     ଠ   ࠬ    ⮬     ᨢ   ⮢
ண ⨯ MyType  㫥 , .. Array [0..N-1] of MyType;
  N  -  ⢮  ⮢ ᨢ, ஥   ।  
 ⠭⭮ 㭪樨 High.
: 祭   ⮢ ᨢ.
program DoubleProgram;
const     n=10; m=20;
type      T1 = array[1..n] of integer;
   T2 = array[-m..m] of integer;
var  A : T1;   B : T2;   k : integer;
Procedure Double(var X : array of integer);
var i : byte;
begin
 for i:=0 to High(X)-1 do X[i]:=X[i]*2;
end;
begin
 for k:=1 to n do read(A[k]);
 for k:=-m to m do read(B[k]);
 Double(A); {㢥祭  2 ࠧ ⮢ ᨢ A}
 Double(B); {㢥祭  2 ࠧ ⮢ ᨢ B}
 Double(k); {  ᠬ,   ᢠ k:=k*2}
 writeln('k=',k); {⠥: k=40 }
 for k:=1 to n do write(A[k],' ');
 writeln;
 for k:=-m to m do write(B[k],' ');
end.

                          

       ࡮  ᪠      ᮧ  楤  
㭪権    ࠬࠬ,  騬 ⨯. ⨯ ࠬ  
   ࠬࠬ-६묨    ࠬࠬ-⠭⠬,  ⠪   
।  ⮫쪮   .  楤   ࠬࠬ,  
騬 ⨯  룫拉 ⠪ ࠧ:
           Procedure MyProc(var par1,par2; const par3,par4);
     ।  ᯮ짮 ଠ ࠬ஢ 室  믮
  ਢ  - ⨯. ᯮ짮 ⨯ ࠬ஢
    ணࠬ,  ⢥⢥    ४⭮
ਬ   ணࠬ.

:   N , 稭  ⮣  ,   X.
program without_type;
var N:word; s:string;
{$R-} (* ⪫祭 ஫  ࠭栬  *)
function Sum(var X; N:byte):word;
type A=array[1..1] of byte;
var i:byte; s:word;
begin
 s:=0;
 for i:=1 to n do S:=S+A(X)[i];
 Sum:=s;
end;
begin
 readln(s);
 writeln(Sum(s,1)); { ப s}
 writeln(Sum(s[1],1)); { ࢮ ᨬ ப s}
 writeln(Sum(s[1],length(s)));
 {㬬   ᨬ ப s}
 read(N);
 writeln(Sum(N,2));
 {㬬  ,   ⮨ N ⨯ word}
end.

                            

       ࡮ ᪠   楤 ⨯: ⨯-楤 
⨯-㭪.    楤୮ ⨯ ᯮ  
楤  㭪樨  .

:
type      Proc1 = Procedure (a,b,c : integer; x:real);
   Proc2 = Procedure (var a,b);
   Proc3 = Procedure;
   Func1 = Function : real;
   Func2 = Function (n:integer) : boolean;
      뢠 ६  ⨯, ਬ: var p1,p2:Proc1;
f1,f2:Func2; ६ 楤 ⨯  ᢠ  ⢥
祭    ᮮ⢥  .    ⮬    ᯮ짮
⠭  楤    㭪樨.  ᫥  ⠪  ᢠ   
६ ⠭ ᨭ  . ६ 楤୮ ⨯
,  ⠪  ।  ணࠬ   ࠬ஢.  
⮬,      ᮧ      ᯮ⥫
⬮.

                               

       -  ᯮᮡ ࣠樨 ᫨⥫쭮 ,  
஬  ணࠬ   室 믮 頥  ᠬ    ᥡ.  
   窨   ७  ४  筠  ⮤  ⥬᪮
樨.    樨  ᮮ⢥  ४ᨨ.  ।
樨 ᮮ⢥ ।  ⮬,  㦭  㦥 ᠭ.
,  蠣 樨 ᮮ⢥ 맮 ᮧ  ४ᨢ
.      ४ᨨ  室 ।ᬮ  ᫮  襭
, ..  맮   ந室.

: ᫨ N- ᫮ . ( ⥬ )
program Fib;
var n:byte;
function F(k:byte):word;
begin
 if k<2 then F:=1 else F:=F(k-1)+F(k-2); {४ᨢ 맮}
end;
begin
 write('  ᫠  ');
 readln(N);
 writeln(N,'- ᫮  =',F(N));
 readln
end.

     ᨢ 맮   ᢥ,  . ਬ 
ந室    砥,    뢠 㣮,        ᢮
।  -  .    ᯮ짮 ⠪ ணࠬ  樨
室  ०饥  ᠭ  楤    㭪権    ४⨢
Forward.  砫   ⮫쪮     ᫮  Forward,  
ॠ  ਢ .  ⮬,       
 ⮫쪮  ,    .

:  ४.
Procedure B(x:byte); forward;
Procedure A(y:byte);
begin
 - - -
 B(y);
 - - -
end;
Procedure B;
begin
     - - -
 A(x);
 - - -
end;

     :  室         ਬ
४ᨨ, ⠪   㡨 ४ᨢ 맮  ਢ 
९  ⥪.      ஡    ࠭,
⠭  ࠧ ⥪  1024  65520    ४⨢
       {$M ࠧ ⥪,  ࠭,  ࠭ }

                        

     ஬     ⠭    ࡮  ᪠    ᯮ짮
⨯஢  ⠭,  䠪᪨   ६묨  
砫묨 祭ﬨ.  뢠  ࠧ Const  ଥ:
         < ⨯஢ ⠭> : <⨯> = <祭>;

:
const     x : integer = 10;        y : real = 3.14;
     A : array[1..5] of integer = (1,2,-3,24,0);
     B : array[1..2,-1..1] of byte = ((1,2,3),(4,5,6));
     R : record m : string[10]; d,y : integer; end =
           (m : 'January'; d : 20; y : 1999);
     S : string[4] = 'abcd';
     ஢ ⠭    ⨯ ஬ 䠩. 
ࠡ    ࠪ᪨  祬  ⫨   ६.  
⮨  ⮫쪮    ⮬,  ᫨ ⨯஢ ⠭  ᠭ  
楤     㭪樨,      ࢮ  맮  ⮩  ணࠬ
⨯஢   ⠭  ਭ  砫쭮   祭,      
᫥  맮 ࠭ 祭  ।饣  맮.  
ᯮᮡ  , ਬ, ஫஢ ⢮ 맮  楤
 㭪権.

: ᯮ짮 ⨯஢ ⠭
program typed_const;
var N:integer;
procedure Test;
const k:integer=1;
begin
 if k<N then
 begin
   writeln(k,'- 맮 楤');
   k:=k+1;
   Test;
 end
 else writeln('᫥ 맮 楤');
end;
begin
 read(N);
 if N>0 then Test;
end.

                                

       (Unit)    ᪠ -  ᯥ樠 ࠧ  ଫ
⥪ । ⨯, ⠭, ६,  ⠪ 楤 
㭪権.    ⤥쭮,  १  祣  ᮧ
䠩    ७ tpu (turbo pascal unit).     饭
  믮 ᠬ⥫쭮,   ᯮ짮 ⮫쪮  㣨
ணࠬ.   ⮣  ணࠬ 㪠뢠 ᯨ᮪  ᯮ㥬
㫥    ࠧ  Uses,  ᫥ 祣  ணࠬ    ᯮ짮
⠭, ⨯  ६, ᠭ   .
      ࡮ ᪠  ᪮쪮 ⠭ 㫥: System,
Crt,  Dos,  Printer,  Overlay,    ⠢  ⥪  ࡮
᪠:  䠩  turbo.tpl (turbo pascal library).    ⠭
㫥 ⠪ ⭮  Graph.
       ᮧ  㫨.    
᫥ :
UNIT < >;
INTERFACE
 <ࠧ >
IMPLEMENTATION
 <ࠧ ॠ樨>
Begin
 <ࠧ 樠樨>
End.
           ᮢ      䠩,    ஬  
࠭.    䥩᭠  ᮤন 
    ꥪ⮢    (⨯,  ⠭,  ६   
ணࠬ),     㯭 ணࠬ,  ᯮ騬  
. ணࠬ  ⮬ ࠧ  ⮫쪮 .  
䥩᭮   㫥  ᯮ짮 ०饥  ᠭ,
.. ४⨢ forward.
       ॠ樨  ᯮ塞   ᮤন ᠭ
 ꥪ⮢  : ⨯, ⠭, ६  ணࠬ.
    ᮤন ᠭ ணࠬ,   䥩᭮
.      ணࠬ    㪠뢠    
ࠬ஢,   ࠬࠬ,   筮   ᠭ
  ࠧ  .  ꥪ  㯭   ।
,   㯭 ணࠬ, ᯮ騬 .
       樠樨  ⢮.   ⮬  砥  
    ᫮ Begin,  ࠧ  , ᠢ End.  
ࠧ  樠樨 室 ,   믮  
᪥  ணࠬ,  ᯮ饩 , ।  믮  ᭮
ணࠬ.  樠権 믮  ⮬ 浪,   ஬
 㫨.

:   ࠡ  묨 ᨢ  100 楫 ᥫ.
{ ᠭ,   ᭮ ணࠬ   㫥}
Unit Globals;
Interface
 const Len=100;
 type Vector = array[1..Len] of integer;
Implementation
End.
Unit Vectors;
Interface
 uses Globals;
 {室 ᨬ  ᨢ}
 function Max_V(A:Vector; n:byte):integer;
 {⭮ ᫮  ஢}
 procedure Add_V(A,B:Vector; n:byte; var C:Vector);
 {᪠୮ ந ஢}
 function Scal_V(A,B:Vector; n:byte):integer;
Implementation
 function Max_V; {  ࠬ஢}
 var     i,max:integer;
 begin
   max:=A[1];
   for i:=2 to n do if A[i]>max then max:=A[i];
   Max_V:=max;
 end;
 procedure Add_V;
 var  i:integer;
 begin
   for i:=1 to n do C[i]:=A[i]+B[i];
 end;
 function Scal_V(A,B:Vector; n:byte):integer;
 {  interface}
 var  s:integer;     i:byte;
 begin
   s:=0;
   for i:=1 to n do s:=s+A[i]*B[i];
   Scal_V:=s;
 end;
End. {ࠧ 樠樨  }

                            

      ᪠ ਬ  宦, ਬ,   ᨢ
    㦭묨  ᢮⢠. 筮 ࠧ  ⠭  
᪠    ࢮ   ᫥ 宦 .      
 ⬠ 㤥 ,  ந    ᨢ
A  N 楫 ᥫ , ࠢ X.

                             

       ⢫ 横 (while  repeat - until) 
 ᫮. ࢮ ᫮ ஫   ਭ
ᨢ,  ਬ,  (i<=N). ஥ ᫮ -   ᫮  ᪠.  
襬  砥  横 while  ᫮ த ᪠: (A[i]<>X),
    横 repeat - until  ᫮ 襭 ᪠: (A[i]=X).  
⥫  横 筮  ⮫쪮  :     
ᨢ.
     ᫥  室  横 室 ஢,    ᫮
  諨.   if 筮  ࢮ ᫮ 横. 
    ᯥ譮  ᪥  横  while    믮  ⮣
᫮,   横 repeat - until   襭.

:  
program Poisk1;
var  A:array[1..100] of integer;
   N, X, i:integer;
begin
 read(N); {N<=100}
 for i:=1 to N do read(A[i]);
 read(X);
 i:=1; {i:=0;}
 while (i<=N) and (A[i]<>X) do i:=i+1;
 {repeat i:=i+1; until (i>N) or (A[i]=X);}
 if i<=N then write('ࢮ 宦 ᫠ ',X,'
  ᨢ A  ',i,' ')
 else write(' 諨');
end.
        ᪥   ᫥  宦  ᫥       
 :
 i:=N; {i:=N+1;}
 while (i>=1) and (A[i]<>X) do  i:=i-1;
 {repeat i:=i-1; until (i<1) or (A[i]=X);}
 if i>=1 then write('᫥ 宦 ᫠ ',X,'  ᨢ A 
',i,' ')
 else write(' 諨');

                             

       ᪠  ஬ ⮨  ⮬, ⮡  ஢  
ࠧ    横  ᫮,  易    ࠭栬  ᨢ.    
ᯥ,  ⠭  ᨢ ⠪ 뢠 :   ,
  㤮⢮  ᫮ ᪠.    ᠬ  㤥  ࠭祭
 .
     室   横,  ஬ ⥯ ⠥ ⮫쪮 ᫮ ᪠,
  ந     ,    .  
ࠧ,  ᫥ 室  横 ஢,        諨?
᫨⥫쭠  ᫮ ᪠  ஬ ,  祬    
᪠,    ⠪   稭 ⮣   浪,      N  -
⢮ ⮢ ᨢ.
           ᯮᮡ   ⠭  :   ⥫
⮬   ࠩ  ᨢ.

:   ஬
program Poisk2a;
var  A:array[1..101] of integer;
   N,X,i:integer;
begin
 read(N); {N<=100}
 for i:=1 to N do read(A[i]);
 read(X);
 A[N+1]:=X; {⠭  ⥫ ⮬}
 i:=1; {i:=0;}
 while A[i]<>X do i:=i+1;
 {repeat i:=i+1; until A[i]=X;}
 if i<=N then write('ࢮ 宦 ᫠ ',X,'  ᨢ A  ',i,'
')
 else write(' 諨');
end.
program Poisk2b;
var  A:array[1..100] of integer;
   N,X,i,y:integer;
begin
 read(N); {N<=100}
 for i:=1 to N do read(A[i]);
 read(X);
 y:=A[N]; {࠭ ᫥ }
 A[N]:=X; {⠭   ᫥  ᨢ}
 i:=1; {i:=0;}
 while A[i]<>X do i:=i+1;
 {repeat i:=i+1; until A[i]=X;}
 if (i<N) or (y=X) then
   write('ࢮ 宦 ᫠ ',X,'  ᨢ A  ',i,' ')
 else write(' 諨');
 A[N]:=y; {⠭ ᫥  ᨢ}
end.

                        () 

       筮 ᪠  ᯮ짮  ᪠ 
    ᢮⢮  ⮫쪮    ᨢ,  㯮冷祭    ⮬
᢮.    ᪥ ᫠   祭 室  
ᨢ,   㯮冷祭    ⠭      뢠   祭
⮢. , ਬ,  ᪥ ᫠   㬬  ᨢ
    㯮冷祭   ⠭     뢠  㬬  
⮢.
       ⬠  ⮨   ⮬,  ᨢ    ࠧ  
    롨ࠥ  ,   室 㦭  .
  த    ᨢ    ᪠    
,  ᫥  祣 ⠥ ஢  ⠢訩    
믮 ᫮ ᪠.
       䨪樨 ⮣ ⬠  ᪠  ࢮ  
onqkedmecn  宦.     ⮣,    롨ࠥ  ।
:  㣫     ஭.   ࢮ  砥
।    ⭮    ᨢ,     ஬  -  
ࠢ.
         ࠡ ⬠ 筮 ᪠ ࠧ  ࠣ,
    த,  ࠧ 㬥蠥 ਬ୮  
  ࠧ.  ᯥ稢 ᫨⥫ ᫮ ⬠ 浪
䬠 N  ᭮ 2,  N - ⢮ ⮢ ᨢ.

:   㯮冷祭  ⠭ ᨢ ࢮ 宦
᫠ X.
program Poisk3a;
var  A:array[1..100] of integer;
   N,X,left,right:integer;
begin
 read(N); {N<=100}
 write(' 㯮冷祭  ⠭ ᨢ');
 for i:=1 to N do read(A[i]);
 read(X);
 left:=1; right:=N;
 {  ࠢ ࠭ ࠣ  ᪠}
 while left<right do
 begin
   c:=(left + right) div 2;
   {।  㣫   ஭}
   if X>A[c] then
   {᫨ ᨢ 㯮冷祭  뢠,  if X<A[c]}
     left:=c+1
     {롨ࠥ ࠢ   ।,  left}
   else right:=c;
   {롨ࠥ    ।,  right}
 end;
 if X=A[left] then { left = right,   ᥣ = c}
   write('ࢮ 宦 ᫠ ',X,'  ᨢ A  ',left,' ')
 else write(' 諨');
end.

:      ᨢ,  㯮冷祭   ⠭  㬬  
⮢ ᨢ, ᫥ ᫠  㬬  ࠢ X.
program Poisk3b;
var  A:array[1..100] of integer;
   N,X,left,right:integer;
{㭪 ⠥ 㬬  ᫠ a,  a - 쭠 ६}
function Sum(a:integer):integer;
var  s:integer;
begin
 s:=0; a:=abs(a);
 while a>0 do
 begin
   s:=s + a mod 10;
   a:=a div 10;
 end;
 Sum:=s;
end;
begin
 read(N); {N<=100}
 write(' ᨢ, 㯮冷祭  ⠭ 㬬 ');
 {ਬ,  N=4 : 122, -432, 88, 593}
 for i:=1 to N do read(A[i]);
 read(X);
 left:=1; right:=N;
 {  ࠢ ࠭ ࠣ  ᪠}
 while left<right do
 begin
   c:=(left+right+1) div 2;
   {।  㣫   ஭}
   if X>=Sum(A[c]) then  left:=c
     {롨ࠥ ࠢ   ।,  left}
   else right:=c-1;
   {롨ࠥ    ।,  right}
 end;
 if X=Sum(A[left]) then { left = right,   ᥣ = c}
   write('᫥ ᫮  㬬 =',X,' ࠢ',A[left], '
   室  ᨢ A  ',left,' ')
 else write(' 諨');
end.

                          

     ⥩  ஢ 砥  㯮冷祭 ⮢
ᨢ      ⠭    뢠.  㣮  祩   
㯮冷祭  ⮢ ᨢ  ᮮ⢥⢨    ਥ.
筮    ⢥  ⠪  㯠  祭  ।
㭪樨,  㬥⠬ ன 㯠  ᨢ.   㭪
ਭ 뢠 㯮冷稢饩 㭪樥.
        ࠧ  ⮤  ஢.  㤥  ᬠਢ
   ⮤  ਬ  ஢  ⠭ ᨢ
 N 楫 ᥫ.

                           

      ⮤ 砥  ⮬,  室 ᨬ 
ᨢ   ⠬  ᫥ ⮬ ( ஬ N). ⥬,
ᨬ  । ⮢  ࢮ  ।᫥  ⠢
 N-1 ,  ⠪ . 室  N-1 ᨬ.  ᪠
  ᨬ,    ⠢   ࢮ, ஥    ⠪  
.    ਬ  䨪  ⮣  ⮤    ६
᪮  ᨬ㬠  㬠.  ⮬ 砥 ⢮ 蠣 譥
横 N div 2.
     ᫨⥫쭠  ᫮ ஢ 롮஬ -  稭  浪
N*N,    筮  뢠  O(N*N).      ⥬,  
⢮ ࠢ  ᪥ ࢮ ᨬ㬠 ࠢ N-1. ⥬  N-
2, N-3,  ⠪   1, ⮣: N*(N-1)/2.

: ஢ 롮஬  ⠭ ᨢ A  N 楫 ᥫ.
program Sort_Vybor1;
var  A:array[1..100] of integer;
   N,i,m,k,x : integer;
begin
 write('⢮ ⮢ ᨢ ');
 read(N);
 for i:=1 to n do read(A[i]);
 for k:=n downto 2 do { k - ⢮ ⮢  ᪠ max }
 begin
   m:=1; { m -  max }
   for i:=2 to k do if A[i]>A[m] then m:=i;
   {塞 ⠬   ஬ m  ஬ k}
   x:=A[m]; A[m]:=A[k]; A[k]:=x;
 end;
 for i:=1 to n do write(A[i],' '); {㯮冷祭 ᨢ}
end.

:     ६ 롮஬ max  min.
program Sort_Vybor2;
var  A:array[1..100] of integer;
   N,i,m,k,x,p : integer;
begin
 write('⢮ ⮢ ᨢ ');
 read(N);
 for i:=1 to n do read(A[i]);
 for k:=1 to n div 2 do { k -   max  min }
 begin
   m:=k; { m -  max }
   p:=k; { p -  min }
   {max  min  । ⮢  k  n-k+1}
   for i:=k+1 to n-k+1 do
     if A[i]>A[m] then m:=i
     else if A[i]<A[p] then p:=i;
   {塞 ⠬   ஬ p  ஬ k}
   x:=A[p]; A[p]:=A[k]; A[k]:=x;
   if m=k then m:=p;
   {᫨ max    k,  ᥩ    p}
   {塞 ⠬   ஬ m  ஬ n-k+1}
   x:=A[m]; A[m]:=A[n-k+1]; A[n-k+1]:=x;
 end;
 for i:=1 to n do write(A[i],' '); {㯮冷祭 ᨢ}
end.

                  (⮤ "쪠")

       ⮤  砥  ⮬,  ᫥⥫쭮 ࠢ
  ᥤ  ⮢ ᨢ. ᫨   ᯮ      ⮬
浪,    ᮢ蠥  ⠭,    ⠬    ᥤ
⮢.  ᫥   ⠪ 室  ᫥      N
  ᨬ  ("ᯫ"  "४").  騩
室   ᬠਢ   ।᫥   ⠪  .
ᥣ   ॡ  N-1  室.  ᫨⥫쭠  ᫮  ஢
 O(N*N).

: ஢   ⠭ ᨢ A  N 楫  ᥫ.
( ਠ)
program Sort_Obmen1;
var  A:array[1..100] of integer;
   N,i,k,x : integer;
begin
 write('⢮ ⮢ ᨢ ');
 read(N);
 for i:=1 to n do read(A[i]);
 for k:=n-1 downto 1 do { k - ⢮ ࠢ  }
   for i:=1 to k do
     if A[i]>A[i+1] then
     {塞 ⠬ ᥤ }
     begin   x:=A[i];  A[i]:=A[i+1];  A[i+1]:=x;     end;
     for i:=1 to n do write(A[i],' '); {㯮冷祭 ᨢ}
end.
       ,    ᫨  믮 ।  室  
஢      ந     ⠭,    
砥,      ᨢ   㦥  㯮冷祭.      ࠧ,   
஢  , ⮡ ᫥騩 室    ⮫쪮  
稨 ⠭  ।饬.

: ஢   ஢મ 䠪 ⠭.
program Sort_Obmen2;
var  A:array[1..100] of integer;
  N,i,k,x : integer; p:boolean;
begin
 write('⢮ ⮢ ᨢ ');
 read(N);
 for i:=1 to n do read(A[i]);
 k:=n-1; {⢮   ࢮ 室}
 p:=true; {᪠ ६ p ⨭, ᫨ 뫨
   ⠭, .. 㦭   த ஢}
 while p do
 begin
   p:=false;
   {砫  室.  ⠭  뫮.}
   for i:=1 to k do
     if A[i]>A[i+1] then
     begin
       x:=A[i]; A[i]:=A[i+1]; A[i+1]:=x;
       {塞  ⠬}
       p:=true; {  䠪 ⠭}
     end;
     k:=k-1;
     {㬥蠥 ⢮   ᫥饣 室}
 end;
 for i:=1 to n do write(A[i],' '); {㯮冷祭 ᨢ}
end.
      䨪 ⬠ ஢  砥 
   ᫥ ⠭. ᫨  ।  室
᫥  ன ⮢,  﫨 ⠬,  뫨  A[i]  
A[i+1],     ᨢ  i+1  ᫥ 㦥     ᢮
. ᯮ짮 ⮩ ଠ樨   ᤥ ⢮
  ᫥饣 室 ࠢ i-1.

:    ஢               ᫥
⠭.
program Sort_Obmen3;
var  A:array[1..100] of integer;
   N,i,k,x,m : integer;
begin
 write('⢮ ⮢ ᨢ ');
 read(N);
 for i:=1 to n do read(A[i]);
 k:=n-1; {⢮   ࢮ 室}
 while k>0 do
 begin
   m:=0;
   { ⠭  ⮬ 室 ,  ࠢ 0}
   for i:=1 to k do
     if A[i]>A[i+1] then
     begin
       x:=A[i]; A[i]:=A[i+1]; A[i+1]:=x; {塞  ⠬}
       m:=i; {   ⠭}
     end;
     k:=m-1; {⢮     ᫥ ⠭}
 end;
 for i:=1 to n do write(A[i],' '); {㯮冷祭 ᨢ}
end.

                          

      ,  ,  䨪樥 ஢ .
⫨稥  ⮨  ⮫쪮  ⮬,  ᫨  ஢   室
⢫﫨 ⮫쪮   ࠢ,   ࠢ 
ࠧ  .    襩୮  ஢ ⠪    ஢  䠪
⠭     ᫥ ⠭.    
⬥  ⢮  室 ࠢ N div  2.  ᫨⥫쭠
᫮ 襩୮ ஢ O(N*N).

:  ୠ  ஢  ⠭ ᨢ  A    N  楫
ᥫ.
program Shaker;
var  A:array[1..100] of integer;
   N,i,k,x,j,d : integer;
begin
 write('⢮ ⮢ ᨢ ');
 read(N);
 for i:=1 to n do read(A[i]);
 d:=1; i:=0;
 for k:=n-1 downto 1 do { k - ⢮ ࠢ  }
 begin
   i:=i+d;
   for j:=1 to k do
   begin
     if (A[i]-A[i+d])*d>0 then
     {塞 ⠬ ᥤ }
     begin x:=A[i]; A[i]:=A[i+d]; A[i+d]:=x; end;
     i:=i+d;
   end;
   d:=-d;
   {塞 ࠢ   ⨢}
 end;
 for i:=1 to n do write(A[i],' '); {㯮冷祭 ᨢ}
end.

                          

         ⮤  ⮨  ⮬,    ࠧ,    㦥
㯮冷祭  ᨢ  K ⮢,  塞     ,
       ᨢ  ⠪  ࠧ,  ⮡  㯮冷祭   
訫.  ஢   ந  ६    
ᨢ.
       砫 ஢ 㯮冷祭  ᨢ ᮤন  ⮫쪮
  ,   ⤥쭮 , ᫨ ᨢ 㦥 ,
⠥  ⢥,  騬  㦭  .    ⮤
᪠         砥    ਢ      ࠧ
䨪 ஢ 祭.
        ᯮ짮    ᪠  ᫨⥫쭠  ᫮
஢ 祭 ⠢ O(N*N),   ᯮ짮 筮
᪠ - O(N*LogN) (     ᭮ 2).

:  ஢    ⠭  ᨢ  A    N  楫   ᥫ
祭   ᪮.
program Sort_Include1;
var  A:array[1..100] of integer;
   N,i,k,x : integer;
begin
 write('⢮ ⮢ ᨢ ');
 read(N);
 read(A[1]); {for i:=1 to n do read(A[i]);}
 {k - ⢮ ⮢  㯮冷祭  ᨢ}
 for k:=1 to n-1 do
 begin
   read(x); {x:=A[k+1];}
   i:=k;
   while (i>0)and(A[i]>x) do
   begin
     A[i+1]:=A[i];
     i:=i-1;
   end;
   A[i+1]:=x;
 end;
 for i:=1 to n do write(A[i],' '); {㯮冷祭 ᨢ}
end.

:  ஢    ⠭  ᨢ  A    N  楫   ᥫ
祭   ᪮.
program Sort_Include2;
var  A:array[1..100] of integer;
   N,i,k,x,c,left,right : integer;
begin
 write('⢮ ⮢ ᨢ ');    read(N);
 read(A[1]); {for i:=1 to n do read(A[i]);}
 {k - ⢮ ⮢  㯮冷祭  ᨢ}
 for k:=1 to n-1 do
 begin
   read(x); {x:=A[k+1];}
   left:=1; right:=k;
   {  ࠢ ࠭ ࠣ  ᪠}
   while left<right do
   {  ᫥ 宦}
   begin
     c:=(left+right+1) div 2;
     {।  㣫   ஭}
     if x>=A[c] then left:=c
     {६ ࠢ   ।}
     else right:=c-1; {६    ।}
   end;
   if x>=A[left] then left:=left+1;
   {ᤢ  1 ࠢ  ᨢ, ᢮ 
    祭 x}
   for i:=k downto left do A[i+1]:=A[i];
   A[left]:=x;
 end;
 for i:=1 to n do write(A[i],' '); {㯮冷祭 ᨢ}
end.

                            

       ஢  ⠪  뢠 ன ஢.  ⮤  
ࠧࠡ⠭    1962    ஬  ᪮  㭨  .
஬.    ४  ਬ  ᯮ짮  ४ᨨ.  ᬮਬ
ophmvho ࠡ ⬠  㯮冷祭 ᨢ A  N ⮢  
⠭.
     祭    -    ,    筮    業ࠫ쭮,
뢠    ६ X. ᬠਢ   ᨢ.  
  ᫥-ࠢ  饬       ࠢ  X.    
  ࠢ- 饬     ࠢ  X.  
  ⠬  த  .
     ᫥  ⮣ ᨢ  ࠧ   .    ࢮ
室    ࠢ X,  ࠢ -   ࠢ
X.      室   ஢  ᨢ  A    
  ஢ 祭 ⥩ ᨢ.
     ᫨⥫쭠  ᫮    맮     ४ᨢ
⬠  ய樮쭠  ⮢ 㥬 ࠣ
ᨢ.    襬  砥       ந  ,
⮬  ᫨⥫쭠 ᫮ ᥣ ⬠  ன  ஢
⠢   稭  浪  N*LogN  (    ᭮   2).
᫨⥫쭠 ᫮  । ⮣  浪.

:  ஢  ⠭ ᨢ A  N 楫 ᥫ.
program Quick_Sort;
var  A:array[1..100] of integer;
   N,i : integer;
{ 楤 ।   ࠢ ࠭ 㥬 ࠣ}
procedure QSort(L,R:integer);
var  X,y,i,j:integer;
begin
 X:=A[(L+R) div 2];
 i:=L; j:=R;
 while i<=j do
 begin
   while A[i]<X do i:=i+1;
   while A[j]>X do j:=j-1;
   if i<=j then
   begin
     y:=A[i]; A[i]:=A[j]; A[j]:=y;
     i:=i+1; j:=j-1;
   end;
 end;
 if L<j then QSort(L,j);
 if i<R then QSort(i,R);
end;
begin
 write('⢮ ⮢ ᨢ ');
 read(N);
 for i:=1 to n do read(A[i]);
 QSort(1,n); {㯮冷   ࢮ  n-}
 for i:=1 to n do write(A[i],' '); {㯮冷祭 ᨢ}
end.

                 

       ⫨稨   ࠭  ⮤ ஢,    
  ᠬ⥫  ⬮,    ।⠢  ᮡ   ,
   ਬ    .  砥  ⮬,  
  ⥫ ᨢ B,  ਭ  뢠  ஬
ᮢ. ᫠     ⮬,   浪 㦭 ᬮ 
  A, ਬ:           ᨢ A : 4 7 3 5       ᨢ B :
3 1 4 2   { A[3] A[1] A[4] A[2] }
        砫   ணࠬ         ᮢ   B   뢠
᫥⥫쭮  ࠫ  ᫠    1    N.    ࠡ  
஢     A[i]     A[B[i]].  
ᤥ   ⮣, ⮡  ⠬   ᨢ  A,    
, ..  ᨢ B.


                    CRT (᭮ )

       Crt  ⭮    ⠭   ࡮  ᪠  
室    䠩 turbo.tpl (Turbo Pascal Library).   祭
  筮   uses Crt.   Crt  ᮤন  ।⢠
ࠢ ࠭  ⥪⮢ ०  ன.
       ࠭  ᯮ  ⨢ 梥: 梥 ⥪    梥
䮭.         ⠭       楤   TextColor   
TextBackground,         ࠬ:  楫  ,
饬  梥.  梥 ⥪ ᯮ ᫠  0  15,
    梥  䮭  -  0  7.   楤 뢠  ﭨ
⮫쪮  ᫥騩 뢮.
     न    ࠭  ᫥騬 ࠧ.   孨
㣮    न (1,1),  ࠢ  (80,25).   
⭮⥫   न,              楤
Window(x1,y1,x2,y2),     x1,y1  -  ᮫   न   
孥,    x2,y2  -  ࠢ  㣫  .  ᫥  ⮣  
楤   㭪樨 ஬ Window ᯮ ⭮⥫ न.
  ࠡ  ᥬ ࠭ , ᠢ Window(1,1,80,25). 
  楤  GotoXY(x,y)   ⠭      
  ,     㭪権 WhereX  WhereY  ࠬ஢
  㧭  ⥪騥 न . 楤 ClrScr    
ࠬ஢  訢 ⥪饥  梥⮬ 䮭.
       Crt  ⢫ ஫ . ⭮,
 ଠ    㯠 ᭠砫   
  ⮫쪮 ⥬ 뢠 ஬.  ⭮,   
樨       ,  ࠢ騥.    १
  筮     㯠  ,  
      1  255,   ⨨ ࠢ饩     
 㯠  ,    0. 㭪 KeyPressed
  ࠬ஢  頥 ⨭ १ ᫨   .
  ⮬  ᮤন   . 㭪 ReadKey  ⠪  
  ࠬ஢    ࠥ     ।  ᫮,
    ணࠬ ᨬ (⨯ char),  ண  ᮮ⢥
⮬  .    砥,    , 㭪  ReadKey  
  .

                              

1.    ࠬ  ..,   䮭 .., 䮭 ..     
  ᪠. ., 㪠, 1988.
2.    ࠬ  ..,    ..,  ⨭ ..,     ..
    ணࠬ஢. ., 㪠, 1988.
3.        .,     .,  쬠  .  ஥     
  ᫨⥫ ⬮. ., , 1979.
4.    .    . ., , 1989.
5.    譨  ., 譨 . ணࠬ஢   ।  Turbo
  Pascal 7.0. ., -, 1993.
6.    㥢  ..  ⥬ ணࠬ஢ Turbo Pascal. .,    
  , 1992.
7.    㥢  ..  ணࠬ஢  몥 ࡮-᪠ 6.0,7.0.  .
    . . 1993.
8.       .  ୮   ணࠬ஢      ஢
  ணࠬ. .: , 1979.
9.      .., 祭 ..   IBM PC. .,    "  
  ", 1992.
10.    .  ⢮ ணࠬ஢   . .: , .1, 1976;
  .2, 1977; .3, 1978.
11.  ᪨ . ਪ  ணࠬ⮢. ., , 1988.
12.     .   ⢮ ஢ ணࠬ.   .:     
  ⨪,  1982.    ., 㠧 .  ஢  ணࠬ
  ᯥ祭, .: , 1983.
13.   騪 .. ୨ ࠦ   ᪠.  .,  㪠,
  1989.
14.   类  ..,   㣫 ..  ணࠬ஢    ।  ࡮
  ᪠ ( 5.5). - , 1992.
15.   .,  ࣥ .,  .  . .,
  , 1980.
16.  ஭ .. ࡮ ᪠ 7.0. 砫 . ., , 1997.
17.   ஭  .. ࡮ ᪠ 7.0. ࠪ⨪ ணࠬ஢.  .,
  , 1997.
18.   . ணࠬ஢: ६  . ., , 1995.
