Tâche

Votre tâche est simple, générez une séquence qui, étant donné l'index i, la valeur à cette position est la somme des carrés de 0jusqu'à ioù i >= 0.

Exemple:

Input: 0
Output: 0           (0^2)

Input: 4
Output: 30          (0^2 + 1^2 + 2^2 + 3^2 + 4^2)

Input: 5
Output: 55          (0^2 + 1^2 + 2^2 + 3^2 + 4^2 + 5^2)

Spécification:

Vous ne pouvez prendre aucune entrée et sortir la séquence indéfiniment;
Vous pouvez entrer Net sortir l' Nthélément de la séquence;
Vous pouvez entrer Net sortir les premiers Néléments de la séquence.

— Felipe Nardi Batista
source

2

Observation amusante d'OEIS: Cette séquence contient exactement deux carrés parfaits:, f(1) == 1 * 1 (1)et f(24) == 70 * 70 (4900).

— DJMcMayhem

Pouvons-nous commencer la séquence à f(1) = 1?

— Emigna

@Emigna désolé mais non, vous devez commencer f(0) = 0. je l'ai souligné que pour les quelques réponses qui ont échoué à cette exigence

— Felipe Nardi Batista

L' f(0) = 0exigence a ruiné quelques-unes de mes solutions :(

— ATaco

4

Gelée , 3 octets

R²S

Essayez-le en ligne!

FGITW

Explication

R²S  Main Link
R    Generate Range
 ²   Square (each term)
  S  Sum

— HyperNeutrino
source

Une alternative plus longue seraitRæ.R

— M. Xcoder

22

Python 2 , 22 octets

lambda n:n*~n*~(n*2)/6

Essayez-le en ligne!

Il utilise la formule fermée n * (n + 1) * (2 * n + 1) / 6 . Le code effectue les opérations suivantes:

Multiplie n par ( n*):
- Le complément au niveau du bit de n ( ~n), ce qui signifie essentiellement -1-n .
- Et par le complément au niveau du bit de 2n ( *~(n*2)), ce qui signifie -1-2n .
Divise par 6 ( /6).

Python 2 , 27 octets

f=lambda n:n and f(n-1)+n*n

Essayez-le en ligne!

_{Enregistré 1 octet grâce à Rod et 1 grâce à GB .}

— M. Xcoder
source

1

C'est très intelligent!

— Skyler

14

MATL , 3 octets

:Us

... ou eux?

Essayez-le en ligne!

Explication

:    % Implicit input n. Push range [1 2 ... n]
U    % Square, element-wise
s    % Sum of array. Implicit display

— Luis Mendo
source

14

JavaScript (ES6), 16 octets

n=>n*(n+++n)*n/6

Démo

Afficher l'extrait de code

let f =

n=>n*(n+++n)*n/6

for(n = 0; n < 10; n++) {
  console.log('a(' + n + ') = ' + f(n))
}

Expand snippet

Comment?

L'expression n+++nest analysée comme n++ + n⁽¹⁾ . Ce n'est pas vraiment important car n + ++ncela fonctionnerait également dans ce cas.

Par conséquent:

n*(n+++n)*n/6 =
n * (n + (n + 1)) * (n + 1) / 6 =
n * (2 * n + 1) * (n + 1) / 6

qui évalue à additionner (k = 0 ... n) (k²) .

_{(1) Cela peut être vérifié en faisant n='2';console.log(n+++n)ce qui donne l'entier 5, alors n + ++nque donnerait la chaîne '23'.}

— Arnauld
source

6

05AB1E , 3 octets

ÝnO

Essayez-le en ligne!

Explication

  O    # sum of
 n     # squares of
Ý      # range [0 ... input]

— Emigna
source

6

Brain-Flak , 36 octets

({<(({}[()])())>{({})({}[()])}{}}{})

Essayez-le en ligne!

# Main algorithm
(                                  )  # Push the sum of:
                {({})({}[()])}{}      #   The square of:
 {                              }     #     0 to i 

# Stuff for the loop
  <(({}[()])())>                      # Push i-1, i without counting it in the sum
                                 {}   # Pop the counter (0)

— Riley
source

Bien fait! :) Je suis venu avec ({<(({}))>{({})({}[()])}{}<({}[()])>})38

— DJMcMayhem

34 octets;)

— Wheat Wizard

6

Brain-Flak , 34 octets

({(({}[()])()){({}[()])({})}{}}{})

Essayez-le en ligne!

Comment ça marche?

Au départ, j'avais la même idée que Riley ^1, mais je me sentais mal d'utiliser un zéro. J'ai alors réalisé que

