Giả sử một quân cờ cổ tích mới có tên Wazir được giới thiệu cho cờ vua. Wazir có thể di chuyển từ một vị trí ( x , y ) đến:
 ( x +1, y )
 ( x , y +1)
 ( x -1, y )
 ( x , y -1)

Đó là, họ di chuyển trực giao như tân binh, nhưng chỉ một bước một lần như nhà vua. Có bao nhiêu wazir như vậy có thể được đặt trên bàn cờ N × N để không có hai wazir nào có thể tấn công lẫn nhau?

 Trên bảng 1 × 1, chỉ có thể có 1 mảnh như vậy.
 Trên bảng 2 × 2, có thể có 2 miếng như vậy.
 Trên bảng 3 × 3, có thể có 5 miếng như vậy.

Cho N, trả về số lượng wazir có thể được đặt trên bàn cờ N × N.

Đây là trình tự OEIS A000982 .

Nhiều trường hợp kiểm tra

7 → 25

8 → 32

100 → 5000

Khoảng trắng , 45 byte

Hãy thử trực tuyến!

Nhân tiện, đây là một bằng chứng cho thấy công thức ⌈n² / 2⌉ là chính xác.

• Chúng tôi luôn có thể đặt ít nhất ⌈n² / 2⌉ wazirs : chỉ cần đặt chúng ra theo mô hình bàn cờ! Giả sử gạch trên cùng bên trái có màu trắng, có n² / 2⌉ gạch trắng và n² / 2⌋ gạch đen trên bảng n × n . Và nếu chúng ta đặt wazir trên các ô màu trắng, thì không có hai trong số chúng đang tấn công lẫn nhau, vì mỗi wazir chỉ nhìn thấy gạch đen.

  Dưới đây là cách chúng tôi đặt 13 wazir trên bảng 5 × 5 (mỗi W là một wazir).

  　　　　　　　　　　

• Chúng ta không thể làm tốt hơn : hãy tùy ý xếp bàn cờ với các quân cờ 2 × 1, tùy ý sử dụng quân cờ 1 × 1 cho góc cuối cùng của bàn cờ có chiều dài kỳ lạ, như vậy:

  　　　　　　　　　　

  Chúng ta cần ⌉n² / 2⌉ domino để phủ lên bàn cờ. Rõ ràng, đặt hai wazir lên một domino để chúng có thể tấn công lẫn nhau! Vì vậy, mỗi domino chỉ có thể chứa tối đa một wazir, có nghĩa là chúng ta không thể đặt nhiều hơn ⌈n² / 2⌉ wazir trên bảng.

Ốc đảo , 3 byte

k>v

Hãy thử trực tuyến!

bình phương - gia tăng - một nửa số nguyên

Prolog (SWI) , 22 19 byte

Đã lưu 3 byte nhờ Kevin Cruijssen

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

Hãy thử trực tuyến!

APL (Dyalog) , 9 7 6 byte

Bây giờ sử dụng công thức của ông Xcoder.

Đây là một hàm ẩn tiền tố ẩn danh, lấy N làm đối số.

⌈2÷⍨×⍨

Hãy thử trực tuyến!

×⍨ bình phương N (lit. phép nhân selfie, tức là nhân với tự)

2÷⍨ chia cho 2

⌈ trần nhà (làm tròn lên)

JS (ES6) / C # polyglot, 11 byte

n=>n*n+1>>1

Các trường hợp thử nghiệm

let f =

n=>n*n+1>>1

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

dc , 6 byte

2^2~+p

2^: Quảng trường; 2~: chia cho 2, đẩy thương số rồi phần còn lại; +p: thêm phần còn lại vào thương số & in.

Hãy thử trực tuyến!

05AB1E , 3 byte

Thực hiện thẳng công thức được đưa ra bởi A000982

n;î

Hãy thử trực tuyến!

Giải trình

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

Python 2 , 17 byte

1 byte nhờ @ovs.

lambda x:x*x+1>>1

Hãy thử trực tuyến!

C (gcc) , 23 18 17 byte

• Đã lưu một byte nhờ Tahg ; chơi golf n/2+n%2để n+1>>1.

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

Hãy thử trực tuyến!

C (gcc) , 22 byte (không sử dụng hành vi không xác định)

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

Hãy thử trực tuyến!

Một số người thực sự không thích khai thác bahavior của một trình biên dịch nhất định khi sử dụng các cờ biên dịch cụ thể. Làm như vậy sẽ tiết kiệm byte, mặc dù.

