Trouve la différence entre le carré des sommes et la somme des carrés.

C'est la représentation mathématique:

$\left(\sum n\right)^2-\sum n^2$

Votre programme / méthode doit prendre deux entrées: ce sont vos limites inférieure et supérieure de la plage et sont inclusives. Les limites seront des entiers supérieurs à 0.

Votre programme / méthode devrait retourner la réponse.

Vous pouvez utiliser la base de votre choix, mais veuillez indiquer dans votre réponse quelle base vous avez utilisée.

Cas de test (base 10)

5,9      970
91,123   12087152
1,10     2640

C'est le code-golf habituel, donc plus la réponse est courte, mieux c'est.

Python 2, 43 octets

f=lambda a,b,s=0:b/a and 2*a*s+f(a+1,b,s+a)

Testez-le sur Ideone .

Comment ça marche

Appelez la fonction définie dans la spécification g (a, b) . Nous avons cela

Définissez la fonction f (x, y, s) de manière récursive comme suit.

En appliquant la relation de récurrence de f (a, b, 0) un total de b - a times, nous pouvons montrer que.

C'est la fonction f de l'implémentation. Alors que b/arenvoie un entier non nul, le code suivant andest exécuté, implémentant ainsi la définition récursive de f .

Une fois que 0b/a atteint , nous avons que b> a et le lambda renvoie False = 0 , implémentant ainsi le cas de base de la définition de f .

MATL , 9 octets

&:&*XRssE

Essayez-le en ligne!

Explication

&:   % Inclusive range between the two implicit inputs
&*   % Matrix of all pair-wise products
XR   % Upper triangular part of matrix, without the diagonal
ss   % Sum of all elements of the matrix
E    % Multiply by 2. Implicit display

Exemple

Ce sont les résultats partiels de chaque ligne pour les entrées 5et 9:

1. &:

   5 6 7 8 9
   

2. &:&*

   25 30 35 40 45
   30 36 42 48 54
   35 42 49 56 63
   40 48 56 64 72
   45 54 63 72 81
   

3. &:&*XR

   0 30 35 40 45
   0  0 42 48 54
   0  0  0 56 63
   0  0  0  0 72
   0  0  0  0  0
   

4. &:&*XRss

   485
   

5. &:&*XRssE

   970
   

Gelée, 9 à 8 octets

rµS²_²S$

Essayez-le en ligne!

r         inclusive range from first input to second input
 µ        pass the range to a new monadic chain
  S       the sum
   ²      squared
    _     minus...
     ²S$  the squares summed

Merci à FryAmTheEggman pour un octet!

Python 2, 45 octets

lambda a,b:(a+~b)*(a-b)*(3*(a+b)**2+a-b-2)/12

Solution de formulaire fermé - pas le plus court, mais je pensais que ça valait le coup de poster.

Explication

Soit p(n)le n e chiffre pyramidal et t(n)le n e chiffre triangulaire . Ensuite, pour n sur la plage a , ..., b :

• ∑n = t(b)-t(a-1), et
• ∑n² = p(b) - p(a-1)
• Donc (∑n) ²-n² = (t(b)-t(a-1))² - (p(b) - p(a-1)).

Cette expression se réduit à celle du code.

05AB1E, 8 octets

ŸDOnsnO-

A expliqué

ŸD       # range from a to b, duplicate
  On     # sum and square first range
    s    # swap top 2 elements
     nO  # square and sum 2nd range
       - # take difference

Essayez-le en ligne

Mathematica, 21 octets

