Digital Roulette
John is developing a videogame that allows players to bet in a wall roulette. Players may bet for integer numbers
from 0 to N, for some N| Digital Roulette |
Of course, the roulette behaves digitally. As a matter of fact, John designed its way to choose a value in the interval 0..N (the result of spinning the roulette) with a digital trigger that moves the roulette with a force that depends on an integer value x randomly chosen in the interval 0..M, where M
It is clear that some result values may be produced by different chosen force values. Also, depending on the mechanism parameters, some numbers in the roulette may be not attainable regardless of the force value. For example, if N = 7, M = 5 and P(x) = x2 + 1, the mechanism can generate only three different results:
John wants to know how many different result values may be attained by his mechanism. Can you help him?
Input
There are several cases to analyze. Each case is described by three lines:- The first line contains two non-negative integer numbers N and M, separated by a blank (
1
N
107, 0
M
105).
- The second line contains an integer k, the grad of the polynomial P (
0
k
10).
- The third line contains k + 1 integers
a0, a1,..., ak separated by blanks, indicating the integer coefficients
that define the polynomial P, i.e.,
P(x) = akxk + ... + a1x + a0. You can assume that
0
ai
N for each 0
i
k. If k > 0 then you may assume that ak
0.
Output
For each case, print one line indicating how many different numbers are attainable by John's mechanism.Sample Input
7 5 2 1 0 1 99 10 0 5 99 10 1 5 25 99 10 1 3 29 99 10 2 3 29 31 0 0
Sample Output
3 1 4 11 10
Intenté usar las tags pre y code, pero no me deja, por favor quien tenga la cuenta administrativa de este blog cheque si es posible permitirlo.
ResponderEliminarRoberto
Les mando un pseudocódigo que hice rápidamente, podría tener errores, luego lo checo con más detalle
ResponderEliminar-------------
int N =0
int M
int a00 =0
...
int a10 =0
leer N, M, a00, ... , a10
while ( N!= 0) {
int contador_obtenidos = 0
// esta variable indica la cantidad de tiros diferentes que se han obtenido
obtenidos es un array de N booleanos inicializados en FALSE
// este arreglo registra los tiros que se han obtenido al menos una vez
int x = 0
while (contador_obtenidos <N && x <= M) {
tiro = mod(polinomio(x,&a00,...,&a10),N)
if (obtenidos(tiro) == FALSE) {
obtenidos(tiro) = TRUE
contador_obtenidos++
}
x++
}
imprimir contador_obtenidos
N=0
leer N, M, a00, ... , a10
}
int function polinomio(x, &a00, ..., &a10) {
int p
p = a0 + a1*x + ... + a10*x10
return p
}
este pseudocódigo que les puse está hecho bajo una idea de fuerza bruta, tal vez existan maneras más elegantes.
ResponderEliminarEl uva acepto ese código? dudo mucho pues si calculan el polinomio de la funtion polinomio de manera anidada eso lo haría tantito más rapido... Por guapa subiremos unas notitas basicas de la definición de algoritmo "más elegante" que hemos visto.
ResponderEliminarno he escrito el código, lo que publiqué aquí es solamente un bosquejo
ResponderEliminarhay que ver que pasa pero siennnto que tendremos que usar ese algoritmo que habla sobre x`b congruente con a (mod c), con b corriendo... si hay que revisar bien este problema
ResponderEliminar