OldPascalProjects/!NewExecutors/Исполнители.pas

///- Ìîäóëü Èñïîëíèòåëè
/// Îïèñûâàåò ðÿä Èñïîëíèòåëåé, êîòîðûå ìîãóò âûïîëíÿòü êîìàíäû
unit Èñïîëíèòåëè;

type
  ///!#
  öåëîå = integer;
  âåùåñòâåííîå = real;
  ëîãè÷åñêîå = boolean;
  ñòðîêîâîå = string;

///- Ïðîöåäóðà Âûâåñòè(çíà÷åíèÿ)
/// Âûâîäèò ñïèñîê çíà÷åíèé
procedure Âûâåñòè(params args: array of object) := Println(args);
/// Âûâîäèò ïóñòóþ ñòðîêó
procedure ÂûâåñòèÏóñòóþÑòðîêó := Println;

///- Ìåòîä Öåëîå.Âûâåñòè
/// Âûâîäèò öåëîå
procedure Âûâåñòè(Self: öåëîå); extensionmethod := Println(Self);
///- Ìåòîä Âåùåñòâåííîå.Âûâåñòè
/// Âûâîäèò âåùåñòâåííîå
procedure Âûâåñòè(Self: real); extensionmethod := Println(Self);
///- Ìåòîä Ñòðîêà.Âûâåñòè
/// Âûâîäèò ñòðîêó
procedure Âûâåñòè(Self: string); extensionmethod := Println(Self);

type
  ///!#
  Seq<T> = interface(IEnumerable<T>)
  
  end;
  
  ///!#
  ÂûâîäÊëàññ = class
  public
    ///- Ìåòîä Âûâîä.Äàííûå(ïàðàìåòðû)
    /// Âûâîäèò äàííûå, ðàçäåëÿÿ èõ ïðîáåëàìè
    procedure Äàííûå(params args: array of object) := Println(args);
    ///- Ìåòîä Âûâîä.ÏóñòàÿÑòðîêà
    /// Âûâîäèò ïóñòóþ ñòðîêó
    procedure ÏóñòàÿÑòðîêà := Println;
  end;
  
  ÏîñëåäîâàòåëüíîñòüÊëàññ = class
    
  end;

// Ñåðâèñíûå ìåòîäû

function DeleteEnd(Self: string; s: string): string; extensionmethod;
begin
  if Self.EndsWith(s) then
  begin
    var i := Self.LastIndexOf(s);
    if (i>=0) and (i<Self.Length) then
      Result := Self.Remove(i)
    else Result := Self;  
  end
  else Result := Self;
end;
 
Procedure PrintAllMethods(o: Object);
begin
  WritelnFormat('Ìåòîäû èñïîëíèòåëÿ {0}:',o.GetType.Name.DeleteEnd('Êëàññ'));
  o.GetType.GetMethods(System.Reflection.BindingFlags.Public or
            System.Reflection.BindingFlags.Instance or 
            System.Reflection.BindingFlags.DeclaredOnly)
    .Select(s->s.ToString.Replace('Void ','')
    .Replace('Int32','öåëîå')
    .Replace('Boolean','ëîãè÷åñêîå')
    .Replace('System.String','ñòðîêîâîå')
    .Replace('Double','âåùåñòâåííîå'))
    .Select(s->'  '+s.DeleteEnd('()'))
    .Where(s->not s.ToString.Contains('$Init$'))
    .Println(NewLine);
end;

