Số đa giác là số chấm trong một đa giác kkích thước n.

Bạn sẽ được cung cấp nvà k, và nhiệm vụ của bạn là viết một chương trình / hàm xuất / in số tương ứng.

Chấm điểm

Đây là môn đánh gôn . Giải pháp ngắn nhất trong byte thắng.

Thí dụ

Số 3lục giác thứ (( k=6, n=3) là 28do có 28các dấu chấm ở trên.

Tủ thử

Có thể được tạo ra từ bộ thử nghiệm Pyth này .

Cách sử dụng: hai dòng trên mỗi testcase, ntrên, kdưới.

n    k  output
10   3  55
10   5  145
100  3  5050
1000 24 10990000

Thêm thông tin

• Trong Wikipedia: https://en.wikipedia.org/wiki/Poly Cross_number
• Trong Wolfram Mathworld: http://mathworld.wolfram.com/Poly CrossNumber.html
• Trong OEIS Wiki: http://oeis.org/wiki/Poly Cross_numbers
• Trình tự OEIS cho các số n cho các số n : 3 (A000217) , 4 (A000290) , 5 (A000326) , 6 (A000384) , 7 (A000566) , 8 (A000567) , 9 (A001106) , 10 (A001106) , 11 (A051682) , 12 (A051624) , 13 (A051865) , 14 (A051866) , 15 (A051867) , 16 (A051868) , 17 (A051869) , 18 (A051870) , 19 (A051871) , 20 (A051872) , 21 (A051873) , 22 (A051874) , 23 (A051875) , 24 (A051876)

Thạch , 7 byte

’;’;PH+

Điều này sử dụng công thức

để tính số ^{thứ tự} s ^thứ n .

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

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

’;’;PH+  Main link. Arguments: s, n

’        Decrement; yield s - 1.
 ;       Concatenate; yield [s - 1, n].
  ’      Decrement; yield [s - 2, n - 1].
   ;     Concatenate; yield [s - 2, n - 1, n].
    P    Product; yield (s - 2)(n - 1)n.
     H   Halve; yield (s - 2)(n - 1)n ÷ 2.
      +  Add; yield (s - 2)(n - 1)n ÷ 2 + n.

Lục giác , 25 byte

?(({"+!@/"*'+{/?('*})/2':

Mở ra:

   ? ( ( {
  " + ! @ /
 " * ' + { /
? ( ' * } ) /
 2 ' : . . .
  . . . . .
   . . . .

Đọc kđầu tiên và nthứ hai (sử dụng bất kỳ dấu phân cách).

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

Giải trình

Chương trình này hoàn toàn tuyến tính, nhưng như thường lệ trong Hexagony, thứ tự thực hiện ở khắp mọi nơi:

Các đường dẫn được thực hiện theo thứ tự xám , xanh đậm , đỏ , xanh nhạt , xanh đậm , hồng . Như bạn có thể thấy, ba /chỉ hành động để chuyển hướng dòng chảy. Ngoài ra, .không có ops. Tước tất cả sự huyền ảo của hình lục giác, chương trình tuyến tính thu được là:

?(({?('*})"*'+{2':"+!@

Điều này tính toán công thức tiêu chuẩn

Giống như hầu hết các câu trả lời khác. Nó làm như vậy bằng cách sử dụng năm cạnh bộ nhớ sau, với con trỏ bộ nhớ (MP) bắt đầu như được hiển thị màu đỏ:

Đây là cách thực hiện:

?    Read integer input s into edge A.
((   Decrement twice to get (s-2).
{    Move the MP forwards onto edge B.
?    Read integer input n into edge B.
(    Decrement to get (n-1).
'    Move the MP backwards onto edge C.
*    Multiply edges A and B to store the result (s-2)(n-1) in edge C.
}    Move the MP forwards onto edge B.
)    Increment to restore the value n.
"    Move the MP backwards onto edge A.
*    Multiply edge B and C to store the result (s-2)(n-1)n in edge A.
'    Move the MP backwards onto edge D.
+    Add edges E (initially 0) and A to copy (s-2)(n-1)n into edge D.
{    Move the MP forwards onto edge E.
2    Set the memory edge to value 2.
'    Move the MP backwards onto edge A.
:    Divide edge D by edge E to store (s-2)(n-1)n/2 in edge A.
"    Move the MP backwards onto edge C.
+    Add edges A and B to store (s-2)(n-1)n/2+n in edge C.
!    Print as integer.
@    Terminate the program.

05AB1E , 8 byte

Mã số:

D<LOIÍ*+

Giải trình:

D         # Duplicate the input
 <LO      # Compute n × (n - 1) / 2
    IÍ    # Compute k - 2
      *   # Multiply, resulting into (k - 2)(n - 1)(n) / 2
       +  # Add, resulting into n + (k - 2)(n - 1)(n) / 2

Sử dụng mã hóa CP-1252 . Hãy thử trực tuyến! .

Mê cung , 13 byte

?::(*?((*#/+!

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

Giải trình

Do các lệnh một ký tự (chỉ đơn thuần là sự cần thiết của tính chất 2D của ngôn ngữ), Labyrinth có thể gây ngạc nhiên cho các chương trình tuyến tính.

Điều này sử dụng cùng một công thức như một số câu trả lời khác:

Op  Explanation                 Stack
?   Read n.                     [n]
::  Make two copies.            [n n n]
(   Decrement.                  [n n (n-1)]
*   Multiply.                   [n (n*(n-1))]
?   Read s.                     [n (n*(n-1)) s]
((  Decrement twice.            [n (n*(n-1)) (s-2)]
*   Multiply.                   [n (n*(n-1)*(s-2))]
#   Push stack depth, 2.        [n (n*(n-1)*(s-2)) 2]
/   Divide.                     [n (n*(n-1)*(s-2))/2]
+   Add.                        [(n+(n*(n-1)*(s-2))/2)]
!   Print.                      []

Tại thời điểm này, con trỏ lệnh chạm vào ngõ cụt và quay lại. Bây giờ +được thực hiện lại, đó là một no-op (vì đáy của ngăn xếp được lấp đầy với một số lượng vô hạn), và sau đó /thử một phép chia bằng 0, kết thúc chương trình có lỗi.

JavaScript (ES6), 24 22 byte

(k,n)=>n+n*--n*(k-2)/2

Giải thích: Mỗi n-gon có thể được coi là n điểm dọc theo một cạnh cộng với tam giác k-2 có kích thước n-1, tức là n + n (n-1) (k-2) / 2.

CJam, 13 byte

q~__(*2/@2-*+

Dùng thử trực tuyến

APL (Dyalog Extended) , 11 byte ^SBCS

Cảm ơn Adám đã giúp đỡ vì đã gợi ý phiên bản thay thế này.

⊢+-∘2⍤⊣×2!⊢

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

Giải trình

⊢+-∘2⍤⊣×2!⊢  Right argument (⊢) is n. Left argument (⊣) is s.

        2!⊢  Binomial(n, 2) == n*(n-1)/2.
  -∘2⍤⊣×     Multiply (×) with by getLeftArgument (⊢) with (⍤) minus 2 (-∘2) called on it.
             In short, multiply binomial(n,2) with (s-2).
⊢+           Add n.

APL (Dyalog Unicode) , 12 11 byte ^SBCS

Cảm ơn Adám vì sự giúp đỡ của anh ấy trong việc chơi golf này.

Chỉnh sửa: -1 byte từ ngn.

⊢+{⍺-2}×2!⊢

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

Ungolfing

⊢+{⍺-2}×2!⊢  Right argument (⊢) is n. Left argument (⊣) is s.

        2!⊢  Binomial(n, 2) == n*(n-1)/2.
  {⍺-2}×     Multiply it by s-2.
⊢+           Add n.

Trên thực tế, 12 byte

3@n(¬@D3╟π½+

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

Giải trình:

3@n(¬@D3╟π½+
3@n           push 3 copies of n (stack: [n, n, n, k])
   (¬         bring k to front and subtract 2 ([k-2, n, n, n])
     @D       bring an n to front and subtract 1 ([n-1, k-2, n, n])
       3╟π    product of top 3 elements ([n*(n-1)*(k-2), n])
          ½   divide by 2 ([n*(n-1)*(k-2)/2, n])
           +  add ([n*(n-1)*(k-2)/2 + n])

dc , 14 byte

?dd1-*2/?2-*+p

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

Giải trình

Điều này sử dụng công thức sau (lưu ý rằng T _n = n*(n-1)/2):

                # inputs              | N S                  | 10 5
?dd             # push N three times  | N, N, N              | 10, 10, 10
   1-           # subtract 1          | (N-1), N, N          | 9, 10, 10
     *          # multiply            | (N-1)*N, N           | 90, 10
      2/        # divide by two       | (N-1)*N/2, N         | 45, 10
        ?       # push S              | S, (N-1)*N/2, N      | 5, 45, 10
         2-     # subtract 2          | (S-2), (N-1)*N/2, N  | 3, 45, 10
           *    # multiply            | (S-2)*(N-1)*N/2, N   | 135, 10
            +   # add                 | (S-2)*(N-1)*N/2 + N  | 145
             p  # print to stdout

Aceto , 18 15 byte

Câu trả lời dc của cảng Bruce Forte :

riddD*2/ri2-*+p

Đã lưu 3 byte bằng cách nhận ra rằng bất kỳ chương trình Aceto "thuần túy" (không có lệnh kết hợp) nào cũng có thể được viết tuyến tính.

MathGolf , 8 byte

_┐*½?⌡*+

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

Giải thích (với $n = 10, k = 5$

_          duplicate first implicit input, stack is [10, 10]
 ┐         push TOS-1 without popping, stack is [10, 10, 9]
  *        multiply, stack is [10, 90]
   ½       halve TOS, stack is [10, 45]
    ?      rotate top 3 stack elements, popping k to the top: [10, 45, 5]
     ⌡     decrement TOS twice: [10, 45, 3]
      *    multiply: [10, 135]
       +   add: [145]

Một 8 -terter thay thế là ┼┐*½\⌡*+, lấy đầu vào theo thứ tự đảo ngược.

> <> , 13 byte

::1-*2,{2-*+n

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

Toán học, 17 byte

(#2-2)#(#-1)/2+#&

Ứng dụng thẳng về phía trước của công thức.

Sử dụng

  f = (#2-2)#(#-1)/2+#&
  f[10, 3]
55
  f[10, 5]
145
  f[100, 3]
5050
  f[1000, 24]
10990000

J, 14 byte

]++/@i.@]*[-2:

Dựa trên công thức.

P(k, n) = (k - 2) * T(n - 1) + n where T(n) = n * (n + 1) / 2
        = (k - 2) * n * (n - 1) / 2 + n

Sử dụng

   f =: ]++/@i.@]*[-2:
   3 f 10
55
   5 f 10
145
   3 f 100
5050
   24 f 1000
10990000

Giải trình

]++/@i.@]*[-2:
            2:  The constant function 2
          [     Get k
           -    Subtract to get k-2
        ]       Get n
     i.@        Make a range from 0 to n-1
  +/@           Sum the range to get the (n-1) Triangle number = n*(n-1)/2
                The nth Triangle number is also the sum of the first n numbers
         *      Multiply n*(n-1)/2 with (k-2)
]               Get n
 +              Add n to (k-2)*n*(n-1)/2

TI-Basic, 20 byte

Prompt K,N:(K-2)N(N-1)/2+N

Ngôn ngữ GameMaker, 44 byte

n=argument1;return (argument0-2)*n*(n-1)/2+n

Python 3, 31 30 28 byte

Phương trình thẳng lên từ bài viết wiki này

lambda s,n:(s-2)*(n-1)*n/2+n

Cảm ơn @Mego đã lưu một byte!

Fourier, 18 byte

I-2~SI~Nv*N/2*S+No

Hãy thử nó trên FourIDE!

Lấy k làm đầu vào đầu tiên và n là đầu vào thứ hai. Sử dụng công thức:

Mã giả giải thích:

S = Input - 2
N = Input
Print (N - 1) * N / 2 *S + N

Excel, 22 byte

Tính số A1thứ tự B1chéo.

=(B1-2)*A1*(A1-1)/2+A1

Java 8, 21 byte

Tất cả các câu trả lời riêng lẻ có độ dài byte bằng nhau:

k->n->n+n*~-n*(k-2)/2
k->n->n+n*--n*(k-2)/2
k->n->n+n*~-n*~-~-k/2
k->n->n+n*--n*~-~-k/2

Giải trình:

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

k->n->            // Method with two integer parameters and integer return-type
  n+              //  Return `n` plus
    n*            //   `n` multiplied by
      ~-n         //   `n-1`
         *(k-2)   //   Multiplied by `k-2`
               /2 //   Divided by 2
                  // End of method (implicit / single-line return-statement)

Japt , 14 12 byte

U+[U½UÉVa2]×

Thử nó

Husk , 9 byte

S+~*-2(Σ←

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

Giải trình

Sử dụng công thức tương tự như trong dccâu trả lời của tôi :

            -- implicit inputs S, N                     | 5, 10
S+          -- compute N + the result of the following  | 10 + 
  ~*        --   multiply these two together            |      (   ) * 
    -2      --     S-2                                  |       S-2
      (Σ←)  --     triangle number of (N-1)             |              tri(N-1)

APL (NARS), 16 char, 32 byte

{⍵+(⍺-2)×+/⍳⍵-1}

Nó dựa trên thực tế là dường như phép thử n × (n-1) / 2 = sum (1..n-1):

  f←{⍵+(⍺-2)×+/⍳⍵-1}
  10 f 3
27
  3 f 10
55
  5 f 19
532
  3 f 10
55
  5 f 10
145
  3 f 100
5050
  24 f 1000
10990000