Вступ

П'ятикутний номер ( 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 доданків). Якщо сума п'ятикутних чисел також є п’ятикутним числом, ми будемо називати це число п'ятикутника п'ятикутника .

При х = 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<

Спробуйте в Інтернеті.

Біг займає пару секунд.

Пояснення

Спочатку нам потрібно перевірити, скільки п’ятикутних чисел нам потрібно вважати потенційними сумами. Сума перших 10000 п'ятикутних чисел дорівнює 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.

Я використовував трохи змінену програму, щоб знайти найбільші входи, які дають не порожнє рішення. Це все рішення для входів більше 9000:

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 байт: збережено 10 байт, видаливши зайвий виклик функції «tonumber».

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елементів знаходиться в списку, виведіть його, інакше повторіть спробу з хвостом списку. Почніть з перших 10000 п'ятикутних чисел, зупиніться та поверніться, 0якщо в списку менше xелементів.

PARI / GP, 71 байт

Мені подобається ispolygonalфункція в PARI / 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 не працює.

Математичний вузол у циклі створює масив усіх чисел. Візьміть Sub-масив, додайте елементи, шукайте це число, якщо знайдено, взяти індекс і зупинити цикл.

Недійсний вхід видає найбільше п'ятикутне число.

R, 114 100 байт

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

неозорий (свого роду)

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- ^я п'ятикутна кількість).

Скоротивши діапазон до чогось більш розумного, ви можете спробувати його в Інтернеті! для досить малих входів.

Ідея

Відомий результат щодо п'ятикутних чисел полягає в тому, що x є п'ятикутним тоді і тільки тоді, коли sqrt (24x + 1) - 1 ділиться на 6 .

Замість того, щоб обчислити перші 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.

Математика 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

esplenation: Ми можемо знайти n, використовуючи результат "a", див. нижче

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