15

A soma dos quadrados dos dez primeiros números naturais é: $1^2 + 2^2 + \dots + 10^2 = 385$

O quadrado da soma dos dez primeiros números naturais é,

$(1 + 2 + ... + 10)^2 = 55^2 = 3025$

Portanto, a diferença entre a soma dos quadrados dos dez primeiros números naturais e o quadrado da soma é

$3025 − 385 = 2640$

Para uma determinada entrada n, encontre a diferença entre a soma dos quadrados dos primeiros n números naturais e o quadrado da soma.

Casos de teste

1       => 0
2       => 4
3       => 22
10      => 2640
24      => 85100
100     => 25164150

Esse desafio foi anunciado pela primeira vez no Projeto Euler # 6 .

Critérios Vencedores

Não há regras sobre qual deve ser o comportamento com entrada negativa ou zero.
A resposta mais curta vence.

code-golf math

— Eduardo Hoefel
fonte

4

Este desafio tem um critério vencedora (por exemplo, golf code)

— dylnan

2

Este é um subconjunto desta pergunta

— caird coinheringaahing 4/18

1

A sequência pode ser indexada em 0? ou seja, os números naturais até n?

— Jo rei

5

Observe que é desencorajado a postar desafios retirados diretamente de outro lugar .

— user202729

3

@ Enigma Eu realmente não acho que isso seja uma duplicata do alvo, já que muitas respostas aqui não são fáceis de serem respostas, então isso adiciona algo.

— Jonathan Allan

10

Geléia , 5 4 bytes

Ḋ²ḋṖ

Experimente online!

Quão?

Implementos $\sum_{i=2}^n{(i^2(i-1))}$ ...

Ḋ²ḋṖ - Link: non-negative integer, n
Ḋ    - dequeue (implicit range)       [2,3,4,5,...,n]
 ²   - square (vectorises)            [4,9,16,25,...,n*n]
   Ṗ - pop (implicit range)           [1,2,3,4,...,n-1]
  ḋ  - dot product                    4*1+9*2+16*3+25*4+...+n*n*(n-1)

— Jonathan Allan
fonte

8

Python 3 , 28 27 bytes

-1 graças a xnor

lambda n:(n**3-n)*(n/4+1/6)

Experimente online!

Implementos $n(n-1)(n+1)(3n+2)/12$

Python 2, ~~29 e~~ 28 bytes:lambda n:(n**3-n)*(3*n+2)/12

— Jonathan Allan
fonte

1

Você pode barbear um byte com n*~-n**2*ou (n**3-n)*.

— Xnor

8

APL (Dyalog Unicode) , 10 bytes

1⊥⍳×⍳×1-⍨⍳

Experimente online!

Como funciona

1⊥⍳×⍳×1-⍨⍳
  ⍳×⍳×1-⍨⍳  Compute (x^3 - x^2) for 1..n
1⊥          Sum

Usa o fato de que "quadrado da soma" é igual a "soma dos cubos".

— Bubbler
fonte

Para mim 1 × × × × 1-⍨⍳ não é uma função; Tentei 1⊥⍳ × ⍳ × 1-⍨⍳10 e para mim não compilar ...

— RosLuP

1

@RosLuP Você deve atribuí-lo a uma variável primeiro (como eu fiz no link TIO) ou envolvê-lo dentro de um par de parênteses, como (1⊥⍳×⍳×1-⍨⍳)10.

— Bubbler

7

TI-Basic (série TI-83), 12 11 bytes

