介绍

甲五角数（A000326）由公式生成P _Ñ = 0.5×（3N ² -n） 。或者，您可以只计算使用的点数：

您可以使用公式或上面的gif查找前几个五边形数字：

1, 5, 12, 22, 35, 51, 70, 92, 117, 145, 176, 210, 247, 287, 330, 376, 425, 477, etc...

接下来，我们需要计算x个连续数字的总和。

例如，如果x = 4，我们需要查看P _n + P _{n + 1} + P _{n + 2} + P _{n + 3}（由4个项组成）。如果五角形的总和也是五角形，我们将其称为五角形五角形。

对于x = 4，最小的五边形五边形数是330，它由4个连续的五边形数组成：51, 70, 92, 117。因此，当输入为时4，您的功能程序应输出330。

任务

• 当给出大于1的整数时，输出最小的五边形五边形数。
• 您可以提供功能或程序。
• 注意：对于x = 3没有解决方案。这意味着，如果不能从前10000个五边形中得出一个数字，则必须停止计算并输出最适合您的内容。
• 这是代码高尔夫球，因此，字节数最少的提交将获胜！

测试用例：

Input: 2
Output: 1926 (which comes from 925, 1001)

Input: 3
Output: ?

Input: 4
Output: 330 (which comes from 51, 70, 92, 117)

Input: 5
Output: 44290 (which comes from 8400, 8626, 8855, 9087, 9322)

Input: 6
Output: 651 (which comes from 51, 70, 92, 117, 145, 176)

Input: 7
Output: 287 (which comes from 5, 12, 22, 35, 51, 70, 92)

Input: 8
Output: ?

Input: 9
Output: 12105 (which comes from 1001, 1080, 1162, 1247, 1335, 1426, 1520, 1617, 1717)

Input: 10
Output: ?

也可以给出更大的数字：

Input: 37
Output: 32782

Input: 55
Output: 71349465

Input: 71
Output: 24565290

CJam，29个字节

6e5{)_3*(*2/}%_A4#<riew::+&1<

在线尝试。

需要几秒钟来运行。

说明

首先，我们需要检查需要考虑多少个五边形数作为潜在的总和。前10,000个五边形的和是500050000000。大于该值的第一个五边形数是577,380。

6e5       e# 600,000 (a short number that's a bit bigger than we need).
{         e# Map this block onto every number from 0 to 599,999...
  )       e#   Increment.
  _3*(*2/ e#   Apply the pentagonal number formula given in the challenge.
}%
_         e# Make a copy.
A4#<      e# Truncate to the first 10,000 elements.
ri        e# Read input and convert to integer.
ew        e# Get sublists of that length.
::+       e# Sum each sublist.
&         e# Set intersection with all 600k pentagonal numbers computed earlier.
1<        e# Truncate to the first result.

我使用了一个经过稍微修改的程序来查找产生非空解决方案的最大输入。这些都是输入大于9,000的解决方案：

9919 -> 496458299155
9577 -> 446991927537
9499 -> 455533474060
9241 -> 401702906276
9017 -> 429351677617

Lua，142字节

p={}o={}n=...for i=1,10^4 do p[i]=(3*i^2-i)/2o[p[i]]=1 end for i=0,10^4-n do s=0 for j=1,n do s=s+p[i+j]end if(o[s])then print(s)break end end

不打高尔夫球

p={}o={}n=tonumber(...)
for i=1,10^4 do 
    p[i]=(3*i^2-i)/2o[p[i]]=1 
end
for i=0,10^4-n do 
    s=0 
    for j=1,n do 
        s=s+p[i+j]
    end 
    if(o[s])then 
        print(s)
        break 
    end 
end

是的，要倒置桌子！

更新142字节：通过删除多余的“ tonumber”功能调用节省了10个字节。

Haskell，109个字节