{({}[()])({})}{}

Calcule n ² - n.

Pourquoi? Eh bien, nous savons

{({})({}[()])}{}

Calcule n ² et boucle n fois. Cela signifie que si nous inversons l'ordre des deux poussées, nous passons de l'augmentation de la somme de n + (n-1) à chaque fois à l'augmentation de la somme de (n-1) + (n-1) à chaque fois. Cela diminuera le résultat d'une par boucle, faisant ainsi notre résultat n ² - n. Au niveau supérieur, ce -n s'annule avec le n généré par la poussée que nous étions en train de mettre à zéro, réduisant ainsi le besoin d'un zéro et nous économisant deux octets.

Brain-Flak , 36 octets

({({})(({}[()])){({})({}[()])}{}}{})

Essayez-le en ligne!

Voici une autre solution, ce n'est pas aussi golfique mais c'est assez étrange alors j'ai pensé que je laisserais comme un défi de comprendre comment cela fonctionne.

Si vous n'êtes pas dans Brain-Flak mais que vous voulez toujours le défi ici, c'est comme une sommation.

^{1: J'ai trouvé ma solution avant de regarder les réponses ici. Donc pas de plagiat ici.}

— Assistant de blé
source

Je savais qu'il devait y avoir un moyen de le faire, et j'avais le sentiment que vous seriez le seul à comprendre les mathématiques.

— Riley

4

Husk , 3 octets

ṁ□ḣ

Essayez-le en ligne!

— M. Xcoder
source

3

Ohm v2 , 3 octets

#²Σ

Essayez-le en ligne!

Explication

#    Range
 ²   Square
  Σ  Sum

— Cinaski
source

3

Japt , 3 octets

ô²x

Essayez-le ici.

-1 merci à Shaggy .

Explication:

ò²x 
ô²  Map square on [0..input]
  x Sum

— Erik le Outgolfer
source

3 octets en utilisant le raccourci pour p2.

— Shaggy

@FelipeNardiBatista corrigé

— Erik the Outgolfer

2

Brain-Flak , 46 octets

{(({})[()])}{}{({({})({}[()])}{}<>)<>}<>({{}})

Essayez-le en ligne!

— HyperNeutrino
source

Une petite compétition amicale :)

— Riley

@Riley Ooh nice :)

— HyperNeutrino

Plutôt que de pousser le carré sur la pile alternative, vous pouvez le résumer directement en l'évaluant et non en le poussant, puis en poussant la boucle entière à la place. Cela change votre seconde moitié en ({{({})({}[()])}{}}{})et vous fait économiser 10 octets. (Si cela n'a pas de sens, envoyez-moi un ping dans la troisième pile )

— DJMcMayhem

2

CJam , 10 octets

ri),{_*+}*

Essayez-le en ligne!

ri            e# Input integer n
  )           e# Add 1
   ,          e# Range [0 1 ... n]
    {   }*    e# Fold (reduce)
     _        e# Duplicate
      *       e# Multiply
       +      e# Add

— Luis Mendo
source

Que diriez-vous ri),_.*:+ou ri),2f#:+?

— Martin Ender

@Martin Bonne idée! Je pense que vous devriez le poster comme une réponse différente

— Luis Mendo

2

Wolfram Language (Mathematica) , 14 octets

Tr[Range@#^2]&

Essayez-le en ligne!

— totalement humain
source

4

#.#&@Range@#&enregistre un octet

— miles

4

#.#&@*Range.

— alephalpha

2

En fait , 3 octets

R;*

Essayez-le en ligne!

Prend N en entrée et sort le Ne élément de la séquence.

Explication:

R;*
R    range(1, N+1) ([1, 2, ..., N])
 ;*  dot product with self

— Mego
source

2

APL (Dyalog) , 7 5 octets

2 octets économisés grâce à @Mego

+.×⍨⍳

Essayez-le en ligne!

Comment?

⍳ - intervalle

+.× - produit scalaire

⍨ - avec lui-même

— Uriel
source

@Uriel ma mauvaise, je pensais que ¨⍳c'était nécessaire

— Felipe Nardi Batista

2

R, 17 octets

sum((0:scan())^2)

Assez simple, il profite du fait que ^(exponentiation) est vectorisé dans R .

— Frédéric
source

1

(x=0:scan())%*%xest plus court d'un octet, mais je pense que vous avez besoin d'un catpour obtenir la sortie.

— Giuseppe

@Giuseppe Je viens de l'essayer et votre code fonctionne sans cat, il génère une matrice 1x1.

— Rui Barradas du

@RuiBarradas Le méta-consensus actuel est qu'il catest nécessaire pour que cela soit considéré comme un programme complet. Si vous souhaitez changer cela, répondez à cette question et obtenez une certaine traction parmi les autres personnes R sur le site.

— Giuseppe

2

CJam , 9 octets

ri),_.*:+

