介绍

在数学中，多边形数是表示为以规则多边形形状排列的点或小卵石的数字。点被认为是alpha（单位）。这些是二维图形数字的一种类型。

例如，数字10可以排列成三角形：

*
**
***
****

但是不能将10布置成正方形。另一方面，数字9可以是：

***
***
***

一些数字（例如36）既可以布置为正方形，也可以布置为三角形：

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

按照惯例，1是任何数量的边的第一个多边形。将多边形放大到下一个尺寸的规则是将两个相邻的臂延伸一个点，然后在这些点之间添加所需的额外边。在下图中，每个额外的层都显示为红色。

三角数：

平方数：

尽管点不再像上面那样形成完全规则的晶格，但也可以根据此规则构造边数更多的多边形，例如五边形和六边形。

五角数字：

六角数：

^{资料来源：维基百科}

你的任务

给定正整数N（1 <= N <= 1000），则打印每种类型的多边形N都是从三角数开始，直至包括余角（20角）数。

例如，数字10是一个三角数和一个十进制数，因此输出应类似于（您可以选择自己的输出格式，但看起来应该像这样）：

3 10

测试用例

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

作为参考，n第- k角数为：

^{信用：xnor}

请记住，这是code-golf，所以字节最少的代码将获胜。

Python 3，68个字节

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

对于两侧的每个可能数量s+2，解决了二次公式R=s*n*(n-1)/2 + n为n看如果结果是一个整数。

比较（73个字节）：

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

解决的另一种方法是s在Python 3中提供62个字节，但在上失败R=1。

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

JavaScript（ES6），90个字节

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

解二次方程。足够新版本的Firefox上为73个字节：

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

> <>，​​62 + 3 = 65字节

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

期望输入在堆栈的顶部，因此该-v标志为+3个字节。

这是我第一次使用> <>进行编程，因此我可能缺少一些明显的技巧来缩短代码。

说明：

初始化

&1v
v0<
1

移动Ñ到寄存器，推动计数器到堆栈（开始于1，其对应于三角形的数字），并开始与值序列0和1。

主循环

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

将堆栈的顶部与寄存器进行比较。如果相等，请转到打印例程。如果更大，请进入重置例程。否则，求出最上面的两个堆栈项之间的差，添加计数器，然后添加到前一个最上面的堆栈项。这将计算下一个多边形数。

打印

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

打印计数器+ 2，后跟换行符，然后进入重置例程。

重启

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

删除栈顶的两个项目并增加计数器。结束程序计数器是否大于18，否则推起始号码0和1堆栈并返回到主循环。

果冻，22字节

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

在线尝试！

说明

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.

公理203字节

 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)

这是少打高尔夫球和显示数字的常规

 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字节

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

在线尝试！

我尝试实际求解二次方，但是检查每个值以查看它是否更短（对我来说更不容易出错）

R，68 66字节

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

N从stdin 读取。使用xnor的公式计算第一个Nk角形数字并获得k它们相等N的位置；但是，通过使用1:18而不是3:20和2在末尾添加，将字节保存在括号中。

expand.grid默认名称的列Var1，Var2...，如果名称没有给出。$通过部分匹配索引，因此m$V对应于m$Var2,第二列。

旧版：

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

在线尝试！

Pari / GP，34个字节

Pari / GP具有内置功能，可以测试数字是否为多边形。

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

在线尝试！

果冻，20 字节

^{我刚刚开始写这篇关于这个挑战的有效论文（尽管涵盖了所有k> 1而不只是[1,20]）...所以我来回答！}

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

完整程序打印结果的果冻列表表示*

在线尝试！

*没有结果不会打印任何内容；
  一个结果仅打印该数字；
  多个结果将打印出一个[]封闭的，, 分开的数字列表

怎么样？

Ṫð’××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]