¿Cuántos Wazirs se pueden colocar en un tablero de ajedrez N × N?

30

Supongamos que una nueva pieza de ajedrez de hadas llamada Wazir se introduce al ajedrez. Los Wazirs pueden moverse desde una posición ( x , y ) a:
 ( x +1, y )
 ( x , y +1)
 ( x -1, y )
 ( x , y -1)

Es decir, se mueven ortogonalmente como la torre, pero solo un paso a la vez como el rey. ¿Cuántos wazirs se pueden colocar en un tablero de ajedrez N × N para que no puedan atacarse dos wazirs?

 En un tablero 1 × 1, solo puede haber 1 pieza de este tipo.
 En un tablero de 2 × 2, puede haber 2 de esas piezas.
 En un tablero de 3 × 3, puede haber 5 de esas piezas.

Dado N, devuelve el número de wazirs que se pueden colocar en un tablero de ajedrez N × N.

Esta es la secuencia OEIS A000982 .

Más casos de prueba

7 → 25

8 → 32

100 → 5000

code-golf  number  chess 
— Sasha R
fuente
44
Entonces, ¿el camello es para la torre lo que el rey es para la reina? Es decir, solo puede moverse ortogonalmente, y solo un paso a la vez.
— Adám
2
@SashaR ¿Puedo reescribir su pregunta como un desafío de golf de código adecuado?
— Adám
2
¡Seguro! De esa manera también puedo ver cómo redactar preguntas relacionadas con la codificación en el futuro
— Sasha R
15
Como nuevo usuario de este sitio, has tenido mucha suerte esta vez. Muchas preguntas de programación (fuera de tema) en este sitio han sido cerradas y rechazadas permanentemente, no editadas como un desafío y votadas como esta. Como ya explicaron otras personas, este sitio es solo para competencias de programación, no para pedir tarea. Puede usar el sandbox (en codegolf.meta.stackexchange.com/questions/2140/… ) antes de publicar un desafío para evitar errores comunes la próxima vez; y tenga en cuenta que la mayoría de los usuarios en este sitio, como ha visto, usan idiomas "ilegibles".
— user202729
16
Esta pregunta es bastante confusa ya que Camel ya es el nombre estándar del ajedrez de hadas para una pieza como un caballero que hace saltos más largos y la pieza que describe ya tiene un nombre de ajedrez de hadas: Wazir .
— Mark S.

Respuestas:

33

Espacio en blanco , 45 bytes

Pruébalo en línea!

Por cierto, aquí hay una prueba de que la fórmula ⌈n² / 2⌉ es correcta.

  • Siempre podemos colocar al menos zn² / 2⌉ wazirs : ¡solo colóquelos en un patrón de tablero de ajedrez! Suponiendo que el mosaico superior izquierdo es blanco, hay ⌈n² / 2⌉ mosaicos blancos y ⌊n² / 2⌋ mosaicos negros en el tablero n × n . Y si colocamos wazirs en las baldosas blancas, no hay dos atacando entre sí, ya que cada wazir solo "ve" las baldosas negras.

    Así es como colocamos 13 wazirs en un tablero de 5 × 5 (cada W es un wazir).

    　　　　　　　　　　13 wazirs en un tablero de 5 × 5

  • No podemos hacer nada mejor : mezclemos arbitrariamente el tablero de ajedrez con piezas de dominó de 2 × 1, opcionalmente usando una pieza de 1 × 1 para la esquina final de un tablero de ajedrez de longitud impar, así:

    　　　　　　　　　　cubierta de dominó de una tabla de 5 × 5

    Necesitamos fichas de dominó ⌈n² / 2⌉ para cubrir el tablero de ajedrez. ¡Claramente, poner dos wazirs en un dominó hace que puedan atacarse unos a otros! Así que cada dominó sólo puede contener como máximo un visir, lo que significa que no podemos posiblemente colocar más de ⌈n² / 2⌉ visires en el tablero.

— Lynn
fuente
No necesitas el principio del casillero para la última parte: tienes exactamente ⌉n² / 2⌉ fichas y, como máximo, camello por ficha, así que tienes como máximo ⌈n² / 2⌉ camellos.
— ShreevatsaR
8
@ShreevatsaR ¿Qué te asegura que no puedes poner x> ⌈n² / 2⌉ camellos en fichas ⌈n² / 2⌉? Es el principio del casillero ...
— frarugi87
2
Al principio pensé que el código no se cargaba, así que actualicé la página y todavía no. Entonces me di cuenta de qué nombre de idioma estaba escrito en la parte superior.
— Arthur
77
Aprecio que fuiste y cambiaste tu C's W' en tu ilustración de prueba.
— Giuseppe
44
También aprecio que las W están en los ESPACIOS BLANCOS con una respuesta en WHITESPACE.
— corsiKa
9

