Implementación de la ley d'Hondt. Un ejercicio de programación en C/C++

/*
 La llei d'Hondt per al repartiment d'escons a partir dels nombres de vots
Joan Aranès Clua
http://www.xtec.cat/~jaranes
jaranes@xtec.cat
19/02/2002
  
Procediment:
El primer escó s'assigna al partit més votat, els altres s'assignen, pas a pas, 
al partit que li correspongui el valor més gran de la següent funció: vots[P]/(esc[P]+1)
aplicada en cada pas del repartiment a cada un dels partits {P} tenint en compte
el nombre de vots nominal.

Cas que a dos partits els correspongui el mateix valor per aquesta funció, l'escó
s'assigna al partit més votat; i, cas que els partits que tinguin el mateix valor
per a la funció vots[P]/(esc[P]+1 i també tinguin també el mateix nombre
de vots (cosa molt poc probable), l'assignació es fa per sorteig la primera vegada 
que es doni l'empat, i per a la resta d'empats, l'escó s'assigna alternativament.

Exemple:
Suposem tres partits: A, B i C amb els següents nombres de vots: 200, 100, 80
Es volen repartir 4 escons. Vegem, pas a pas el procés:

A				B			C    		escons ...
200/(1+0)=200 		100/(1+0)		80/(1+0)  	A ->1; B->0; C->0
200/(1+1)=100		100/(1+0)		80/(1+0)  	A-> 1+1=2; B->0; C->0  
200/(2+1)~67		100/(1+0)		80/(1+0)  	A-> 2; B->1; C->0  
200/(2+1)~67		100/(1+1)=50	80/(1+0)  	A-> 2; B->1; C->1  

En aquest cas, correspondrien dos escons a A, un a B i un a C 
*/

#include <stdio.h>
    #define N_ESC 20 // nombre d’escons
    #define N_PAR 30 // nombre de partits

    int nou_esc(int *, int *, int);

    void main(void){

        int ct;
        int esc[N_PAR]={0}; // esc{[N_ESC]= nomb. d’esc per partit
        int vots[N_PAR]; // vots[N_PAR]= nomb. de vots per partit
		int np,ne; //np = nombre de partits, ne = nombre d'escons

		printf("nombre de partits = ");
		scanf("%d", &np);
		printf("nombre d'escons = ");
		scanf("%d", &ne);


        printf("Tecleja el nombre de vots de cada partit.\n");

        for (ct=0; ct<np; ++ct) {
            printf("\nPartit %d: ", ct+1);
            scanf("%d", &vots[ct]);
        }

        for(ct=0; ct<ne; ++ct) esc[nou_esc(vots, esc, np)]++;
        for (ct=0; ct<np; ++ct)
        printf("\nEl partit %d ha obtingut %d escons.", ct+1,
                esc[ct]);
    }

     

    int nou_esc( int vots[], int esc[], int np) 
	{

        int imax=0, ct;
        int max=0;
		int maxvots=0;

		// nombre màxim de vots
        for (ct=0;ct<np;++ct)
		{if (maxvots<vots[ct]) maxvots=vots[ct];}

        for (ct=0; ct<np; ++ct) 
		{
			if( max<=(vots[ct]/(esc[ct]+1)) ) 
			{
				if (max<(vots[ct]/(esc[ct]+1)))
                {
					max=vots[ct]/(esc[ct]+1);
					imax=ct;
				}
				if (max==(vots[ct]/(esc[ct]+1)))
				{
					if (maxvots<vots[ct]) {imax=ct;}
				}								
            }
			
        }
        return imax;
    }

Comprobando las leyes de Morgan. Un ejercicio de programación en C/C++

//-----------------------------------------------------------------
//lleis de Morgan 
//
// Joan Aranès Clua
// data: 15/12/2001
// 
//Comprovació de lleis de Morgan per comparació de les taules de 
// veritat 
//(no (p i q)) equival a ((no p) o (no q))
//(no (p o q)) equival a ((no p) i (no q))
// 
//-----------------------------------------------------------------

#define V 1
#define F 0

#include <stdio.h>


void main()

{

    printf("1a llei de Morgan\n");
    printf("Taula de veritat de !(p||q) \n");
    printf("!(F||F) = %d\n",!(F ||F) );
    printf("!(F||V) = %d\n",!(F ||V) );
    printf("!(V||F) = %d\n",!(V ||F) );
    printf("!(V||V) = %d\n",!(V ||V) );

    printf("Taula de veritat de !p&&!q \n");
    printf("!F&&!F = %d\n",!F && !F );
    printf("!F&&!V = %d\n",!F && !V );
    printf("!V&&!F = %d\n",!V && !F );
    printf("!V&&!V = %d\n",!V && !V );
    
    printf("------------\n");    

    printf("2a llei de Morgan\n");
    printf("Taula de veritat de !(p&&q) \n");
    printf("!(F&&F) = %d\n",!(F && F));
    printf("!(F&&V) = %d\n",!(F && V) );
    printf("!(V&&F) = %d\n",!(V && F) );
    printf("!(V&&V) = %d\n",!(V && V) );

    printf("Taula de veritat de !p||!q \n");
    printf("!F||!F = %d\n",!F || !F );
    printf("!F||!V = %d\n",!F || !V );
    printf("!V||!F = %d\n",!V || !F );
    printf("!V||!V = %d\n",!V || !V );

}

Localización de una celda en un retículo rectangular. Un ejercicio sencillo de programación en C/C++

//-----------------------------------------------------------------
// Localització d'una cel.la en un rectangle 
//
// Joan Aranès Clua
// data: 15/12/2001
// 
// 
// Un rectangle està dividida en n files i m columnes. 
// Les files estan numerades des del 0 fins al (n-1) i les columnes 
// des del 0 fins al (m-1). 
// 
// Es tracta d'escriure un programa que, 
// donat un número p comprés entre 0 i (n x m)-1, 
// ens indiqui a quina fila i columna pertany aquest número. 
// Per exemple, si el rectangle està dividit en n = 4 files i 
// m = 5 columnes i escrivim p = 14, ha de respondre: 
// "fila 2, columna 4"
//-----------------------------------------------------------------


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

void main ()

{
  //declaració de les variables
  unsigned short int n,m;  // nombre de files i columnes que defineixen el rectangle
  unsigned short int p;    // variable d'entrada

    
  //definició del rectangle n files x m columnes
  printf("-----------------------------------\n");
  printf("Definiu un rectangle donant el nombre de files n i columnes m:\n");
  printf("separats per un espai\n");
  scanf("%u %u",&n, &m);
  
  
  //entrada d'un nombre p
  printf("-----------------------------------\n");
  printf("Entreu nombre p compr\x08As entre\n");
  printf("%u",0);
  printf(" i ");
  printf("%u\n",n*m-1);
  printf("p=");
  scanf("%u",&p);
  
 
 //ubicació de la cel.la
  printf("-----------------------------------\n");
  printf("fila = %u\n",int(p/m));
  printf("columna = %u\n",p%m);

}