{rachet premii sotrydnikov Igo i IIgo otdelov
v zavisimosti ot togo, skol`ko otrabotano bulo dnei}
type stryk=record
     nomer: string;
     fio: string;
     oklad: real;
     otrab: array [1..12] of integer;
     premiya: real;
end;
const mecyac: array [1..12] of string=
      ('yanvar`','fevral`','mart','aprel`','maj','iun`','iul`',
       'avgyst','sentyabr`','oktyabr`','noyabr`','dekabr`');
var sotryd: array [1..100] of stryk;
    dn_kol: array [1..12,1..5] of integer;
    dni,spisok,otchet: text;
    i,k,den,code,mec,kol_dn,n,j,n1,n2,god_int,action: integer;
    str,chi,god: string;
    prem: real;
    error: boolean;
    temp: array [1..12,1..5] of integer;

{--------------------------
 polychenie iz stroki chisla}
procedure chislo(var i: integer; var str,chi: string);
begin
  chi:='';
  while (str[i]<>' ') and (i<=length(str)) do
    begin
      chi:=chi+str[i];
      i:=i+1;
    end;
end;

{--------------------------
 peremena mestami dvyh elementov}
procedure swap(var a,b: stryk);
var t: stryk;
begin
  t:=b;
  b:=a;
  a:=t;
end;

{--------------------------
 rachet rabochih dnej}
procedure r_dni(k: integer);
begin
  assign(dni,'dni.txt');
  reset(dni);
  k:=0;
  while not eof(dni) do
    begin
    i:=0;
    readln(dni,str);
    k:=k+1;
    for j:=1 to 12 do
      begin
        i:=i+1;
        chislo(i,str,chi);
        val(chi,den,code);
        dn_kol[j,k]:=den;
      end;
    end;
  close(dni);
end;

{--------------------------
 spisok sotrydnikov}
procedure r_sotr(e: integer);
begin
  assign(spisok,'otdel.txt');
  reset(spisok);
  n:=0;
  while not eof(spisok) do
    begin
      i:=1;
      readln(spisok,str);
      chislo(i,str,chi);
      n:=n+1;
      sotryd[n].nomer:=chi;
      i:=i+1;
      chislo(i,str,chi);
      sotryd[n].fio:=chi;
    end;
  close(spisok);
  for i:=1 to n do
    if sotryd[i].nomer[1]+sotryd[i].nomer[2]='01' then n1:=n1+1;
  n2:=n-n1;
end;

{--------------------------------------
oklad i kol-vo otrabotannuh dnei sotrydniko Igo otdela}
procedure r_oklad(ime: string);
var st,stol,j: integer;
begin
  assign(spisok,ime);
  reset(spisok);
  while not eof(spisok) do
    begin
      readln(spisok,str);
      i:=1;
      chislo(i,str,chi);
      k:=1;
      i:=i+1;
      while sotryd[k].nomer<>chi do k:=k+1;
      chislo(i,str,chi);
      i:=i+1;
      val(chi,sotryd[k].oklad,code);
      st:=1;
      stol:=1;
      while i<=length(str) do
        begin
          chislo(i,str,chi);
          val(chi,temp[st,stol],code);
          st:=st+1;
          if st=13 then
             begin
               st:=1;
               stol:=stol+1;
             end;
          i:=i+1;
        end;
      for i:=1 to 12 do
        sotryd[k].otrab[i]:=temp[i,god_int];
      for i:=1 to 12 do
        if sotryd[k].otrab[i]>dn_kol[i,god_int] then error:=True;
  end;
  close(spisok);
end;

{-----------------------------
 sortirovka}
procedure sort(nach,con: integer);
begin
     for i:=nach to con do
         for j:=nach to con-1 do
             if sotryd[j].fio>sotryd[j+1].fio then swap(sotryd[j],sotryd[j+1]);
end;

{----------------------------
 schitaem premiu}
procedure prem_(a: integer);
begin
  for i:=1 to n do
    begin
      if sotryd[i].otrab[mec]<15
         then sotryd[i].premiya:=-1;
      if sotryd[i].otrab[mec]>=15
         then sotryd[i].premiya:=sotryd[i].oklad*sotryd[i].otrab[mec]/kol_dn*0.4;
    end;
end;

