Introducción

Un tablero de damas normal contiene 8 x 8 = 64 cuadrados:

Puedes ver que en total, hay 12 piezas blancas . Blanco y negro siempre tienen la misma cantidad de piezas. Si hay más piezas en el tablero, las piezas serían vecinas, lo que no está permitido para este desafío. Para aclarar las cosas, aquí hay algunos ejemplos:

La tabla más pequeña posible para este desafío es 3 x 3 :

Puedes ver que la cantidad máxima de piezas es igual a 2 . Entonces, cuando se le da N = 3 , necesita dar salida a 2 . Si la entrada es N = 4 , obtenemos lo siguiente:

Puede ver que la cantidad máxima también es 2. Entonces, para N = 4 , la salida debe ser 2 . Para N = 5 , la salida debe ser igual a 5 :

Ejemplos

STDIN:  3
STDOUT: 2

STDIN:  4
STDOUT: 2

STDIN:  5
STDOUT: 5

STDIN:  6
STDOUT: 6

STDIN:  8
STDOUT: 12

Reglas

• Su envío debe ser un programa o función, etc. que tome un número entero y genere o devuelva el número de piezas en el tablero
• Puede suponer con seguridad que la entrada es un entero no negativo> 2
• Este es el código de golf , por lo que gana el programa con la menor cantidad de bytes.
• Tenga en cuenta que el cuadrado en la parte inferior izquierda del tablero siempre está oscuro. Las piezas solo se colocan en cuadrados oscuros
• Tienes que ocupar una fila completa con piezas

Par , 8 bytes

✶″½↓┐*½┐

Se usa un byte por carácter.

Explicación

               ## [implicit: read line]      Example
✶              ## Convert to number           7
″              ## Duplicate                   7 7
½              ## Divide by two               7 3.5    half the board
↓              ## Minus one                   7 2.5    leave one row empty
┐              ## Ceiling                     7 3      a whole number of rows
*              ## Multiply                    21       total number of spaces
½              ## Divide by two               10.5     only the blue squares
┐              ## Ceiling                     11       starts with blue, so round up

Hexagonía , 19 bytes.

