介绍

普通的棋盘包含8 x 8 = 64个正方形：

您可以看到总共有 12个白色小块。黑白始终具有相同数量的碎片。如果棋盘上还有其他棋子，这些棋子将相邻，这是此挑战所不允许的。为了说明问题，下面是一些示例：

应对这种挑战的最小木板为3 x 3：

您可以看到最大件数等于2。因此，当给定N = 3时，您需要输出2。如果输入为N = 4，则得到以下结果：

您可以看到最大数量也是2。因此，对于N = 4，输出应为2。对于N = 5，输出应等于5：

例子

STDIN:  3
STDOUT: 2

STDIN:  4
STDOUT: 2

STDIN:  5
STDOUT: 5

STDIN:  6
STDOUT: 6

STDIN:  8
STDOUT: 12

规则

• 您提交的内容必须是一个程序或函数等，它需要一个整数并输出或返回板上的棋子数
• 您可以放心地假设输入是非负整数> 2
• 这是代码高尔夫球，因此字节最少的程序将获胜！
• 请注意，板左下方的正方形始终是深色的。作品只能放在深色方块上
• 你必须整整地占据一排

Par，8字节

✶″½↓┐*½┐

每个字符使用一个字节。

说明

               ## [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

六边形，19字节

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

在线尝试。

说明

这仍然与我在CJam和Labyrinth答案中使用的计算相同，但是由于Hexagony的...特殊的...内存模型，将计算压缩到19个字节有点麻烦（因此它适合放入一个边长3六角形）。

就像我的迷宫答案一样，此操作以0除错误结束。

这是展开的代码：

正如我所说的，代码是完全线性的。您可以按灰色，紫色，绿色，红色，蓝色顺序将执行的路径拼凑在一起。实际上，该路径会继续延伸直到:到达左侧。除去/（仅重定向控制流），整个程序将线性展开：

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

所以问题是它如何工作。六边形的内存是十六进制网格的线图，其中网格的每个边都包含一个整数值（最初为零）。内存指针（MP）始终在一条边上，并沿该边指向某个方向。算术操作一般适用于所指示的两个边缘处，并存储在边缘上的MP上。

对于此程序，我们将使用标记为A，B，C的三个边，MP如下所示开始：

所以这是如何工作的：

?  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 LabVIEW原语

CJam，10个字节

ri_(2/*)2/

在这里测试。

说明

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.

迷宫，11字节

Woohoo，仅落后CJam一个字节。

?:(#/*)_2/!

在线尝试。

本质上是同一件事：

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

但是，此时程序尚未终止。取而代之的是，指令指针已死胡同并转身。但现在/试图计算0/0其以一个错误终止。

严重的是，8个字节

,;D½L*½K

认真有方便 ½（浮点除以2），并且K（上限），因此我们不需要在除法之前添加一个。

在这里尝试进行解释。

Python 2中，22 21个字节

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

我首先分开两种情况，奇数N和偶数N。

使用奇数N，我们可以填充（N-1）/ 2行，平均包含N / 2条。由于第一行总是有更多的片段，因此我们应该将此结果作为上限。因此，当N为奇数时，我们得到ceil（（N-1）/ 2 * N / 2）件。

使用偶数N，我们可以填充N / 2-1或floor（（N-1）/ 2）行，每行包含N / 2件。

我们可以通过ceil（floor（（N-1）/ 2）* N / 2）组合这两个表达式。由于ceil（x / 2）= floor（（x + 1）/ 2），我们可以使用Flooring除法：((N - 1) // 2 * N + 1) // 2。

JavaScript，37 35字节

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

说明

对其余答案使用类似的技术。这是非高尔夫算法：

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

直流电，12

?d1-2/*1+2/p

测试输出：

$ 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个字节

/h*/tQ2Q2

与我的Python 2答案相同的算法。

Japt，16 14字节

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

在线尝试！

怎么运行的

很简单：

         // 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

我希望有某种方式可以考虑到这两个代码是如此相似。建议欢迎！

旧版本（16字节）：

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

Java中，230 155 52

打高尔夫球：

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

取消高尔夫：

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

}