{-----------------------------
 rachet premii}
procedure r_prem(ime,pyt: string);
var sum: real;
    t,max_leng,l: integer;
    otdel_prov: string;
begin
  otdel_prov:=ime[7]+ime[8];
  assign(otchet,pyt);
  rewrite(otchet);
  writeln(otchet,'----------------------------------------------');
  writeln(otchet,'        PREMII SOTRYDNIKOV');
  writeln(otchet,'za ',mecyac[mec],' ',god,' goda');
  writeln(otchet);
  writeln(otchet,ime:10);
  k:=0;
  sum:=0;
  t:=0;
  max_leng:=0;
  for i:=1 to n do
    if (sotryd[i].nomer[1]+sotryd[i].nomer[2])=otdel_prov
     then if sotryd[i].premiya<>-1
      then if length(sotryd[i].fio)>=max_leng
       then max_leng:=length(sotryd[i].fio);
  for i:=1 to n do
    if ((sotryd[i].nomer[1]+sotryd[i].nomer[2])=otdel_prov) and
        (sotryd[i].premiya<>-1)
       then
         begin
           t:=t+1;
           write(otchet,t:2,'. ');
           write(otchet,sotryd[i].fio);
           for l:=0 to (max_leng-length(sotryd[i].fio)) do write(otchet,' ');
           writeln(otchet,'  ',sotryd[i].premiya:6:2);
           sum:=sum+sotryd[i].premiya;
         end;
  writeln(otchet);
  writeln(otchet,'ITOGO: ',sum:8:2);
  writeln(otchet);
  writeln(otchet,'                  podpis`__________//Ivanov PS');
  writeln('otchet po ',ime,' za ',mecyac[mec],' ',god,' goda mojete prosmotret` v faile ',pyt);
  close(otchet);
end;

{-----------------------------------
 raschet premij dlya sotrydnikov}
procedure raschet(a: integer);
begin
  error:=False;
  write('vvedite tekyschii god - ');
  readln(god);
  write('vvedite tekyschii mesyac - ');
  readln(mec);
 if (god[1]+god[2]+god[3]='200') and
    (god[4]>'2') and
    (god[4]<'8') and
    (mec>=1) and
    (mec<=12) then
   begin
     val(god[4],god_int,code);
     god_int:=god_int-2;
     r_dni(1);
     kol_dn:=dn_kol[mec,god_int];
     writeln;
     if kol_dn<>0 then
        begin
          r_sotr(1);
          r_oklad('01_rab.txt');
          r_oklad('02_rab.txt');
          sort(1,n1);
          sort(n1+1,n);
          if error=False then
             begin
               prem_(1);
               r_prem('otdel_01','otdel01.txt');
               r_prem('otdel_02','otdel02.txt');
             end
                         else
               writeln('oshibka dannuh tabelya');
          writeln;
     end else writeln('dannuh za eto vremya net');
    end else writeln('oshibka vvoda daty');
end;

{-----------------------------------
 otchet po sotrydniky}
procedure otchet_sotryd(a: integer);
var nomer: string;
    t: integer;
    prem: real;
begin
  write('vvedite tabel`nuj nomer sotrydnika - ');
  readln(nomer);
  error:=False;
  write('vvedite interesyushij god - ');
  readln(god);
  write('vvedite interesyushij mesyac - ');
  readln(mec);
  if (god[1]+god[2]+god[3]='200') and
     (god[4]>'2') and
     (god[4]<'8') and
     (mec>=1) and
     (mec<=12) then
    begin
      val(god[4],god_int,code);
      god_int:=god_int-2;
      r_dni(1);
      kol_dn:=dn_kol[mec,god_int];
      if kol_dn<>0 then
         begin
           r_sotr(1);
           r_oklad('01_rab.txt');
           r_oklad('02_rab.txt');
           sort(1,n1);
           sort(n1+1,n);
           if error=False then
              begin
                prem_(1);
                t:=0;
                for i:=1 to n do
                  if sotryd[i].nomer=nomer then
                     begin
                       writeln(nomer,' ',sotryd[i].fio,' ',sotryd[i].oklad:7:2);
                       t:=i;
                     end;
                if t=0 then writeln('sotrydnika s tabel`num nomerom ',nomer,' net');
                if t<>0 then
                   if sotryd[t].premiya<>-1 then
                      writeln('vudana premiya v razmere  ',sotryd[t].premiya:5:2)
                                            else
                      writeln('premiya ne vudana');
             end
                        else
             writeln('oshibka dannuh tabelya');
          writeln;
     end else writeln('dannuh za eto vremya net');
    end else writeln('oshibka vvoda daty');