// Ðåàëèçàöèÿ
type
  ///!#
  ÌíîæåñòâîÊëàññ = class
  private
    s := new SortedSet<integer>;
  public
    constructor;
    begin end;
    ///- Ìåòîä Ìíîæåñòâî.Äîáàâèòü(ýëåìåíò: öåëîå)
    /// Äîáàâëÿåò ýëåìåíò ê ìíîæåñòâó. Åñëè òàêîé ýëåìåíò åñòü, òî íè÷åãî íå ïðîèñõîäèò
    procedure Äîáàâèòü(params a: array of integer);
    begin
      a.ForEach(x->begin s.Add(x) end);
      //s.Add(ýëåìåíò);
    end;   
    ///- Ìåòîä Ìíîæåñòâî.Óäàëèòü(ýëåìåíò: öåëîå)
    /// Óäàëÿåò ýëåìåíò èç ìíîæåñòâà. Åñëè òàêîãî ýëåìåíòà íåò, òî íè÷åãî íå ïðîèñõîäèò
    procedure Óäàëèòü(ýëåìåíò: öåëîå);
    begin
      s.Remove(ýëåìåíò);
    end;
    ///- Ìåòîä Ìíîæåñòâî.Âûâåñòè
    /// Âûâîäèò ýëåìåíòû ìíîæåñòâà
    procedure Âûâåñòè;
    begin
      s.Println;
    end;
    ///- Ìåòîä Ìíîæåñòâî.Ñîäåðæèò(ýëåìåíò: öåëîå): ëîãè÷åñêèé
    /// Ïðîâåðÿåò, åñòü ëè ýëåìåíò âî ìíîæåñòâå
    function Ñîäåðæèò(ýëåìåíò: öåëîå): ëîãè÷åñêîå;
    begin
      Result := s.Contains(ýëåìåíò)
    end;
    ///- Ìåòîä Ìíîæåñòâî.ÂûâåñòèÂñåÌåòîäû
    /// Âûâîäèò âñå ìåòîäû Èñïîëíèòåëÿ Ìíîæåñòâî
    procedure ÂûâåñòèÂñåÌåòîäû;
    begin
      if Random(2)=1 then
        PrintAllMethods(Self)
      else 
      begin
        WritelnFormat('Ìåòîäû èñïîëíèòåëÿ {0}:',Self.GetType.Name.DeleteEnd('Êëàññ'));
        Writeln('  Äîáàâèòü(ýëåìåíò: öåëîå)');
        Writeln('  Óäàëèòü(ýëåìåíò: öåëîå)');
        Writeln('  Âûâåñòè');
        Writeln('  Ñîäåðæèò(ýëåìåíò: öåëîå): ëîãè÷åñêîå');
        Writeln('  ÂûâåñòèÂñåÌåòîäû');
      end;
    end;
    ///- Ìåòîä Ìíîæåñòâî.Î÷èñòèòü
    /// Äåëàåò ìíîæåñòâî ïóñòûì
    procedure Î÷èñòèòü;
    begin
      s.Clear
    end;
    ///- Ìåòîä Ìíîæåñòâî.Íîâîå
    /// Ñîçäàåò íîâîå ìíîæåñòâî
    function Íîâîå(params a: array of integer): ÌíîæåñòâîÊëàññ;
    begin
      Result := new ÌíîæåñòâîÊëàññ();
      Result.Äîáàâèòü(a)
    end;
    ///- Ìåòîä Ìíîæåñòâî.Ïåðåñå÷åíèå(Ìíîæåñòâî1)
    /// Âîçâðàùàåò ïåðåñå÷åíèå ìíîæåñòâ   
    function Ïåðåñå÷åíèå(s1: ÌíîæåñòâîÊëàññ): ÌíîæåñòâîÊëàññ;
    begin
      Result := new ÌíîæåñòâîÊëàññ();
      var ss := SSet(s.AsEnumerable&<integer>);
      ss.IntersectWith(s1.s);
      Result.s := ss;
    end;
  end;
  
