Différence du carré de la somme


37

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

C'est la représentation mathématique:

(n)2n2

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.


11
Il m'a fallu un certain temps pour comprendre que l'entrée était le point final d'une plage.
Brad Gilbert b2gills

@ BradGilbertb2gills édité pour plus de clarté
george

C'est plus simple qu'il n'y paraît?
Chat

@cat que voulez-vous dire par là? Oui, le calcul est simple. Mais tout dépend de votre façon de
jouer

@george La question et la plupart des réponses donnent l'impression qu'il y a beaucoup de travail, mais ce n'est pas le cas
cat

Réponses:


23

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 .


Ah ok. Pourriez-vous expliquer votre méthode cependant?
george

Je vais le faire, mais j'essaie actuellement de jouer un peu plus au golf.
Dennis

merci pour la formule. Je suppose que je n’ai jamais vu cela comme ça parce que nous ne couvrons pas de telles séries à l’école. Très intéressant cependant!
george

2
@george j'ai fini l'explication.
Dennis

Voulez-vous nous en dire un peu plus sur la manière dont l’idée de définir le terme «f» est venue à l’esprit! La motivation! Je suis vraiment intéressé.
Musa Al-hassy

15

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
    

7
J'aime vraiment voir les résultats partiels. Ils aident vraiment à comprendre le programme. Merci de les avoir inclus!
DanTheMan

10

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!


3
Pour une fois, Jelly est en fait très lisible.
Adám

Puis-je ajouter ceci à ma réponse?
Leaky Nun

@ LeakyNun qu'est-ce que cela signifie?
Poignée de porte


6
Belles boucles d'oreilles: S²_²S
Thomas Weller

10

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.


Bonjour, pourriez-vous expliquer votre équation si possible? Ma version en python a 16 octets de plus et je n'arrive pas à comprendre comment vous avez dérivé votre équation
george

1
@george Soit p(n)le nombre pyramidal du thème ne et le nombre triangulaire du th . Ensuite, ceci est une version simplifiée de . t(n)n(t(b)-t(a-1))^2 - (p(b) - p(a-1))
Martin Ender

@MartinEnder Voilà donc la formule exacte que j'ai utilisée, mais Sp3000 l'a simplifiée d'une manière que je ne peux pas comprendre. Mon script python est: (b * - ~ ba * ~ -a) ** 2 / 4- (b * - ~ b * (2 * b + 1) -a * ~ -a * (2 * a-1) ) / 6 si cela est utile. J'ai joué au golf autant que je peux les deux formules
george

@george Parfois, avec des problèmes comme ceux-là, le moyen le plus simple est de faire effectuer à Wolfram | Alpha la tâche fastidieuse, puis de la revérifier pour s'assurer que tout va bien. Pour être honnête, je ne pense pas que j'aurais pu (a-b-1)éliminer le facteur par (b*(b+1)*(2b+1)-a*(a-1)*(2a-1))/6moi-même.
Sp3000

@ Sp3000 c'est un excellent moyen de le faire. Je vais essayer cela à l'avenir
george

6

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


Est-ce que 05AB1E est une version ROT13 de Jelly? Remplacez r par Ÿ, µ par D, S par O, ² par n, _ par s et $ par -.
Thomas Weller

4
@ThomasWeller: Ils sont assez différents en fait. Un décalage commun entre certaines "fonctions" est fort probablement un hasard. Jelly est un langage tacite sur les fonctions de chaînage (autant que je sache), tandis que 05AB1E est un langage basé sur la pile.
Emigna

6

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

Aiderait Variance?
Leaky Nun

@ LeakyNun Je ne vois pas comment, car l'un des deux termes Varianceest divisé par net l'autre par n^2et je ne vois pas de moyen facile de les annuler séparément.
Martin Ender

1
Tr@#^2-#.#&@*Rangeest seulement 18 octets.
Misha Lavrov

@ MishaLavrov soignée! N'hésitez pas à en faire une réponse séparée. :)
Martin Ender

5

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.


4

Haskell, 34 octets

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

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

Rien à expliquer.


3

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)

3

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.


3

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.


Bienvenue chez PPCG! Vous pouvez probablement économiser un octet en mettant que ++sur f+=b*b++(vous pouvez laisser la troisième fente du forvide) et vous pouvez aussi ne pas besoin de la place eavant de le retourner (c. -à- faire juste return e*e-f).
Martin Ender

En fait, au lieu de laisser le troisième emplacement du forvide, déplacez-le f+=b*b++afin que vous puissiez économiser sur le point-virgule et les accolades.
Martin Ender

Bonne prise @MartinEnder, merci :)
Mario Ishac

Également basé sur ce que Martin avait en tête, cela semble être un peu plus court.
FryAmTheEggman

1
Apparemment, mon dernier commentaire était incorrect. Il s’agit en fait d’une partie spéciale de la grammaire Java: l’énoncé final d’un for est en fait un type d’instruction spécial, appelé liste d’expressions. Cette déclaration spéciale peut avoir plus d'une déclaration jointe par une virgule. Voir 14.14.1 (vous devrez y naviguer vous-même, je ne pouvais pas trouver un moyen de faire un lien plus précis) de la spécification de langue.
FryAmTheEggman


3

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


Essayez d'utilisern=>m=>eval(`for(s=t=0;n<=m;t+=n++)s+=n*n;t*t-s`)
Mama Fun Roll

@MamaFunRoll D'autre part, je pourrais essayer de porter la solution Python de Dennis ♦ ...
Neil

3

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
]

3

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

(k=mnk)2k=mnk2==k1=mnk2=mk2k1nk1k2=k1=mnk2=k1+1n2k1k2

1
Vous n'avez pas besoin de parens autour i+1.
Wheat Wizard

2
De plus, si vous voulez parler de golf Haskell et Haskell, vous pouvez nous rejoindre dans la salle de discussion .
Wheat Wizard

3

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

1
Enregistrez un octet déplaçant la tâche et évitant les parens:{$_=$^a..$^b;.sum²-[+] $_»²}
Phil H

1
25 octets:{.sum²-[+] $_»²}o&[..]
nwellnhof

2

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

2

APL, 23 à 20 octets

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

Fonctionne dans NARS2000.


2

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

2

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.

Belle utilisation du filtre. Bien qu'il y ait déjà un s*M.P}FQ2
élément


1

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*{)-},::*:+

1

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.


1

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



1

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]

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)


1
a\b=-(x=a:b)'x+sum(x)^2enregistre quelques octets.
Dennis

1

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.


1

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
}

1
Si vous aimez le prorgamme fonctionnel postfixe, sans point et basé sur la pile, vous pourriez aimer Factor : D
cat

1

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.


Bonjour, comment appeler la fonction que cela définit? J'ai été capable de comprendre l'entrée sur geogebra.org/classic#cas , mais je n'ai pas trouvé comment trouver ou appeler la fonction finale.
dimanche - Réintégrer Monica le

@sundar: La dernière ligne est une expression en x et y. Nous pourrions préfixer e(x,y)=pour lui donner un nom, mais pour économiser des octets, nous n'en avons pas ici. GeoGebra attribue automatiquement à l'expression un nom (probablement e, puisqu'il s'agit de la prochaine lettre disponible). Je n'ai pas l'environnement disponible pour le moment, mais je n'utiliserais pas le volet CAS. Le volet d’algèbre et la barre de saisie doivent faire le travail correctement. (Cela fait longtemps que je n'ai pas utilisé GGb en ligne; mon image mentale en est peut-être dépassée.)
Joe
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.