Wprowadzenie

Liczba pięciokątny ( A000326 ) jest generowana przez wzorze P _n = 0,5 x (3n ² N) . Lub możesz po prostu policzyć ilość użytych kropek:

Możesz użyć powyższego wzoru lub gif powyżej, aby znaleźć kilka pierwszych liczb pięciokątnych:

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

Następnie musimy obliczyć sumę x kolejnych liczb.

Na przykład, jeśli x = 4 , musimy spojrzeć na P _n + P _{n + 1} + P _{n + 2} + P _{n + 3} (który składa się z 4 terminów). Jeśli suma liczb pięciokątnych również jest liczbą pięciokątną, nazwiemy to pięciokątną liczbą pięciokątną .

Dla x = 4 , najmniejsza ilość pięciokątny pięciokąt 330, który jest wykonany z 4 kolejnych liczb pięcio-: 51, 70, 92, 117. Więc kiedy wejście jest 4, twój program funkcji powinien wypisać 330.

Zadanie

• Gdy podano liczbę całkowitą większą niż 1, wyprowadza najmniejszą pięciokątną liczbę pięciokątną.
• Możesz podać funkcję lub program.
• Uwaga: Nie ma rozwiązań dla np. X = 3 . Oznacza to, że jeśli nie można utworzyć liczby z pierwszych 10000 liczb pięciokątnych, musisz przerwać obliczanie i wyprowadzić wszystko, co najbardziej ci odpowiada.
• To jest golf golfowy , więc wygrywanie z najmniejszą ilością bajtów wygrywa!

Przypadki testowe:

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: ?

Można również podać większe liczby:

Input: 37
Output: 32782

Input: 55
Output: 71349465

Input: 71
Output: 24565290

CJam, 29 bajtów

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

Wypróbuj online.

Uruchomienie zajmuje kilka sekund.

Wyjaśnienie

Najpierw musimy sprawdzić, ile liczb pięciokątnych musimy wziąć pod uwagę jako potencjalne sumy. Suma pierwszych 10 000 liczb pięciokątnych wynosi 500050000000. Pierwsza liczba pięciokątna większa niż 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.

Użyłem nieco zmodyfikowanego programu, aby znaleźć największe dane wejściowe, które dają niepuste rozwiązanie. Są to wszystkie rozwiązania dla nakładów większych niż 9 000:

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

Lua, 142 bajtów

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

Nie golfił

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

Tak dla odwracania tabel!

Aktualizacja 142 bajtów: Zapisano 10 bajtów, usuwając zbędne wywołanie funkcji „tonumber”.

Haskell, 109 bajtów

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)

Zwroty 0 jeśli nie ma pięciokątnej liczby pięciokątnej.

Przykład użycia (zakończenie zajmuje trochę czasu): map (#take(10^4)p) [1..10]-> [1,1926,0,330,44290,651,287,0,12105,0].

Jest to mniej więcej bezpośrednia implementacja definicji: jeśli suma pierwszych xelementów znajduje się na liście, wypisz ją, w przeciwnym razie spróbuj ponownie z ogonem listy. Zacznij od pierwszych 10 000 liczb pięciokątnych, zatrzymaj się i wróć, 0jeśli lista zawiera mniej niż xelementy.

PARI / GP, 71 bajtów

Podoba mi się ta ispolygonalfunkcja w 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 bajty

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

To odwraca definicję liczby pięciokątnej; jeśli P (n) = (3n ^ 2-n) / 2, to dane P będzie liczbą pięciokątną iff (1 + sqrt (24 * P + 1)) / 6 jest liczbą całkowitą. (Technicznie powinien on również wyglądać na (1-sqrt (24 * P + 1)) / 6, ale to zawsze powinno być ujemne.) Również wykorzystuje spacje i tabulatory jako dwa różne poziomy wcięcia, jak sugerowano tutaj . Nie wyświetla niczego, jeśli nie może znaleźć pięciokątnej liczby pięciokątnej; Ufam, że to w porządku?

Mocno wierzę, że ktoś sprytniejszy ode mnie może znaleźć sposób, by jeszcze bardziej to skrócić, prawdopodobnie w pobliżu pętli for.

LabVIEW, 39 Prymitywy LabVIEW

Tym razem nie ma gif.

Węzeł matematyczny w pętli tworzy tablicę wszystkich liczb. Weź pod-tablicę, dodaj elementy, wyszukaj tę liczbę, jeśli znaleziono, weź indeks i zatrzymaj pętlę.

Niepoprawne wejście powoduje wyświetlenie najwyższej liczby pięciokątnej.

R, 114 100 bajtów

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

nieprzygotowany (trochę)

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

Galaretka , 30 bajtów

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

Ten kod działa z tą wersją Jelly i jest równoważny z następującym kodem binarnym:

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

Jest to zdecydowanie zwolnić pamięć i głodny dla tłumacza on-line, ponieważ sprawdza pierwszy 150000000 dla pentagonality (149995000 dzieje się 10.000 ^th liczba pięciokątny).

Skracając zasięg do czegoś bardziej sensownego, możesz wypróbować online! dla wystarczająco małych nakładów.

Pomysł

Znanym rezultatem liczb pięciokątnych jest to, że x jest pięciokątny wtedy i tylko wtedy, gdy sqrt (24x + 1) - 1 jest podzielny przez 6 .

Zamiast obliczać pierwsze 10 000 liczb pięciokątnych, definiujemy łącze pomocnicze, które usuwa liczby niepentagonalne z danej tablicy. Dlaczego? Ponieważ najnowsza wersja Jelly, która poprzedza to wyzwanie, nie ma rozsądnego sposobu na przecięcie list ...

Kod

×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.

Galaretka, 21 bajtów (niekonkurencyjna)

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

Najnowsza wersja Jelly ma dwie nowe funkcje (nakładające się plasterki i filtrowanie / przecinanie list) oraz poprawkę błędu, która pozwala na znacznie niższą liczbę bajtów.

Ten kod działa dobrze na moim komputerze stacjonarnym, ale odrobinę spowalnia limit czasu TIO. Aby Spróbuj online!(w przypadku wystarczająco małych danych wejściowych) musimy ponownie zmniejszyć początkowy zakres.

Jak to działa

ȷ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.

Matematyka 85 bajtów

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

szybkie wyszukiwanie do P _{10 ⁴} .

Aksjomat, 157 bajtów

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)

niepoddane golfowi i wyniki

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

esplenacja: Możemy znaleźć n używając wyniku „a”, patrz poniżej

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

[użyj 1 + sqrt (...), ponieważ n> 0]

Powyższe oznacza, że ​​jeśli istnieje jeden n0 taki, że

p(n0)=a 

niż

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

Po tym, że musimy udowodnić, że p (n0) = a dla pewności (ponieważ nie zawsze tak jest)

Ale główną sztuczką byłoby zrobienie sumy

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

dopiero na początku i znajdź kolejne x elementów sumy, używając po prostu

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

i tak dalej dla innych sum (używając powyższej instrukcji a: = a + p (j + x) -p (j)). Oznacza to, że nie jest konieczne sumowanie jednej liczby x elementu wewnątrz pętli ...

Python 2 , 128 124 bajtów

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

Wypróbuj online!

JavaScript 93 bajty

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