type  
  ///!#
  ÌíîæåñòâîÑòðîêÊëàññ = class
  private
    s := new SortedSet<string>;
  public
    constructor;
    begin end;
    ///- Ìåòîä Ìíîæåñòâî.Äîáàâèòü(ýëåìåíò: ñòðîêîâîå)
    /// Äîáàâëÿåò ýëåìåíò ê ìíîæåñòâó. Åñëè òàêîé ýëåìåíò åñòü, òî íè÷åãî íå ïðîèñõîäèò
    procedure Äîáàâèòü(ýëåìåíò: string);
    begin
      s.Add(ýëåìåíò);
    end;
    ///- Ìåòîä Ìíîæåñòâî.Óäàëèòü(ýëåìåíò: ñòðîêîâîå)
    /// Óäàëÿåò ýëåìåíò èç ìíîæåñòâà. Åñëè òàêîãî ýëåìåíòà íåò, òî íè÷åãî íå ïðîèñõîäèò
    procedure Óäàëèòü(ýëåìåíò: string);
    begin
      s.Remove(ýëåìåíò);
    end;
    ///- Ìåòîä Ìíîæåñòâî.Âûâåñòè
    /// Âûâîäèò ýëåìåíòû ìíîæåñòâà
    procedure Âûâåñòè;
    begin
      s.Println;
    end;
    ///- Ìåòîä Ìíîæåñòâî.Ñîäåðæèò(ýëåìåíò: ñòðîêîâîå): ëîãè÷åñêèé
    /// Ïðîâåðÿåò, åñòü ëè ýëåìåíò âî ìíîæåñòâå
    function Ñîäåðæèò(ýëåìåíò: string): ëîãè÷åñêîå;
    begin
      Result := s.Contains(ýëåìåíò)
    end;
    ///- Ìåòîä Ìíîæåñòâî.ÂûâåñòèÂñåÌåòîäû
    /// Âûâîäèò âñå ìåòîäû Èñïîëíèòåëÿ Ìíîæåñòâî
    procedure ÂûâåñòèÂñåÌåòîäû;
    begin
      if Random(2)=1 then
        PrintAllMethods(Self)
      else 
      begin
        WritelnFormat('Ìåòîäû èñïîëíèòåëÿ {0}:',Self.GetType.Name.DeleteEnd('Êëàññ'));
        Writeln('  Äîáàâèòü(ýëåìåíò: öåëîå)');
        Writeln('  Óäàëèòü(ýëåìåíò: öåëîå)');
        Writeln('  Âûâåñòè');
        Writeln('  Ñîäåðæèò(ýëåìåíò: öåëîå): ëîãè÷åñêîå');
        Writeln('  ÂûâåñòèÂñåÌåòîäû');
      end;
    end;
    ///- Ìåòîä Ìíîæåñòâî.Î÷èñòèòü
    /// Äåëàåò ìíîæåñòâî ïóñòûì
    procedure Î÷èñòèòü;
    begin
      s.Clear
    end;
    ///- Ìåòîä Ìíîæåñòâî.Íîâîå
    /// Ñîçäàåò íîâîå ìíîæåñòâî
    function Íîâîå := new ÌíîæåñòâîÑòðîêÊëàññ;
    ///- Ìåòîä Ìíîæåñòâî.ÑîçäàòüÏàðû(ìíîæåñòâî1)
    /// Ñîçäàåò ïàðû ýëåìåíòîâ èç äâóõ ìíîæåñòâ
    function ÑîçäàòüÏàðû(ìí1: ÌíîæåñòâîÑòðîêÊëàññ): ÌíîæåñòâîÑòðîêÊëàññ;
    begin
      var ss: SortedSet<string>;
      ss := (ìí1 as ÌíîæåñòâîÑòðîêÊëàññ).s;
      
      var m := new ÌíîæåñòâîÑòðîêÊëàññ;
      m.s := s.ZipTuple(ss).Select(x -> x.ToString()).ToSortedSet;
      Result := m
    end;
  end;
  
