บทนำ

กระดานหมากฮอสปกติประกอบด้วย 8 x 8 = 64 กำลังสอง:

คุณจะเห็นว่าในทั้งหมดมี12 ชิ้นสีขาว ขาวดำมีจำนวนชิ้นเท่ากันเสมอ หากมีชิ้นส่วนใด ๆ บนกระดานชิ้นส่วนจะอยู่ใกล้เคียงซึ่งไม่ได้รับอนุญาตสำหรับความท้าทายนี้ เพื่อชี้แจงสิ่งต่าง ๆ ต่อไปนี้เป็นตัวอย่าง:

บอร์ดที่เล็กที่สุดที่เป็นไปได้สำหรับความท้าทายนี้คือ3 x 3 :

คุณจะเห็นว่าจำนวนเงินสูงสุดของชิ้นเท่ากับ2 ดังนั้นเมื่อได้รับN = 3คุณจะต้องเอาท์พุท2 หากอินพุตคือN = 4เราจะได้รับสิ่งต่อไปนี้:

คุณจะเห็นว่าจำนวนเงินสูงสุดยังเป็น 2. ดังนั้นสำหรับN = 4ผลผลิตที่ควรจะเป็น2 สำหรับN = 5ผลลัพธ์ควรเท่ากับ5 :

ตัวอย่าง

STDIN:  3
STDOUT: 2

STDIN:  4
STDOUT: 2

STDIN:  5
STDOUT: 5

STDIN:  6
STDOUT: 6

STDIN:  8
STDOUT: 12

กฎระเบียบ

• การส่งของคุณจะต้องเป็นโปรแกรมหรือฟังก์ชั่นอื่น ๆ ที่ใช้จำนวนเต็มหนึ่งค่าและส่งออกหรือส่งคืนจำนวนชิ้นส่วนบนกระดาน
• คุณสามารถสันนิษฐานได้อย่างปลอดภัยว่าอินพุตเป็นจำนวนเต็มไม่เป็นลบ> 2
• นี่คือรหัสกอล์ฟดังนั้นโปรแกรมที่มีจำนวนไบต์น้อยที่สุดจะเป็นผู้ชนะ!
• โปรดทราบว่าสี่เหลี่ยมที่ด้านซ้ายล่างของกระดานจะมืดเสมอ ชิ้นจะถูกวางไว้ในสี่เหลี่ยมสีเข้มเท่านั้น
• คุณต้องครอบครองเต็มแถวด้วยชิ้น

พาร์ 8 ไบต์

✶″½↓┐*½┐

ใช้หนึ่งไบต์ต่ออักขระ

คำอธิบาย

               ## [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 ไบต์

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

ลองออนไลน์

คำอธิบาย

นี่ยังคงเป็นการคำนวณแบบเดียวกับที่ฉันใช้ในคำตอบ CJam และ Labyrinth ของฉัน แต่เนื่องจากรูปแบบหน่วยความจำ ... พิเศษของ Hexagony ... มันเป็นเรื่องยากที่จะบีบการคำนวณเป็น 19 ไบต์ (เพื่อให้พอดีกับภายใน ความยาวด้านหกเหลี่ยม 3)

เช่นเดียวกับคำตอบเขาวงกตของฉันสิ่งนี้จะสิ้นสุดลงด้วยข้อผิดพลาดการหารด้วย 0

นี่คือรหัสที่กางออก:

อย่างที่ฉันบอกว่ารหัสนั้นเป็นเส้นตรงทั้งหมด คุณสามารถแบ่งเส้นทางการดำเนินการเข้าด้วยกันตามลำดับสีเทา - ม่วง - เขียว - แดง - น้ำเงิน เส้นทางยังคงดำเนินต่อไปอีกเล็กน้อยจนกว่าจะ:ถึงทางซ้าย การลบ/(ซึ่งควบคุมการเปลี่ยนเส้นทางการไหลเท่านั้น) โปรแกรมทั้งหมดที่ไม่ได้เลื่อนเป็นเชิงเส้นคือ:

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

ดังนั้นคำถามคือมันทำงานอย่างไร หน่วยความจำของ Hexagony เป็นกราฟเส้นของกริดหกเหลี่ยมโดยที่ขอบของกริดแต่ละอันมีค่าจำนวนเต็ม (เริ่มต้นเป็นศูนย์) ตัวชี้หน่วยความจำ (MP) อยู่บนขอบด้านหนึ่งเสมอและชี้ไปในทิศทางที่แน่นอนตามขอบนั้น การดำเนินการทางคณิตศาสตร์มักใช้กับขอบทั้งสองที่ชี้ไปที่และเก็บไว้ในขอบที่ MP เปิดอยู่

สำหรับโปรแกรมนี้เราจะใช้ขอบทั้งสามที่มีป้ายกำกับA , B , Cโดยมี MP เริ่มต้นดังแสดงที่นี่:

ดังนั้นนี่คือวิธีการทำงาน:

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

CJam, 10 ไบต์

