Tarefa

Sua tarefa é simples, gere uma sequência que, dado o índice i, o valor nessa posição seja a soma dos quadrados de 0até ionde i >= 0.

Exemplo:

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)

Especificação:

Você não pode receber nenhuma entrada e produzir a sequência indefinidamente;
Você pode receber Ne enviar o Nthelemento da sequência;
Você pode receber Ne enviar os primeiros Nelementos da sequência.

— Felipe Nardi Batista
fonte

2

Observação divertida do OEIS: Esta sequência contém exatamente dois quadrados perfeitos:, f(1) == 1 * 1 (1)e f(24) == 70 * 70 (4900).

— DJMcMayhem

Podemos começar a sequência em f(1) = 1?

— Emigna

@ Emigna desculpe, mas não, você precisa começar f(0) = 0. i já assinalou que para as poucas respostas que falhou essa exigência

— Felipe Nardi Batista

O f(0) = 0requisito arruinou algumas das minhas soluções :(

— ATaco 19/17

4

Gelatina , 3 bytes

R²S

Experimente online!

FGITW

Explicação

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

— HyperNeutrino
fonte

Uma alternativa mais longa seriaRæ.R

— Sr. Xcoder 17/10/19

22

Python 2 , 22 bytes

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

Experimente online!

Isso usa a fórmula de forma fechada n * (n + 1) * (2 * n + 1) / 6 . O código executa as seguintes operações:

Multiplica n por ( n*):
- O complemento bit a bit de n ( ~n), que significa essencialmente -1-n .
- E pelo complemento bit a bit de 2n ( *~(n*2)), que significa -1-2n .
Divide por 6 ( /6).

Python 2 , 27 bytes

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

Experimente online!

_{Economizou 1 byte graças a Rod e 1 graças a GB .}

— Mr. Xcoder
fonte

1

Isso é muito inteligente!

— Skyler

14

MATL , 3 bytes

:Us

... ou eles?

Experimente online!

Explicação

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

— Luis Mendo
fonte

14

JavaScript (ES6), 16 bytes

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

Demo

Mostrar snippet de código

let f =

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

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

Expandir snippet

Quão?

A expressão n+++né analisada como n++ + n⁽¹⁾ . Não que isso realmente importe, porque n + ++ntambém funcionaria neste caso.

Assim sendo:

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

que avalia como soma (k = 0 ... n) (k²) .

_{(1) Isso pode ser verificado fazendo o n='2';console.log(n+++n)que fornece o número inteiro 5, ao passo n + ++nque daria a string '23'.}

— Arnauld
fonte

6

05AB1E , 3 bytes

ÝnO

Experimente online!

Explicação

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

— Emigna
fonte

6

Brain-Flak , 36 bytes

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

Experimente online!

# 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
fonte

Bem feito! :) Eu ({<(({}))>{({})({}[()])}{}<({}[()])>})

— criei

34 bytes;)

— Assistente de trigo

6

Brain-Flak , 34 bytes

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

Experimente online!

Como funciona?

Inicialmente, tive a mesma ideia que Riley ^1, mas parecia errado usar um zero. Então eu percebi que

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

Calcula n ² - n.

Por quê? Bem nós sabemos

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

Calcula n ² e faz loops n vezes. Isso significa que, se mudarmos a ordem dos dois impulsos, passamos de aumentar a soma em n + (n-1) a cada vez para aumentar a soma em (n-1) + (n-1) a cada vez. Isso diminuirá o resultado em um por loop, tornando nosso resultado n ² - n. No nível superior, isso -n cancela com o n gerado pelo push que estávamos zerando, aliviando a necessidade de um zero e economizando dois bytes.

Brain-Flak , 36 bytes

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

Experimente online!

Aqui está outra solução, não é tão divertida, mas é bem estranha, então pensei em deixar como um desafio descobrir como funciona.

Se você não gosta de Brain-Flak, mas ainda quer o desafio aqui, é um resumo.

Cenário

^{1: Encontrei minha solução antes de analisar as respostas aqui. Portanto, sem plágio aqui.}

— Assistente de Trigo
fonte

Eu sabia que tinha que haver uma maneira de fazer isso, e tinha a sensação de que você seria o único a descobrir a matemática para isso.

