Giới thiệu

Một bảng kiểm tra bình thường chứa 8 x 8 = 64 ô vuông:

Bạn có thể thấy rằng trong tổng số, có 12 mảnh màu trắng . Đen và trắng luôn có cùng số lượng miếng. Nếu có thêm bất kỳ mảnh nào trên bảng, các mảnh sẽ lân cận, không được phép cho thử thách này. Để làm rõ mọi thứ, đây là một số ví dụ:

Bảng nhỏ nhất có thể cho thử thách này là 3 x 3 :

Bạn có thể thấy rằng số lượng tối đa của các mảnh bằng 2 . Vì vậy, khi cho N = 3 , bạn cần xuất 2 . Nếu đầu vào là N = 4 , chúng tôi nhận được như sau:

Bạn có thể thấy rằng số tiền tối đa cũng là 2. Vì vậy, với N = 4 , đầu ra phải là 2 . Với N = 5 , đầu ra phải bằng 5 :

Ví dụ

STDIN:  3
STDOUT: 2

STDIN:  4
STDOUT: 2

STDIN:  5
STDOUT: 5

STDIN:  6
STDOUT: 6

STDIN:  8
STDOUT: 12

Quy tắc

• Nội dung gửi của bạn phải là một chương trình hoặc hàm, v.v ... lấy một số nguyên và xuất ra hoặc trả về số lượng mảnh trên bảng
• Bạn có thể giả định rằng đầu vào là số nguyên không âm> 2
• Đây là môn đánh gôn , vì vậy chương trình có số byte ít nhất sẽ thắng!
• Lưu ý rằng hình vuông ở phía dưới bên trái của bảng luôn tối. Các mảnh chỉ được đặt trên hình vuông tối
• Bạn phải chiếm một hàng đầy đủ với các mảnh

Mệnh , 8 byte

✶″½↓┐*½┐

Một byte được sử dụng cho mỗi ký tự.

Giải trình

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

Lục giác , 19 byte

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

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

Giải trình

Đây vẫn là tính toán giống như tôi đã sử dụng trong các câu trả lời của CJam và Labyrinth của tôi, nhưng do mô hình bộ nhớ ... đặc biệt ... của Hexagony, nên việc nén tính toán thành 19 byte (để nó phù hợp với bên trong một cạnh dài 3 hình lục giác).

Giống như câu trả lời Labyrinth của tôi, điều này chấm dứt với lỗi chia cho 0.

Đây là mã mở ra:

Như tôi đã nói mã hoàn toàn tuyến tính. Bạn có thể ghép các đường dẫn được thực hiện lại với nhau theo thứ tự xám-tím-xanh-đỏ-xanh. Con đường thực sự tiếp tục xa hơn một chút cho đến khi nó chạm :vào bên trái. Loại bỏ /(chỉ điều hướng luồng điều khiển), toàn bộ chương trình không được kiểm soát tuyến tính là:

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

Vì vậy, câu hỏi là làm thế nào nó hoạt động. Bộ nhớ của hexagony là biểu đồ đường của lưới hex, trong đó mỗi cạnh của lưới chứa một giá trị nguyên (ban đầu là 0). Con trỏ bộ nhớ (MP) luôn nằm trên một cạnh và chỉ theo một hướng nhất định dọc theo cạnh đó. Các phép toán số học thường được áp dụng cho hai cạnh được chỉ vào và được lưu trữ ở cạnh mà MP được bật.

Đối với chương trình này, chúng tôi sẽ sử dụng ba cạnh có nhãn A , B , C , với MP bắt đầu như được hiển thị ở đây:

Vì vậy, đây là cách làm việc này:

?  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 Nguyên thủy

CJam, 10 byte