Tr[x=Range@##]^2-x.x&

Une fonction sans nom prenant deux arguments et renvoyant la différence. Usage:

Tr[x=Range@##]^2-x.x&[91, 123]
(* 12087152 *)

Il y a trois petites astuces (et assez standard) de golf ici:

• ##représente les deux arguments en même temps, afin que nous puissions utiliser la notation préfixe pour Range. Range@##est l’abréviation pour Range[##]laquelle s’élargit Range[a, b]et nous donne une plage inclusive au besoin.
• Trest pour la trace mais son utilisation sur un vecteur additionne simplement ce vecteur en économisant trois octets Total.
• x.xest un produit scalaire, économisant quatre octets de plus Tr[x^2].

Labyrinthe , 28 à 24 octets

?:?:}+=-:(:(#{:**+**#2/!

Essayez-le en ligne!

Explication

Comme les boucles ont tendance à être chères dans Labyrinth, j’ai pensé que la formule explicite devrait être la plus courte, car elle peut être exprimée sous forme de code linéaire.

Cmd Explanation                 Stacks [ Main | Aux ]
?   Read M.                     [ M | ]
:   Duplicate.                  [ M M | ]
?   Read N.                     [ M M N | ]
:   Duplicate.                  [ M M N N | ]
}   Move copy to aux.           [ M M N | N ]
+   Add.                        [ M (M+N) | N ]
=   Swap tops of stacks.        [ M N | (M+N) ]
-   Subtract.                   [ (M-N) | (M+N) ]
:   Duplicate.                  [ (M-N) (M-N) | (M+N) ]
(   Decrement.                  [ (M-N) (M-N-1) | (M+N) ]
:   Duplicate.                  [ (M-N) (M-N-1) (M-N-1) | (M+N) ]
(   Decrement.                  [ (M-N) (M-N-1) (M-N-2) | (M+N) ]
#   Push stack depth.           [ (M-N) (M-N-1) (M-N-2) 3 | (M+N) ]
{   Pull (M+N) over from aux.   [ (M-N) (M-N-1) (M-N-2) 3 (M+N) | ]
:   Duplicate.                  [ (M-N) (M-N-1) (M-N-2) 3 (M+N) (M+N) | ]
*   Multiply.                   [ (M-N) (M-N-1) (M-N-2) 3 ((M+N)^2) | ]
*   Multiply.                   [ (M-N) (M-N-1) (M-N-2) (3*(M+N)^2) | ]
+   Add.                        [ (M-N) (M-N-1) (3*(M+N)^2 + M - N - 2) | ]
*   Multiply.                   [ (M-N) ((M-N-1)*(3*(M+N)^2 + M - N - 2)) | ]
*   Multiply.                   [ ((M-N)*(M-N-1)*(3*(M+N)^2 + M - N - 2)) | ]
#   Push stack depth.           [ ((M-N)*(M-N-1)*(3*(M+N)^2 + M - N - 2)) 1 | ]
2   Multiply by 10, add 2.      [ ((M-N)*(M-N-1)*(3*(M+N)^2 + M - N - 2)) 12 | ]
/   Divide.                     [ ((M-N)*(M-N-1)*(3*(M+N)^2 + M - N - 2)/12) | ]
!   Print.                      [ | ]

Le pointeur d'instruction frappe alors une impasse et doit faire demi-tour. Lorsqu'il rencontre maintenant, /il tente une division par zéro (le bas de la pile étant implicitement rempli de zéros), ce qui termine le programme.

Haskell, 34 octets

a#b=sum[a..b]^2-sum(map(^2)[a..b])

Exemple d'utilisation: 91 # 123-> 12087152.

Rien à expliquer.

Matlab, 30 29 28 octets

Utiliser l’idée de Suever normnous donne 2 octets de moins

@(x,y)sum(x:y)^2-norm(x:y)^2

Ancienne version (simple):

@(x,y)sum(x:y)^2-sum((x:y).^2)

Octave, 27 23 octets

@(x,y)sum(z=x:y)^2-z*z'

Crée une fonction anonyme nommée ansqui accepte deux entrées:ans(lower, upper)

Démo en ligne

Explication

Crée un vecteur de ligne de xà y(inclus) et le stocke dans z. Nous additionnons ensuite tous les éléments en utilisant un sumcarré ( ^2). Pour calculer la somme des carrés, nous effectuons une multiplication matricielle entre le vecteur ligne et sa transposition. Cela mettra effectivement chaque élément en carré et résumera le résultat. Nous soustrayons ensuite les deux.

Java, 84 77 caractères, 84 77 octets

7 octets plus petits à cause de Martin Ender et FryAmTheEggMan, merci.

public int a(int b,int c){int e=0,f=0;for(;b<=c;e+=b,f+=b*b++);return e*e-f;}

Utilisation des trois cas de test de la publication d'origine: http://ideone.com/q9MZSZ

Ungolfed:

public int g(int b, int c) {
    int e = 0, f = 0;
    for (; b <= c; e += b, f += b * b++);
    return e*e-f;
}

Le processus est assez explicite. J'ai déclaré deux variables représentant le carré des sommes et la somme des carrés et les ai incrémentées à plusieurs reprises de façon appropriée. Enfin, je retourne la différence calculée.

JavaScript (ES6), 46 octets

f=(x,y,s=0,p=0)=>x<=y?f(x+1,y,s+x,p+x*x):s*s-p

JavaScript (ES6), 50 37 octets

f=(n,m,s=0)=>n>m?0:2*n*s+f(n+1,m,n+s)

Maintenant un port de la solution Python de @ Dennis ♦.

Facteur, 48 octets

[ [a,b] [ [ sq ] map sum ] [ sum sq ] bi - abs ]

Une fonction anonyme.

[ 
  [a,b] ! a range from a to b 
  [ 
    [ sq ] map sum ! anonymous function: map sq over the range and sum the result 
  ] 
  [ sum sq ] ! the same thing, in reverse order
  bi - abs   ! apply both anon funcs to the range, subtract them and abs the result
]

Haskell, 36 octets

m#n=sum[2*i*j|i<-[m..n],j<-[i+1..n]]

λ> m # n = sum [ 2*i*j | i <- [m..n], j <- [i+1..n] ]
λ> 5 # 9
970
λ> 91 # 123
12087152
λ> 1 # 10
2640

Notez que

Perl 6 ,  36 32  31 octets

{([+] $_=@_[0]..@_[1])²-[+] $_»²}
{([+] $_=$^a..$^b)²-[+] $_»²}
{[+]($_=$^a..$^b)²-[+] $_»²}

Essaye-le

Explication:

{ # bare block with placeholder parameters $a and $b

  [+](# reduce with &infix:<+>
      # create a range, and store it in $_
      $_ = $^a .. $^b
  )²
  -
  [+] # reduce with &infix:<+>
    # square each element of $_ ( possibly in parallel )
    $_»²
}

Tester:

#! /usr/bin/env perl6
use v6.c;
use Test;

my @tests = (
  (5,9) => 970,
  (91,123) => 12087152,
  (1,10) => 2640,
);

plan +@tests;

my &diff-sq-of-sum = {[+]($_=$^a..$^b)²-[+] $_»²}

for @tests -> $_ ( :key(@input), :value($expected) ) {
  is diff-sq-of-sum(|@input), $expected, .gist
}

1..3
ok 1 - (5 9) => 970
ok 2 - (91 123) => 12087152
ok 3 - (1 10) => 2640

Brachylog , 24 octets

:efL:{:2^.}a+S,L+:2^:S-.

Attend les 2 nombres en entrée sous forme de liste, par exemple [91:123].

Explication

:efL                     Find the list L of all integers in the range given in Input
    :{:2^.}a             Apply squaring to each element of that list
            +S,          Unify S with the sum of the elements of that list
               L+:2^     Sum the elements of L, then square the result
                    :S-. Unify the Output with that number minus S

APL, 23 à 20 octets

-/+/¨2*⍨{(+/⍵)⍵}⎕..⎕

Fonctionne dans NARS2000.

MATL, 11 octets

&:ts2^w2^s-

Essayez-le en ligne!

Explication:

&:           #Create a range from the input
  t          #Duplicate it
   s2^       #Sum it and square it
      w      #swap the two ranges
       2^s   #Square it and sum it
          -  #Take the difference

Pyth, 11 octets

s*M-F#^}FQ2

Essayez-le en ligne!

s*M-F#^}FQ2
       }FQ    Compute the range
      ^   2   Generate all pairs
   -F#        Remove those pairs who have identical elements
 *M           Product of all pairs
s             Sum.

Japt, 10 octets

õV
x²aUx ²

L'essayer

CJam, 17 octets

q~),>_:+2#\2f#:+-

Testez-le ici.

Explication

q~       e# Read and evaluate input, dumping M and N on the stack.
),       e# Increment, create range [0 1 ... N].
>        e# Discard first M elements, yielding [M M+1 ... N].
_        e# Duplicate.
:+2#     e# Sum and square.
\2f#:+   e# Swap with other copy. Square and sum.
-        e# Subtract.

Alternativement, on peut simplement additionner les produits de toutes les paires distinctes (en multipliant fondamentalement le carré de la somme et en supprimant les carrés), mais c'est un octet plus long:

q~),>2m*{)-},::*:+

