Skip to content

Fichas de ajedrez

by en 04/11/2013

¡Estamos de vuelta!

Os prometimos antes del verano que volveríamos con más acertijos tras él y, aunque con un poco de retraso, volvemos a la carga 🙂 Para los que os sigáis ahora por primera vez, os recordamos que la filosofía de este blog es proponeros acertijos que, aunque puedan resolverse con lápiz y papel, también se puedan programar. Y… ¡no sólo eso! Si los programáis, podréis probar vuestras soluciones. Pero eso será el domingo 😉 De momento, vamos con el acertijo…

Una tarde de las ya lejanas y calurosas vacaciones, decidimos entretenernos durante la hora de la digestión debajo de una sombrilla, jugando una tranquila partida de ajedrez. Al acabar, terminamos jugueteando con las fichas sobre el tablero y nos preguntamos cuál sería el máximo número de torres que podríamos colocar sobre él sin que se atacaran unas a las otras.

No tardamos mucho en dar con la respuesta. Como las torres “comen” en vertical y en horizontal, cada una afecta a toda su fila y toda su columna, impidiendo poder poner más torres en ellas:

Escaques atacados por una torre en un tablero de ajedrez

Por tanto, dado que sólo se puede poner una torre en cada una de las 8 filas (o de las 8 columnas) el número máximo de torres que podemos poner es 8. Si en lugar de tener un tablero de 8×8 tuviéramos un tablero de NxM habría que tener un poco de cuidado, porque tendríamos que quedarnos con el menor de los dos números. Por ejemplo, si el tablero fuera de 10 filas y de 7 columnas, el número máximo de torres sería de 7, quedando 3 filas “libres”.

Luego nos preguntamos cuántas reinas podríamos poner. Ésta resulta ser una pregunta muy famosa en el mundo de la informática, y se la conoce como el problema de las 8 reinas. Sin embargo, llegamos a la conclusión de que el número de reinas que se pueden colocar es el mismo que el número de torres; la única diferencia es que colocarlas ahora es mucho más difícil, porque hay que tener cuidado con la posibilidad de que las reinas coman en diagonal (conseguir esa disposición es precisamente lo que busca el problema de las 8 reinas mencionado).

Como no podía ser de otra forma, luego seguimos con el rey, y con los caballos. Pero la hora de la digestión terminó, nos entró calor y nos fuimos a dar un chapuzón… de modo que no llegamos a obtener una respuesta… Y ahí es donde entráis vosotros :-). En un tablero de 8×8, ¿cuántos caballos se pueden poner en total sin que ninguno ataque a otro? ¿Y cuántos reyes? ¿Y si el tablero es de 6×7? ¿Y de 5×5?

¡Echadnos una mano poniendo vuestras soluciones en los comentarios!

¡Hasta el domingo!

Anuncios

From → Fáciles, Problemas

4 comentarios
  1. David permalink


    >>> def caballos(x, y):
    ... return int(max(x, y) * math.ceil(min(x, y) / 3.0))
    ...
    >>> def reyes(x, y):
    ... return ((x + 1) / 2) * ((y + 1) / 2)
    ...

    >>> caballos(8, 8)
    24
    >>> reyes(8, 8)
    16
    >>> caballos(6, 7)
    14
    >>> reyes(6,7)
    12
    >>> caballos(5, 5)
    10
    >>> reyes(5, 5)
    9

    Espero no haberme equivocado. =/
    Salu2 =)

  2. Borja permalink

    Para el caso de los caballos:
    Los caballos siempre atacan una casilla de diferente color a la que ocupan, con lo que el número máximo de ellos que se pueden colocar en un tablero sin que se ataquen. Ello quiere decir que podemos colocar NxM/2 (redondeando al alza si el resultado no es un entero).
    Tablero 8×8: 32 caballos
    Tablero 6×7: 21 caballos
    Tablero 5×5: 13 caballos
    Para el caso de los reyes todavía no tengo un sistema, en cuanto lo tenga (si lo consigo) lo publico. Un saludo

    • Borja permalink

      Corrección de error: …con lo que el número máximo de ellos que se pueden colocar en un tablero de ajedrez sin que se ataquen SERÁ IGUAL AL NUMERO MAXIMO DE CASILLAS DE UN MISMO COLOR.

  3. Caballo:
    #include

    #define X 9
    #define Y 9

    int main(int argc, char **argv)
    {
    if(X==Y && X%2==0 && Y%2==0) std::cout << X*Y/2;
    else std:cout << (X*Y/2)+1;
    }

    Rey:
    (lo mismo que antes pero dentro del main)
    int resultat=0;

    if(X==Y) for(int i=1; i<=X; i+=2) resultat = resultat+i;

    Para hacerlo que el Rey sea de tablas variables (8×7, 6×8, etc.) hay que contar con lo siguiente:
    La posicion de la tabla[X][Y] tiene el mismo valor que tabla[Y][X].

    Si os haceis una tabla en un papel des de X=1 y X=1 hasta X=7 y Y=7 lo pillais a la primera.

    Ademas, podeis saber hasta como hacer la formula.

    En el codigo:
    (defines y el include el mismo que arriba)

    int operador;
    int temp;
    int resultat;

    if( X<Y) temp=Y;
    else temp=X;

    if(temp % 2 != 0) temp++

    for(int i=1; i<=temp/2;i++) operador=i;

    if( X<Y) temp=X;
    else temp=Y;

    if(temp % 2 != 0) temp++

    for(int i=1; i<=temp/2;i++) resultat=resultat+operador;

    std::cout << resultat;

    Saludos

Responder

Introduce tus datos o haz clic en un icono para iniciar sesión:

Logo de WordPress.com

Estás comentando usando tu cuenta de WordPress.com. Cerrar sesión / Cambiar )

Imagen de Twitter

Estás comentando usando tu cuenta de Twitter. Cerrar sesión / Cambiar )

Foto de Facebook

Estás comentando usando tu cuenta de Facebook. Cerrar sesión / Cambiar )

Google+ photo

Estás comentando usando tu cuenta de Google+. Cerrar sesión / Cambiar )

Conectando a %s

A %d blogueros les gusta esto: