pengantar

Papan catur normal berisi 8 x 8 = 64 kotak:

Anda dapat melihat bahwa secara total, ada 12 keping putih . Hitam dan putih selalu memiliki jumlah potongan yang sama. Jika ada potongan lagi di papan tulis, potongan akan bertetangga, yang tidak diperbolehkan untuk tantangan ini. Untuk memperjelas beberapa hal, berikut adalah beberapa contoh:

Papan terkecil yang memungkinkan untuk tantangan ini adalah 3 x 3 :

Anda dapat melihat bahwa jumlah maksimum potongan sama dengan 2 . Jadi, ketika diberi N = 3 , Anda perlu output 2 . Jika inputnya adalah N = 4 , kita mendapatkan yang berikut:

Anda dapat melihat bahwa jumlah maksimum juga 2. Jadi untuk N = 4 , output harus 2 . Untuk N = 5 , output harus sama dengan 5 :

Contohnya

STDIN:  3
STDOUT: 2

STDIN:  4
STDOUT: 2

STDIN:  5
STDOUT: 5

STDIN:  6
STDOUT: 6

STDIN:  8
STDOUT: 12

Aturan

• Kiriman Anda harus berupa program, atau fungsi dll. Yang mengambil satu bilangan bulat dan menampilkan atau mengembalikan jumlah potongan di papan tulis
• Anda dapat dengan aman berasumsi bahwa inputnya adalah bilangan bulat non-negatif> 2
• Ini adalah kode-golf , sehingga program dengan jumlah byte terkecil menang!
• Perhatikan bahwa kotak di bagian kiri bawah papan selalu gelap. Potongan hanya ditempatkan di kotak gelap
• Anda harus menempati barisan penuh dengan potongan-potongan

Par , 8 byte

✶″½↓┐*½┐

Satu byte digunakan per karakter.

Penjelasan

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

Hexagony , 19 byte

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

Cobalah online.

Penjelasan

Ini masih perhitungan yang sama seperti yang saya gunakan dalam jawaban CJam dan Labyrinth saya, tetapi karena model memori Hexagony ... khusus, agak sulit untuk memeras perhitungan menjadi 19 byte (sehingga pas di dalam sebuah panjang sisi 3 hexagon).

Seperti jawaban Labyrinth saya, ini diakhiri dengan kesalahan pembagian-oleh-0.

Ini kode yang tidak dilipat:

Seperti yang saya katakan kode sepenuhnya linier. Anda dapat menyatukan jalur yang dieksekusi bersama-sama dalam urutan abu-abu-ungu-hijau-merah-biru. Jalan itu sebenarnya berlanjut sedikit lebih jauh sampai menyentuh :di sebelah kiri. Menghapus /(yang hanya mengarahkan kontrol aliran), seluruh program membuka gulungan secara linear adalah:

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

Jadi pertanyaannya adalah bagaimana cara kerjanya. Memori Hexagony adalah grafik garis dari kisi heks, di mana setiap tepi kisi berisi nilai integer (awalnya nol). Memory pointer (MP) selalu berada di satu sisi dan menunjuk ke arah tertentu di sepanjang sisi itu. Operasi aritmatika umumnya diterapkan pada dua sisi menunjuk pada dan disimpan di tepi MP aktif.

Untuk program ini, kita akan menggunakan tiga sisi berlabel A , B , C , dengan MP dimulai seperti yang ditunjukkan di sini:

Jadi, inilah cara kerjanya:

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

CJam, 10 byte

ri_(2/*)2/

Uji di sini.

Penjelasan

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.

Labirin , 11 byte

Woohoo, hanya satu byte di belakang CJam .

?:(#/*)_2/!

Cobalah online.

Ini pada dasarnya hal yang sama:

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

Namun, pada saat ini program belum berakhir. Sebaliknya, penunjuk instruksi telah menemui jalan buntu dan berbalik. Tetapi sekarang /mencoba untuk menghitung 0/0yang berakhir dengan kesalahan .

Serius , 8 byte

,;D½L*½K

Serius memiliki yang praktis ½(float divide by 2), dan K(ceiling), jadi kita tidak perlu menambahkan satu sebelum pembagian.

Coba di sini dengan penjelasan.

Python 2, 22 21 byte

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

Saya pertama kali berpisah dalam dua kasus, N aneh dan bahkan N.

Dengan N aneh kita dapat mengisi (N - 1) / 2 baris, yang berisi rata-rata N / 2 buah. Karena baris pertama selalu memiliki lebih banyak bagian, kita harus menghentikan hasil ini. Jadi ketika N aneh, kami memiliki potongan ceil ((N-1) / 2 * N / 2).

Dengan bahkan N kita dapat mengisi baris N / 2 - 1, atau lantai ((N - 1) / 2), setiap baris berisi potongan N / 2.

Kita dapat menggabungkan dua ekspresi ini dengan ceil (floor ((N-1) / 2) * N / 2). Sejak ceil (x / 2) = lantai ((x + 1) / 2) kita bisa menggunakan lantai divisi: ((N - 1) // 2 * N + 1) // 2.

JavaScript, 37 35 byte

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

Penjelasan

Gunakan teknik yang mirip dengan jawaban lainnya. Ini adalah algoritma ungolfed:

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

dc, 12

?d1-2/*1+2/p

Hasil tes:

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

Pyth, 9 byte

/h*/tQ2Q2

Algoritma yang sama dengan jawaban Python 2 saya.

Japt , 16 14 byte

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

Cobalah online!

Bagaimana itu bekerja

Cukup mudah:

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

Saya berharap ada beberapa cara untuk memperhitungkan bahwa dua bagian dari kode sangat mirip. Saran diterima!

Versi lama (16 byte):

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

Jawa, 230 155 52

Golf:

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

Tidak Disatukan:

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

}