type
///!#
  Âû÷èñëèòåëüÊëàññ = class
  public
  ///- Ìåòîä Âû÷èñëèòåëü.ÊâàäðàòíîåÓðàâíåíèå(a,b,c: âåùåñòâåííîå)
  /// Âûâîäèò âñå ðåøåíèÿ êâàäðàòíîãî óðàâíåíèÿ
    procedure ÐåøèòüÊâàäðàòíîåÓðàâíåíèå(a,b,c: real);
    begin
      writelnFormat('Êâàäðàòíîå óðàâíåíèå: {0}*x*x+{1}*x+{2}=0',a,b,c);
      var D := b*b-4*a*c;
      if D<0 then
        writeln('Ðåøåíèé íåò')
      else
      begin
        var x1 := (-b-sqrt(D))/2/a;
        var x2 := (-b+sqrt(D))/2/a;
        writelnFormat('Ðåøåíèÿ: x1={0} x2={1}',x1,x2)
      end;
    end;
  ///- Ìåòîä Âû÷èñëèòåëü.Àðèôìåòè÷åñêàÿÏðîãðåññèÿ(a0,d: öåëîå)
  /// Âûâîäèò àðèôìåòè÷åñêóþ ïðîãðåññèþ
    procedure ÂûâåñòèÀðèôìåòè÷åñêóþÏðîãðåññèþ(a0,d: integer);
    begin
      writelnFormat('Àðèôìåòè÷åñêàÿ ïðîãðåññèÿ: a0={0} d={1}',a0,d);
      SeqGen(10,a0,x->x+d).Println; // ! Îøèáêà åñëè ïðîöåäóðû îïèñûâàþòñÿ ïåðåä
    end;
    procedure ÂûâåñòèÂñåÌåòîäû;
    begin
      PrintAllMethods(Self);
    end;
  end;

  FileState = (Closed,OpenedForRead,OpenedForWrite);
  ///!#
  ÔàéëÊëàññ = class
  private
    f: Text;
    State := FileState.Closed;
  public
    constructor ;
    begin
    end;
  ///- Ìåòîä Ôàéë.ÎòêðûòüÍà×òåíèå(èìÿ)
  /// Îòêðûâàåò ôàéë íà ÷òåíèå
    procedure ÎòêðûòüÍà×òåíèå(èìÿ: ñòðîêîâîå);
    begin
      if State<>FileState.Closed then
        f.Close;
      f := OpenRead(èìÿ);
      State := FileState.OpenedForRead
    end;
  ///- Ìåòîä Ôàéë.ÎòêðûòüÍàÇàïèñü(èìÿ)
  /// Îòêðûâàåò ôàéë íà çàïèñü
    procedure ÎòêðûòüÍàÇàïèñü(èìÿ: ñòðîêîâîå);
    begin
      if State<>FileState.Closed then
        f.Close;
      f := OpenWrite(èìÿ);
      State := FileState.OpenedForWrite
    end;
  ///- Ìåòîä Ôàéë.Çàêðûòü
  /// Çàêðûâàåò ôàéë
    procedure Çàêðûòü;
    begin
      if State=FileState.Closed then
        Println('Îøèáêà: Ôàéë óæå çàêðûò')
      else f.Close;
      State := FileState.Closed;
    end;
  ///- Ìåòîä Ôàéë.Çàïèñàòü(ñòðîêà)
  /// Çàïèñûâàåò ñòðîêó â ôàéë
    procedure Çàïèñàòü(ñòðîêà: ñòðîêîâîå);
    begin
      if State=FileState.Closed then
        Println('Îøèáêà: Ïåðåä çàïèñüþ ôàéë ñëåäóåò îòêðûòü')
      else f.Writeln(ñòðîêà)
    end;
  ///- Ìåòîä Ôàéë.Ïðî÷èòàòüÑòðîêó
  /// Âîçâðàùàåò ñòðîêó, ñ÷èòàííóþ èç ôàéëà
    function Ïðî÷èòàòüÑòðîêó: ñòðîêîâîå;
    begin
      if State=FileState.Closed then
      begin
        Println('Îøèáêà: Ïåðåä ÷òåíèåì ôàéë ñëåäóåò îòêðûòü');
        Result := '';
      end
      else 
      begin
        Result := f.ReadlnString;
        Println(Result);
      end;  
    end;
  ///- Ìåòîä Ôàéë.Ïðî÷èòàòüÖåëîå
  /// Âîçâðàùàåò öåëîå, ñ÷èòàííîå èç ôàéëà
    function Ïðî÷èòàòüÖåëîå: öåëîå;
    begin
      if State=FileState.Closed then
      begin
        Println('Îøèáêà: Ïåðåä ÷òåíèåì ôàéë íàäî îòêðûòü');
        Result := 0;
      end
      else 
      begin
        Result := f.ReadInteger;
        Print(Result);
      end;  
    end;
  ///- Ìåòîä Ôàéë.Ïðî÷èòàòüÂåùåñòâåííîå
  /// Âîçâðàùàåò âåùåñòâåííîå, ñ÷èòàííîå èç ôàéëà
    function Ïðî÷èòàòüÂåùåñòâåííîå: âåùåñòâåííîå;
    begin
      if State=FileState.Closed then
      begin
        Println('Îøèáêà: Ïåðåä ÷òåíèåì ôàéë íàäî îòêðûòü');
        Result := 0;
      end
      else 
      begin
        Result := f.ReadReal;
        Print(Result);
      end;  
    end;
  ///- Ìåòîä Ôàéë.ÊîíåöÔàéëà
  /// Âîçâðàùàåò, äîñòèãíóò ëè êîíåö ôàéëà
    function ÊîíåöÔàéëà: ëîãè÷åñêîå;
    begin
      Result := f.Eof;
    end;
  ///- Ìåòîä Ôàéë.ÈìÿÔàéëà
  /// Âîçâðàùàåò èìÿ ôàéëà
    function ÈìÿÔàéëà: ñòðîêîâîå;
    begin
      if State=FileState.Closed then
      begin
        Println('Îøèáêà: Ôàéë çàêðûò, ïîýòîìó îí íå èìååò èìåíè');
        Result := '';
      end
      else 
      begin
        Println('Èìÿ ôàéëà: ',f.Name);
        Result := f.Name;
      end
    end;
  ///- Ìåòîä Ôàéë.ÂûâåñòèÑîäåðæèìîå
  /// Âûâîäèò ñîäåðæèìîå ôàéëà
    procedure ÂûâåñòèÑîäåðæèìîå(èìÿôàéëà: ñòðîêîâîå);
    begin
      if (State<>FileState.Closed) and (f.Name.ToLower=èìÿôàéëà.ToLower) then
        Println('Îøèáêà: Ñîäåðæèìîå ìîæíî âûâåñòè òîëüêî ó çàêðûòîãî ôàéëà')
      else 
      begin
        WritelnFormat('Ñîäåðæèìîå ôàéëà {0}:',èìÿôàéëà);
        try
          ReadLines(èìÿôàéëà).Println(NewLine);
        except
          WritelnFormat('Ôàéë {0}: îòñóòñòâóåò íà äèñêå',èìÿôàéëà);
        end;
      end;  
        
    end;
  ///- Ìåòîä Ôàéë.ÂûâåñòèÂñåÌåòîäû
  /// Âûâîäèò âñå ìåòîäû èñïîëíèòåëÿ Ôàéë
    procedure ÂûâåñòèÂñåÌåòîäû;
    begin
      PrintAllMethods(Self);
    end;
  ///- Ìåòîä Ôàéë.Íîâûé
  /// Ñîçäàåò è âîçâðàùàåò íîâîãî èñïîëíèòåëÿ Ôàéë
    function Íîâûé := new ÔàéëÊëàññ;
  ///- Ìåòîä Ôàéë.ÂñåÑòðîêè
  /// Âîçâðàùàåò âñå ñòðîêè ôàéëà â âèäå ïîñëåäîâàòåëüíîñòè
    function ÂñåÑòðîêè(èìÿôàéëà: ñòðîêîâîå): sequence of ñòðîêîâîå;
    begin
      if (State<>FileState.Closed) and (f.Name.ToLower=èìÿôàéëà.ToLower) then
      begin
        Println('Îøèáêà: Ñòðîêè ìîæíî ïîëó÷èòü òîëüêî ó çàêðûòîãî ôàéëà');
        Result := nil;
        exit;
      end;
      Result := ReadLines(èìÿôàéëà).ToArray;
    end;
  end;

