program HashTable;
type
  link = ^node;
  node = record
      key: integer;
      str: string;
      next: link;
      prev: link;
    end;

  var Table : array of link;
  Gcommand : string;
  Gsize : integer;
  Gkey : integer;
  Gdata : string;
  Gi : integer;
  GRfind : link;
  GRinsert : boolean;
  GRdelete : boolean;
  Gview : link;
function Hash(key : integer): integer;
begin
  Hash := key mod Gsize;
end;

function Find(key : integer) : link;
var hk : integer;
begin
   hk := Hash(key);
   Find := Table[hk];
   while Find <> nil do
   begin
      if Find^.key = key then
         exit;
      Find := Find^.next;
   end;
end;

function Insert(key : integer; data :string) : boolean;
var newData : link;
var hk : integer;
begin
     if Find(key) = nil then
        begin
             hk := Hash(key);
             new(newData);
             newData^.key := key;
             newData^.str := data;
             newData^.next := nil;
             newdata^.prev := nil;
             if Table[hk] <> nil then
                begin
                     newData^.next := Table[hk];
                     newData^.next^.prev := newData;
                end;
             Table[hk] := newData;
             Insert := true;
        end
     else
         Insert := false;
end;

function Delete(key : integer) : boolean;
var hk : integer;
var data : link;
begin
   hk := Hash(key);
   Delete := false;
   if Table[hk] <> nil then
         begin
           if Table[hk]^.key = key then
              begin
                   Table[hk] := Table[hk]^.next;
                   Delete := true;
              end
           else
               begin
                 data := Find(key);
                 if data <> nil then
                    begin

                       if data^.prev <> nil then
                          data^.prev^.next := data^.next;
                       if data^.next <> nil then
                          data^.next^.prev := data^.prev;
                       Delete := true;
                    end;
               end;
         end;
end;


begin
    WriteLn('Enter size of table:');
    ReadLn(Gsize);
    SetLength(Table, Gsize);
    for Gi := 0 to Gsize - 1 do
        Table[Gi] := nil;
    while true do
    begin
       WriteLn();
       WriteLn('Enter command (insert, find, delete, view, exit):');
       ReadLn(Gcommand);
       if Gcommand = 'exit' then
          break;
       if Gcommand = 'insert' then
          begin
            WriteLn('Enter key:');
            ReadLn(Gkey);
            WriteLn('Enter string data:');
            ReadLn(Gdata);
            GRinsert := Insert(Gkey, Gdata);
            if GRinsert then
               WriteLn('Successful insert data')
            else
               WriteLn('Error insert, key already exist')
          end;
       if Gcommand = 'find' then
          begin
            WriteLn('Enter key:');
            ReadLn(Gkey);
            GRfind := Find(Gkey);
            if GRfind = nil then
               WriteLn('Not found')
            else
               WriteLn(GRfind^.str);
          end;
       if Gcommand = 'delete' then
          begin
            WriteLn('Enter key:');
            ReadLn(Gkey);
            GRdelete := Delete(Gkey);
            if GRdelete then
               WriteLn('Successful delete data')
            else
               WriteLn('Not exist');
          end;
       if Gcommand = 'view' then
          begin
          WriteLn('key: value');
          WriteLn('----------');
            for Gi := 0 to Gsize-1 do
                begin
                     if Table[Gi] = nil then
                        WriteLn('null')
                     else
                        begin
                          Gview := Table[Gi];
                             while Gview <> nil do
                               begin
                                  Write(Gview^.key, ': ', Gview^.str, ' -> ');
                                  Gview := Gview^.next;
                               end;
                               WriteLn('null')
                        end;
                end;
          end;
    end;
end.