Список на базе динамического массива

type
  TDynamicArray<TValue> = class
  private 
    _A: array of TValue;
    _Count, _Capacity: int64;
    
    procedure TryRaiseIndexOutOfRangeException(i: int64);
    begin
      if (i >= _Count) or (i < 0) then
        raise new System.IndexOutOfRangeException();
    end;
    
    procedure TryRaiseZeroCountException();
    begin
      if _Count = 0 then
        raise new Exception('Список пуст.');
    end;
    
    function GetItem(i: int64): TValue;
    begin
      TryRaiseIndexOutOfRangeException(i);
      Result := _A[i];
    end;
    
    procedure SetItem(i: int64; v: TValue);
    begin
      TryRaiseIndexOutOfRangeException(i);
      _A[i] := v;
    end;
    
    procedure TryResize();
    begin
      Inc(_Count);
      if _Count > _Capacity then
      begin
        _Capacity *= 2;
        SetLength(_A, _Capacity);
      end;
    end;
  
  public 
    property Items[i: int64]: TValue read GetItem write SetItem;default;
    property Count: int64 read _Count;
    property Capacity: int64 read _Capacity;
    
    constructor();
    begin
      _Capacity := 2;
      SetLength(_A, _Capacity);
    end;
    
    procedure AddLast(v: TValue);
    begin
      TryResize();
      _A[Pred(_Count)] := v;
    end;
    
    procedure RemoveLast();
    begin
      TryRaiseZeroCountException();
      Dec(_Count);
    end;
    
    procedure AddFirst(v: TValue);
    begin
      TryResize();
      for var i := Pred(_Count) downto 1 do
        _A[i] := _A[Pred(i)];
      _A[0] := v;
    end;
    
    procedure RemoveFirst();
    begin
      TryRaiseZeroCountException();
      for var i := 0 to _Count - 2 do
        _A[i] := _A[Succ(i)];
    end;
    
    function Seach(v1: TValue): int64;
    begin
      Result := 0;
      while (Result < Pred(_Count)) and (_A[Result] <> v1) do Inc(Result);
      TryRaiseIndexOutOfRangeException(Result);
    end;
    
    procedure Insert(v1, v2: TValue);
    begin
      TryResize();
      var j := Seach(v1);
      for var i := Pred(_Count) downto Succ(j) do
        _A[i] := _A[Pred(i)];
      _A[j] := v2;
    end;
    
    procedure Remove(v1: TValue);
    begin
      TryRaiseZeroCountException();
      var j := Seach(v1);
      for var i := j to _Count - 2 do
        _A[i] := _A[Succ(i)];
      Dec(_Count);
    end;
    
    procedure Shuffle();
    begin
      for var i := 0 to _Count - 2 do
        Swap(_A[i], _A[Random(Succ(i), Pred(_Count))]);
    end;
    
    procedure Println();
    begin
      for var i := 0 to Pred(_Count) do
        Write(_A[i].ToString():4);
      Writeln();
    end;
    
    function Copy(): TDynamicArray<TValue>;
    begin
      Result := new TDynamicArray<TValue>();
      for var i := 0 to Pred(_Count) do
        Result.AddLast(_A[i]);
    end;
    
    procedure Append(a: TDynamicArray<TValue>);
    begin
      for var i := 0 to Pred(a.Count) do
        AddLast(a[i]);
    end;
    
    class function operator*(a: TDynamicArray<TValue>; c: integer): TDynamicArray<TValue>;
    begin
      Result := new TDynamicArray<TValue>();
      for var i := 1 to c do
        Result.Append(a);
    end;
    
    class function operator+(a: TDynamicArray<TValue>; v1: TValue): TDynamicArray<TValue>;
    begin
      Result := a.Copy();
      Result.AddLast(v1);
    end;
    
    class function operator+(v1: TValue; a: TDynamicArray<TValue>): TDynamicArray<TValue>;
    begin
      Result := a.Copy();
      Result.AddFirst(v1);
    end;
    
    class function operator+(a, b: TDynamicArray<TValue>): TDynamicArray<TValue>;
    begin
      Result := a.Copy();
      Result.Append(b);
    end;
    
    class function operator-(a: TDynamicArray<TValue>; v1: TValue): TDynamicArray<TValue>;
    begin
      Result := a.Copy();
      Result.Remove(v1);
    end;
    
    class function operator-(a, b: TDynamicArray<TValue>): TDynamicArray<TValue>;
    begin
      Result := a.Copy();
      for var i := 0 to Pred(b.Count) do
        Result.Remove(b[i]);
    end;
  end;
  
begin
  var L := new TDynamicArray<integer>();
  
  for var i := 0 to 2 do
    L := i + L;
  
  L.Println();
  L.Shuffle();
  L.Println();
  (4 + L * 2 + 5).Println();
  Writeln(L.Capacity);
end.