— Riley

4

Casca , 3 bytes

ṁ□ḣ

Experimente online!

— Mr. Xcoder
fonte

3

Ohm v2 , 3 bytes

#²Σ

Experimente online!

Explicação

#    Range
 ²   Square
  Σ  Sum

— Cinaski
fonte

3

Japonês , 3 bytes

ô²x

Experimente aqui.

-1 graças a Shaggy .

Explicação:

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

— Erik, o Outgolfer
fonte

3 bytes usando o atalho para p2.

— Shaggy

@FelipeNardiBatista corrigido

— Erik the Outgolfer

2

Brain-Flak , 46 bytes

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

Experimente online!

— HyperNeutrino
fonte

Um pouco de competição amigável :)

— Riley

@Riley Ooh nice :)

— HyperNeutrino

Em vez de empurrar o quadrado para a pilha alternativa, você pode somar diretamente avaliando e não pressionando, e pressionando o loop inteiro. Isso altera sua segunda metade para ({{({})({}[()])}{}}{})e economiza 10 bytes. (Se isso não faz sentido,

— envie-

2

CJam , 10 bytes

ri),{_*+}*

Experimente online!

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

— Luis Mendo
fonte

Que tal ri),_.*:+ou ri),2f#:+?

— Martin Ender

@Martin Boa ideia! Eu acho que você deve publicá-la como uma resposta diferente

— Luis Mendo

2

Wolfram Language (Mathematica) , 14 bytes

Tr[Range@#^2]&

Experimente online!

— totalmente humano
fonte

4

#.#&@Range@#&salva um byte

— milhas

4

#.#&@*Range.

— alephalpha

2

Na verdade , 3 bytes

R;*

Experimente online!

Pega Ncomo entrada e gera o Nth elemento na sequência.

Explicação:

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

— Mego
fonte

2

APL (Dyalog) , 7 5 bytes

2 bytes salvos graças ao @Mego

+.×⍨⍳

Experimente online!

Quão?

⍳ - alcance

+.× - produto pontual

⍨ - consigo mesmo

— Uriel
fonte

@Uriel meu mau, eu pensei que o ¨⍳necessário

— Felipe Nardi Batista

2

R, 17 bytes

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

Bastante simples, ele tira proveito do fato de que ^(exponenciação) é vetorizado em R .

— Frédéric
fonte

1

(x=0:scan())%*%xé mais curto por um byte, mas acredito que você precisa de um catpara obter saída.

— 21717 Giuseppe

@ Giuseppe Acabei de experimentar e seu código funciona sem cat, ele gera uma matriz 1x1.

— Rui Barradas

@RuiBarradas O meta consenso atual é que caté necessário para que isso se qualifique como um programa completo. Se você quiser mudar isso, responda a esta pergunta e obtenha alguma tração entre as outras pessoas no site.

— 21717 Giuseppe

2

CJam , 9 bytes

ri),_.*:+

Experimente online!

Explicação

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.

Alternativamente:

ri),2f#:+

Isso esquadrinha cada elemento mapeando em 2#vez de usar produtos em pares. E, apenas por diversão, outra alternativa que é imprecisa para entradas grandes porque usa aritmética de ponto flutuante:

ri),:mh2#

— Martin Ender
fonte

2

Julia , 16 14 bytes

2 bytes salvos graças a @MartinEnder

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

Experimente online!

Quão?

(x=1:n)cria uma gama de 1ao ne atribuir a x, ⋅dot produto com x.

— Uriel
fonte

2

Labirinto , 11 bytes

:!\
+ :
*:#

Experimente online!

Imprime a sequência indefinidamente.

Explicação

O ponteiro de instruções continua rodando repetidamente o quadrado do código:

:!\    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
fonte

2

Cubix , 15 bytes

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

Experimente online!

Meu código está um pouco triste ):

Computadores 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
fonte

2

Befunge , 16 bytes

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

Usando a fórmula de forma fechada n * (n + 1) * (2n + 1) / 6 .

Experimente online!

Befunge , 38 bytes

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

Usando um loop.

Experimente online!

— Cinaski
fonte

2

Haskell, 20 bytes

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

Experimente online!

— nimi
fonte

2