const dbname = 'countries.db';

var coun: array of string := nil;

function ÑòðàíûÑòðîêè: sequence of string;
begin
  if coun = nil then
    coun := ReadLines(dbname).ToArray();
  Result := coun;  
end;

///- Ìåòîä Ïîñëåäîâàòåëüíîñòü.Âûâåñòè
/// Âûâîäèò âñå ýëåìåíòû ïîñëåäîâàòåëüíîñòè, ðàçäåëÿÿ èõ ïðîáåëàìè
function Âûâåñòè<T>(Self: sequence of T): sequence of T; extensionmethod;
begin
  Self.Println;
  Result := Self;
end;

///- Ìåòîä Ïîñëåäîâàòåëüíîñòü.ÂûâåñòèÏîñòðî÷íî
/// Âûâîäèò âñå ýëåìåíòû ïîñëåäîâàòåëüíîñòè - êàæäûé ýëåìåíò ñ íîâîé ñòðîêè
function ÂûâåñòèÏîñòðî÷íî<T>(Self: sequence of T): sequence of T; extensionmethod;
begin
  Self.Println(NewLine);
  Result := Self;
end;

///- Ìåòîä Ïîñëåäîâàòåëüíîñòü.Âûáðàòü(óñëîâèå)
/// Âûáèðàåò âñå ýëåìåíòû ïîñëåäîâàòåëüíîñòè, óäîâëåòâîðÿþùèå óêàçàííîìó óñëîâèþ
function Âûáðàòü<T>(Self: sequence of T; cond: T -> boolean): sequence of T; extensionmethod;
begin
  Result := Self.Where(cond);  
end;

///- Ìåòîä Ïîñëåäîâàòåëüíîñòü.Âçÿòü(n)
/// Âîçâðàùàåò ïåðâûå n ýëåìåíòîâ ïîñëåäîâàòåëüíîñòè
function Âçÿòü<T>(Self: sequence of T; n: integer): sequence of T; extensionmethod;
begin
  Result := Self.Take(n);  
end;