PowerShell v2 +, 47 octets

Deux variations

param($n,$m)$n..$m|%{$o+=$_;$p+=$_*$_};$o*$o-$p

$args-join'..'|iex|%{$o+=$_;$p+=$_*$_};$o*$o-$p

Dans les deux cas, nous générons une plage avec l' ..opérateur, en la canalisant vers une boucle |%{...}. A chaque itération, nous accumulons $oet $psoit la somme, soit la somme des carrés. Nous calculons ensuite le carré des sommes avec $o*$oet soustrayons $p. La sortie est laissée sur le pipeline et l'impression est implicite.

JavaScript (ES6), 67 octets

a=>b=>([s=q=0,...Array(b-a)].map((_,i)=>q+=(s+=(n=i+a),n*n)),s*s-q)

Suite de tests

f=a=>b=>([s=q=0,...Array(b-a)].map((_,i)=>q+=(s+=(n=i+a),n*n)),s*s-q)
e=s=>`${s} => ${eval(s[0])}` // template tag format for tests
console.log(e`f(5)(9)`)
console.log(e`f(91)(123)`)
console.log(e`f(1)(10)`)

J, 29 octets

Réponse de la gelée du port de poignée de porte .

[:(+/@(^&2)-~2^~+/)[}.[:i.1+]

Usage

>> f = [:(+/@(^&2)-~2^~+/)[}.[:i.1+]
>> 91 f 123x
<< 12087152

Où >>est STDIN, <<est STDOUT et xpour une précision étendue.

Pyke, 11 octets

h1:Ds]MXXs-

Essayez-le ici!

h1:         - inclusive_range(input)
   Ds]      -     [^, sum(^)]
      MX    -    deep_map(^, <--**2)
         s  -   ^[1] = sum(^[1])
          - -  ^[0]-^[1]

