Вступление

Пятиугольный номер ( A000326 ) генерируется по формуле P _п = 0,5 × (3n ² -n) . Или вы можете просто посчитать количество используемых точек:

Вы можете использовать формулу или рисунок выше, чтобы найти первые несколько пятиугольных чисел:

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

Далее нам нужно вычислить сумму х последовательных чисел.

Например, если 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

Ungolfed

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

Yay для переворачивания таблиц!

Обновление 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 элементов находится в списке, выведите ее, иначе повторите попытку с хвостом списка. Начните с первых 10 000 пятиугольных чисел, остановитесь и вернитесь, 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]

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 будет пятиугольным числом, если (1 + sqrt (24 * P + 1)) / 6 - целое число. (Технически, он также должен смотреть на (1-sqrt (24 * P + 1)) / 6, но это всегда должно быть отрицательным.) Также использует пробелы и табуляции как два разных уровня отступа, как предложено здесь . Это ничего не выводит, если не может найти пятиугольное пятиугольное число; Я верю, что все в порядке?

Я твердо верю, что кто-то более умный, чем я, мог бы найти способ сократить это еще больше, вероятно, в рамках цикла for.

LabVIEW, 39 примитивов LabVIEW

На этот раз не получится.

Математический узел в цикле создает массив всех чисел. Взять подмассив, добавить элементы, найти это число, если найден, взять индекс и остановить цикл.

Неверный ввод выводит наибольшее пятиугольное число.

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.

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=(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] 

только в начале, и найти следующую сумму элементов х, просто используя

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