Essayez-le en ligne!

Explication

ri        e# Read input and convert to integer N.
  ),      e# Get range [0 1 2 ... N].
    _     e# Duplicate.
     .*   e# Pairwise products, giving [0 1 4 ... N^2].
       :+ e# Sum.

Alternativement:

ri),2f#:+

Cela place chaque élément en correspondance 2#au lieu d'utiliser des produits par paire. Et juste pour le plaisir, une autre alternative qui devient inexacte pour les grandes entrées car elle utilise l'arithmétique à virgule flottante:

ri),:mh2#

— Martin Ender
source

2

Julia , 16 ans 14 octets

2 octets enregistrés grâce à @MartinEnder

!n=(x=1:n)⋅x

Essayez-le en ligne!

Comment?

(x=1:n)crée une gamme de 1à net attribue à x, ⋅produit scalaire avec x.

— Uriel
source

2

Labyrinthe , 11 octets

:!\
+ :
*:#

Essayez-le en ligne!

Imprime la séquence indéfiniment.

Explication

Le pointeur d'instruction continue de tourner autour du carré de code encore et encore:

:!\    Duplicate the last result (initially zero), print it and a linefeed.
:      Duplicate the result again, which increases the stack depth.
#      Push the stack depth (used as a counter variable).
:*     Square it.
+      Add it to the running total.

— Martin Ender
source

2

Cubix , 15 octets

Iu):^\+*p*6u@O,

Essayez-le en ligne!

Mon code est un peu triste ):

Calcule n*(n+1)*(2n+1)/6

    I u
    ) :
^ \ + * p * 6 u
@ O , . . . . .
    . .
    . .

^Iu : read in input, u-turn
    : stack  n
:)\ : dup, increment, go right..oh, hey, it cheered up!
    : stack: n, n+1
+   : sum
    : stack: n, n+1, 2*n+1
*   : multiply
    : stack: n, n+1, 2*n+1, (n+1)*(2*n+1)
p   : move bottom of stack to top
    : stack: n+1, 2*n+1, (n+1)*(2*n+1), n
*   : multiply
6   : push 6
u   : right u-turn
,   : divide
O   : output
@   : terminate

— Giuseppe
source

2

Befunge , 16 octets

&::2*1+*\1+*6/.@

En utilisant la formule fermée n * (n + 1) * (2n + 1) / 6 .

Essayez-le en ligne!

Befunge , 38 octets

v>::*\1-:v0+_$.@
&^ <     _\:^
>:#^_.@

À l'aide d'une boucle.

Essayez-le en ligne!

— Cinaski
source

2

Haskell, 20 octets

f 0=0
f n=n*n+f(n-1)

Essayez-le en ligne!

— nimi
source

2

Excel, 19 octets

=A1^3/3+A1^2/2+A1/6

— Wernisch
source

2

Hexagonie , 23 octets