APL (Dyalog) , 9 7 6 bytes

Ahora usa la fórmula del Sr. Xcoder.

Esta es una función tácita de prefijo anónimo que toma N como argumento.

⌈2÷⍨×⍨

Pruébalo en línea!

×⍨ cuadrado N (literalmente, multiplicación selfie, es decir, multiplicar por sí mismo)

2÷⍨ dividir por 2

⌈ techo (redondeado)

— Adán
fuente
¡Wow! ¡No tengo idea de cómo hiciste esto! No entendí la lógica aunque suspiré
— Sasha R
Maldición, alguien ya descubrió el patrón.
— Feathercrown
1
Huh, me acabo de dar cuenta de que la fórmula está en la página OEIS. Probablemente no debería haber vinculado eso.
— Feathercrown
6

dc , 6 bytes

2^2~+p

2^: cuadrado; 2~: dividir por 2, empujando el cociente y luego el resto; +p: agrega el resto al cociente e imprime.

Pruébalo en línea!

— brhfl
fuente
5

C (gcc) , 23 18 17 bytes

  • Salvó un byte gracias a Tahg ; golf n/2+n%2a n+1>>1.
f(n){n=n*n+1>>1;}

Pruébalo en línea!

C (gcc) , 22 bytes (sin usar comportamiento indefinido)

f(n){return n*n+1>>1;}

Pruébalo en línea!

A algunas personas realmente no les gusta explotar el comportamiento indefinido de cierto compilador cuando se usan indicadores específicos del compilador. Sin embargo, hacerlo ahorra bytes.

— Jonathan Frech
fuente
3
Una forma extraña de proporcionar una respuesta IMO, pero: f (n) {n = n * n + 1 >> 1;} para guardar un byte.
— Tahg
1
@Tahg Gracias; aunque, ¿de qué manera mi respuesta es extraña?
— Jonathan Frech
2
No pensé que cambiar el argumento de entrada era una forma normal de devolver un valor en C.
— Tahg
2
@YSC Sin embargo, en opinión del compilador, es comprensible y crea un ejecutable que funciona.
— Jonathan Frech
55
@YSC Creemos aquí en PPCG que, si el programa funciona con un solo intérprete, es una presentación válida. Funciona en un intérprete en línea, por lo tanto, es válido sin más comentarios.
— Conor O'Brien
4

Python 3 , 19 bytes

lambda x:-(-x*x//2)

Pruébalo en línea!

lambda x:-(-x*x//2)  # Unnamed function
lambda x:            # Given input x:
            x*x      # Square
           -         # Negate
               //2   # Halve and Floor (equivalent of Ceil)
         -(       )  # Negate again (floor -> ceil)

-1 byte gracias al Sr. Xcoder

— Hiperneutrino
fuente
x**2->x*x
— Sr. Xcoder
@ Mr.Xcoder Facepalm gracias
— HyperNeutrino
¿Qué hay de lambda x:x*x+1>>1?
— Alix Eisenhardt
O lambda x:x*x+1//2 descargo de responsabilidad: no sé la sintaxis ni el orden de operaciones de este idioma, así que supuse; Estoy diciendo que agregue 1 antes que usted en //2 lugar de negar dos veces.
— Dan Henderson
@DanHenderson Todavía necesita paréntesis, de lo contrario, se analiza como (x*x) + (1//2), por lo que en realidad no es más corto.
— Skyler
4

lenguaje de máquina x86_64 (Linux), 9 8 bytes

0:       97                      xchg   %eax,%edi
1:       f7 e8                   imul   %eax
3:       ff c0                   inc    %eax
5:       d1 f8                   sar    %eax
7:       c3                      retq

Para probarlo en línea! , compila y ejecuta el siguiente programa en C.

#include<stdio.h>
const char *f="\x97\xf7\xe8\xff\xc0\xd1\xf8\xc3";
int main() {
  for(int i=1; i<10; i++) {
    printf("%d\n", ((int(*)())f)(i));
  }
}
— techo
fuente
3

J , 8 bytes

Función de prefijo tácito anónimo.

2>.@%~*:

Pruébalo en línea!

*: cuadrado

>. techo (redondear)
@ después de
2... %~ dividir por dos

— Adán
fuente
Soluciones alternativas: <.@-:@*:y*:<.@%2:
— Conor O'Brien
2
@ ConorO'Brien‽ 2>.@%~*:¿De dónde saqué eso? No puedo leer eso, me parece ruido de línea ...
— Adám el
>.@-:@*:consigue mi voto
— Jonás
1
@ Jonás Si entrecierras los ojos, puedes ver un camello.
— Adám
3

R , 22 21 bytes

cat((scan()^2+1)%/%2)

Pruébalo en línea!

Cuadrado, incremento, división entera. Pan comido.

Entrada de stdin; puede ocupar espacio o entrada separada por nueva línea y calculará el máximo de wazirs para cada tamaño de tablero de entrada. Salida a stdout.

-1 byte gracias a plannapus

— Giuseppe
fuente
@plannapus arreglado, gracias.
— Giuseppe
2

Cubix , 11 bytes

Iu*:^\)2,O@

Jeje :^\)

Pruébalo en línea!

Se expande al siguiente cubo:

    I u
    * :
^ \ ) 2 , O @ .
. . . . . . . .
    . .
    . .

