소개

오각 수 ( A000326가 ) 식에 의해 생성 된 P _N = 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 개의 오각형 숫자로 숫자를 만들 수 없으면 계산을 중지하고 가장 적합한 것을 출력해야합니다.
• 이것은 code-golf 이므로 바이트 수가 가장 적은 제출이 승리합니다!

테스트 사례 :

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

루아, 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 바이트를 절약했습니다.

하스켈, 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]

파이썬 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가 없습니다.

루프의 연산 노드는 모든 숫자의 배열을 만듭니다. 인덱스를 가져오고 루프를 중지하면 하위 배열을 가져 와서 요소를 추가하고 해당 숫자를 검색하십시오.

유효하지 않은 입력은 가장 높은 오각형을 나타냅니다.

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])

ungolfed (킨다)

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)

ungolfed 및 결과

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

[n> 0이므로 1 + sqrt (...) 사용]

이것은 위의 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 요소 합계가 필요하지 않음을 의미합니다 ... ..

파이썬 (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

온라인으로 사용해보십시오!

자바 스크립트 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))