introduction

Un nombre pentagonal ( A000326 ) est généré par la formule P _n = 0,5 × (3n ² -n) . Ou vous pouvez simplement compter la quantité de points utilisés:

Vous pouvez utiliser la formule ou le gif ci-dessus pour trouver les premiers nombres pentagonaux:

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

Ensuite, nous devons calculer la somme de x nombres consécutifs.

Par exemple, si x = 4 , nous devons regarder P _n + P _{n + 1} + P _{n + 2} + P _{n + 3} (qui se compose de 4 termes). Si la somme des nombres pentagonaux est également un nombre pentagonal, nous l'appellerons un nombre pentagonal pentagonal .

Pour x = 4 , le plus petit nombre pentagonal pentagone est 330, qui est fait de 4 nombres pentagonaux consécutifs: 51, 70, 92, 117. Ainsi, lorsque l'entrée est 4, votre programme de fonction devrait sortir 330.

Tâche

• Lorsque vous donnez un entier supérieur à 1, sortez le plus petit nombre pentagone pentagonal.
• Vous pouvez fournir une fonction ou un programme.
• Remarque: Il n'y a pas de solutions pour par exemple x = 3 . Cela signifie que si un nombre ne peut pas être créé à partir des 10000 premiers nombres pentagonaux, vous devez arrêter le calcul et produire ce qui vous convient le mieux.
• C'est du code-golf , donc la soumission avec le moins d'octets gagne!

Cas de test:

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

De plus grands nombres peuvent également être donnés:

Input: 37
Output: 32782

Input: 55
Output: 71349465

Input: 71
Output: 24565290

CJam, 29 octets

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

Essayez-le en ligne.

Prend quelques secondes à courir.

Explication

Tout d'abord, nous devons vérifier combien de nombres pentagonaux nous devons considérer comme des sommes potentielles. La somme des 10 000 premiers nombres pentagonaux est 500050000000. Le premier nombre pentagonal supérieur à celui-ci est le 577 380ème.

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.

J'ai utilisé un programme légèrement modifié pour trouver les entrées les plus importantes qui donnent une solution non vide. Ce sont toutes les solutions pour des entrées supérieures à 9 000:

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

Lua, 142 octets

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

Non golfé

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

Ouais pour inverser les tables!

Mise à jour de 142 octets: économisé 10 octets en supprimant l'appel de fonction 'tonumber' superflu.

Haskell, 109 octets

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)

Renvoie 0s'il n'y a pas de nombre pentagone pentagonal.

Exemple d'utilisation (prend un certain temps pour terminer): map (#take(10^4)p) [1..10] -> [1,1926,0,330,44290,651,287,0,12105,0].

C'est plus ou moins une implémentation directe de la définition: si la somme des premiers xéléments est dans la liste, sortez-la, sinon réessayez avec la queue de la liste. Commencez avec les 10 000 premiers nombres pentagonaux, arrêtez et revenez 0si la liste contient moins de xéléments.

PARI / GP, 71 octets

J'aime la ispolygonalfonction dans 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 octets

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

Cela inverse la définition d'un nombre pentagonal; si P (n) = (3n ^ 2-n) / 2, alors un P donné sera un nombre pentagonal ssi (1 + sqrt (24 * P + 1)) / 6 est un entier. (Techniquement, il devrait également regarder (1-sqrt (24 * P + 1)) / 6, mais cela doit toujours être négatif.) Utilise également des espaces et des tabulations comme deux niveaux d'indentation différents, comme suggéré ici . Cela ne produit rien s'il ne trouve pas de nombre pentagonal pentagonal; J'espère que c'est OK?

Je crois fermement que quelqu'un de plus intelligent que moi pourrait trouver un moyen de raccourcir encore plus cela, probablement autour de la boucle for.

LabVIEW, 39 primitives LabVIEW

Pas de gif en cours d'exécution cette fois.

Le nœud mathématique en boucle crée un tableau de tous les nombres. Prenez un sous-tableau, ajoutez des éléments, recherchez ce numéro, s'il est trouvé, prenez l'index et la boucle d'arrêt.

Une entrée non valide affiche le nombre pentagonal le plus élevé.

R, 114 100 octets

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

non golfé (un peu)

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

Gelée , 30 octets

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

Ce code fonctionne avec cette version de Jelly et est équivalent au code binaire suivant:

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

Il est de loin lent et gourmand en mémoire pour l'interprète en ligne, car il vérifie les premiers 150 000 000 de pentagonalité (149 995 000 se trouve être le 10 000 ^e nombre pentagonal).

En réduisant la gamme à quelque chose de plus sensé, vous pouvez l' essayer en ligne! pour des entrées suffisamment petites.

Idée

Un résultat connu sur les nombres pentagonaux est que x est pentagonal si et seulement si sqrt (24x + 1) - 1 est divisible par 6 .

Plutôt que de calculer les 10 000 premiers nombres pentagonaux, nous définissons un lien d'assistance qui supprime les nombres non pentagonaux d'un tableau donné. Pourquoi? Parce que la dernière version de Jelly antérieure à ce défi n'a aucun moyen raisonnable d'intersecter les listes ...

Code

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

Gelée, 21 octets (non concurrent)

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

La dernière version de Jelly a deux nouvelles fonctionnalités (superposition de tranches et filtrage / intersection de listes) et une correction de bogue, qui permet un nombre d'octets beaucoup plus faible.

Ce code fonctionne bien sur mon ordinateur de bureau, mais c'est un peu lent pour le délai de TIO. Pour l' essayer en ligne! (pour des entrées suffisamment petites), nous devons à nouveau réduire la plage initiale.

Comment ça fonctionne

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

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

effectue une recherche rapide jusqu'à P _{10 ⁴} .

Axiome, 157 octets

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)

non golfé et résultats

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

esplénation: on peut trouver n en utilisant le résultat "a", voir ci-dessous

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

[utilisez 1 + sqrt (...) car n> 0]

Cela signifie que s'il existe un n0 tel que

p(n0)=a 

que

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

Après, il faut prouver que p (n0) = a pour être sûr (car il n'en est pas toujours ainsi)

Mais l'astuce principale serait de faire la somme

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

seulement au début, et trouver la somme des éléments x suivants simplement en utilisant

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

et ainsi de suite pour les autres sommes (en utilisant ci-dessus dans l'instruction a: = a + p (j + x) -p (j)). Cela signifie qu'il n'est pas nécessaire un nombre x élément somme à l'intérieur de la boucle ... ..

Python 2 , 128 124 octets

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

Essayez-le en ligne!

Javascript 93 octets

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