ri_(2/*)2/

Kiểm tra nó ở đây.

Giải trình

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.

Mê cung , 11 byte

Woohoo, chỉ một byte sau CJam .

?:(#/*)_2/!

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

Về cơ bản nó giống nhau:

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

Tuy nhiên, tại thời điểm này chương trình chưa kết thúc. Thay vào đó, con trỏ lệnh đã đi vào ngõ cụt và quay lại. Nhưng bây giờ /cố gắng tính toán 0/0mà kết thúc với một lỗi .

Nghiêm túc , 8 byte

,;D½L*½K

Nghiêm túc có tiện dụng ½(phao chia cho 2) vàK (trần), vì vậy chúng ta không cần thêm một trước khi chia.

Hãy thử nó ở đây với lời giải thích.

Python 2, 22 21 byte

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

Lần đầu tiên tôi tách ra trong hai trường hợp, N lẻ và thậm chí là N.

Với N lẻ chúng ta có thể điền (N - 1) / 2 hàng, chứa trung bình N / 2 miếng. Vì hàng đầu tiên luôn có nhiều mảnh hơn nên chúng tôi sẽ đưa ra kết quả này. Vì vậy, khi N là số lẻ, chúng ta có các mảnh trần ((N-1) / 2 * N / 2).

Với thậm chí N, chúng ta có thể điền N / 2 - 1 hoặc sàn ((N - 1) / 2), mỗi hàng chứa N / 2 miếng.

Chúng ta có thể kết hợp hai biểu thức này bằng ceil (floor ((N-1) / 2) * N / 2). Vì trần (x / 2) = sàn ((x + 1) / 2) nên chúng tôi có thể sử dụng phân chia sàn : ((N - 1) // 2 * N + 1) // 2.

JavaScript, 37 35 byte

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

Giải trình

Sử dụng một kỹ thuật tương tự với phần còn lại của câu trả lời. Đây là thuật toán vô căn cứ:

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

đc, 12

?d1-2/*1+2/p

Đầu ra thử nghiệm:

$ for t in 3 4 5 6 8; do echo $t | dc -e?d1-2/*1+2/p; done
2
2
5
6
12
$ 

Bình thường, 9 byte

/h*/tQ2Q2

Thuật toán tương tự như câu trả lời Python 2 của tôi.

Japt , 16 14 byte

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

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

Làm thế nào nó hoạt động

Khá đơn giản:

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

Tôi ước có một số cách để tính đến việc hai nửa mã giống nhau. Đề nghị chào mừng!

Phiên bản cũ (16 byte):

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

Java, 230 155 52

Chơi gôn

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

Ung dung:

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

}

Đầu ra chương trình:

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

Mã máy Zilog ez80, 9 byte

Trong hex:

6C 2D CB3D ED6C 2C CB3D

Trong lắp ráp:

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

Đầu vào là trong thanh ghi h, và đầu ra là trong l.

Zilog ez80 là bộ xử lý 8 bit với bộ tích lũy 8 bit và thanh ghi 24 bit. Không giống như z80, nó có một lệnh mlt(nhân 8 bit), ở chế độ 16 bit, nhân các byte cao và thấp của một cặp thanh ghi, ở đây hlvà lưu trữ lại hl.

Điều này chỉ hoạt động cho các giá trị mà hai lần kết quả phù hợp trong 8 bit; nghĩa là, 23.

TI-BASIC, 13 byte

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

