30

假设将名为Wazir 的新童话棋子引入国际象棋。游荡者可以从（x，y）位置移动到：
（x +1，y）
（x，y +1）
（x -1，y）
（x，y -1）

也就是说，它们像车子一样正交移动，但一次只能像国王一样移动一步。在N×N棋盘上可以放置多少个这样的游击手，以使两个游击手不能互相攻击？

在1×1的板上，只能有1个这样的棋子。
在2×2板上，可以有2个这样的块。
在3×3板上，可以有5个这样的块。

给定N，返回可以放置在N×N棋盘上的游标的数量。

这是OEIS序列A000982。

空格，45字节

在线尝试！

顺便说一下，这里证明⌈n²/2⌉公式正确。

我们总是可以放置至少⌈n²/2⌉个wazirs：只需以棋盘状图案布置它们即可！假设左上角的瓷砖为白色，则n×n板上有⌈n²/2⌉白色瓷砖和⌊n²/2⌋黑色瓷砖。而且，如果我们将游击手放在白色瓷砖上，则不会有两个相互攻击，因为每个游骑兵只会“看到”黑色瓷砖。

这是我们在5×5板上放置13个wazirs的方式（每个W是wazir）。

　　　　　　　　　　
我们不能做得更好：让我们任意用2×1多米诺骨牌平铺棋盘，或者在奇长棋盘的最后一角使用1×1棋盘格，如下所示：

　　　　　　　　　　

我们需要⌈n²/2⌉多米诺骨牌来覆盖棋盘。显然，在一个多米诺骨牌上放两个守卫者就可以使他们互相攻击！因此，每个骨牌只能包含最多一个瓦齐尔，这意味着我们不能可能将超过⌈n²/2⌉wazirs在黑板上。

— 林恩
source

最后一部分不需要信鸽原理：您拥有精确的⌈n²/2⌉瓦片，每个瓦片最多有骆驼，因此您最多有⌈n²/2⌉骆驼。

— ShreevatsaR

8

@ShreevatsaR是什么确保您不能将x>⌈n²/2⌉骆驼放在⌈n²/2⌉瓷砖中？这是

— 信鸽的

2

我以为起初代码没有加载，所以我刷新了页面，但仍然没有加载。然后我意识到什么语言名称写在顶部。

— 亚瑟

7

感谢您在证明图中将您的更改C为W。

— 朱塞佩

4

我也很欣赏W都在白色空间中，并在WHITESPACE中给出了答案。

— corsiKa

16

绿洲，3个字节

k>v

在线尝试！

平方-增量-整数减半

— 漏尼姑
source

10

序言（SWI），22 19字节

感谢Kevin Cruijssen节省了3个字节

X*Y:-Y is(X*X+1)/2.

在线尝试！

— 艾米尼亚
source

X*Y:-Y is(X*X+1)/2.（19个字节）

— 凯文·克鲁伊森

2

@KevinCruijssen：哦！我向其他用户建议了相同的更改，但不知何故我没有采纳自己的建议。谢谢您：）

— Emigna '17

9

APL（Dyalog），9 7 6字节

现在使用Xcoder先生的公式。

这是一个匿名前缀默认函数，以N为参数。

⌈2÷⍨×⍨

在线尝试！

×⍨ 平方N（照明自拍，即乘以自己）

2÷⍨ 除以2

⌈ 天花板（向上）

— 亚当
source

哇！我不知道你是怎么做到的！！虽然叹了口气

— Sasha R

该死，有人已经发现了这种模式。

— Feathercrown

1

呵呵，刚意识到公式在OEIS页面上。可能不应该链接到该链接。

— Feathercrown

7

JS（ES6）/ C＃多种语言，11个字节

n=>n*n+1>>1

测试用例

显示代码段

let f =

n=>n*n+1>>1

console.log(f(7))
console.log(f(8))
console.log(f(100))

Expand snippet

— Arnauld
source

3

C＃多语种

— Shaggy

@Shaggy感谢您的关注！

— 阿纳尔德

1

鉴于它们之间的差异，JS和C＃的多语言版本似乎极为罕见。+1

— Caird coinheringaahing