?({{&2'2':{):!/)'*/

Pruébalo en línea.

Explicación

Este sigue siendo el mismo cálculo que he usado en mis respuestas de CJam y Labyrinth, pero debido al modelo de memoria ... especial ... de Hexagony, es un poco más complicado exprimir el cálculo en 19 bytes (para que quepa dentro de un longitud lateral 3 hexágono).

Al igual que mi respuesta Labyrinth, esto termina con un error de división por 0.

Aquí está el código desplegado:

Como dije, el código es completamente lineal. Puede juntar la ruta ejecutada en orden gris-púrpura-verde-rojo-azul. El camino en realidad continúa un poco más hasta que llega :a la izquierda. Al eliminar el /(que solo redirige el flujo de control), todo el programa desenrollado linealmente es:

?({2':{)'*){&2':!:&?':

Entonces la pregunta es cómo funciona. La memoria de Hexagony es el gráfico lineal de una cuadrícula hexadecimal, donde cada borde de la cuadrícula contiene un valor entero (inicialmente cero). El puntero de memoria (MP) siempre está en un borde y apunta en una dirección determinada a lo largo de ese borde. Las operaciones aritméticas se aplican generalmente a los dos bordes puntiagudos en y almacenados en el borde de la MP está encendido.

Para este programa, usaremos los tres bordes etiquetados A , B , C , con el MP comenzando como se muestra aquí:

Así es como funciona esto:

?  Read an integer N from STDIN into edge A.
(  Decrement to get N-1.
{  Move the MP forwards onto edge B.
2  Set the edge to 2.
'  Move the MP backwards onto edge C.
:  Divide edge A by edge B (rounding down) to compute (N-1)/2.
{  Move the MP forwards onto edge A.
)  Increment to restore value of N.
'  Move the MP backwards onto edge B.
*  Multiply edges A and C to compute N*(N-1)/2.
)  Increment to compute N*(N-1)/2 + 1.
{  Move the MP forwards onto edge C.
&  This actually a copy operation, but we use it to reset the edge to zero.
2  Set the edge to 2.
'  Move the MP backwards onto edge A.
:  Divide edge B by edge C to compute (N*(N-1)/2 + 1)/2.
!  Output the result as an integer. We're basically done now.
:  no-op (we already have this value)
&  Copy either B or C into A (doesn't matter).
?  Read a zero (EOF) into A.
'  Move the MP backwards onto an unused cell.
:  Divide some unused cell by A (which is zero), terminating with an error.

LabVIEW, 28 20 Primitivas de LabVIEW

CJam, 10 bytes

ri_(2/*)2/

Pruébalo aquí.

Explicación

ri   e# Read input and convert to integer N.
_    e# Duplicate N.
(2/  e# Decrement, integer divide by two, to determine the number of rows that can be used.
*    e# Multiply by the input to determine the number of cells that can be used.
)2/  e# Increment, integer divide by two, which essentially ceil()s the result of the
     e# division.

Laberinto , 11 bytes

Woohoo, solo un byte detrás de CJam .

?:(#/*)_2/!

Pruébalo en línea.

Es esencialmente lo mismo:

? reads an integer value.
: duplicates the result.
( decrements it.
# pushes the stack depth which happens to be 2.
/ is integer division.
* is multiplication.
) increments the result.
_ pushes a 0.
2 turns it into a 2.
/ is once again integer division.
! prints the result as an integer.

Sin embargo, en este punto el programa aún no termina. En cambio, el puntero de instrucciones ha llegado a un callejón sin salida y se da vuelta. Pero ahora /intenta calcular 0/0cuál termina con un error .

En serio , 8 bytes

,;D½L*½K

En serio tiene a la mano ½ (flotante dividido por 2) y K(techo), por lo que no necesitamos agregar uno antes de la división.

Pruébalo aquí con una explicación.

Python 2, 22 21 bytes

lambda n:~-n/2*n+1>>1

Primero me separo en dos casos, N impar e incluso N.

Con N impar podemos llenar (N - 1) / 2 filas, que contienen en promedio N / 2 piezas. Como la primera fila siempre tiene más piezas, debemos limitar este resultado. Entonces, cuando N es impar, tenemos piezas ceil ((N-1) / 2 * N / 2).

Incluso con N podemos llenar N / 2 - 1, o piso ((N - 1) / 2) filas, cada fila contiene N / 2 piezas.

Podemos combinar estas dos expresiones por ceil (floor ((N-1) / 2) * N / 2). Desde ceil (x / 2) = floor ((x + 1) / 2) podemos utilizar el suelo de división: ((N - 1) // 2 * N + 1) // 2.

JavaScript, 37 35 bytes

alert(((n=prompt()/2)-.5|0)*n+.5|0)

Explicación

Utiliza una técnica similar al resto de las respuestas. Este es el algoritmo no golfista:

var n = parseInt(prompt());
var result = Math.ceil(Math.floor((n - 1) / 2) * n / 2);
alert(result);

dc, 12

?d1-2/*1+2/p

Prueba de salida:

$ for t in 3 4 5 6 8; do echo $t | dc -e?d1-2/*1+2/p; done
2
2
5
6
12
$ 

Pyth, 9 bytes

/h*/tQ2Q2

Mismo algoritmo que mi respuesta de Python 2.

Japt , 16 14 bytes

U-1>>1 *U+1>>1

Pruébalo en línea!

Cómo funciona

Bastante simple:

         // Implicit: U = input number
U-1>>1   // Subtract 1 from U and integer divide by 2.
*U+1>>1  // Multiply the result by U, add 1, and integer divide by 2.
         // Implicit: output last expression

Desearía que hubiera alguna forma de tener en cuenta que las dos mitades del código son tan similares. Sugerencias bienvenidas!

Versión anterior (16 bytes):

U*½-½|0 *U*½+½|0

Java, 230 155 52

Golfizado:

int f(int s){return(int)Math.ceil(s*((s-1)/2)/2.0);}

Sin golf:

public class NumberOfPiecesOnACheckersBoard {

  public static void main(String[] args) {
    // @formatter:off
    int[][] testData = new int[][] {
      {3, 2},
      {4, 2},
      {5, 5},
      {6, 6},
      {8, 12}
    };
    // @formatter:on

    for (int[] data : testData) {
      System.out.println("Input: " + data[0]);
      System.out.println("Expected: " + data[1]);
      System.out.print("Actual:   ");
      System.out.println(new NumberOfPiecesOnACheckersBoard().f(data[0]));
      System.out.println();
    }
  }

  // Begin golf
  int f(int s) {
    return (int) Math.ceil(s * ((s - 1) / 2) / 2.0);
  }
  // End golf

}

Salida del programa:

Input: 3
Expected: 2
Actual:   2

Input: 4
Expected: 2
Actual:   2

Input: 5
Expected: 5
Actual:   5

Input: 6
Expected: 6
Actual:   6

Input: 8
Expected: 12
Actual:   12

Código máquina Zilog ez80, 9 bytes

En hexadecimal:

6C 2D CB3D ED6C 2C CB3D

En asamblea:

ld l,h
dec l
srl l
mlt hl
inc l
srl l

La entrada está en el registro hy la salida está enl .

El Zilog ez80 es un procesador de 8 bits con un acumulador de 8 bits y registros de 24 bits. A diferencia del z80, tiene unmlt instrucción (multiplicación de 8 bits) que, en modo de 16 bits, multiplica los bytes alto y bajo de un par de registros, aquí hl, y se almacena de nuevo enhl .

Esto solo funciona para valores para los cuales el doble del resultado cabe en 8 bits; es decir, n≤23.

TI-BASIC, 13 bytes

⁻int(⁻.5Ansint(Ans/2-.5

La multiplicación implícita de TI-BASIC ayuda, pero no tiene división entera. ⁻int(⁻Xes una forma más corta de techo (x).

vba, 46

Function f(x)
f=(((x-1)\2)*x+1)\2
End Function

Llame con? F (x), o = f (A1) en una fórmula

Pyth, 17 14 13 bytes

-3 bytes gracias a Ypnypn ! Reorganizó los números del operador * para guardar 1 byte.

/+*Q-/Q2-1%Q2 1 2 (original)
/h*Q-/Q2!%Q2 2
/h*-/Q2!%Q2Q2

Explicación:

Cuando n es par, podemos ocupar n / 2-1 filas con n / 2 piezas, haciendo un total de n * (n / 2-1) / 2 piezas. Esta expresión es equivalente a (n * (n / 2-1) +1) / 2

Cuando n es impar, podemos encontrar cómo se vería el doble del número de piezas, el doble del número de piezas abarcará n-1 filas, y si quito una pieza, podemos dividir las n-1 filas en (n- 1) / 2 grupos de 2 filas de modo que cada grupo tenga n piezas, por lo que la expresión para este caso es (n * (n / 2) +1) / 2

Ahora que ambas expresiones son bastante similares, podemos escribir el código.

/h*-/Q2!%Q2Q2
        %Q2   Check if the number is odd
       !      Logical not to make 1 if even and 0 if odd
    /Q2       n/2
   -          n/2-1 if even, and n/2 if odd
  *        Q  n*(n/2-1) if even, n*(n/2) if odd
 h            Add one
/           2 Divide the result by two.

Mi primera vez usando un lenguaje de golf.

Javascript, 33 bytes

a=prompt();alert(a*(a-1>>1)+1>>1)

Si se permite una función ES6, entonces 18 bytes:

a=>a*(a-1>>1)+1>>1

MATLAB, 37 25 bytes

@(a)ceil(fix(a/2-.5)*a/2)

Creo que esto debería funcionar, lo hace para todos los casos de prueba.

También funciona en Octave . Puedes probar en línea aquí .

Para el código anterior, agregué el programa a ese espacio de trabajo en un archivo llamado checkerboard.m . Puede ejecutarlo simplemente ingresando checkerboarden el indicador, luego, cuando se inicia, ingrese el tamaño requerido en el indicador. El resultado será impreso.

Para el nuevo código, simplemente ingrese el código publicado aquí en la solicitud, luego llame a la función anónima como ans(n).

Retina , 18 bytes

11(..?$)?
$_
11?
1

Entrada y salida es en unario .

Pruébalo en línea!

La última versión de Retina (más nueva que este desafío) podría manejar E / S decimal para cuatro bytes adicionales:

.+
$*
11(..?$)?
$_
11?

Pruébalo en línea!

Con entrada unaria y salida decimal, podemos hacer 16 bytes, pero eso parece un poco exagerado:

11(..?$)?
$_
11?

Explicación

Sigue siendo el mismo enfoque que cualquier otra persona, pero usa el reemplazo de expresiones regulares en una representación unaria del número.

11(..?$)?
$_

Esto computa n*((n-1)/2). Hacemos esto haciendo coincidir dos caracteres a la vez (división por dos) y reemplazándolos con la cadena completa (multiplicación por n). La disminución de nse realiza omitiendo el resto de la cadena, si solo quedan uno o dos caracteres.

11?
1

Esta es la división entera por 2, redondeada. Simplemente reemplazamos dos caracteres con uno (división por 2), pero permitimos que la última coincidencia consista en un solo personaje (redondeo).

Python 3, 39 bytes

Esto está un poco hinchado, pero no estoy seguro de poder jugar mucho más que esto. Un enlace para probar.

n=int(input());print(((n-1)//2*n+1)//2)

Prolog, 39 38 bytes

Código:

p(N):-X is ((N-1)//2*N+1)//2,write(X).

Explicación:

Subtract 1 from input and integer divide by 2 to get number of rows available.
Multiply that number by input to get number of squares available. 
Add one and integer divide by 2 to round up, since at at least half the rows 
will have a checker at the first square.
Print.

Ejemplo:

p(8).
12

Pruébalo en línea aquí

Editar: Guardado 1 byte reemplazando ceil / 2 con + 1 // 2

Paperas, 17 bytes

R I W I-1\2*I+1\2

Gracias a Emigna por la simple explicación del algoritmo. Esto explota la "deficiencia" matemática de Mumps de que las operaciones se ejecutan estrictamente de izquierda a derecha (no PEMDAS), por lo que no se requieren paréntesis. :-)

Sin embargo, la salida parece un poco extraña, ya que Cache's Ensemble (el entorno de paperas al que tengo acceso) no emite automáticamente retornos de carro incluso cuando se presiona en la entrada. Si lo desea más bonito, agregue 4 caracteres para los retornos de carro anteriores / posteriores:

R I W !,I-1\2*I+1\2,!

¡Gracias!

Bash, 32 bytes

read a;echo $((a*(a-1>>1)+1>>1))

Pyke, 8 bytes, sin competencia

Dt2f*h2f

dup, dec, mitad, mult, inc, mitad

Pruébalo aquí!

Lote, 30 bytes.

@cmd/cset/a(%1*((%1-1)/2)+1)/2

38 bytes si se requiere entrada en stdin:

@set/pa=
@cmd/cset/a(a*((a-1)/2)+1)/2