[Rubiograna]

Hola a todos y gracias de antemano
Soy nuevo en el foro, mi nick es rubiograna y soy de españa
Llevo años colaborando en la federación española de culturismo, tenemos una forma peculiar de puntuar a nuestros competidores, y ahora que estoy intentando informatizar el sistema me surge una gran duda a la hora de resolver los empates con algún algoritmo, siempre lo hicimos a mano y necesito ayuda de formulación de algún matemático , si este es el lugar y el modo de pedir ayuda os ruego me lo hagáis saber y os planteo el problema
De nuevo, muchísimas gracias De antemano

[manooooh]

Hola Rubiograna, bienvenido al foro!!

Hola a todos y gracias de antemano
Soy nuevo en el foro, mi nick es rubiograna y soy de españa
Llevo años colaborando en la federación española de culturismo, tenemos una forma peculiar de puntuar a nuestros competidores, y ahora que estoy intentando informatizar el sistema me surge una gran duda a la hora de resolver los empates con algún algoritmo, siempre lo hicimos a mano y necesito ayuda de formulación de algún matemático , si este es el lugar y el modo de pedir ayuda os ruego me lo hagáis saber y os planteo el problema
De nuevo, muchísimas gracias De antemano

Diría que plantees el contexto del problema (qué programa querés emplear, si necesitás fórmulas, por qué es complicado resolver un empate, etcétera) y los problemas que surgen, para que las personas estén interesadas en intentar resolverlos.

Saludos

[Rubiograna]

Gracias!! Planteó la situación
Tenemos varios jueces, pueden ser 5,7,9,11 el número para la solución creo que es irrelevante
Y tenemos un número variable de competidores, que puede ir desde 2 hasta 15.
Cada juez otorga una puntuación que se corresponde con la plaza , es decir: si creo que eres el mejor te otorgo un 1, al siguiente un 2, etc...
Una vez sumadas las plazas otorgadas por cada juez Iara competidor, el orden se obtiene dando campeón al que menos puntos tiene(obvio) pero encontramos plazas de empate que coinciden en puntuación, como resolvemos nosotros?
Revisamos cada competidor, viendo cuál de ellos ha tenido mejores plazas en mayor cantidad, si tengo dos comoetidores igualados a puntos, veo cuál de ellos tiene más primeros puestos (más 1) si ambos tienen los mismos pues veo cuál tiene más segundos puestos (más 2) así hasta que uno de los tiene más de un número menor, y ese ganaría
Mi pregunta es que fórmula o algoritmo sería el correcto para usar en este caso.
Estamos programando en ruby in rails, por si sirve de ayuda, aunque creo que la fórmula sería la misma para cualquier lenguaje de programacion
De nuevo agradezco enormemente su ayuda.
Un saludo

[pierrot]

Hola,

Un algoritmo posible podría ser éste:

Entrada

m : cantidad de participantes
n : cantidad de jueces
puesto(i,j) : puesto que ocupa el participante i según el juez j (matriz mxn)

Salida

ganador_puesto(i) :
                    número del participante que salió en el lugar i en la competencia
                    de esta manera, ganador_puesto(1) es el que salió en primer lugar,
                    ganador_puesto(2) el que salió en segundo lugar, etc

Estructuras auxiliares

puntaje(i) : representa la suma de los puntos que obtuvo el participante i
nro_puestos(k, i) : número de puestos k que obtuvo el participante i (matriz nxm)

Funciones auxiliares

bool ganador(pos, i, j)
 if nro_puestos(pos, i) > nro_puestos(pos, j)
   return true
 else if nro_puestos(pos, i) == nro_puestos(pos, j)
   return ganador(pos-1, i, j)
 else
   return false
 end if
end

(Devuelve verdadero si el participante i tuvo más puestos pos que el participante j)

Inicialización

-puntaje(i) y nro_puestos(k,i) se inicializan con todos ceros.
-ganador_puesto(i) se inicializa con (1,2,...,m)

Algoritmo

for i=1..m
  for j=1..n
    puntaje(i) := puntaje(i) + puesto(i,j)
    nro_puestos(puesto(i,j), i) := nro_puestos(puesto(i,j), i) + 1
  end for
end for

Al final se ordenan los índices usando el algoritmo de la burbuja (podría usarse otro, pero dado que se manejan números chicos, no hay problemas de eficiencia):

for i=1..m
 for k=1..(m-i)
   if ( puntaje(k) > puntaje(k+1) || (puntaje(k) == puntaje(k+1) && ganador(1,k+1,k)) )
     intercambiar(ganador_puesto,k,k+1)
   end if
 end for
end for


Saludos

[Rubiograna]

Muchísimas gracias!! Voy a probarlo !! Os voy contando

[feriva]

Hola, Rubiograna.

Cada uno de los jueces o una persona encargada tendrá que meter los datos a mano mediante un input, ¿no?

Entonces, cada participante puede tener asociada una “string” o cadena mediante una variable.

