Número de piezas en un tablero de damas

14

Introducción

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

ingrese la descripción de la imagen aquí

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 :

ingrese la descripción de la imagen aquí

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:

ingrese la descripción de la imagen aquí

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 :

ingrese la descripción de la imagen aquí

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 , 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
Adnan
fuente
3
¿Por qué la restricción a los programas completos y STDIN / STDOUT? La OMI es injusto para los lenguajes que tienen una sobrecarga de programa y / o entrada necesaria.
lirtosiast el
@ThomasKwa, tienes razón. Ahora se permiten funciones, etc.
Adnan

Respuestas:

5

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
Ypnypn
fuente
12

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:

ingrese la descripción de la imagen aquí

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í:

ingrese la descripción de la imagen 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.
Martin Ender
fuente
{{mueve el borde de la memoria dos veces para que el & en la segunda fila no esté haciendo nada? Ambos vecinos deberían ser 0 allí
Eumel
@Eumel Ese no es el orden en que se ejecuta el código. Después del primero {, la IP salta a la 2esquina izquierda. Después )de la esquina derecha, la IP salta a la 'esquina inferior izquierda. Luego, la IP atraviesa las líneas 2 y 4 de una forma cíclica extraña.
Martin Ender
oh, pensé que solo cambió el ME, no la IP. también +1 solo por usar la hexagonía de que el lenguaje es demasiado divertido
Eumel
@Eumel lo hace. Así es como se ajustan los bordes del código en Hexagony.
Martin Ender
8

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.
Martin Ender
fuente
8

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 .

Martin Ender
fuente
5

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.

lirtosiast
fuente
5

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.

orlp
fuente
3

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);
usuario81655
fuente
3

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
$ 
Trauma digital
fuente
3

Pyth, 9 bytes

/h*/tQ2Q2

Mismo algoritmo que mi respuesta de Python 2.

orlp
fuente
3

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
ETHproductions
fuente
3

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

fuente
throws Exceptiones permisible
Neil
1
OP funciones permitidas.
lirtosiast
Podrías usar la Scannerclase como entrada. Eso te ahorraría un montón de bytes, creo. (El BufferedReader/ InputStreamReadercombo puede ser mejor en uso general, pero este es el código de golf, y Scannerfunciona bien para una entrada simple).
Darrel Hoffman
La conversión a una función independiente y el uso de parámetros / valores de retorno en lugar de entrada / salida estándar hicieron una gran diferencia.
2

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.

lirtosiast
fuente
2

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).

lirtosiast
fuente
2

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

SeanC
fuente
2

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.

Element118
fuente
2

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
Neil
fuente
2

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).

Tom Carpenter
fuente
Gracias por los votos, finalmente llegó a 1000 Rep :) Woop.
Tom Carpenter
@ThomasKwa gracias por señalar eso. Guardado 12 bytes :).
Tom Carpenter
2

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).

Martin Ender
fuente
Felicitaciones por su respuesta número 1000: p
Adnan
1

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)
Sherlock9
fuente
1

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

Emigna
fuente
1

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!

zmerch
fuente
1

Bash, 32 bytes

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

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
Neil
fuente