Giới thiệu

Trong toán học, một số đa giác là một số được biểu diễn dưới dạng các chấm hoặc sỏi được sắp xếp theo hình đa giác thông thường. Các dấu chấm được coi là bảng chữ cái (đơn vị). Đây là một loại số chính xác 2 chiều.

Số 10, ví dụ, có thể được sắp xếp thành một hình tam giác:

*
**
***
****

Nhưng 10 không thể được sắp xếp như một hình vuông. Số 9, mặt khác, có thể là:

***
***
***

Một số số, như 36, có thể được sắp xếp cả hình vuông và hình tam giác:

******  *
******  **
******  ***
******  ****
******  *****
******  ******

Theo quy ước, 1 là số đa giác đầu tiên cho bất kỳ số cạnh nào. Quy tắc để mở rộng đa giác lên kích thước tiếp theo là mở rộng hai nhánh liền kề thêm một điểm và sau đó thêm các cạnh phụ cần thiết giữa các điểm đó. Trong các sơ đồ sau, mỗi lớp thêm được hiển thị như màu đỏ.

Số tam giác:

Số vuông:

Các đa giác có số cạnh cao hơn, chẳng hạn như ngũ giác và lục giác, cũng có thể được xây dựng theo quy tắc này, mặc dù các chấm sẽ không còn tạo thành một mạng hoàn toàn đều đặn như trên.

Số ngũ giác:

Số lục giác:

^{Nguồn: Wikipedia}

Nhiệm vụ của bạn

Cho số nguyên dương N (1 <= N <= 1000), in mọi loại Số đa giác N bắt đầu từ Số tam giác cho đến và bao gồm Số Icosagonal (20-gon).

Ví dụ, số 10 là số tam giác và số thập phân, do đó, đầu ra phải giống như (bạn có thể chọn định dạng đầu ra của riêng mình, nhưng nó sẽ trông giống như thế này):

3 10

Các trường hợp thử nghiệm

1 -> 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
2 -> (None)
3 -> 3
6 -> 3 6
36 -> 3 4 13

Để tham khảo, số nthứ tự kchéo là:

^{Tín dụng: xnor}

Hãy nhớ rằng, đây là mã golf , vì vậy mã có ít byte nhất sẽ thắng.

Python 3, 68 byte

lambda R:[s+2for s in range(1,19)if(s-2+(4+s*(s-4+8*R))**.5)/2%s==0]

Đối với mỗi số tiềm năng của hai bên s+2, giải quyết công thức bậc hai R=s*n*(n-1)/2 + ncho nthấy nếu kết quả là một số nguyên.

So sánh (73 byte):

lambda R:[s+2for s in range(1,19)if R in[n+s*n*~-n/2for n in range(R+1)]]

Một cách tiếp cận khác để giải quyết cho s62 byte trong Python 3, nhưng không thành công R=1.

lambda R:{(R-n)*2/n/~-n+2for n in range(2,R+1)}&{*range(3,21)}

JavaScript (ES6), 90 byte

n=>[...Array(21).keys(n--)].slice(3).filter(i=>(Math.sqrt(i*i+8*i*n-16*n)+i-4)%(i+i-4)==0)

Giải phương trình bậc hai. 73 byte trên các phiên bản Firefox mới đủ:

n=>[for(i of Array(18).keys())if(((~-i**2+8*n*-~i)**.5+~-i)/2%-~i==0)i+3]

> <>, 62 + 3 = 65 byte

&1v
v0<;?)+8a:+1~~<
1.292:{<>+n}ao^
>:&:&=?^:&:&)?^:@:@$-{:}++

Yêu cầu đầu vào ở đầu ngăn xếp, vì vậy +3 byte cho -vcờ.

Đây là lần đầu tiên tôi lập trình trong> <>, vì vậy tôi có thể thiếu một số thủ thuật rõ ràng để rút ngắn mã.

Giải trình:

Khởi tạo

&1v
v0<
1

Di chuyển N đến thanh ghi, đẩy bộ đếm vào ngăn xếp (bắt đầu từ 1, tương ứng với số tam giác) và bắt đầu chuỗi với các giá trị 0và 1.

Vòng lặp chính

 :&:&=?^:&:&)?^:@:@$-{:}++

So sánh đỉnh của ngăn xếp với thanh ghi. Nếu nó bằng nhau, đi đến thói quen in. Nếu nó lớn hơn, hãy đến thói quen thiết lập lại. Mặt khác, lấy sự khác biệt giữa hai mục ngăn xếp trên cùng, thêm bộ đếm và thêm vào mục ngăn xếp trên cùng trước đó. Điều này tính toán số đa giác tiếp theo.

In

 .292:{<>+n}ao^
       ^

In bộ đếm + 2, theo sau là một dòng mới, sau đó chuyển sang thói quen đặt lại.

Cài lại

v0<;?)+8a:+1~~<
1             ^

Loại bỏ hai mục trên cùng ngăn xếp và tăng bộ đếm. Kết thúc chương trình nếu bộ đếm lớn hơn 18, nếu không sẽ đẩy các số bắt đầu 0và 1đến ngăn xếp và quay trở lại vòng lặp chính.

Thạch , 22 byte

18pȷµḢ×’×H+µ€_³¬FT:ȷ+3

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

Giải trình

18pȷµḢ×’×H+µ€_³¬FT:ȷ+3
18pȷ                   - All possible (k-2,n) pairs
    µ      µ€          - to each pair compute the corresponding polygonal number:
     Ḣ                 -   retrieve k-2
      ×’               -   multiply by n-1
        ×H             -   multiply by half of n
          +            -   add n
             _³        - subtract the input. There will now be 0's at (k-2,n) pairs which produce the input
               ¬FT     - retrieve all indices of 0's. The indices are now (k-2)*1000+n
                  :ȷ   - floor division by 1000, returning k-3
                    +3 - add 3 to get all possible k.

Tiên đề 203 byte

 l(x)==(local q,m,a;v:List INT:=[];for i in 3..20 repeat(q:=solve((i-2)*n*(n-1)+2*n-2*x=0,n);if #q>1 then(m:=rhs q.1;a:=rhs q.2;if(m>0 and denom(m)=1)or(a>0 and denom(a)=1)then v:=cons(i,v)));v:=sort v;v)

Ở đây ít chơi gôn và thường xuyên hiển thị số

 l(x)==
  local q,m,a
  v:List INT:=[]
  for i in 3..20 repeat 
     q:=solve((i-2)*n*(n-1)+2*n-2*x=0,n)  -- this would find only rational solutions as r/s with r,s INT
     if #q>1 then -- if exist rational solution and denominator =1=> add to list of result
        m:=rhs q.1;a:=rhs q.2;
        if(m>0 and denom(m)=1)or(a>0 and denom(a)=1)then v:=cons(i,v) 
  v:=sort v
  v

 (2) ->  [[i,l(i)]  for i in 1..45]
    Compiling function l with type PositiveInteger -> List Integer

    (2)
    [[1,[3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20]], [2,[]], [3,[3]],
     [4,[4]], [5,[5]], [6,[3,6]], [7,[7]], [8,[8]], [9,[4,9]], [10,[3,10]],
     [11,[11]], [12,[5,12]], [13,[13]], [14,[14]], [15,[3,6,15]], [16,[4,16]],
     [17,[17]], [18,[7,18]], [19,[19]], [20,[20]], [21,[3,8]], [22,[5]],
     [23,[]], [24,[9]], [25,[4]], [26,[]], [27,[10]], [28,[3,6]], [29,[]],
     [30,[11]], [31,[]], [32,[]], [33,[12]], [34,[7]], [35,[5]], [36,[3,4,13]],
     [37,[]], [38,[]], [39,[14]], [40,[8]], [41,[]], [42,[15]], [43,[]],
     [44,[]], [45,[3,6,16]]]
                                                           Type: List List Any

AWK , 67 byte

{for(k=2;++k<21;)for(n=0;++n<=$1;)if((k/2-1)*(n*n-n)+n==$1)print k}

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

Tôi đã cố gắng thực sự giải quyết bậc hai, nhưng kiểm tra từng giá trị để xem nó có hoạt động ngắn hơn không (và ít bị lỗi hơn đối với tôi)

R, 68 66 byte

N=scan();m=expand.grid(k=1:18,1:N);n=m$V;m$k[m$k*n*(n-1)/2+n==N]+2

Đọc Ntừ stdin. Tính các số Nk-gonal đầu tiên và lấy vị ktrí của chúng bằng nhau N, sử dụng công thức của xnor; tuy nhiên, lưu byte trên dấu ngoặc đơn bằng cách sử dụng 1:18thay vì 3:20và thêm 2vào cuối.

expand.gridtheo mặc định đặt tên cho các cột Var1, Var2..., nếu tên không được đưa ra. $lập chỉ mục bằng cách khớp một phần, do đó m$Vtương ứng với m$Var2,cột thứ hai.

phiên bản cũ:

N=scan();m=expand.grid(k=3:20,1:N);n=m$V;m$k[(m$k-2)*n*(n-1)/2+n==N]

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

Pari / GP , 34 byte

Pari / GP có tích hợp sẵn để kiểm tra xem một số có phải là số đa giác hay không.

x->[s|s<-[3..20],ispolygonal(x,s)]

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

Thạch , 20 byte

^{Tôi mới bắt đầu viết một bản dupe hiệu quả cho thử thách này (mặc dù bao gồm tất cả k> 1 không chỉ [1,20]) ... vì vậy thay vào đó tôi sẽ trả lời nó!}

Ṫð’××H+⁸
18pÇċ¥Ðf⁸+2

Một chương trình đầy đủ in một danh sách Jelly đại diện cho kết quả *

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

* Không có kết quả in không có gì;
  một kết quả duy nhất chỉ in số đó;
  nhiều kết quả in ra một danh sách các con số []kèm theo,

Làm sao?

Ṫð’××H+⁸ - Link 1, ith (x+2)-gonal number: list [x,i]   e.g. [3,4] (for 4th Pentagonal)
Ṫ        - tail & modify (i.e. yield i & make input [x])     4
 ð       - new dyadic chain, i.e. left = i, right = [x]
  ’      - decrement i                                       3
   ×     - multiply by [x]                                   [9]
     H   - halve [x]                                         [2]
    ×    - multiply                                          [18]
       ⁸ - chain's left argument, i                          4
      +  - add                                               [22]

18pÇċ¥Ðf⁸+2 - Main link: number, n                      e.g. 36
18p         - Cartesian product of range [1,18] with n       [[1,1],[1,2],...,[1,36],[2,1],...,[18,1],[18,2],[18,36]]
            -   (all pairs of [(k-2),i] which could result in the ith k-gonal number being n)
      Ðf    - filter keep if this is truthy:
        ⁸   -   chain's left argument, n                     36
     ¥      -   last two links as a dyad:
   Ç        -     call the last link as a monad (note this removes the tail of each)
    ċ       -     count (this is 1 if the result is [n] and 0 otherwise)
            -                            filter keep result: [[1],[2],[11]]
         +2 - add two                                        [[3],[4],[13]]
            - implicit print ...due to Jelly representation: [3, 4, 13]