ri_(2/*)2/

ทดสอบที่นี่

คำอธิบาย

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.

เขาวงกต 11 ไบต์

วู้เพียงหนึ่งไบต์อยู่เบื้องหลัง CJam

?:(#/*)_2/!

ลองออนไลน์

เป็นสิ่งเดียวกัน:

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

อย่างไรก็ตาม ณ จุดนี้โปรแกรมยังไม่ยุติ แต่ตัวชี้คำแนะนำกลับกลายเป็นจุดตายและหมุนไปรอบ ๆ แต่ตอนนี้/พยายามที่จะคำนวณ0/0ซึ่งสิ้นสุดลงด้วยข้อผิดพลาด

อย่างจริงจัง 8 ไบต์

,;D½L*½K

มีประโยชน์อย่างจริงจัง½(หารด้วย 2) และK(เพดาน) ดังนั้นเราไม่จำเป็นต้องเพิ่มก่อนหาร

ลองที่นี่พร้อมคำอธิบาย

Python 2, 22 21 ไบต์

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

ฉันแยกจากกันเป็นสองกรณีแปลก ๆ N และแม้แต่ N

ด้วยเลขคี่ N เราสามารถเติม (N - 1) / 2 แถวโดยมีค่าเฉลี่ย N / 2 ชิ้น เนื่องจากแถวแรกมีชิ้นส่วนมากเราควรจะตัดผลลัพธ์นี้ ดังนั้นเมื่อ N เป็นเลขคี่เราจะมีชิ้นส่วน ((N-1) / 2 * N / 2)

ด้วยเลข N เราสามารถเติม N / 2 - 1 หรือแถว ((N - 1) / 2) แถวแต่ละแถวมี N / 2 ชิ้น

เราสามารถรวมสองนิพจน์เข้าด้วยกันโดย ceil (floor ((N-1) / 2) * N / 2) ตั้งแต่ ceil (x / 2) = ชั้น ((x + 1) / 2) ((N - 1) // 2 * N + 1) // 2เราสามารถใช้พื้นส่วน:

JavaScript, 37 35 bytes

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

คำอธิบาย

ใช้เทคนิคที่คล้ายกันกับคำตอบที่เหลือ นี่คืออัลกอริทึมที่ไม่ได้รับการดัดแปลง:

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

dc, 12

?d1-2/*1+2/p

ผลการทดสอบ:

$ 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 ไบต์

/h*/tQ2Q2

อัลกอริทึมเช่นเดียวกับคำตอบ Python 2 ของฉัน

Japt , 16 14 ไบต์

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

ลองออนไลน์!

มันทำงานอย่างไร

ค่อนข้างง่าย:

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

ฉันหวังว่าจะมีวิธีที่จะคำนึงถึงว่าครึ่งหนึ่งของรหัสนั้นคล้ายกันมาก ข้อเสนอแนะยินดีต้อนรับ!

รุ่นเก่า (16 ไบต์):

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

Java, 230 155 52

แข็งแรงเล่นกอล์ฟ:

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

Ungolfed:

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

}

ผลลัพธ์ของโปรแกรม:

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

รหัสเครื่อง Zilog ez80 ขนาด 9 ไบต์

ในรูปหกเหลี่ยม:

6C 2D CB3D ED6C 2C CB3D

ในการชุมนุม:

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

อินพุตอยู่ในการลงทะเบียน hและเอาต์พุตอยู่lและการส่งออกอยู่ใน

Zilog ez80 เป็นโปรเซสเซอร์ 8 บิตพร้อมตัวสะสม 8 บิตและรีจิสเตอร์ 24 บิต ต่างจาก z80 แต่ก็มีmlt (8 บิตคูณ) ซึ่งในโหมด 16 บิตคูณจำนวนสูงและต่ำของคู่การลงทะเบียนที่นี่hlและเก็บไว้ข้างหลังhlและร้านค้ากลับมาอยู่ใน

ใช้งานได้กับค่าที่ผลลัพธ์สองเท่าพอดีใน 8 บิต นั่นคือn≤23

TI-BASIC ขนาด 13 ไบต์

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