end;

{-----------------------------------
 prosmotr sotrydnikov}
procedure prosmotr(a: integer);
var k,max_leng,t,l,est,vu_ot1,vu_ot2: integer;
begin
  error:=False;
  write('vvedite interesyushij god - ');
  readln(god);
  write('vvedite interesyushij mesyac - ');
  readln(mec);
  if (god[1]+god[2]+god[3]='200') and
     (god[4]>'2') and
     (god[4]<'8') and
     (mec>=1) and
     (mec<=12) then
     begin
       val(god[4],god_int,code);
       god_int:=god_int-2;
       r_dni(1);
       kol_dn:=dn_kol[mec,god_int];
       writeln;
       writeln('SOTRYDNIKI, NE POLYCHIVSHIE PREMIY');
       writeln('za ',mecyac[mec],' ',god,' goda');
       if kol_dn<>0 then
          begin
            r_sotr(1);
            r_oklad('01_rab.txt');
            r_oklad('02_rab.txt');
            sort(1,n1);
            sort(n1+1,n);
            if error=False then
               begin
                 prem_(1);
                 k:=0;
                 t:=0;
                 est:=0;
                 max_leng:=0;
                 vu_ot1:=0;
                 vu_ot2:=0;
                 for i:=1 to n do
                     if sotryd[i].premiya=-1
                        then if length(sotryd[i].fio)>=max_leng
                                then max_leng:=length(sotryd[i].fio);
                 for i:=1 to n do
                     if sotryd[i].premiya=-1 then
                        begin
                          if i<=n1 then
                            if vu_ot1=0 then
                              begin
                                vu_ot1:=1;
                                writeln('otdel1');
                              end;
                            if i>n1 then
                               if vu_ot2=0 then
                                  begin
                                    vu_ot2:=1;
                                    writeln('otdel2');
                                  end;
                            t:=t+1;
                            write(t,'. ',sotryd[i].fio);
                            for l:=0 to (max_leng-length(sotryd[i].fio))
                               do write(' ');
                            write('  (',sotryd[i].otrab[mec],' iz ',kol_dn,')');
                            writeln;
                            est:=1;
                        end;
                       if est=0 then write('takih sotrydnikov net');
                    end
                         else
              writeln('oshibka dannuh tabelya');
          writeln;
     end else writeln('dannuh za eto vremya net');
   end else writeln('oshibka vvoda daty');
end;

begin
  action:=1;
  while action<>0 do
     begin
       writeln('vuberite odno iz dejstvij:');
       writeln('1. rasschitat` premii sotrydnikam');
       writeln('2. otchet po sotrydnikam');
       writeln('3. prosmotr sotrydnikov, ne polychivshih premiu');
       writeln('0. zavershit` raboty s programmoj');
       readln(str);
       writeln;
       if str='1' then action:=1;
       if str='2' then action:=2;
       if str='3' then action:=3;
       if str='0' then action:=0;
       if (str<>'1') and
          (str<>'2') and
          (str<>'3') and
          (str<>'0') then action:=-1;
       for i:=1 to 100 do
         begin
           sotryd[i].fio:='';
           sotryd[i].nomer:='';
           sotryd[i].premiya:=0;
           sotryd[i].oklad:=0;
         end;
       n:=0;
       n1:=0;
       case action of
         1: raschet(1);
         2: otchet_sotryd(1);
         3: prosmotr(1);
       end;
       if action<>0 then readln;
    end;
end.

#include <iostream>
#include <windows.h>

using namespace std;

//Создадим структуру, в которой будет описан элемент нашей очереди
struct QueueItem
{
  //Переменная для хранения данных
  int Data;
  //Указатель на предыдущий элемент в очереди
  QueueItem* prevItem;
  //Указатель на следующий элемент в очереди
  QueueItem* nextItem;
};