///- Ìåòîä Ïîñëåäîâàòåëüíîñòü.Êîëè÷åñòâî(óñëîâèå)
/// Âîçâðàùàåò êîëè÷åñòâî ýëåìåíòîâ ïîñëåäîâàòåëüíîñòè, óäîâëåòâîðÿþùèõ óêàçàííîìó óñëîâèþ
function Êîëè÷åñòâî<T>(Self: sequence of T; cond: T -> boolean := nil): öåëîå; extensionmethod;
begin
  if cond = nil then
    Result := Self.Count()
  else Result := Self.Count(cond)
end;

///- Ìåòîä Ïîñëåäîâàòåëüíîñòü.Ñóììà
/// Âîçâðàùàåò ñóììó ýëåìåíòîâ ïîñëåäîâàòåëüíîñòè
function Ñóììà(Self: sequence of integer): integer; extensionmethod;
begin
  Result := Self.Sum();  
end;  

///- Ìåòîä Ïîñëåäîâàòåëüíîñòü.Ñðåäíåå
/// Âîçâðàùàåò ñðåäíåå ýëåìåíòîâ ïîñëåäîâàòåëüíîñòè
function Ñðåäíåå(Self: sequence of integer): real; extensionmethod;
begin
  Result := Self.Average;  
end;  

///- Ìåòîä Ïîñëåäîâàòåëüíîñòü.Ìèíèìóì
/// Âîçâðàùàåò ìèíèìàëüíûé ýëåìåíò ïîñëåäîâàòåëüíîñòè
function Ìèíèìóì(Self: sequence of integer): integer; extensionmethod;
begin
  Result := Self.Min;  
end;  

///- Ìåòîä Ïîñëåäîâàòåëüíîñòü.Ìàêñèìóì
/// Âîçâðàùàåò ìàêñèìàëüíûé ýëåìåíò ïîñëåäîâàòåëüíîñòè
function Ìàêñèìóì(Self: sequence of integer): integer; extensionmethod;
begin
  Result := Self.Max;
end;  

///- Ìåòîä Ïîñëåäîâàòåëüíîñòü.Ïðåîáðàçîâàòü(ôóíêöèÿ ïðåîáðàçîâàíèÿ)
/// Ïðåîáðàçóåò ýëåìåíòû ïîñëåäîâàòåëüíîñòè ñ ïîìîùüþ ôóíêöèè è âîçâðàùàåò íîâóþ ïîñëåäîâàòåëüíîñòü
function Ïðåîáðàçîâàòü<T,Key>(Self: sequence of T; conv: T -> Key): sequence of Key; extensionmethod;
begin
  Result := Self.Select(conv);  
end;

///- Ìåòîä Ïîñëåäîâàòåëüíîñòü.ÎòñîðòèðîâàòüÏî(ïðîåêöèÿ ýëåìåíòà íà êëþ÷)
/// Ñîðòèðóåò ýëåìåíòû ïîñëåäîâàòåëüíîñòè ïî âîçðàñòàíèþ êëþ÷à
function ÎòñîðòèðîâàòüÏî<T,Key>(Self: sequence of T; cond: T -> Key): sequence of T; extensionmethod;
begin
  Result := Self.OrderBy(cond);  
end;

///- Ìåòîä Ïîñëåäîâàòåëüíîñòü.ÎòñîðòèðîâàòüÏî(ïðîåêöèÿ ýëåìåíòà íà êëþ÷)
/// Ñîðòèðóåò ýëåìåíòû ïîñëåäîâàòåëüíîñòè ïî êëþ÷ó
function Îòñîðòèðîâàòü<T>(Self: sequence of T): sequence of T; extensionmethod;
begin
  Result := Self.OrderBy(x->x);  
end;

///- Ìåòîä Ïîñëåäîâàòåëüíîñòü.ÎòñîðòèðîâàòüÏîÓáûâàíèþ(ïðîåêöèÿ ýëåìåíòà íà êëþ÷)
/// Ñîðòèðóåò ýëåìåíòû ïîñëåäîâàòåëüíîñòè ïî óáûâàíèþ êëþ÷à
function ÎòñîðòèðîâàòüÏîÓáûâàíèþ<T,Key>(Self: sequence of T; cond: T -> Key): sequence of T; extensionmethod;
begin
  Result := Self.OrderByDescending(cond);  
end;

///- Ìåòîä Ïîñëåäîâàòåëüíîñòü.ÄëÿÂñåõ(äåéñòâèå)
/// Âûïîëíÿåò óêàçàííîå äåéñòâèå äëÿ êàæäîãî ýëåìåíòà ïîñëåäîâàòåëüíîñòè
procedure ÄëÿÂñåõ<T>(Self: sequence of T; act: T -> ()); extensionmethod;
begin
  Self.Foreach(act);  
