สมมติว่าชิ้นหมากรุกนางฟ้าใหม่ที่ชื่อว่า Wazir ได้รับการแนะนำให้รู้จักกับหมากรุก Wazirs สามารถย้ายจากตำแหน่ง ( x , y ) ไปที่:
 ( x +1, y )
 ( x , y +1)
 ( x -1, y )
 ( x , y -1)

นั่นคือพวกเขาเคลื่อนตัวแบบออโธกอนอิกเหมือนโกง แต่เพียงก้าวเดียวในเวลาเดียวกับราชา สามารถวาง wazirs บนกระดานหมากรุก N × N ได้กี่คนเพื่อที่จะไม่มีผู้โจมตีสองคนโจมตีกันได้

 บนกระดาน 1 × 1 สามารถมีได้เพียง 1 ชิ้นเท่านั้น
 บนกระดาน 2 × 2 สามารถมีได้ 2 ชิ้น
 บนกระดาน 3 × 3 สามารถมีได้ 5 ชิ้น

รับ N ส่งคืนจำนวน wazirs ที่สามารถวางบนกระดานหมากรุก N × N

นี่คือ OEIS ลำดับ A000982

กรณีทดสอบเพิ่มเติม

7 → 25

8 → 32

100 → 5000

ช่องว่างขนาด 45 ไบต์

ลองออนไลน์!

นี่เป็นข้อพิสูจน์ว่าสูตร⌈n² / 2⌉นั้นถูกต้อง

• เราสามารถวางอย่างน้อยazn² / 2⌉ wazirs : เพียงวางมันในรูปแบบกระดานหมากรุก! สมมติว่าแผ่นกระเบื้องด้านซ้ายบนเป็นสีขาวมีแผ่นกระเบื้องสีขาว⌈n² / 2⌉และแผ่นสีดำ⌊n² / 2⌋บนกระดานn × n และถ้าเราวาง wazirs ไว้บนแผ่นกระเบื้องสีขาวก็จะไม่มีใครโจมตีพวกเขาสองคนเพราะทุกคนมีเพียง "เห็น" กระเบื้องสีดำ

  นี่คือวิธีที่เราวาง 13 wazirs บนกระดาน 5 × 5 (แต่ละ w เป็น wazir)

  　　　　　　　　　　

• เราไม่สามารถทำอะไรได้ดีกว่านี้ : ลองเรียงกระดานหมากรุกกับชิ้นส่วนโดมิโน 2 × 1 โดยเลือกใช้ชิ้นส่วน 1 × 1 สำหรับมุมสุดท้ายของกระดานหมากรุกที่มีความยาวคี่เช่น:

  　　　　　　　　　　

  เราต้องการแต้มโดมิโนcovern² / 2⌉เพื่อให้ครอบคลุมกระดานหมากรุก เห็นได้ชัดว่าวางสอง wazirs บนโดมิโนหนึ่งทำให้มันเพื่อให้พวกเขาสามารถโจมตีซึ่งกันและกัน! ดังนั้นแต่ละโดมิโนสามารถมีมากที่สุดคนหนึ่งอัลวาหมายถึงเราไม่สามารถเป็นไปได้วางมากกว่า⌈n² / 2⌉ wazirs บนกระดาน

โอเอซิส 3 ไบต์

k>v

ลองออนไลน์!

สแควร์ - การเพิ่มขึ้น - จำนวนเต็มครึ่งหนึ่ง

Prolog (SWI) , 22 19 ไบต์

บันทึกแล้ว 3 ไบต์ขอบคุณKevin Cruijssen

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

ลองออนไลน์!

APL (Dyalog), 9 7 6 bytes

Now uses Mr. Xcoder's formula.

This is an anonymous prefix tacit function which takes N as argument.

⌈2÷⍨×⍨

Try it online!

×⍨ square N (lit. multiplication selfie, i.e. multiply by self)

2÷⍨ divide by 2

⌈ ceiling (round up)

JS (ES6) / C# polyglot, 11 bytes

n=>n*n+1>>1

Test cases

let f =

n=>n*n+1>>1

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

dc, 6 bytes

2^2~+p

2^: square; 2~: divide by 2, pushing the quotient then the remainder; +p: add the remainder to the quotient & print.

Try it online!

05AB1E, 3 bytes

Straight implementation of the formula given by A000982

n;î

Try it online!

Explanation

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

Python 2, 17 bytes

1 byte thanks to @ovs.

lambda x:x*x+1>>1

Try it online!

C (gcc), 23 18 17 bytes

• Saved a byte thanks to Tahg; golfing n/2+n%2 to n+1>>1.

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

Try it online!

C (gcc), 22 bytes (not using undefined behavior)

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

Try it online!

Some people really do not like exploiting a certain compiler's undefined bahavior when using specific compiler flags. Doing so does save bytes, though.

Brachylog, 6 bytes

^₂/₂⌉₁

Try it online!

Python 3, 19 bytes

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

Try it online!

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 thanks to Mr. Xcoder

x86_64 machine language (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

To Try it online!, compile and run the following C program.

#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));
  }
}

J, 8 bytes

Anonymous tacit prefix function.

2>.@%~*:

Try it online!

*: square

>. ceiling (round up)
@ after
2…%~ dividing by two

Actually, 3 bytes

²½K

Try it online!

R, 22 21 bytes

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

Try it online!

Square, increment, integer divide. Easy peasy.

Input from stdin; it can take space or newline separated input and it will compute the max wazirs for each input boardsize. Output to stdout.

-1 byte thanks to plannapus

Pyth, 6 bytes

.E**.5

Try it online!

Pyke, 3 bytes

Xhe

Try it here!

How?

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

C# (.NET Core), 14 12 bytes

^{-2 bytes thanks to Emigna}

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

Try it online!

Perl 5, 16 bytes

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

Try it online!

MATL, 5 bytes

UH/Xk

Try it online!

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.

Mathematica, 12 bytes

⌈#^2/2⌉&

Pyke, 3 bytes

Xhe

Try it here!

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

Ohm v2, 3 bytes

²½ı

Try it online!

² squares, ½ halves, ı ceils.

Jelly, 3 bytes

-1 thanks to Mr. Xcoder.

Based on my APL solution.

²HĊ

Try it online!

² Square

H Halve

Ċ Ceiling (round up)

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.

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]

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.

TI-Basic, 7 bytes

round(Ans²/2,0

Alternatively (8 bytes):

int(Ans²/2+.5

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