6

dc，6个字节

2^2~+p

2^正方形 2~：除以2，先推商再乘余数； +p：将余数添加到商并打印。

在线尝试！

— h
source

5

05AB1E，3个字节

直接执行A000982给出的公式

n;î

在线尝试！

说明

n      # square
 ;     # divide by 2
  î    # round up

— 艾米尼亚
source

5

Python 2个字节

1字节感谢@ovs。

lambda x:x*x+1>>1

在线尝试！

— Xcoder先生
source

或者：lambda x：

— -〜x

5

C（gcc），23 18 17字节

感谢Tahg节省了一个字节；打高尔夫球n/2+n%2去n+1>>1。

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

在线尝试！

C（gcc），22个字节（不使用未定义的行为）

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

在线尝试！

当使用特定的编译器标志时，有些人真的不喜欢利用某个编译器的未定义行为。但是，这样做确实可以节省字节。

— 乔纳森·弗雷奇
source

3

提供答案IMO的奇怪方法，但是：f（n）{n = n * n + 1 >> 1;}保存一个字节。

— 塔赫格

1

@Tahg谢谢；尽管您觉得我提供答案的方式有些奇怪吗？

— 乔纳森·弗雷希

2

我不认为更改输入参数是在C中返回值的正常方法

— 。– Tahg

2

@YSC然而，在编译器看来，它是可以理解的，并创建了一个有效的可执行文件。

— 乔纳森·弗雷希

5

@YSC我们在PPCG上认为，如果该程序可以使用一个口译员，则表示该提交是有效的。它可以在在线解释器上运行，因此有效，无需任何其他说明。

— Conor O'Brien

4

Brachylog，6个字节

^₂/₂⌉₁

在线尝试！

— 暴民埃里克
source

4

Python 3，19个字节

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

在线尝试！

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字节感谢Xcoder先生

— 超中微子
source

x**2->x*x

— Xcoder先生17年

@ Mr.Xcoder Facepalm感谢

— HyperNeutrino

那lambda x:x*x+1>>1呢

— 艾力克斯·艾森哈特

或lambda x:x*x+1//2 免责声明：我不知道该语言的语法或操作顺序，所以我猜到了；我是说在您之前加1， //2 而不是两次否定。

— 丹·亨德森

@DanHenderson您仍然需要括号，否则将其解析为(x*x) + (1//2)，因此实际上并不短。

— 斯凯勒

4

x86_64机器语言（Linux），9 8字节

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

到网上试试吧！，编译并运行以下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));
  }
}

— 吊顶猫
source

3

Ĵ，8个字节

匿名默认前缀功能。

2>.@%~*:

在线尝试！

*: 广场

>.…… 除
@ 以后的上限（向上取整）
2%~

— 亚当
source

替代解决方案：<.@-:@*:以及*:<.@%2:

— Conor O'Brien

2

@ ConorO'Brien 2>.@%~*:I我从哪里得到的？我无法读取-看起来像线路噪声，我...

— 亚当

>.@-:@*:得到我的投票。

— 约拿（Jonah）

1

@乔纳（Jonah）如果you着眼睛，可以看到骆驼。

— 阿达姆（Adám）'17年

3

实际上，3个字节

²½K

在线尝试！

— 夏洛克9
source

3

R，22 21字节

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

在线尝试！

平方，增量，整数除法。十分简单。

来自stdin的输入；它可以使用空格或换行符分隔的输入，并且将计算每个输入电路板尺寸的最大游标。输出到标准输出。

-1字节归功于Plannapus

— 朱塞佩
source

@plannapus已修复，谢谢。

— 朱塞佩

2

Pyth，6个字节

.E**.5

在线尝试！

— Xcoder先生
source

2

派克（Pyke），3个字节

Xhe

在这里尝试！

怎么样？

X   - Square.
 h  - Increment.
  e - Floor halve.

— Xcoder先生
source

2

C＃（.NET Core），14 12字节

^{-2字节归功于Emigna}

n=>(n*n+1)/2

在线尝试！

— 我的代词是莫尼卡
source

Save 2 bytes

— Emigna

2