การคูณโดยนัยของ TI-BASIC ช่วยได้ แต่ไม่มีการแบ่งจำนวนเต็ม ⁻int(⁻Xเป็นรูปแบบที่สั้นกว่าของ ceil (x)

vba, 46

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

เรียกด้วย? f (x) หรือ = f (A1) ในสูตร

Pyth, 17 14 13 ไบต์

-3 ไบต์ขอบคุณYpnypn ! ปรับหมายเลขของตัวดำเนินการ * ใหม่เพื่อบันทึก 1 ไบต์

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

คำอธิบาย:

เมื่อ n เป็นเลขคู่เราสามารถครองแถว n / 2-1 ด้วย n / 2 ชิ้นทำให้มีจำนวน n * (n / 2-1) / 2 ชิ้น นิพจน์นี้เทียบเท่ากับ (n * (n / 2-1) +1) / 2

เมื่อ n เป็นเลขคี่เราสามารถหาจำนวนของชิ้นส่วนที่ดูเหมือนเป็นสองเท่าสองเท่าของจำนวนชิ้นจะมีจำนวนแถวที่ n-1 และถ้าฉันเอาชิ้นหนึ่งไปเราจะแบ่งแถว n-1 ออกเป็น (n- 1) / 2 กลุ่ม 2 แถวโดยที่แต่ละกลุ่มมีจำนวน n ชิ้นดังนั้นนิพจน์สำหรับกรณีนี้คือ (n * (n / 2) +1) / 2

ตอนนี้ทั้งสองนิพจน์มีความคล้ายคลึงกันมากเราสามารถเขียนโค้ดได้

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

ครั้งแรกที่ฉันใช้ภาษากอล์ฟ

Javascript, 33 ไบต์

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

หากอนุญาตให้ใช้ฟังก์ชั่น ES6 จะได้ 18 ไบต์:

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

MATLAB, 37 25 ไบต์

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

ฉันเชื่อว่าวิธีนี้ใช้ได้ผลสำหรับทุกกรณีทดสอบ

มันยังใช้งานได้ในระดับแปดเสียง คุณสามารถลองออนไลน์ได้ที่นี่

checkerboard.mสำหรับรหัสเดิมผมเพิ่มโปรแกรมไปยังพื้นที่ทำงานว่าในไฟล์ชื่อ คุณสามารถเรียกใช้โดยป้อนcheckerboardที่พรอมต์จากนั้นเมื่อมันเริ่มให้ป้อนขนาดที่ต้องการที่พรอมต์ ผลลัพธ์จะถูกพิมพ์

ans(n)สำหรับรหัสใหม่เพียงแค่ใส่รหัสที่โพสต์ที่นี่เข้าสู่พรอมต์แล้วโทรฟังก์ชั่นที่ไม่ระบุชื่อเป็น

เรติน่า 18 ไบต์

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

อินพุตและเอาต์พุตอยู่ในสภาวะเดียวกัน

ลองออนไลน์!

รุ่นล่าสุดของ Retina (ใหม่กว่าความท้าทายนี้) สามารถจัดการทศนิยม I / O สำหรับสี่ไบต์เพิ่มเติม:

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

ลองออนไลน์!

ด้วยอินพุตและเอาต์พุตทศนิยมเราสามารถทำได้ 16 ไบต์ แต่ดูเหมือนจะยืดออกเล็กน้อย:

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

คำอธิบาย

ยังคงเป็นวิธีการเดียวกันกับใครก็ตาม แต่ใช้การแทนที่ regex แทนตัวเลขที่ไม่เหมือนกัน

11(..?$)?
$_

การคำนวณn*((n-1)/2)นี้ เราทำสิ่งนี้โดยการจับคู่อักขระสองตัวในแต่ละครั้ง (หารด้วยสอง) และแทนที่ด้วยสตริงทั้งหมด (การคูณด้วยn) การลดลงของnจะกระทำโดยการข้ามส่วนที่เหลือของสตริงถ้าเหลือเพียงหนึ่งหรือสองตัวอักษร

11?
1

นี่คือการหารจำนวนเต็มด้วย 2 ปัดเศษขึ้น เราเพียงแค่แทนที่ตัวละครสองตัวด้วยหนึ่ง (หารด้วย 2) แต่อนุญาตให้การแข่งขันครั้งสุดท้ายประกอบด้วยเพียงหนึ่งตัวอักษร (ปัดเศษขึ้น)

Python 3, 39 ไบต์

นี่เป็นเรื่องเล็กน้อย แต่ฉันไม่แน่ใจว่าฉันจะตีกอล์ฟได้ไกลกว่านี้อีก ลิงค์สำหรับทดสอบ

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

Prolog, 39 38 ไบต์

รหัส:

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

คำอธิบาย:

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.

ตัวอย่าง:

p(8).
12

ลองออนไลน์ได้ที่นี่

แก้ไข:บันทึก 1 ไบต์โดยแทนที่ ceil / 2 ด้วย + 1 // 2

คางทูม 17 ไบต์

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

ขอบคุณEmignaสำหรับคำอธิบายอัลกอริทึมที่ง่าย วิธีการนี้ใช้ประโยชน์จาก "ขาด" คณิตศาสตร์ของคางทูมที่ดำเนินการอย่างเคร่งครัดจากซ้ายไปขวา (ไม่ใช่ PEMDAS) ดังนั้นจึงไม่จำเป็นต้องใส่วงเล็บ :-)

เอาท์พุทดูแปลก ๆ แต่เนื่องจาก Cache's Ensemble (สภาพแวดล้อมแบบคางทูมที่ฉันมีการเข้าถึง) จะไม่คืนค่าการส่งออกโดยอัตโนมัติแม้ว่าจะกดที่อินพุต หากคุณต้องการให้สวยขึ้นให้เพิ่ม 4 อักขระสำหรับการขึ้นบรรทัดใหม่ / การขึ้นบรรทัดใหม่:

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

ขอบคุณ!

Bash, 32 ไบต์

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

Pyke, 8 ไบต์, ไม่ใช่การแข่งขัน

Dt2f*h2f

dup, ธ.ค. , ครึ่ง Mult, INC ครึ่ง

ลองที่นี่!

แบตช์ 30 ไบต์

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

38 ไบต์หากจำเป็นต้องใช้อินพุตบน stdin:

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