#include <stdio.h>
#include <string.h>
#include <math.h>

#define TMAX 60
#define LMAX 30

struct __circunscripcionUnica{
    int numeroPartidos;
    int numeroEscanos;
    char nombrePartidos[TMAX][LMAX];
    int votosPartidos[TMAX];
};
typedef struct __circunscripcionUnica CircunscripcionUnica;

/* Calcula el índice de la componente que contiene el valor
   máximo de un array de reales.

   Entradas: w, el array de reales
             numero, el número de componentes del array
   Salida: un entero 0 <= jmax < numero tal que
           w[jmax]>=v[j] para todo 0<=j<n.
*/
int maximoVector(const double w[], int numero);

/* Calcula la suma de las componentes de un array de enteros.

   Entradas: w, el array de enteros
             numero, el número de componentes del array
   Salidas: un entero, suma = SUMA{w[i]; 0<=i<numero}
*/
int sumaVector(const int w[], int numero);

/* Realiza el reparto de escaños entre los partidos de una circunscripción
   siguiendo un método tipo promedio mayor que está caracterizado por los
   valores del primer divisor y el factor.

   Entradas: v, una circunscripción, que contiene el número de escaños
                a repartir, el número de partidos, sus nombres y los votos
                que han recibido
             divisor1, un real
             factor, un entero, que caracterizan el método de reparto
   Salida: escanos, un array de enteros que contiene los escaños que se
           asignan a los partidos.

   El array resultado utilizado en la invocación debe tener, al menos,
   v.numeroPartidos componentes. Al finalizar la ejecución del subalgoritmo,
   escanos[i] es el número de escanos asignado al partido v.nombrePartidos[i].

   Observación: el parámetro v se pasa por referencia para reducir el coste
   de la llamada, que implicaría la copia de toda la información que contiene
   el struct CircunscripcionUnica en caso de hacer un paso por valor.
   En consecuencia, se declara como un parámetro constante, ya que es un dato.
*/
void calculaEscanosCircunscripcionPromedio(const CircunscripcionUnica& v,
                             int escanos[], double divisor1, int factor);

/* Calcula los índices de las componentes de una array de enteros que contienen
   los n mayores valores.

   Entradas: v, un array de enteros
             nComponentes, el número de componentes de v
             n, un entero 0<=n<=nComponentes
   Salidas:  result, un array de enteros tal que
                v[result[i-1]]>=v[result[i]], para todo 0<i<nComponentes.

   En la invocación, el tamaño físico de los arrays w y result debe ser al menos
   de nComponentes componentes.
*/
void  calculaNMayoresRestos(const int v[], int nComponentes, int result[], int n);

/* Realiza el reparto de escaños entre los partidos de una circunscripción
   siguiendo un método tipo resto mayor que está caracterizado por su cuota.

   Entradas: v, una circunscripción, que contiene el número de escaños
                a repartir, el número de partidos, sus nombres y los votos
                que han recibido
             cuota, un entero, que caracterizan el método de reparto
   Salida: escanos, un array de enteros que contiene los escaños que se
           asignan a los partidos.

   El array resultado utilizado en la invocación debe tener, al menos,
   v.numeroPartidos componentes. Al finalizar la ejecución del subalgoritmo,
   escanos[i] es el número de escanos asignado al partido v.nombrePartidos[i].

   Observación: el parámetro v se pasa por referencia para reducir el coste
   de la llamada, que implicaría la copia de toda la información que contiene
   el struct CircunscripcionUnica en caso de hacer un paso por valor.
   En consecuencia, se declara como un parámetro constante, ya que es un dato.
*/
void calculaEscanosCircunscripcionRestoMayor(
                const CircunscripcionUnica &v, int escanos[], int cuota);

/* Muestra en pantalla los datos almacenados en un struct de tipo
   CircunscripcionUnica.

   Entradas: v, una circunscripcion
   Salidas:  los valores de los campos de v

   Observación: esta función sólo debe utilizarse para comprobar el contenido
   del struct CircunscripcionUnica que se construye en el proceso de lectura
   de los datos del fichero.
*/
void muestraCircunscripcionUnica(const CircunscripcionUnica &c);