p=map(\n->div(3*n^2-n)2)[1..10^7]
(%)=(sum.).take
x#l|length l<x=0|elem(x%l)p=x%l|1<2=x#tail l
(#take(10^4)p)

0如果没有五边形，则返回五角形。

使用示例（需要一些时间才能完成）：map (#take(10^4)p) [1..10]-> [1,1926,0,330,44290,651,287,0,12105,0]。

它或多或少是该定义的直接实现：如果x列表中有第一个元素的总和，则将其输出，否则用列表的末尾重试。从前10,000个五边形数字开始，0如果列表少于个x元素，则停止并返回。

PARI / GP，71字节

我喜欢ispolygonalPARI / GP中的功能。

x->[p|p<-vector(10^4,i,sum(n=i,i+x-1,(3*n^2-n)/2)),ispolygonal(p,5)][1]

Python 3，144个字节

R,P=range,list(map(lambda n:(3*n*n-n)/2,R(1,10001)))
def F(X):
 for a in R(0,len(P)-X):
    S=sum(P[a:a+X])
    if(1+(1+24*S)**.5)%6==0:print(S);break

这颠倒了五角形数字的定义；如果P（n）=（3n ^ 2-n）/ 2，则给定的P将是五边形数iff（1 + sqrt（24 * P + 1））/ 6是整数。（从技术上讲，它还应查看（1-sqrt（24 * P + 1））/ 6，但应始终为负数。）也建议使用空格和制表符作为两个不同的缩进级别处所示。如果找不到五角形的五角形数，则不会输出任何内容。我相信可以吗？

我坚信，比我聪明的人可以找到一种方法，甚至可以在for循环中将其缩短得更多。

LabVIEW，39个LabVIEW原语

这次没有gif信息。

循环中的Math节点将创建一个包含所有数字的数组。使用子数组，添加元素，搜索该数字，如果找到则使用索引并停止循环。

无效的输入将输出最高的五边形数。

R，114100字节

k=.5*(3*(t=1:1e6)^2-t);z=1;for(i in 1:(1e4-(n=scan()-1)))z[i]=sum(k[i:(i+n)]);cat(intersect(k,z)[1])

不打高尔夫球（kinda）

k=.5*(3*(t=1:1e6)^2-t)                 # map all pentagon numbers up to 1e6
z=1                                    # create a vector
for(i in 1:(1e4-(n=scan()-1))){        # from 1 to 10.000 - n loop
  z[i]=sum(k[i:(i+n)])}                # get the sum of all pentagon numbers i:(i+n)
cat(intersect(k,z)[1])                 # see which sums is a pentagon number itself, plot the first

果冻，30个字节

×24‘½‘%6¬Oị
15ȷ7RÇṫ³R$zȷ.5ZSÇḢ

此代码适用于此版本的Jelly，并且等效于以下二进制代码：

0000000: 94 32 34 b2 90 b2 25 36 87 4f b1 0a 31 35 a0  .24...%6.O..15.
000000f: 37 52 92 ad 8b 52 24 7a a0 2e 35 5a 53 92 a6  7R...R$z..5ZS..

到目前为止，这对于在线解释器来说速度太慢，而且内存不足，因为它会检查前150,000,000个五边形（149,995,000个正好是第10,000 ^个五边形数字）。

通过将范围缩短到更明智的范围，您可以在线尝试！对于足够小的输入。

理念

关于五边形数的已知结果是，当且仅当sqrt（24x +1）-1被6整除时，x才是五边形。

我们定义了一个帮助程序链接，该链接从给定数组中删除非五边形数字，而不是计算前10,000个五角形数字。为什么？因为在此挑战之前的最新版本的Jelly无法明智地与列表相交...

码

×24‘½‘%6¬Oị  Define the aforementioned helper link. Left argument: a (list)

×24          Multiply each list item by 24.
   ‘         Increment each product.
    ½        Apply square root to each result.
     ’       Decrement each square root.
      %6     Compute all remainders of division by 6.
        ¬    Apply logical NOT.
         O   Get the indices of ones.
          ị  Hook; get the elements of a at those indices.

15ȷ7RÇṫ³R$zȷ.5ZSÇḢ  Define the main link. Input: x

15ȷ7R               Yields [1, ..., 1.5e8].
     Ç              Apply the helper link; keep only pentagonal numbers.
       ³R$          Yield r = [1, ..., x].
      ṫ             Remove the first y-1 pentagonal numbers for each y in r.
          zȷ.5      Transpose the resulting array, padding with sqrt(10).
              Z     Transpose once more. The shifted lists have now been padded.
                    This makes sure incomplete sums (i.e., of less than x
                    pentagonal numbers) will not be integers.
               S    Compute all sums.
                Ç   Apply the helper link once more.
                 Ḣ  Select the first match, if any.

果冻，21字节（无竞争）

ȷ6Rµ²×3_¹Hµḣȷ4ṡ³ZSf¹Ḣ

Jelly的最新版本具有两个新功能（重叠切片和列表过滤/交集）和一个错误修复程序，该错误程序允许更少的字节数。

这段代码在我的台式计算机上可以正常工作，但是对于TIO的时间限制来说有点慢。到网上试试吧！（对于足够小的输入），我们必须再次减小初始范围。

怎么运行的

ȷ6Rµ²×3_¹Hµḣȷ4ṡ³ZSf¹Ḣ  Input: x

ȷ6R                    Yield [1, ..., 1,000,000].
   µ                   Begin a new, monadic chain.
    ²                  Square each number in the range.
     ×3                Multiply the squares by 3.
       _¹              Subtract the numbers from the range.
         H             Halve each difference.
                       This yields the first 1,000,000 pentagonal numbers.
          µ            Begin a new, monadic chain.
           ḣȷ4         Keep only the first 10,000 pentagonal numbers.
              ṡ³       Yield all overlapping slices of length x.
                ZS     Transpose and sum. This computes the sum of each slice.
                  f¹   Filter; intersect with the long list of pentagonal numbers.
                    Ḣ  Select the first match, if any.

Mathematica 85字节

n=577380;Intersection[#(3#-1)/2&/@Range@n,Table[#((#-1)^2+x(3#-4+3x))/2,{x,n}]][[1]]&

快速搜索到 P _{10 ⁴}。

公理，157字节

p(n)==(3*n*n-n)quo 2;f(x)==(a:=0;for i in 1..x repeat a:=a+p(i);for j in 1..10000 repeat(p(floor((1+sqrt(1.+24*a))/6)::INT)=a=>return a;a:=a+p(j+x)-p(j));-1)

不满意和结果

h(x:PI):INT==
   a:=0;for i in 1..x repeat a:=a+p(i) -- sum(p(i),i=1..x)
   for j in 1..10000 repeat
      p(floor((1+sqrt(1.+24*a))/6)::INT)=a=>return a
      a:=a+p(j+x)-p(j)
   -1

(5) -> [[i,f(i)] for i in 1..10]
   (5)
   [[1,1], [2,1926], [3,- 1], [4,330], [5,44290], [6,651], [7,287], [8,- 1],
    [9,12105], [10,- 1]]
                                                  Type: List List Integer

简化：我们可以使用结果“ a”找到n，请参见下文

a=(3*n^2-n)/2 => 3*n^2-n-2*a=0 => n=floor((1+sqrt(1.+24*a))/6)::INT

[使用1 + sqrt（...），因为n> 0]

上面的意思是如果存在一个n0使得

p(n0)=a 

比

n0=floor((1+sqrt(1.+24*a))/6)::INT

假设我们必须证明p（n0）= a可以肯定（因为并非总是如此）

但主要的技巧是求和

a:=sum(p(i),i=1..x) [x elements sum] 

仅在开始时，使用以下命令即可找到下一个x元素的总和

a=a+p(x+1)-p(1)=sum(p(i), i=2..x+1)

以此类推，得出其他总和（在上面的语句a：= a + p（j + x）-p（j）中使用）。这意味着在循环内部不需要一个数字x元素和。

Python 2中，128个 124字节

X=input();N=S=0
while all(S-(3*n*n-n)/2for n in range(S)):N+=1;S=sum(3*(n+N)**2-n-N>>1for n in range(X));N<1e4or 0/0
print S

在线尝试！

Javascript 93字节

p=i=>i>0&&3*i*i-i>>1
f=(x,i=1,t=0)=>i<1e4?(24*(t+=p(i)-p(i-x))+1)**.5%6==5&i>x?t:f(x,i+1,t):0

console.log(f(4))
console.log(f(5))
console.log(f(6))
console.log(f(7))
console.log(f(8))
console.log(f(9919)==496458299155)
console.log(f(9577)==446991927537)
console.log(f(9499)==455533474060)
console.log(f(9241)==401702906276)
console.log(f(9017)==429351677617)
console.log(f(9))
console.log(f(10))