n=>n*n+1>>1 (11 bytes)

— Kevin Cruijssen

I have noticed the javascript answer to do the same, and this change would make our answers byte to byte equivalent.

— my pronoun is monicareinstate

2

Perl 5, 16 bytes

$_=0|$_*$_/2+.5

Try it online!

— Xcali
source

$_=$_*$_+1>>1 14 bytes

— Nahuel Fouilleul

2

MATL, 5 bytes

UH/Xk

Try it online!

— Cinaski
source

1

or UQ2/k at the same byte count.

— Giuseppe

2

Cubix, 11 bytes

Iu*:^\)2,O@

Heheh, :^\)

Try it online!

Expands to the following cube:

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

Which is the same algorithm that many use.

^Iu : read in input as int and change directions
:* : dup top of stack, multiply
\) : change direction, increment
2, : push 2, integer divide
O@ : print output as int, end program.

— Giuseppe
source

2

Mathematica, 12 bytes

⌈#^2/2⌉&

— J42161217
source

2

11 bytes: ⌈#.5#⌉&

— user202729

2

Pyke, 3 bytes

Xhe

Try it here!

X   -   input ** 2
 h  -  ^ + 1
  e - floor_half(^)

— Blue
source

I ninja'd you by about 12 hours :-/

— Mr. Xcoder

2

Ohm v2, 3 bytes

²½ı

Try it online!

² squares, ½ halves, ı ceils.

— Mr. Xcoder
source

1

Jelly, 3 bytes

-1 thanks to Mr. Xcoder.

Based on my APL solution.

²HĊ

Try it online!

² Square

H Halve

Ċ Ceiling (round up)

— Adám
source

1

Japt, 4 bytes

Been sitting on these since the challenge was closed.

²Ä z

Try it

Explanation: Square, add 1, floor divide by 2

Alternative

²ÄÁ1

Try it

Explanation: Square, add 1, bit-shift right by 1.

— Shaggy
source

1

Commentator, 19 bytes

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

Try it online!

Who needs golfing languages? I've got confusing languages!

Ungolfed version:

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

Try it online!

How does it work? I'll explain, with input 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
source

1

OCaml, 19 bytes

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

Try it online!

I'm a bit bummed the name got changed from "camels" to "wazirs" before I managed to write this, but I figured I'd post it anyway.

— Giuseppe
source

1

TI-Basic, 7 bytes

round(Ans²/2,0

Alternatively (8 bytes):

int(Ans²/2+.5

— Timtech
source

-int(-.5Ans² also works

— Oki

@Oki It sure does. I just wish they had a ceil( function.

— Timtech

1

///, 35 bytes

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

Try it online!

Takes input in unary using symbol *, and output in unary using symbol A. This is allowed for some specific languages, including /// (meta)

Because there is no way to take input in ///, input should be hardcoded:

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

for input = 4.

Explanation: (before reading, you need to know that the only syntax of /// are /pattern/replacement/, which replace every occurence of pattern by replacement; and \ for escaping; other characters is printed to output)

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

— user202729
source

一个N×N棋盘上可以放置多少个Wazirs？

更多测试案例

空格，45字节

绿洲，3个字节

序言（SWI），22 19字节

APL（Dyalog），9 7 6字节

JS（ES6）/ C＃多种语言，11个字节

测试用例

dc，6个字节

05AB1E，3个字节

Python 2个字节

C（gcc），23 18 17字节

C（gcc），22个字节（不使用未定义的行为）

Brachylog，6个字节

Python 3，19个字节

x86_64机器语言（Linux），9 8字节

Ĵ，8个字节

实际上，3个字节

R，22 21字节

Pyth，6个字节

派克（Pyke），3个字节

怎么样？

C＃（.NET Core），14 12字节

Perl 5, 16 bytes

MATL, 5 bytes

Cubix, 11 bytes

Mathematica, 12 bytes

Pyke, 3 bytes

Ohm v2, 3 bytes

Jelly, 3 bytes

Japt, 4 bytes

Alternative

Commentator, 19 bytes

OCaml, 19 bytes

TI-Basic, 7 bytes

///, 35 bytes