/* Realiza el reparto de escaños entre los partidos de una circunscripción
   usando el método de Hare.

   Entradas: c, una circunscripcion
   Salidas:  escanos, un array de enteros en el que se devuelve el número
             de escaños que se asigna a cada partido.

   El array resultado utilizado en la invocación debe tener, al menos,
   c.numeroPartidos componentes. Al finalizar la ejecución del subalgoritmo,
   escanos[i] es el número de escanos asignado al partido c.nombrePartidos[i].
*/
void metodoHare(const CircunscripcionUnica &c, int escanos[]);




int main()
{


    return 0;
}




int maximoVector(const double w[], int numero) {
    int jmax, j;
    double maximo;
    maximo = w[0];
    jmax = 0;
    for(j=1; j<numero; j++)
    if (w[j]>maximo) {
        maximo = w[j];
        jmax = j;
    }
    return jmax;
}

int sumaVector(const int w[], int numero) {
    int suma = 0;
    for(int j=0; j<numero; j++) {
        suma = suma+w[j];
    }
    return suma;
}

void calculaEscanosCircunscripcionPromedio(const CircunscripcionUnica &v,
                             int escanos[], double divisor1, int factor) {
    double w[v.numeroPartidos];
    int jmax;
    for(int i=0; i<v.numeroPartidos; i++) {
        escanos[i]=0;
    }
    //Reparto de escaños
    for(int i=0; i<v.numeroPartidos; i++) {
        w[i] = v.votosPartidos[i]/divisor1;
    }
    for(int i=0; i<v.numeroEscanos; i++) {
        jmax=maximoVector(w,v.numeroPartidos);
        escanos[jmax] = escanos[jmax]+1;
        w[jmax] = v.votosPartidos[jmax]/(factor*escanos[jmax]+1);
    }
}

void  calculaNMayoresRestos(const int v[], int nComponentes, int result[], int n) {
    int w[nComponentes];
    //Copia del array dato e inicialización del resultado.
    //Cada componente del resultado se inicializa con el propio índice.
    for(int i=0; i<nComponentes; i++) {
        w[i] = v[i];
        result[i] = i;
    }
    /* Ordenamos decrecientemente la componentes del array w y,
       en paralelo, se hacen los mismos cambios en el array de
       índices, result, que se devuelve como resultado. El método
       utilizado para la ordenación es el del máximo.
    */
    for (int i = 0; i<nComponentes; i++) {
        int imax = i;
        for (int j = i+1; j<nComponentes; j++) {
            if (w[j]>w[imax]) {
                imax = j;
            }
        }
        if (imax != i) {
            int temp = w[imax];
            w[imax] = w[i];
            w[i] = temp;
            temp = result[imax];
            result[imax] = result[i];
            result[i] = temp;
        }
    }
}

void calculaEscanosCircunscripcionRestoMayor(
                const CircunscripcionUnica &v, int escanos[], int cuota) {
    int escanosrepartidos, escanosquedan,
        restoVotos[v.numeroPartidos],
        resultado[v.numeroPartidos];

    for(int i=0; i<v.numeroPartidos; i++) {
        escanos[i] = v.votosPartidos[i]/cuota;
        restoVotos[i] = v.votosPartidos[i]%cuota;
    }
    escanosrepartidos = sumaVector(escanos, v.numeroPartidos);
    escanosquedan = v.numeroEscanos-escanosrepartidos;

    //Tenemos que repartir escanosquedan escaños entre los mayores
    //restos, uno para cada mayor resto
    calculaNMayoresRestos(restoVotos, v.numeroPartidos, resultado, escanosquedan);
    for (int i = 0; i < escanosquedan; i++){
        escanos[resultado[i]]++;
    }
}

void metodoHare(const CircunscripcionUnica &c, int escanos[]) {
    int suma = sumaVector(c.votosPartidos, c.numeroPartidos);
    int cuota = round((double)suma/c.numeroEscanos);
    calculaEscanosCircunscripcionRestoMayor(c, escanos, cuota);
}


void muestraCircunscripcionUnica(const CircunscripcionUnica &c) {
    printf("Numero de partidos: %3d\n", c.numeroPartidos);
    printf("Numero de escanos:  %3d\n", c.numeroEscanos);
    printf("Partidos y votos\n");
    printf("%25s\t%15s\n", "Partido", "Votos");
    for(int i=0; i<c.numeroPartidos; i++) {
        printf("%25s\t%15d\n", c.nombrePartidos[i],
                               c.votosPartidos[i]);
    }
}