Excel, 19 bytes

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

— Wernisch
fonte

2

Hexagonia , 23 bytes

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

Experimente online!

Explicação

Desdobrado:

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

Este é realmente apenas um programa linear com o /usado para algum redirecionamento. O código linear é:

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

Qual calcula n (n + 1) (2n + 1) / 6 . Ele usa as seguintes bordas da memória:

Onde o ponto de memória (MP) começa na borda rotulada n , apontando para o norte.

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

Em teoria, pode ser possível ajustar esse programa no lado 3, porque /não são necessários para o cálculo, :podem ser reutilizados para finalizar o programa e alguns '"=+*{podem ser reutilizáveis, aumentando o número de solicitações necessárias. comandos abaixo de 19 (o máximo para o comprimento lateral 3). Duvido que seja possível encontrar essa solução manualmente, se é que existe alguma.

— Martin Ender
fonte

2

> <> , 15 13 11 bytes

Economizou 2 bytes graças a Not a tree

0:n:l1-:*+!

Experimente online!

Produz a sequência indefinidamente.

— Emigna
fonte

1

14 bytes (12 + 2 para -vsinalizador): ::1+:}+**6,n( Experimente on-line! )

— Não é uma árvore

1

Ou 11 bytes (impressos para sempre, a partir de N=1): Experimente online!

— Não é uma árvore

@ Notatree: Idéia muito boa usando l. Verificando com o OP se está tudo bem começar com 1.

— Emigna

@ Notatree: Infelizmente não temos permissão para iniciar em 1, mas ainda economiza 2 bytes. Obrigado!

— Emigna

1

(Devo mencionar que eu tive a lidéia de Martin Ender resposta Labirinto .)

— Nem uma árvore

2

Pitão , 7 5 bytes graças a Steven H

s^R2h

Explicação:

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

Minha primeira solução

sm*ddUh

Experimente online!

Explicação:

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

— Dave
fonte

Não existe uma praça construída em Pyth?

— caird coinheringaahing

Não tanto quanto eu sei ...

— Dave

Não, não há Pyth quadrado embutido. Também 6 bytes

— Sr. Xcoder 17/17

1

5 bytes .

— Steven H.

Pode ser corrigido com +1 byte para cada resposta, editarei assim que sair do celular.

— Dave

1

Neim , 3 bytes

𝐈ᛦ𝐬

Isso poderia ter sido um desafio para mostrar os números poligonais de Neim, mas aparentemente não.

Experimente online!

— Okx
fonte

1

Oásis , 4 bytes

nk+0

Experimente online!

Explicação

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

— Emigna
fonte

1

Braquilog , 5 bytes

⟦^₂ᵐ+

Experimente online!

Explicação

⟦        Range
 ^₂ᵐ     Map square
    +    Sum

— Fatalizar
fonte

1

Gaia , 3 bytes

s¦Σ

Experimente online!

— Mr. Xcoder
fonte

Números piramidais quadrados

Tarefa

Exemplo:

Especificação:

Gelatina , 3 bytes

Explicação

Python 2 , 22 bytes

Python 2 , 27 bytes

MATL , 3 bytes

Explicação

JavaScript (ES6), 16 bytes

Demo

Quão?

05AB1E , 3 bytes

Brain-Flak , 36 bytes

Brain-Flak , 34 bytes

Como funciona?

Brain-Flak , 36 bytes

Casca , 3 bytes

Ohm v2 , 3 bytes

Japonês , 3 bytes

Brain-Flak , 46 bytes

CJam , 10 bytes

Wolfram Language (Mathematica) , 14 bytes

Na verdade , 3 bytes

APL (Dyalog) , 7 5 bytes

R, 17 bytes

CJam , 9 bytes

Explicação

Julia , 16 14 bytes

Labirinto , 11 bytes

Explicação

Cubix , 15 bytes

Befunge , 16 bytes

Befunge , 38 bytes

Haskell, 20 bytes

Excel, 19 bytes

Hexagonia , 23 bytes

Explicação

> <> , 15 13 11 bytes

Pitão , 7 5 bytes graças a Steven H

Neim , 3 bytes

Oásis , 4 bytes

Braquilog , 5 bytes

Explicação

Gaia , 3 bytes