程序输出：

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

Zilog ez80机器码，9个字节

十六进制：

6C 2D CB3D ED6C 2C CB3D

组装中：

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

输入在寄存器中h，输出在中l。

Zilog ez80是具有8位累加器和24位寄存器的8位处理器。与z80不同，它具有mlt（8位乘法）指令，该指令在16位模式下将寄存器对的高字节和低字节相乘hl，然后存储回hl。

这仅适用于结果两倍于8位的值。即，n≤23。

TI-BASIC，13个字节

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

TI-BASIC的隐式乘法有帮助，但它没有整数除法。⁻int(⁻X是ceil（x）的较短形式。

vba，46岁

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

在公式中用？f（x）或= f（A1）调用

Pyth，17 14 13字节

-3个字节，感谢Ypnypn！重新排列*运算符的数字以节省1个字节。

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

说明：

当n为偶数时，我们可以用n / 2个块占用n / 2-1行，总共形成n *（n / 2-1）/ 2个块。此表达式等效于（n *（n / 2-1）+1）/ 2

当n为奇数时，我们可以找到两倍的碎片数，两倍的碎片将覆盖n-1行，如果我拿走一块，我们可以将n-1行划分为（n- 1）/ 2组2行，每组有n个，因此这种情况下的表达式为（n *（n / 2）+1）/ 2

现在两个表达式都非常相似，我们可以编写代码了。

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

我第一次使用高尔夫语言。

Javascript，33个字节

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

如果允许使用ES6功能，则需要18个字节：

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

MATLAB，37 25字节

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

我相信这应该适用于所有测试用例。

它也可以在Octave上使用。您可以在这里尝试在线。

对于旧代码，我将该程序添加到名为的文件中checkerboard.m。您只需输入以下内容即可运行它checkerboard在提示符下，然后在其启动时在提示符下输入所需的大小。结果将被打印。

对于新代码，只需在提示中输入此处发布的代码，然后以调用匿名函数ans(n)。

视网膜，18字节

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

输入和输出为一元。

在线尝试！

Retina的最新版本（比该挑战要新）可以处理四个附加字节的十进制I / O：

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

在线尝试！

使用一元输入和十进制输出，我们可以执行16个字节，但这似乎有点麻烦：

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

说明

仍然和其他人一样，只是对数字的一元表示使用正则表达式替换。

11(..?$)?
$_

计算n*((n-1)/2)。为此，我们一次匹配两个字符（一分为二），然后将其替换为整个字符串（乘以n）。n如果只剩下一个或两个字符，则通过跳过字符串的其余部分来减少。

11?
1

这是2的整数除法。我们仅将两个字符替换为一个（除以2），但是允许最后一个匹配仅包含一个字符（向上舍入）。

Python 3，39个字节

这有点肿，但我不确定我能打得比这还远。测试链接。

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

Prolog，39岁 38字节

码：

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

说明：

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.

例：

p(8).
12

在这里在线尝试

编辑：通过将ceil / 2替换为+ 1 // 2保存了1个字节

腮腺炎，17字节

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

感谢Emigna提供的简单算法说明。这利用了Mumps的数学“缺陷”，即操作严格从左到右执行（不是PEMDAS），因此不需要括号。:-)

输出确实有点奇怪，但是，即使按了输入，Cache的Ensemble（我有权访问的Mumps环境）也不会自动输出回车。如果您希望它更漂亮，请在回车之前/之后添加4个字符：

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

谢谢！

Bash，32个字节

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

Pyke，8字节，无竞争

Dt2f*h2f

dup，dec，一半，mult，inc，一半

在这里尝试！

批处理，30个字节

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

如果需要在stdin上输入，则为38个字节：

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