?'+)=:!@/*"*'6/{=+'+}/{

Essayez-le en ligne!

Explication

Déplié:

   ? ' + )
  = : ! @ /
 * " * ' 6 /
{ = + ' + } /
 { . . . . .
  . . . . .
   . . . .

C'est vraiment juste un programme linéaire avec la /redirection utilisée. Le code linéaire est:

?'+){=+'+}*"*'6{=:!@

Qui calcule n (n + 1) (2n + 1) / 6 . Il utilise les bords de mémoire suivants:

Où le point mémoire (MP) commence sur le bord étiqueté n , pointant vers le nord.

?   Read input into edge labelled 'n'.
'   Move MP backwards onto edge labelled 'n+1'.
+   Copy 'n' into 'n+1'.
)   Increment the value (so that it actually stores the value n+1).
{=  Move MP forwards onto edge labelled 'temp' and turn around to face
    edges 'n' and 'n+1'.
+   Add 'n' and 'n+1' into edge 'temp', so that it stores the value 2n+1.
'   Move MP backwards onto edge labelled '2n+1'.
+   Copy the value 2n+1 into this edge.
}   Move MP forwards onto 'temp' again.
*   Multiply 'n' and 'n+1' into edge 'temp', so that it stores the value
    n(n+1).
"   Move MP backwards onto edge labelled 'product'.
*   Multiply 'temp' and '2n+1' into edge 'product', so that it stores the
    value n(n+1)(2n+1).
'   Move MP backwards onto edge labelled '6'.
6   Store an actual 6 there.
{=  Move MP forwards onto edge labelled 'result' and turn around, so that
    the MP faces edges 'product' and '6'.
:   Divide 'product' by '6' into 'result', so that it stores the value
    n(n+1)(2n+1)/6, i.e. the actual result.
!   Print the result.
@   Terminate the program.

En théorie, il pourrait être possible d'adapter ce programme à la longueur de côté 3, car /ils ne sont pas nécessaires pour le calcul, ils :peuvent être réutilisés pour terminer le programme, et certains '"=+*{peuvent également être réutilisables, ce qui porte le nombre de commandes inférieures à 19 (le maximum pour la longueur latérale 3). Je doute qu'il soit possible de trouver une telle solution à la main, s'il en existe une.

— Martin Ender
source

2

> <> , 15 13 11 octets

Enregistré 2 octets grâce à Pas un arbre

0:n:l1-:*+!

Essayez-le en ligne!

Sort la séquence indéfiniment.

— Emigna
source

1

14 octets (12 + 2 pour le -vdrapeau): ::1+:}+**6,n( Essayez-le en ligne! )

— Pas un arbre

1

Ou 11 octets (imprime pour toujours, à partir de N=1): Essayez-le en ligne!

— Pas un arbre du

@Notatree: Très belle idée d'utilisation l. Vérifier avec OP s'il est correct de commencer à 1.

— Emigna

@Notatree: Malheureusement, nous ne sommes pas autorisés à commencer à 1, mais cela économise toujours 2 octets. Merci!

— Emigna

1

(Je dois mentionner que j'ai eu l' lidée de la réponse Labyrinthe de Martin Ender .)

— Pas un arbre

2

Pyth , 7 5 octets grâce à Steven H

s^R2h

Explication:

s^R2h       Full program - inputs from stdin and outputs to stdout
s           output the sum of
    h       range(input), with
 ^R2         each element squared

Ma première solution

sm*ddUh

Essayez-le en ligne!

Explication:

sm*ddUh    Full program - inputs from stdin and outputs to stdout
s          sum of
 m   Uh    each d in range(input)
  *dd      squared

— Dave
source

N'y a-t-il pas de carré intégré en Pyth?

— caird coinheringaahing

Pas autant que je sache ...

— Dave

Non, il n'y a pas de Pyth carré intégré. Aussi 6 octets

— M. Xcoder

1

5 octets .

— Steven H.

Fixable avec +1 octet à chaque réponse, je modifierai une fois que je serai hors du mobile.

— Dave

1

Neim , 3 octets

𝐈ᛦ𝐬

Cela aurait pu être un défi pour montrer les blocs de nombres polygonaux de Neim, mais apparemment pas.

Essayez-le en ligne!

— Okx
source

1

Oasis , 4 octets

nk+0

Essayez-le en ligne!

Explication

   0      # a(0) = 0
nk+       # a(n) = a(n-1)+n^2

— Emigna
source

1

Brachylog , 5 octets

⟦^₂ᵐ+

Essayez-le en ligne!

Explication

⟦        Range
 ^₂ᵐ     Map square
    +    Sum

— Fatalize
source

1

Gaia , 3 octets

s¦Σ

Essayez-le en ligne!

— M. Xcoder
source

Nombres pyramidaux carrés

Tâche

Exemple:

Spécification:

Gelée , 3 octets

Explication

Python 2 , 22 octets

Python 2 , 27 octets

MATL , 3 octets

Explication

JavaScript (ES6), 16 octets

Démo

Comment?

05AB1E , 3 octets

Brain-Flak , 36 octets

Brain-Flak , 34 octets

Comment ça marche?

Brain-Flak , 36 octets

Husk , 3 octets

Ohm v2 , 3 octets

Japt , 3 octets

Brain-Flak , 46 octets

CJam , 10 octets

Wolfram Language (Mathematica) , 14 octets

En fait , 3 octets

APL (Dyalog) , 7 5 octets

R, 17 octets

CJam , 9 octets

Explication

Julia , 16 ans 14 octets

Labyrinthe , 11 octets

Explication

Cubix , 15 octets

Befunge , 16 octets

Befunge , 38 octets

Haskell, 20 octets

Excel, 19 octets

Hexagonie , 23 octets

Explication

> <> , 15 13 11 octets

Pyth , 7 5 octets grâce à Steven H

Neim , 3 octets

Oasis , 4 octets

Brachylog , 5 octets

Explication

Gaia , 3 octets