Brachylog , 6 byte

^₂/₂⌉₁

Hãy thử trực tuyến!

Python 3 , 19 byte

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

Hãy thử trực tuyến!

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 nhờ ông Xcoder

ngôn ngữ máy x86_64 (Linux), 9 8 byte

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

Để thử trực tuyến! , biên dịch và chạy chương trình C sau.

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

Chức năng tiền tố ẩn danh.

2>.@%~*:

Hãy thử trực tuyến!

*: Quảng trường

>. trần (lên tròn)
@ sau khi
2... %~ người chia làm hai

Trên thực tế , 3 byte

²½K

Hãy thử trực tuyến!

R , 22 21 byte

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

Hãy thử trực tuyến!

Bình phương, tăng, chia số nguyên. Dễ như ăn bánh.

Đầu vào từ stdin; nó có thể lấy không gian hoặc đầu vào được phân tách bằng dòng mới và nó sẽ tính toán các wazir tối đa cho mỗi bảng đầu vào. Đầu ra cho thiết bị xuất chuẩn.

-1 byte nhờ vào plannapus

Bình thường , 6 byte

.E**.5

Hãy thử trực tuyến!

Pyke , 3 byte

Xhe

Hãy thử nó ở đây!

Làm sao?

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

C # (.NET Core) , 14 12 byte

^{-2 byte nhờ Emigna}

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

Hãy thử trực tuyến!

Perl 5 , 16 byte

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

Hãy thử trực tuyến!

MATL , 5 byte

UH/Xk

Hãy thử trực tuyến!

Khối , 11 byte

Iu*:^\)2,O@

Heheh, :^\)

Hãy thử trực tuyến!

Mở rộng đến khối sau:

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

Đó là cùng một thuật toán mà nhiều người sử dụng.

• ^Iu : đọc trong đầu vào dưới dạng int và thay đổi hướng
• :* : dup top của stack, nhân lên
• \) : thay đổi hướng, tăng
• 2, : đẩy 2, chia số nguyên
• O@ : in đầu ra như int, chương trình kết thúc.

Toán học, 12 byte

⌈#^2/2⌉&

Pyke , 3 byte

Xhe

Hãy thử nó ở đây!

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

Ohm v2 , 3 byte

²½ı

Hãy thử trực tuyến!

²hình vuông, ½một nửa, ıtrần nhà.

Thạch , 3 byte

-1 cảm ơn ông Xcoder.

Dựa trên giải pháp APL của tôi .

²HĊ

Hãy thử trực tuyến!

² Quảng trường

H H alve

Ċ C eiling (làm tròn lên)

Japt , 4 byte

Đã ngồi trên những điều này kể từ khi thách thức đã kết thúc.

²Ä z

Thử nó

Giải thích: Hình vuông, thêm 1, chia tầng cho 2

Thay thế

²ÄÁ1

Thử nó

Giải thích: Hình vuông, thêm 1, bit-shift phải bằng 1.

Bình luận viên , 19 byte

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

Hãy thử trực tuyến!

Ai cần ngôn ngữ chơi golf? Tôi đã có những ngôn ngữ khó hiểu!

Phiên bản bị đánh cắp:

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

Hãy thử trực tuyến!

Làm thế nào nó hoạt động? Tôi sẽ giải thích, với đầu vào 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 byte

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

Hãy thử trực tuyến!

Tôi hơi bực mình vì cái tên đã được đổi từ "lạc đà" thành "wazirs" trước khi tôi có thể viết nó, nhưng tôi nghĩ rằng dù sao tôi cũng sẽ đăng nó.

TI-Basic, 7 byte

round(Ans²/2,0

Hoặc (8 byte):

int(Ans²/2+.5

/// , 35 byte

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

Hãy thử trực tuyến!

Đưa đầu vào trong unary bằng ký hiệu *và đầu ra trong unary sử dụng ký hiệu A. Điều này được phép cho một số ngôn ngữ cụ thể, bao gồm /// ( meta )

Vì không có cách nào để nhận đầu vào trong ///, nên đầu vào phải được mã hóa cứng:

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

cho đầu vào = 4.

Giải thích: (trước khi đọc, bạn cần phải biết rằng cú pháp duy nhất của ///là /pattern/replacement/, mà thay thế mỗi sự xuất hiện của patternbằng replacement; và \cho thoát; nhân vật khác được in đến đầu ra)

Dành cho 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.