sum(Ans² nCr 2/{2,3Ans

Implementos $\binom{n^2}{2}(\frac12 + \frac1{3n})$ . Recebe entradaAns: por exemplo, execute10:prgmXpara calcular o resultado da entrada10.

— Misha Lavrov
fonte

Bom uso de nCr!

— Lynn

6

Flacidez Cerebral , 74 72 68 64 bytes

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

Experimente online!

Maneira bastante simples de fazer isso com algumas mudanças complicadas. Espero que alguém encontre mais alguns truques para tornar isso ainda mais curto.

— Post Rock Garf Hunter
fonte

5

Carvão , 12 10 bytes

ＩΣＥＮ×ιＸ⊕ι²

Experimente online! Link é a versão detalhada do código. Explicação: $( \sum_1^n x )^2 = \sum_1^n x^3$ de modo $( \sum_1^n x )^2 - \sum_1^n x^2 = \sum_1^n (x^3 - x^2) = \sum_1^n (x - 1)x^2 = \sum_0^{n-1} x(x + 1)^2$ .

   Ｎ        Input number
  Ｅ         Map over implicit range i.e. 0 .. n - 1
        ι   Current value
       ⊕    Incremented
         ²  Literal 2
      Ｘ     Power
     ι      Current value
    ×       Multiply
 Σ          Sum
Ｉ           Cast to string
            Implicitly print

— Neil
fonte

5

Perl 6 , 22 bytes

{sum (1..$_)>>²Z*^$_}

Experimente online!

$\sum_{i=1}^n {(i^2(i-1))}$

— Brincadeira
fonte

4

Japonês `-x`, 9 8 5 4 bytes

õ²í*

Tente

Explicação

õ        :Range [1,input]
 ²       :Square each
  í      :Interleave with 0-based indices
   *     :Reduce each pair by multiplication
         :Implicit output of the sum of the resulting array

— Shaggy
fonte

4

JavaScript, 20 bytes

f=n=>n&&n*n*--n+f(n)

Experimente online

— Shaggy
fonte

o que deviltry é este

— don brilhante

3

APL (Dyalog), 17 bytes

{+/(¯1↓⍵)×1↓×⍨⍵}⍳

(Muito mais tempo) Resposta do porto de Jonathan Allan Jelly.

Experimente online!

— Quintec
fonte

+/¯1↓⍳×1⌽⍳×⍳

— Torne-se

3

APL (Dyalog) , 16 bytes

((×⍨+/)-(+/×⍨))⍳

Experimente online!

 (×⍨+/)            The square (× self) of the sum (+ fold)
       -           minus
        (+/×⍨)     the sum of the square
(             )⍳   of [1, 2, … input].

— Lynn
fonte

(+/×⍨)→ 1⊥×⍨conforme dica .

— Adám 5/11

1

Um outro byte poderia ser salvo por guardar o ⍳interior(×⍨1⊥⍳)-⍳+.×⍳

— Kritixi Lithos

3

Mathematica, 21 17 bytes

^{-4 bytes graças a alefhalpha .}

(3#+2)(#^3-#)/12&

Função pura. Pega um número inteiro como entrada e retorna um número inteiro como saída. Apenas implementa o polinômio, pois Sums, Ranges, Trs, etc. ocupam muitos bytes.

— LegionMammal978
fonte

(3#+2)(#^3-#)/12&

— Alephalpha #

@alephalpha Thanks!

— precisa

É possível chegar lá sem apenas avaliar o polinômio: #.(#^2-#)&@*Rangeimplementa outra solução comum. (Mas também é 17 bytes.) E nós podemos implementar o algoritmo ingênuo em 18 bytes: Tr@#^2-#.#&@*Range.

— Misha Lavrov #

3

Java (JDK) , 23 bytes

n->(3*n+2)*(n*n*n-n)/12

Experimente online!

— Olivier Grégoire
fonte

3

dc , 16 bytes

?dd3^r-r3*2+*C/p

Implementos $(n^3-n)(3n+2)/12$

Experimente online!

— Trauma Digital
fonte

3

05AB1E , 8 bytes

ÝDOnsnO-

Explicação:

ÝDOnsnO-     //Full program
Ý            //Push [0..a] where a is implicit input
 D           //Duplicate top of stack
  On         //Push sum, then square it
    s        //Swap top two elements of stack
     nO      //Square each element, then push sum
       -     //Difference (implicitly printed)

Experimente online!

— Cowabunghole
fonte

LDnOsOn-foi a minha primeira tentativa também.

— Magic Octopus Urn

3

C, C ++, 46 40 37 bytes (#define), 50 47 46 bytes (função)

-1 byte graças a Zacharý

-11 bytes graças ao ceilingcat

Versão macro:

#define F(n)n*n*~n*~n/4+n*~n*(n-~n)/6

Versão da função:

int f(int n){return~n*n*n*~n/4+n*~n*(n-~n)/6;}

Essas linhas são baseadas nessas 2 fórmulas:

Soma dos números entre 1 e n = n*(n+1)/2
Soma dos quadrados entre 1 e n =n*(n+1)*(2n+1)/6

Portanto, a fórmula para obter a resposta é simplesmente (n*(n+1)/2) * (n*(n+1)/2) - n*(n+1)*(2n+1)/6

E agora, para "otimizar" a contagem de bytes, quebramos os parênteses e movemos as coisas, enquanto o teste sempre dá o mesmo resultado

(n*(n+1)/2) * (n*(n+1)/2) - n*(n+1)*(2n+1)/6=> n*(n+1)/2*n*(n+1)/2 - n*(n+1)*(2n+1)/6=> n*(n+1)*n*(n+1)/4 - n*(n+1)*(2n+1)/6

Observe o padrão p = n*n+1 = n*n+n, portanto, na função, declaramos outra variável int p = n*n+ne ela fornece:

p*p/4 - p*(2n+1)/6

Por p*(p/4-(2*n+1)/6)isso n*(n+1)*(n*(n+1)/4 - (2n+1)/6), funciona apenas na metade do tempo, e suspeito que a divisão inteira seja a causa ( f(3)dando 24 em vez de 22, f(24)dando 85200 em vez de 85100, por isso não podemos fatorar a fórmula da macro dessa maneira, mesmo que matematicamente seja o mesmo.

Tanto a macro quanto a versão da função estão aqui devido à substituição da macro:

F (3) dá 3*3*(3+1)*(3+1)/4-3*(3+1)*(2*3+1)/6 = 22
F (5-2) dá5-2*5-2*(5-2+1)*(5-2+1)/4-5-2*(5-2+1)*(2*5-2+1)/6 = -30

e mexer com a precedência do operador. a versão da função não tem esse problema

— HatsuPointerKun
fonte

1

Você pode resolver o problema com as macros ao custo de MUITOS bytes, substituindo todos npor (n). Além disso, F(n) n=> F(n)nindependentemente.

— Zacharý

É possível reorganizar return p*p/4-p*(n-~n)/6para return(p/4-(n-~n)/6)*p.

— Zachary

@ Zacharý Não, isso me dá resultados ruins às vezes como 24 em vez de 22 na entrada "3" ou 85200 em vez de 85100 na entrada "24". Eu suspeito inteiro divisão para ser a causa de que

— HatsuPointerKun

Ugh, sempre esqueça isso.

— Zachary

2

JavaScript (ES6), 22 bytes

n=>n*~-n*-~n*(n/4+1/6)

Experimente online!

— Arnauld
fonte

2

Pitão, 7 bytes

sm**hdh

Experimente online aqui .

Usa a fórmula na resposta de Neil .

sm**hdhddQ   Implicit: Q=eval(input())
             Trailing ddQ inferred
 m       Q   Map [0-Q) as d, using:
    hd         Increment d
   *  hd       Multiply the above with another copy
  *     d      Multiply the above by d
s            Sum, implicit print

— Sok
fonte

2

SNOBOL4 (CSNOBOL4) , 70 69 bytes

 N =INPUT
I X =X + N ^ 3 - N ^ 2
 N =GT(N) N - 1 :S(I)
 OUTPUT =X
END

Experimente online!

— Giuseppe
fonte

2

Pari / GP , 21 bytes

n->(3*n+2)*(n^3-n)/12

Experimente online!

— alefalpha
fonte

2

05AB1E , 6 bytes

LnDƶαO

Experimente online!

Explicação

L         # push range [1 ... input]
 n        # square each
  D       # duplicate
   ƶ      # lift, multiply each by its 1-based index
    α     # element-wise absolute difference
     O    # sum

Algumas outras versões no mesmo byte contam:

L<ān*O
Ln.āPO
L¦nā*O

— Emigna
fonte

2

R , 28 bytes

x=1:scan();sum(x)^2-sum(x^2)

Experimente online!

— Sumner18
fonte

3

sum(x<-1:scan())^2-sum(x^2)para -1

— J.Doe 7/11

2

MathGolf , 6 bytes

{î²ï*+

Experimente online!

Calcula $\sum_{k=1}^n (k^2(k-1))$

Explicação:

{       Loop (implicit) input times
 î²     1-index of loop squared
    *   Multiplied by
   ï    The 0-index of the loop
     +  And add to the running total

— Brincadeira
fonte

2

Clojure , 58 bytes

~~(fn[s](-(Math/pow(reduce + s)2)(reduce +(map #(* % %)s))))~~

Experimente online!

Edit: Eu entendi mal a pergunta

Clojure , 55 , 35 bytes

#(* %(+ 1 %)(- % 1)(+(* 3 %)2)1/12)

Experimente online!

— TheGreatGeek
fonte

1

Obrigado por corrigir isso. E apenas um aviso sobre sua última entrada (apply +é menor que (reduce +.

— Carcigenicate

@Carcigenicate Thanks!

— TheGreatGeek

1

Você poderia editar seu link permanente para executar um dos casos de teste? Como é, não ajudo pessoas que não conhecem o Clojure.

— Dennis

2

cQuents , 17 15 bytes

b$)^2-c$
;$
;$$

Experimente online!

Explicação

 b$)^2-c$     First line
:             Implicit (output nth term in sequence)
 b$)          Each term in the sequence equals the second line at the current index
    ^2        squared
      -c$     minus the third line at the current index

;$            Second line - sum of integers up to n
;$$           Third line - sum of squares up to n

— Stephen
fonte

1

APL (NARS), 13 caracteres, 26 bytes

{+/⍵×⍵×⍵-1}∘⍳

use a fórmula Sum'w = 1..n '(w w (w-1)) possível eu escrevi o mesmo algum outro escreveu + ou - como "1⊥⍳ × ⍳ × ⍳-1"; teste:

  g←{+/⍵×⍵×⍵-1}∘⍳
  g 0
0
  g 1
0
  g 2
4
  g 3
22
  g 10
2640

— RosLuP
fonte

1

Stax , 4 bytes

╡⌠(♠

Execute e depure

Para todos os knúmeros inteiros positivos até a entrada, adicione k^2 * (k-1).

— recursivo
fonte

1

QBASIC, 45 44 bytes

A matemática pura economiza 1 byte!

INPUT n
?n^2*(n+1)*(n+1)/4-n*(n+1)*(2*n+1)/6

Experimente ISSO online!

Resposta anterior, baseada em loop

INPUT n
FOR q=1TO n
a=a+q^2
b=b+q
NEXT
?b^2-a

Experimente online!

Observe que o REPL é um pouco mais expandido porque o intérprete falha de outra maneira.

— steenbergh
fonte

1

JAEL , 13 10 bytes

#&àĝ&oȦ

Experimente online!

Explicação (gerada automaticamente):

./jael --explain '#&àĝ&oȦ'
ORIGINAL CODE:  #&àĝ&oȦ

EXPANDING EXPLANATION:
à => `a
ĝ => ^g
Ȧ => .a!

EXPANDED CODE:  #&`a^g&o.a!

COMPLETED CODE: #&`a^g&o.a!,

#          ,            repeat (p1) times:
 &                              push number of iterations of this loop
  `                             push 1
   a                            push p1 + p2
    ^                           push 2
     g                          push p2 ^ p1
      &                         push number of iterations of this loop
       o                        push p1 * p2
        .                       push the value under the tape head
         a                      push p1 + p2
          !                     write p1 to the tapehead
            ␄           print machine state

— Eduardo Hoefel
fonte

1

05AB1E , 6 bytes

LDOšnÆ

Experimente online!

Explicação:

           # implicit input (example: 3)
L          # range ([1, 2, 3])
 DOš       # prepend the sum ([6, 1, 2, 3])
    n      # square each ([36, 1, 4, 9])
     Æ     # reduce by subtraction (22)
           # implicit output

Ænão é útil com frequência, mas é hora de brilhar. Isso bate o ingênuo LOnILnO-por dois bytes inteiros.

— Grimmy
fonte

Soma diferença quadrada

Critérios Vencedores

Geléia , 5 4 bytes

Quão?

Python 3 , 28 27 bytes

APL (Dyalog Unicode) , 10 bytes

Como funciona

TI-Basic (série TI-83), 12 11 bytes

Flacidez Cerebral , 74 72 68 64 bytes

Carvão , 12 10 bytes

Perl 6 , 22 bytes

Japonês -x, 9 8 5 4 bytes

Explicação

JavaScript, 20 bytes

APL (Dyalog), 17 bytes

APL (Dyalog) , 16 bytes

Mathematica, 21 17 bytes

Java (JDK) , 23 bytes

dc , 16 bytes

05AB1E , 8 bytes

C, C ++, 46 40 37 bytes (#define), 50 47 46 bytes (função)

JavaScript (ES6), 22 bytes

Pitão, 7 bytes

SNOBOL4 (CSNOBOL4) , 70 69 bytes

Pari / GP , 21 bytes

05AB1E , 6 bytes

R , 28 bytes

MathGolf , 6 bytes

Explicação:

Clojure , 58 bytes

Edit: Eu entendi mal a pergunta

Clojure , 55 , 35 bytes

cQuents , 17 15 bytes

Explicação

APL (NARS), 13 caracteres, 26 bytes

Stax , 4 bytes

QBASIC, 45 44 bytes

JAEL , 13 10 bytes

Explicação (gerada automaticamente):

05AB1E , 6 bytes

Japonês `-x`, 9 8 5 4 bytes