Si un juez da un “1” a un participante, este se introduce mediante un “push” (o la orden que sea en ese lenguaje) por la  izquierda en la cadena correspondiente a la variable alfanumérica del participante. Y así sucesivamente lo hace cada juez.

Si después la cadena se convierte a “int”, a entero, pues lógicamente el número que tiene cifras más pequeñas (por la izquierda) también tiene el valor más pequeño; es menos cantidad 11123 que 11223.

Es decir, al evaluar el “int” de la cadena, esto nos da un voto de calidad añadido al voto de cantidad que supone sumar los dígitos (que sería en sí la suma de todos los votos de los jueces, la puntuación normal).

Pero hay una cuestión, que es que los participantes pueden llegar hasta 15 y nos faltan dígitos en base 10; no obstante, se podría hacer en hexadecimal, supongo.

Ah: supongo que ese lenguaje tendrá, como Python, una orden para ordenar los dígitos dentro de la cadena (o matriz que se puede convertir a cadena después). Porque, si son los jueces los que introducen los datos, no van a meter en orden las cifras más pequeñas

Es el número de jueces lo que da la cantidad de cifras en la cadena, no el número de participantes; me he despistado. Entonces dices que cómo máximo 11; quítale 1 y ya sirve en base diez. De esta forma al primero se la da 0 puntos, al segundo 1... Sigue funcionando igual porque los ceros a la izquierda no valen nada y, cuantos más ceros a la izquierda, más pequeño es el número, no cambia la mecánica.

Así que los jueces sin influyen; y también aunque lo programes de la forma larga (contando unos, doses... para cada participante). Influyen porque, aunque sería mucha casualidad, dos de ellos podría sacar exactamente el mismo número de unos, doses... y  entonces sólo se puede desempatar echando a suerte. Lo único que se puede hacer, para evitar eso, es aumentar el número de jueces, pero es muy improbable que dos saquen exactamente un mismo número de diez cifras, hay muchas variaciones con repetición.

 

Saludos.

[pierrot]

Muchísimas gracias!! Voy a probarlo !! Os voy contando

De nada. Aquí hay una errata:

Funciones auxiliares

bool ganador(pos, i, j)
 if nro_puestos(pos, i) > nro_puestos(pos, j)
   return true
 else if nro_puestos(pos, i) == nro_puestos(pos, j)
   return ganador(pos-1, i, j)
 else
   return false
 end if
end

O sea, si empataron, por ejemplo, en la cantidad de puestos 1 que tienen los participantes i y j, hay que desempatar fijándose en los puestos 2, no puestos 0. Es decir, lo correcto en esa línea es:


bool ganador(pos, i, j)
 if nro_puestos(pos, i) > nro_puestos(pos, j)
   return true
 else if nro_puestos(pos, i) == nro_puestos(pos, j)
   return ganador(pos+1, i, j)
 else
   return false
 end if
end


Algo que habría que preguntarse también es si no existe la posibilidad de que empaten absolutamente en todo; en ese caso, se accedería a un índice fuera de rango en la matriz nro_puestos (por ejemplo, si esto estuviese implementado en C, ocurriría una violación de segmento). Para evitarlo, puedes tomar por convención que si empatan absolutamente en todo, doy por ganador al i. Quedaría así:


bool ganador(pos, i, j)

 if pos==m+1
   return true

 if nro_puestos(pos, i) > nro_puestos(pos, j)
   return true
 else if nro_puestos(pos, i) == nro_puestos(pos, j)
   return ganador(pos+1, i, j)
 else
   return false
 end if

end


De esta manera, se evita que en algún caso ocurra un fallo.

Saludos.

[sugata]

Pierrot, no pueden empatar a todo, son jueces impares.

[pierrot]

Pierrot, no pueden empatar a todo, son jueces impares.

En mi modelo abstracto yo no hice ninguna restricción sobre \( m \) y \( n \) (aparte de que sean no nulos).

[feriva]

no pueden empatar a todo, son jueces impares.

Depende de la paridad de jueces unida a la de participantes, Sugata.

Si fueran, por ejemplo, dos participantes y tres jueces, un ejemplo sería éste:

Participantes A y B.

El “juez uno” da 1 punto a A y 2 puntos a B.

El “juez dos” le da 2 puntos a A y 1 puntos a B.

El “juez” tres le da 1 punto a A y 2 puntos a B.

El participante A obtiene 1+2+1=4

El participante B obtiene 2+1+2=5

Aquí, por ejemplo, no pueden empatar ni por cómputo total si quiera, si no me equivoco.

Pero si fueran tres jueces y tres participantes, podría ser:

El “juez uno”  1 punto a A,  2 puntos a B y 3 a C.

El “juez dos”  2 punto a A,  3 puntos a B y 1 a C.

El “juez tres”  3 punto a A,  1 puntos a B y 2 a C.

Y, si sumas columnas, los tres obtienen la misma cantidad y la misma puntuación particular 1+2+3.

Saludos.