Output program:

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

Kode mesin Zilog ez80, 9 byte

Dalam hex:

6C 2D CB3D ED6C 2C CB3D

Dalam perakitan:

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

Input dalam register h, dan output dalam l.

Zilog ez80 adalah prosesor 8-bit dengan akumulator 8 bit dan register 24-bit. Berbeda dengan z80, ia memiliki mltinstruksi (multiply 8-bit), yang, dalam mode 16-bit, mengalikan byte tinggi dan rendah dari pasangan register, di sini hl, dan menyimpan kembali hl.

Ini hanya berfungsi untuk nilai yang hasilnya dua kali pas dalam 8 bit; yaitu, n≤23.

TI-BASIC, 13 byte

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

Penggandaan implisit TI-BASIC membantu, tetapi tidak memiliki divisi integer. ⁻int(⁻Xadalah bentuk ceil yang lebih pendek (x).

vba, 46

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

Panggil dengan? F (x), atau = f (A1) dalam formula

Pyth, 17 14 13 byte

-3 byte terima kasih kepada Ypnypn ! Mengatur ulang jumlah operator * untuk menghemat 1 byte.

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

Penjelasan:

Ketika n adalah genap, kita dapat menempati baris n / 2-1 dengan potongan n / 2, sehingga menghasilkan total n * (n / 2-1) / 2 buah. Ungkapan ini setara dengan (n * (n / 2-1) +1) / 2

Ketika n ganjil, kita dapat menemukan bagaimana dua kali jumlah potongan akan terlihat, dua kali jumlah potongan akan merentang n-1 baris, dan jika saya mengambil satu potong, kita dapat membagi n-1 baris menjadi (n- 1) / 2 grup yang terdiri dari 2 baris sehingga setiap grup memiliki n buah, sehingga ekspresi untuk kasus ini adalah (n * (n / 2) +1) / 2

Sekarang kedua ekspresi sangat mirip, kita dapat menulis kode.

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

Pertama kali saya menggunakan bahasa golf.

Javascript, 33 byte

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

Jika fungsi ES6 diizinkan maka 18 byte:

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

MATLAB, 37 25 byte

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

Saya percaya ini harus berhasil, tidak untuk semua kasus uji.

Ini juga berfungsi pada Oktaf . Anda dapat mencoba online di sini .

Untuk kode lama saya menambahkan program ke ruang kerja itu dalam file bernama checkerboard.m. Anda dapat menjalankannya dengan hanya memasukkan checkerboardpada prompt, lalu ketika mulai, masukkan ukuran yang diperlukan pada prompt. Hasilnya akan dicetak.

Untuk kode baru, cukup masukkan kode yang diposting di sini ke prompt, lalu panggil fungsi anonim sebagai ans(n).

Retina , 18 byte

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

Input dan output di unary .

Cobalah online!

Versi terbaru dari Retina (lebih baru dari tantangan ini) dapat menangani I / O desimal untuk empat byte tambahan:

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

Cobalah online!

Dengan input unary dan output desimal, kita dapat melakukan 16 byte, tetapi sepertinya sedikit peregangan:

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

Penjelasan

Masih pendekatan yang sama seperti orang lain, tetapi menggunakan penggantian regex pada representasi nomor unary.

11(..?$)?
$_

Ini menghitung n*((n-1)/2). Kami melakukan ini dengan mencocokkan dua karakter sekaligus (pembagian dua) dan menggantinya dengan seluruh string (dikalikan dengan n). Penguraian ndilakukan dengan melewatkan sisa string, jika hanya satu atau dua karakter yang tersisa.

11?
1

Ini adalah pembagian integer dengan 2, dibulatkan ke atas. Kami hanya mengganti dua karakter dengan satu (pembagian dengan 2), tetapi memungkinkan pertandingan terakhir hanya terdiri dari satu karakter (pembulatan ke atas).

Python 3, 39 byte

Ini sedikit membengkak, tapi saya tidak yakin saya bisa bermain golf lebih jauh dari ini. Tautan untuk pengujian.

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

Prolog, 39 38 byte

Kode:

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

Penjelasan:

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.

Contoh:

p(8).
12

Cobalah online di sini

Sunting: Disimpan 1 byte dengan mengganti ceil / 2 dengan + 1 // 2

Mumps, 17 byte

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

Terima kasih kepada Emigna untuk penjelasan algoritma sederhana. Ini mengeksploitasi "kekurangan" matematika Mumps bahwa operasi dijalankan secara ketat dari kiri ke kanan (bukan PEMDAS) sehingga tanda kurung tidak diperlukan. :-)

Output memang terlihat agak aneh, namun, sebagai Cache's Ensemble (lingkungan Mumps yang saya akses) tidak secara otomatis menampilkan carriage return bahkan ketika ditekan pada input. Jika Anda menginginkannya lebih cantik, tambahkan 4 karakter untuk pengembalian kereta sebelum / sesudah:

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

Terima kasih!

Bash, 32 byte

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

Pyke, 8 byte, tidak bersaing

Dt2f*h2f

dup, dec, half, mult, inc, half

Coba di sini!

Batch, 30 byte

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

38 byte jika input pada stdin diperlukan:

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