//Создадим класс, в котором опишем простейшую очередь
class SimpleQueue
{
private:
  //Указатель на текущий элемент
  QueueItem* _Item;
public:

  //Конструктор
  SimpleQueue(int Data)
  {
    _Item = new QueueItem();
    _Item->Data = Data;
    _Item->nextItem = NULL;
    _Item->prevItem = NULL;
  };

  //Деструктор
  ~SimpleQueue()
  {
    delete _Item;
  }

  //Удаление элемента из очереди
  void RemoveItem(int index)
  {
    QueueItem* deleteItem = _Item;
    if ((index > -1) && (_Item != NULL))
    {
      for (int i = 0; (i < index) && (deleteItem->nextItem != NULL); i++)
        deleteItem = deleteItem->nextItem;
      QueueItem* prevItem = deleteItem->prevItem;
      QueueItem* nextItem = deleteItem->nextItem;
      if (prevItem != NULL)
      {
        prevItem->nextItem = nextItem;
        if (nextItem != NULL)
          nextItem->prevItem = prevItem;     
      }
      else
      {
        _Item = nextItem;
        if (_Item != NULL)
          _Item->prevItem = NULL;
      }
    }
  };

  //Удаление текущего элемента из очереди
  void RemoveItem()
  {
    return this->RemoveItem(0);
  };

  //Добавление элемента в очередь с определенным индексом
  void AddItem(int index, int Data)
  {
    QueueItem* lastItem = _Item;
    if (lastItem != NULL)
    {
      if (index > -1)
      {
        for (int i = 0; (i < index) && (lastItem->nextItem != NULL); i++)
          lastItem = lastItem->nextItem;
        QueueItem* newItem = new QueueItem();
        newItem->Data = Data;
        newItem->prevItem = lastItem;
        newItem->nextItem = lastItem->nextItem;
        lastItem->nextItem = newItem;
      }
    }
    else
    {
      _Item = new QueueItem();
      _Item->Data = Data;
      _Item->nextItem = NULL;
      _Item->prevItem = NULL;
    }
  }

  //Добавление элемента в конец очереди
  void AddItem(int Data)
  {
    this->AddItem(this->Length(), Data);
  }

  //Перемещение элемента на определенную позицию
  void ShiftItem(int currentIndex, int futureIndex)
  {
    if (_Item != NULL)
    {
      QueueItem* item1 = _Item;
      if (currentIndex > -1)
      {
        for (int i = 0; (i < currentIndex) && (item1->nextItem != NULL); i++)
          item1 = item1->nextItem;
      }
      QueueItem* item2 = _Item;
      if (futureIndex > -1)
      {
        for (int i = 0; (i < futureIndex) && (item2->nextItem != NULL); i++)
          item2 = item2->nextItem;
      }
      //Здесь нужно уточнить, переставить элементы можно поменяв указатели, а можно просто данные
      if ((item2 != NULL) && (item1 != NULL))
      {
        int data = item2->Data;
        item2->Data = item1->Data;
        item1->Data = data;
      }
    }
  }

  //Длина очереди
  int Length()
  {
    int length = 0;
    QueueItem* lastItem = _Item;
    do
    {
      if (lastItem != NULL)
      {
        lastItem = lastItem->nextItem;
        length++;
      }
    } while (lastItem != NULL);
    return length;
  }

  //Метод для получения данных текущего элемента
  int GetItemData()
  {
    return this->GetItemData(0);
  }

  //Метод для получения данных из элемента с определенным индексом
  int GetItemData(int index)
  {
    QueueItem* lastItem = _Item;
    if (index > -1)
    {
      for (int i = 0; (i < index) && (lastItem->nextItem != NULL); i++)
        lastItem = lastItem->nextItem;
    }
    if (lastItem != NULL)
      return lastItem->Data;
    else
      return NULL;
  }
};

int main()
{
 //Небольшой тест класса
 int len;
 SimpleQueue myQueue(11);
 myQueue.AddItem(22);
 myQueue.AddItem(1, 33);
 myQueue.ShiftItem(0, 2);
 cout << myQueue.GetItemData() << endl;
 cout << myQueue.GetItemData(2) << endl;
 cout << myQueue.Length() << endl;
 myQueue.RemoveItem();
 cout << myQueue.Length() << endl;
 cin >> len;
 return 0;
}