Phép nhân ngầm của TI-BASIC giúp, nhưng nó không có phép chia số nguyên. ⁻int(⁻Xlà một dạng ngắn hơn của trần (x).

vba, 46

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

Gọi bằng? F (x) hoặc = f (A1) trong công thức

Bình thường, 17 14 13 byte

-3 byte nhờ Ypnypn ! Sắp xếp lại các số của toán tử * để lưu 1 byte.

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

Giải trình:

Khi n chẵn, chúng ta có thể chiếm n / 2-1 hàng với n / 2 mảnh, tạo ra tổng số n * (n / 2-1) / 2 mảnh. Biểu thức này tương đương với (n * (n / 2-1) +1) / 2

Khi n là số lẻ, chúng ta có thể tìm thấy số lượng các mảnh sẽ gấp đôi, hai lần số mảnh sẽ trải qua n-1 hàng và nếu tôi lấy đi một mảnh, chúng ta có thể chia các hàng n-1 thành (n- 1) / 2 nhóm gồm 2 hàng sao cho mỗi nhóm có n mảnh, vì vậy biểu thức cho trường hợp này là (n * (n / 2) +1) / 2

Bây giờ cả hai biểu thức khá giống nhau, chúng ta có thể viết mã.

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

Lần đầu tiên tôi sử dụng ngôn ngữ chơi gôn.

Javascript, 33 byte

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

Nếu chức năng ES6 được cho phép thì 18 byte:

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

MATLAB, 37 25 byte

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

Tôi tin rằng điều này sẽ làm việc, làm cho tất cả các trường hợp thử nghiệm.

Nó cũng hoạt động trên Octave . Bạn có thể thử trực tuyến tại đây .

Đối với mã cũ, tôi đã thêm chương trình vào không gian làm việc đó trong một tệp có tên checkerboard.m. Bạn có thể chạy nó bằng cách nhậpcheckerboard tại dấu nhắc, sau đó khi nó khởi động, nhập kích thước yêu cầu tại dấu nhắc. Kết quả sẽ được in.

Đối với mã mới, chỉ cần nhập mã được đăng ở đây vào dấu nhắc, sau đó gọi hàm ẩn danh là ans(n).

Võng mạc , 18 byte

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

Đầu vào và đầu ra là đơn nhất .

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

Phiên bản mới nhất của Retina (mới hơn thử thách này) có thể xử lý I / O thập phân cho bốn byte bổ sung:

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

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

Với đầu vào đơn và đầu ra thập phân, chúng ta có thể thực hiện 16 byte, nhưng điều đó có vẻ hơi căng:

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

Giải trình

Vẫn là cách tiếp cận giống như bất kỳ ai khác, nhưng sử dụng thay thế regex trên một đại diện đơn nhất của số.

11(..?$)?
$_

Điều này tính toán n*((n-1)/2). Chúng tôi thực hiện điều này bằng cách khớp hai ký tự cùng một lúc (chia cho hai) và thay thế chúng bằng toàn bộ chuỗi (nhân với n). Việc giảm nđược thực hiện bằng cách bỏ qua phần còn lại của chuỗi, nếu chỉ còn lại một hoặc hai ký tự.

11?
1

Đây là số nguyên chia cho 2, làm tròn lên. Chúng tôi chỉ cần thay thế hai ký tự bằng một (chia cho 2), nhưng cho phép trận đấu cuối cùng chỉ bao gồm một ký tự (làm tròn số).

Python 3, 39 byte

Điều này hơi khó hiểu, nhưng tôi không chắc mình có thể chơi gôn xa hơn thế này. Một liên kết để thử nghiệm.

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

Prolog, 39 38 byte

Mã số:

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

Giải trình:

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.

Thí dụ:

p(8).
12

Dùng thử trực tuyến tại đây

Biên tập: Đã lưu 1 byte bằng cách thay thế ceil / 2 bằng + 1 // 2

Quai bị, 17 byte

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

Nhờ vào Emigna giải thích thuật toán đơn giản. Điều này khai thác "thiếu sót" toán học của Quai bị rằng các hoạt động được thực hiện nghiêm ngặt từ trái sang phải (không phải PEMDAS) nên không cần phải sử dụng dấu ngoặc đơn. :-)

Tuy nhiên, đầu ra trông có vẻ hơi kỳ quặc, vì Bộ đồng phục của Cache (môi trường Quai bị mà tôi có quyền truy cập) không tự động xuất trả về vận chuyển ngay cả khi nhấn vào đầu vào. Nếu bạn muốn nó đẹp hơn, hãy thêm 4 ký tự để trả về vận chuyển trước / sau:

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

Cảm ơn!

Bash, 32 byte

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

Pyke, 8 byte, không lọc

Dt2f*h2f

song, dec, một nửa, nhiều, inc, một nửa

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

Hàng loạt, 30 byte

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

38 byte nếu đầu vào trên stdin là bắt buộc:

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