Cuál es el mismo algoritmo que muchos usan.

  • ^Iu : leer en la entrada como int y cambiar direcciones
  • :* : dup top de la pila, multiplicar
  • \) : cambio de dirección, incremento
  • 2, : empuje 2, división entera
  • O@ : imprime la salida como int, finaliza el programa.
— Giuseppe
fuente
1

Japt , 4 bytes

He estado sentado en estos desde que se cerró el desafío.

²Ä z

Intentalo

Explicación: Cuadrado, suma 1, piso dividido por 2

Alternativa

²ÄÁ1

Intentalo

Explicación: Square, add 1, bit-shift right by 1.

— Lanudo
fuente
1

Comentarista , 19 bytes

//{-//-}! {-#  -}<!

Pruébalo en línea!

¿Quién necesita idiomas de golf? ¡Tengo idiomas confusos!

Versión sin golf:

5//{-8}//{5-}
print(10!= 5)
x={-1,3,4} # Smiley :-}
print(5<!=10)*/ # Weird comparision.

Pruébalo en línea!

¿Como funciona? Explicaré, con la entrada 5

//                         - Take input.                           Tape: [5 0 0]
  {-//-}!                  - Square the input.                     Tape: [25 0 0]
  {-                         - Move one along the tape
    //                       - Copy the input to the tape.         Tape: [5 5 0]
      -}                     - Move one back along the tape
        !                    - Take the product of the tape.       Tape: [25 5 0]
         <space>           - Increment the tape head.              Tape: [26 5 0]
                 {-#  -}<! - Halve the tape head (floor division). Tape: [13 2 0]
                 {-          - Move one along the tape
                   #         - Set the tape head to 2.             Tape: [26 2 0]
                      -}     - Move one back along the tape
                        <!   - Reduce the tape by floor division.  Tape: [13 2 0]
— caird coinheringaahing
fuente
1

OCaml , 19 bytes

let f n=(n*n+1)/2;;

Pruébalo en línea!

Estoy un poco molesto porque el nombre cambió de "camellos" a "wazirs" antes de que pudiera escribir esto, pero pensé que lo publicaría de todos modos.

— Giuseppe
fuente
1

TI-Basic, 7 bytes

round(Ans²/2,0

Alternativamente (8 bytes):

int(Ans²/2+.5
— Timtech
fuente
-int(-.5Ans²también funciona
— Oki
@Oki Seguro que sí. Solo desearía que tuvieran una ceil(función.
— Timtech
1

/// , 35 bytes

/I///,*/+,//+/I//**,/,A//*/A//,//,I

Pruébalo en línea!

Toma la entrada en unario usando el símbolo *, y la salida en unario usando el símbolo A. Esto está permitido para algunos idiomas específicos, incluido /// ( meta )

Debido a que no hay forma de tomar entrada en ///, la entrada debe estar codificada:

/I/«put input here»//,*/+,//+/I//**,/,A//*/A//,//,I

para input = 4.

Explicación: (antes de leer, debe saber que la única sintaxis de ///are /pattern/replacement/, que reemplaza cada aparición de patternby replacement; y \para escapar; otros caracteres se imprimen en la salida)

Para n=4:

/I/****//,*/+,//+/I//**,/,A//*/A//,//,I    Start program.
/I/****/                                   Replace all `I` in the program by the input.

/,*/+,//+/****//**,/,A//*/A//,//,****      Remaining part of the program.
/,*/+,/                                    Use the `,` as a scanner, scan through `*` after it and convert to `+`.
       /+/****//**,/,A//*/A//,//++++,      Note that only `*` in the second group is affected.
       /+/****/                            Replace all `+` (which is just created) by `n` asterisks (from the first `I` group)

/**,/,A//*/A//,//****************,         Now at the last of the program before the `,` there are `n²` asterisks.
/**,/,A/                                   Scan the `,` to the left to perform division by 2:
                                           replace each `**` by a `A` as the scanner `,` pass through.
/*/A//,//,AAAAAAAA                         Remaining program.
/*/A/                                      If there is any `*` remaining (if `n²` is odd), replace it with `A`.
     /,//                                  Remove the scanner `,`.
          AAAAAAAA                         Output the result.
— usuario202729
fuente
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.