end;

function ÍàÁóêâó(c: char): string -> boolean;
begin
  Result := ñòðàíà -> ñòðàíà[1] = c;
end;

function ÍàÁóêâó(s: string): string -> boolean;
begin
  Result := ñòðàíà -> ñòðàíà[1] = s[1];
end;

function Íà÷èíàåòñÿÍà(Self: string; s: string): boolean; extensionmethod;
begin
  Result := Self.StartsWith(s);  
end;

///- ×åòíîå(çíà÷åíèå)
/// Âîçâðàùàåò, ÿâëÿåòñÿ ëè çíà÷åíèå ÷åòíûì
function ×åòíîå(x: integer): boolean;
begin
  Result := x mod 2 = 0;
end;

///- Íå÷åòíîå(çíà÷åíèå)
/// Âîçâðàùàåò, ÿâëÿåòñÿ ëè çíà÷åíèå íå÷åòíûì
function Íå÷åòíîå(x: integer): boolean;
begin
  Result := x mod 2 <> 0;
end;

type 
///!#
  ÂñåÈñïîëíèòåëèÊëàññ = class
public
  ///- Èñïîëíèòåëü Ìíîæåñòâî 
  /// Ïðåäîñòàâëÿåò ìåòîäû äëÿ ìíîæåñòâà öåëûõ
  Ìíîæåñòâî: ÌíîæåñòâîÊëàññ;
  ///- Èñïîëíèòåëü ÌíîæåñòâîÑòðîê
  /// Ïðåäîñòàâëÿåò ìåòîäû äëÿ ìíîæåñòâà ñòðîê
  ÌíîæåñòâîÑòðîê: ÌíîæåñòâîÑòðîêÊëàññ;
  ///- Èñïîëíèòåëü Âû÷èñëèòåëü
  /// Ïðåäîñòàâëÿåò ðÿä ìåòîäîâ èç îáëàñòè ìàòåìàòèêè
  Âû÷èñëèòåëü: Âû÷èñëèòåëüÊëàññ;
  ///- Èñïîëíèòåëü Ôàéë
  /// Ïðåäîñòàâëÿåò ðÿä ìåòîäîâ äëÿ ðàáîòû ñ ôàéëàìè íà äèñêå
  Ôàéë: ÔàéëÊëàññ;
  ///- Èñïîëíèòåëü Âûâîä
  /// Ïðåäîñòàâëÿåò ìåòîäû äëÿ âûâîäà äàííûõ
  Âûâîä: ÂûâîäÊëàññ;
  ///- Ìåòîä Âûâåñòè
  /// Âûâîäèò âñåõ èñïîëíèòåëåé
  procedure Âûâåñòè;
  begin
    Println('Ìíîæåñòâî');
    Println('ÌíîæåñòâîÑòðîê');
    Println('Âû÷èñëèòåëü');
    Println('Ôàéë');
    Println('Âûâîä');
  end;
end;

type 
  ///!#
  Country = auto class
    nm,cap: string;
    inh: integer;
    cont: string;
  public  
    property Íàçâàíèå: string read nm;
    property Ñòîëèöà: string read cap;
    property Íàñåëåíèå: integer read inh;
    property Êîíòèíåíò: string read cont;
  end;
  
var ñòðàíû: sequence of Country;  

procedure InitCountries();
begin
  ñòðàíû := ReadLines('Ñòðàíû.csv')
    .Select(s->s.ToWords(';'))
    .Select(w->new Country(w[0],w[1],w[2].ToInteger,w[3])).ToArray;
end;

// Ïîñëåäîâàòåëüíîñòè

///- Àðèôìåòè÷åñêàÿÏðîãðåññèÿ(ïåðâûé,øàã,êîëè÷åñòâî)
/// Âîçâðàùàåò àðèôìåòè÷åñêóþ ïðîãðåññèþ ñ óêàçàííûì ïåðâûì ýëåìåíòîì, øàãîì è êîëè÷åñòâîì
function Àðèôìåòè÷åñêàÿÏðîãðåññèÿ(a,d: integer; n: integer := 20): sequence of integer;
begin
  Result := SeqGen(n,a,a->a+d)
end;