Julia, 25 octets

f(a,b,x=a:b)=sum(x)^2-x'x

C'est une fonction qui accepte deux entiers et retourne un tableau d'entiers 1x1.

L’approche est simple: construisez un à UnitRangepartir des points de terminaison aet bappelez-le x, faites la somme x, mettez -le en carré et soustrayez sa norme, qui est calculée comme transpose(x) * x.

Essayez-le en ligne! (inclut tous les cas de test)

TI-BASIC, 19 octets

Prompt N,M
randIntNoRep(N,M
sum(Ans)2-sum(Ans2

randIntNoRepobtient la gamme (mélangé). Le reste est assez explicite.

Fith , 52 octets

{ 1 + range dup sum 2 pow swap { 2 pow } map sum - }

Il s'agit d'une fonction anonyme qui prend les deux nombres de la pile et ne laisse qu'un seul nombre.

Explication:

{
    1 + range dup      2 ranges from a to b inclusive
    sum 2 pow          Sum one and square it
    swap               Bring a fresh range to the top
    { 2 pow } map sum  Square every element and sum the list
    -                  Subtract
}

GeoGebra, 91 octets

a(x)=(x²+x)/2
b(x)=x³/3+x²/2+x/6
c(x,y)=(a(y)-a(x))²
d(x,y)=b(y)-b(x)
c(x-1,y)-d(x-1,y)

Définit une fonction (probablement e(x,y)) qui calcule la différence souhaitée.
a(x)calcule la somme des nombres naturels entre 0et x.
b(x)calcule la somme des carrés des nombres naturels entre 0et x.
c(x,y)calcule d’abord la somme des nombres naturels entre xet y, puis la met au carré.
d(x,y)calcule la somme des carrés entre b(x)et b(y).
La dernière ligne définit une fonction multi-variable qui termine le calcul. Un nom est automatiquement attribué à la fonction, enregistrant quelques octets.