Wazir라는 새로운 요정 체스 조각 이 체스에 도입되었다고 가정 해보십시오 . Wazirs는 위치 ( x , y )에서 다음 위치로 이동할 수 있습니다 :
 ( x +1, y )
 ( x , y +1)
 ( x -1, y )
 ( x , y -1)

즉, 그들은 루크처럼 직교 적으로 움직이지만 왕처럼 한 번에 한 걸음 만 움직입니다. NxN 체스 판에 두 개의 화이자가 서로를 공격 할 수 없도록 얼마나 많은 화이자를 배치 할 수 있습니까?

 1 × 1 보드에는 그러한 조각이 하나만있을 수 있습니다.
 2 × 2 보드에는 2 개의 조각이있을 수 있습니다.
 3 x 3 보드에는 5 조각이있을 수 있습니다.

N이 주어지면 N × N 체스 판에 놓을 수있는 wazirs의 수를 반환하십시오.

이다 OEIS 순서 A000982 .

더 많은 테스트 사례

7 → 25

8 → 32

100 → 5000

공백 , 45 바이트

온라인으로 사용해보십시오!

그런데 여기에 ⌈n² / 2⌉ 공식이 옳다는 증거가 있습니다.

• 우리는 항상 적어도 ⌈n² / 2⌉의 wazirs를 배치 할 수 있습니다 : 바둑판 패턴으로 배치하십시오! 왼쪽 상단 타일이 흰색이라고 가정하면 n × n 보드 에 ⌈n² / 2⌉ 흰색 타일과 ⌊n² / 2⌋ 검은 색 타일이 있습니다. 그리고 우리가 흰 타일에 wazirs를 놓으면, 두 wazair는 모두 검은 타일을“보는”것처럼 서로를 공격하지 않습니다.

  5 x 5 보드에 13 개의 wazir를 배치하는 방법은 다음과 같습니다 (각 W는 wazir 임).

  　　　　　　　　　　

• 우리는 더 잘 할 수 없습니다 : 바둑판을 임의로 2 × 1 도미노 조각으로 바둑판 식으로 배열하십시오. 선택적으로 홀수 길이 체스 판의 마지막 모서리에 1 × 1 조각을 사용하십시오.

  　　　　　　　　　　

  체스 판을 덮기 위해서는 ⌈n² / 2⌉ 도미노가 필요합니다. 분명히, 하나의 도미노에 두 개의 wazir를두면 서로 공격 할 수 있습니다! 각 도미노는 단지 우리가 할 수없는 의미를 가장 한 지르에 포함 할 수 있도록 가능한 보드에 대한 자세한 ⌈n² 이상 / 2⌉ wazirs 놓습니다.

오아시스 , 3 바이트

k>v

온라인으로 사용해보십시오!

제곱-증분-정수 반

프롤로그 (SWI) , 22 19 바이트

Kevin Cruijssen 덕분에 3 바이트 절약

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

온라인으로 사용해보십시오!

APL (Dyalog) , 9 7 6 바이트

이제 Xcoder 씨의 공식을 사용합니다.

이것은 N을 인수로 사용하는 익명의 접두사 암묵 함수입니다.

⌈2÷⍨×⍨

온라인으로 사용해보십시오!

×⍨ 정사각형 N (점등 곱셈 셀카, 즉 자기 곱하기)

2÷⍨ 2로 나누다

⌈ 천장 (반올림)

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

dc , 6 바이트

2^2~+p

2^: 정사각형; 2~: 몫을 나머지로 밀고 2로 나눕니다. +p: 나머지를 몫 및 인쇄에 추가합니다.

온라인으로 사용해보십시오!

05AB1E , 3 바이트

A000982에 의해 주어진 공식의 직접적인 구현

n;î

온라인으로 사용해보십시오!

설명

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

파이썬 2 , 17 바이트

@ovs 덕분에 1 바이트.

lambda x:x*x+1>>1

온라인으로 사용해보십시오!

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

온라인으로 사용해보십시오!

어떤 사람들은 특정 컴파일러 플래그를 사용할 때 특정 컴파일러의 정의되지 않은 bahavior를 이용하는 것을 정말로 좋아하지 않습니다. 그렇게하면 바이트가 절약됩니다.

Brachylog , 6 바이트

^₂/₂⌉₁

온라인으로 사용해보십시오!

파이썬 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)

Mr. Xcoder 덕분에 -1 바이트

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

J , 8 바이트

익명의 암묵적 접두사 기능.

2>.@%~*:

온라인으로 사용해보십시오!

*: 광장

>.…  2로 나눈
@ 후  천장 (반올림)
2%~

실제로 3 바이트

²½K

온라인으로 사용해보십시오!

R , 22 21 바이트

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

온라인으로 사용해보십시오!

제곱, 증분, 정수 나누기. 쉬워요.

stdin에서 입력; 공간 또는 줄 바꿈으로 구분 된 입력을 취할 수 있으며 각 입력 보드 크기에 대한 최대 wazirs를 계산합니다. 표준 출력으로 출력합니다.

plannapus 덕분에 -1 바이트

Pyth , 6 바이트

.E**.5

온라인으로 사용해보십시오!

파이크 , 3 바이트

Xhe

여기 사용해보십시오!

방법?

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

C # (. NET 코어) , 14 12 바이트

^{Emigna 덕분에 -2 바이트}

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

온라인으로 사용해보십시오!

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.