///- Àðèôìåòè÷åñêàÿÏðîãðåññèÿ(ïåðâûé,øàã,êîëè÷åñòâî)
/// Âîçâðàùàåò àðèôìåòè÷åñêóþ ïðîãðåññèþ ñ óêàçàííûì ïåðâûì ýëåìåíòîì, øàãîì è êîëè÷åñòâîì
function Àðèôìåòè÷åñêàÿÏðîãðåññèÿ(a,d: real; n: integer := 20): sequence of real;
begin
  Result := SeqGen(n,a,a->a+d)
end;

///- Ãåîìåòè÷åñêàÿÏðîãðåññèÿ(ïåðâûé,øàã,êîëè÷åñòâî)
/// Âîçâðàùàåò ãåîìåòè÷åñêóþ ïðîãðåññèþ ñ óêàçàííûì ïåðâûì ýëåìåíòîì, øàãîì è êîëè÷åñòâîì
function Ãåîìåòè÷åñêàÿÏðîãðåññèÿ(a,d: integer; n: integer := 10): sequence of integer;
begin
  Result := SeqGen(n,a,a->a*d)
end;

///- Ãåîìåòè÷åñêàÿÏðîãðåññèÿ(ïåðâûé,øàã,êîëè÷åñòâî)
/// Âîçâðàùàåò ãåîìåòè÷åñêóþ ïðîãðåññèþ ñ óêàçàííûì ïåðâûì ýëåìåíòîì, øàãîì è êîëè÷åñòâîì
function Ãåîìåòè÷åñêàÿÏðîãðåññèÿ(a,d: real; n: integer := 10): sequence of real;
begin
  Result := SeqGen(n,a,a->a*d)
end;

///- Ñëó÷àéíàÿÏîñëåäîâàòåëüíîñòü(êîëè÷åñòâî,îò,äî)
/// Âîçâðàùàåò ñëó÷àéíóþ ïîñëåäîâàòåëüíîñòü ýëåìåíòîâ â äèàïàçîíå [îò, äî] 
function Ñëó÷àéíàÿÏîñëåäîâàòåëüíîñòü(n: integer := 10; a: integer := 0; b: integer := 10): sequence of integer;
begin
  Result := ArrRandom(n,a,b)
end;

function ÍîâûéÔàéë := new ÔàéëÊëàññ;

var 
  ///- Èñïîëíèòåëü Ìíîæåñòâî. Ïðåäîñòàâëÿåò ìåòîäû äëÿ ìíîæåñòâà öåëûõ
  Ìíîæåñòâî := new ÌíîæåñòâîÊëàññ;
  ///- Èñïîëíèòåëü ÌíîæåñòâîÑòðîê. Ïðåäîñòàâëÿåò ìåòîäû äëÿ ìíîæåñòâà ñòðîê
  ÌíîæåñòâîÑòðîê := new ÌíîæåñòâîÑòðîêÊëàññ;
  ///- Èñïîëíèòåëü Âû÷èñëèòåëü. Ïðåäîñòàâëÿåò ðÿä ìåòîäîâ èç îáëàñòè ìàòåìàòèêè
  Âû÷èñëèòåëü := new Âû÷èñëèòåëüÊëàññ;
  ///- Èñïîëíèòåëü Ôàéë. Ïðåäîñòàâëÿåò ðÿä ìåòîäîâ äëÿ ðàáîòû ñ ôàéëàìè íà äèñêå
  Ôàéë := new ÔàéëÊëàññ;
  ///- Èñïîëíèòåëü Âûâîä. Ïðåäîñòàâëÿåò ìåòîäû äëÿ âûâîäà äàííûõ
  Âûâîä := new ÂûâîäÊëàññ;
  ///- Èñïîëíèòåëü ÌèðÈñïîëíèòåëåé. Ñîäåðæèò âñåõ èñïîëíèòåëåé 
  ÌèðÈñïîëíèòåëåé := new ÂñåÈñïîëíèòåëèÊëàññ;
begin  
  ÌèðÈñïîëíèòåëåé.Ìíîæåñòâî := Ìíîæåñòâî;
  ÌèðÈñïîëíèòåëåé.ÌíîæåñòâîÑòðîê := ÌíîæåñòâîÑòðîê;
  ÌèðÈñïîëíèòåëåé.Âû÷èñëèòåëü := Âû÷èñëèòåëü;
  ÌèðÈñïîëíèòåëåé.Ôàéë := Ôàéë;
  ÌèðÈñïîëíèòåëåé.Âûâîä := Âûâîä;
  InitCountries;
end.