Przydzielanie mandatow na podstawie wynikow za pomoca metod:
                   
                   * dHondt'a
                   * Sainte-Lague
                   * zmienionej metody Sainte-Lague
                   * Hare Nemeyer'a

    /*
Name: Przydzielanie mandatow
      Copyright: GPL GNU
      Date:05-02-09 21:00

      Description: Przydzielanie mandatow na podstawie wynikow za pomoca metod:
                   
                   * dHondt'a
                   * Sainte-Lague
                   * zmienionej metody Sainte-Lague
                   * Hare Nemeyer'a
*/

#include <iostream>
#include <iomanip>

using namespace std;
int main()
{
int manDoPrzydz,partie,lacznie=0,mandaty[100][4],glosy[100],i,j,k,maxInd[100],maxIndPom,tmpGlosy,tmpPartie;
float calc[100][4],max,prog;

do
{
      cout<<"\n\n\tPodaj liczbe partii (maksymalnie 100): ";
      cin>>partie;

      cout<<"\n\tPodaj liczbe mandatow: ";
      cin>>manDoPrzydz;

      cout<<"\n\tPodaj prog procentowy (w %): ";
      cin>>prog;
      cout<<endl;
}
while(partie>100||manDoPrzydz<1||prog<0||prog>100);

for(i=0;i<partie;i++)
{
                     cout<<"\tPodaj liczbe glosow na partie "<<i+1<<": ";
                     cin>>glosy[i];
                     calc[i][3]=calc[i][2]=calc[i][1]=calc[i][0]=glosy[i];
                     mandaty[i][0]=mandaty[i][1]=mandaty[i][2]=mandaty[i][3]=0;
                     lacznie+=glosy[i];
}

/* Metoda dHondt'a */

for(i=0;i<manDoPrzydz;i++)
   {
      max=-1;
      for (j=0;j<partie;j++)
      {
      
         if((max<calc[j][0])&&((float)glosy[j]/lacznie*100.0>=prog))
         {
            max=calc[j][0];
            maxInd[0]=j;
            k=1;
         }
         else if((max==calc[j][0])&&((float)glosy[j]/lacznie*100.0>=prog))
         {
              maxInd[k]=j;
              k++;
         }
      }
      
      if(max==-1)
      break;
      
      if((k>1)&&(k>(manDoPrzydz-i)))
      {
          tmpGlosy=-1;
          for(j=0;j<k;j++)
          {
                          if(glosy[maxInd[j]]>tmpGlosy)
                          {
                                                       tmpGlosy=glosy[maxInd[j]];
                                                       maxIndPom=maxInd[j];
                          }
                         
          }
          mandaty[maxIndPom][0]++;
          calc[maxIndPom][0]=(glosy[maxIndPom]*1.0)/(mandaty[maxIndPom][0]+1);
      }
      else
      {
          mandaty[maxInd[0]][0]++;
          calc[maxInd[0]][0]=(glosy[maxInd[0]]*1.0)/(mandaty[maxInd[0]][0]+1); 
      }
   }
   
cout<<endl<<"\tMandaty przydzielone za pomoca metody d'Hondt'a:"<<endl<<endl;
for(i=0;i<partie;i++)
   cout<<right<<"Partia"<<setw(3)<<i+1<<": "<<setw(5)<<left<<mandaty[i][0];
cout<<endl;

/* Metoda Sainte-Lague */
      
for(i=0;i<manDoPrzydz;i++)
   {
      max=-1;
      for (j=0;j<partie;j++)
      {
         if((max<calc[j][1])&&((float)glosy[j]/lacznie*100.0>=prog))
         {
            max=calc[j][1];
            maxInd[0]=j;
            k=1;
         }
         else if((max==calc[j][1])&&((float)glosy[j]/lacznie*100.0>=prog))
         {
              maxInd[k]=j;
              k++;
         }
      }
     
      if(max==-1)
      break;
      
      if((k>1)&&(k>(manDoPrzydz-i)))
      {
          tmpGlosy=-1;
          for(j=0;j<k;j++)
          {
                          if(glosy[maxInd[j]]>tmpGlosy)
                          {
                                                       tmpGlosy=glosy[maxInd[j]];
                                                       maxIndPom=maxInd[j];
                          }
                         
          }
          mandaty[maxIndPom][1]++;
          calc[maxIndPom][1]=(glosy[maxIndPom]*1.0)/(2*mandaty[maxIndPom][1]+1);
      }
      else
      {
          mandaty[maxInd[0]][1]++;
          calc[maxInd[0]][1]=(glosy[maxInd[0]]*1.0)/(2*mandaty[maxInd[0]][1]+1); 
          }
      }
      
cout<<endl<<"\tMandaty przydzielone za pomoca metody Sainte-Lague:"<<endl<<endl;

for(i=0;i<partie;i++)
   cout<<right<<"Partia"<<setw(3)<<i+1<<": "<<setw(5)<<left<<mandaty[i][1];
cout<<endl;

/* Zmieniona metoda Sainte-Lague */
   
for(i=0;i<manDoPrzydz;i++)
   {
      max=-1;
      for (j=0;j<partie;j++)
      {
         if((max<calc[j][2])&&((float)glosy[j]/lacznie*100.0>=prog))
         {
            max=calc[j][2];
            maxInd[0]=j;
            k=1;
         }
         else if((max==calc[j][2])&&((float)glosy[j]/lacznie*100.0>=prog))
         {
              maxInd[k]=j;
              k++;
         }
      }
      
      if(max==-1)
      break;
      
      if((k>1)&&(k>(manDoPrzydz-i)))
      {
          tmpGlosy=-1;
          for(j=0;j<k;j++)
          {
                          if(glosy[maxInd[j]]>tmpGlosy)
                          {
                                                       tmpGlosy=glosy[maxInd[j]];
                                                       maxIndPom=maxInd[j];
                          }
                         
          }
          mandaty[maxIndPom][2]++;
          if (mandaty[maxIndPom][2]==0)
             calc[maxIndPom][2]=(glosy[maxIndPom]*1.0)/1.4;
          else
              calc[maxIndPom][2]=((glosy[maxIndPom])*1.0)/(2*(mandaty[maxIndPom][2])+1); 
      }
      else
      {
          if (mandaty[maxInd[0]][2]==0)
             calc[maxInd[0]][2]=(glosy[maxInd[0]]*1.0)/1.4;
          else
              calc[maxInd[0]][2]=((glosy[maxInd[0]])*1.0)/(2*(mandaty[maxInd[0]][2])+1); 
          mandaty[maxInd[0]][2]++;
      }
      }
      
cout<<endl<<"\tMandaty przydzielone za pomoca zmienionej metody Sainte-Lague:"<<endl<<endl;

for(i=0;i<partie;i++)
   cout<<right<<"Partia"<<setw(3)<<i+1<<": "<<setw(5)<<left<<mandaty[i][2];
cout<<endl;

/* Metoda Hare Nemeyer'a */
   
   j=0;
   for (i=0;i<partie;i++)
   {
      calc[i][3]=(glosy[i]*manDoPrzydz*1.0)/lacznie;
      mandaty[i][3]=(int)(calc[i][3]);
      calc[i][3]-=mandaty[i][3];
      j+=mandaty[i][3];
   }
   
   while(j<manDoPrzydz)
   {
      max=-1;
      for(i=0;i<partie;i++)
      {
         if(max<calc[i][3])
         {
            max=calc[i][3];
            maxInd[0]=i;
         }
      }
      mandaty[maxInd[0]][3]++;
      j++;
      calc[maxInd[0]][3]=0;
   }
   
cout<<endl<<"\tMandaty przydzielone za pomoca metody Hare Nemeyer'a:"<<endl<<endl;

for(i=0;i<partie;i++)
   cout<<right<<"Partia"<<setw(3)<<i+1<<": "<<setw(5)<<left<<mandaty[i][3];
   
cout<<endl<<endl<<"\t";
cin.ignore();
system("pause");
return 0;
}