합의 제곱과 제곱의 합의 차이를 찾으십시오.

이것은 수학적 표현입니다.

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

프로그램 / 방법은 두 가지 입력을 가져야합니다. 입력의 범위는 상한 및 하한이며 포괄적입니다. 한계는 0보다 큰 정수입니다.

프로그램 / 방법이 답을 반환해야합니다.

원하는 기지를 사용할 수 있지만, 사용한 기지를 답으로 기재하십시오.

테스트 사례 (10 진법)

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

이것은 일반적인 코드 골프이므로 대답이 짧을수록 좋습니다.

파이썬 2, 43 바이트

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

Ideone에서 테스트하십시오 .

작동 원리

사양 g (a, b)에 정의 된 함수를 호출하십시오 . 우리는 그것을 가지고

함수 f (x, y, s) 를 다음과 같이 재귀 적으로 정의하십시오 .

f (a, b, 0) 의 재귀 관계를 총 b-a 번 적용하면이를 알 수 있습니다.

이것이 구현 의 함수 f 입니다. b/a0이 아닌 정수를 반환하는 동안 다음 코드 and가 실행되므로 재귀 적 정의 f가 구현 됩니다.

일단 0 에 b/a도달하면 b> a 이고 람다는 False = 0을 반환 하므로 f 정의의 기본 사례를 구현합니다 .

MATL , 9 바이트

&:&*XRssE

온라인으로 사용해보십시오!

설명

&:   % 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

예

이러한 입력에 대한 각 광고의 결과 부분이다 5하고 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
   

젤리, 9 8 바이트

rµS²_²S$

온라인으로 사용해보십시오!

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

바이트에 대한 FryAmTheEggman 에게 감사합니다 !

파이썬 2, 45 바이트

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

닫힌 양식 솔루션-가장 짧지는 않지만 어쨌든 게시 할 가치가 있다고 생각했습니다.

설명

하자 p(n)될 N 번째 사각뿔 수 및 t(n)될 N 번째 삼각수 . 그런 다음 범위 a , ..., b에 걸쳐 n의 경우 :

• ∑n = t(b)-t(a-1)및
• ∑n² = p(b) - p(a-1)
• 따라서 (∑n) ²-∑n² = (t(b)-t(a-1))² - (p(b) - p(a-1)).

이 표현은 코드의 표현으로 줄어 듭니다.

05AB1E, 8 바이트

ŸDOnsnO-

설명

Ÿ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

온라인으로 사용해보십시오

수학, 21 바이트

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

명명되지 않은 함수는 두 개의 인수를 사용하여 차이를 반환합니다. 용법:

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

여기에는 세 가지 작은 (그리고 상당히 표준적인) 골프 트릭이 있습니다.

• ##접두사 표기법을 사용할 수 있도록 두 인수를 한 번에 나타냅니다 Range. Range@##대한 속기 Range[##]로 확장하는 Range[a, b]필요에 따라 우리에게 포괄적 인 범위를 제공합니다.
• Tr위한 추적 하지만 벡터에 그것을 사용하는 것은 단순히 위에 세 바이트를 저장하는 벡터를 요약한다 Total.
• x.x는 4 바이트를 절약하는 내적 Tr[x^2]입니다.

미로 , 28 24 바이트

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

온라인으로 사용해보십시오!

설명

루프는 Labyrinth에서 비용이 많이 드는 경향이 있기 때문에 선형 코드로 표현할 수 있으므로 명시 적 수식이 가장 짧아야한다고 생각했습니다.

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

그러면 명령 포인터가 막 다른 골목에 닿아 돌아서야합니다. 이제 발생 /하면 스택의 맨 아래가 암시 적으로 0으로 채워지기 때문에 0으로 나누기를 시도하여 프로그램을 종료합니다.

하스켈, 34 바이트

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

사용 예 : 91 # 123-> 12087152.

설명 할 것이 없습니다.

Matlab, 30 29 28 바이트

Suever의 아이디어를 사용하면 norm2 바이트가 줄어 듭니다.

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

이전 (간단한) 버전 :

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

옥타브, 27 23 바이트

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

ans두 개의 입력을 허용 하는 익명 함수 를 작성합니다.ans(lower, upper)

온라인 데모

설명

에서 (포함) 행 벡터를 만들어 x로 y저장합니다 z. 그런 다음 사용하여 모든 요소를 ​​합산 sum하고 제곱합니다 ( ^2). 제곱의 합을 계산하기 위해 행 벡터와 전치 사이의 행렬 곱셈을 수행합니다. 이것은 각 요소를 효과적으로 제곱하고 결과를 요약합니다. 그런 다음 둘을 뺍니다.

Java, 84 77 자, 84 77 바이트

Martin Ender와 FryAmTheEggMan으로 인해 7 바이트가 작습니다. 감사합니다.

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

원래 게시물에서 세 가지 테스트 사례 사용 : http://ideone.com/q9MZSZ

언 골프 드 :

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

프로세스는 설명이 필요 없습니다. 나는 합의 제곱과 제곱의 합을 나타내는 두 개의 변수를 선언하고 반복적으로 적절하게 증가시켰다. 마지막으로 계산 된 차이를 반환합니다.

자바 스크립트 (ES6), 46 바이트

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

자바 스크립트 (ES6), 50 37 바이트

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

이제 @ Dennis ♦의 Python 솔루션 포트입니다.

48 바이트

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

익명의 기능.

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

하스켈, 36 바이트

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

참고

펄 6 ,  36 32  31 바이트

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

그것을 테스트

설명:

{ # 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 )
    $_»²
}

테스트:

#! /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 바이트

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

입력에서 2 개의 숫자를 목록으로 예상합니다 (예 :) [91:123].

설명

: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 바이트

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

NARS2000에서 작동합니다.

MATL, 11 바이트

&:ts2^w2^s-

온라인으로 사용해보십시오!

설명:

&:           #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 바이트

s*M-F#^}FQ2

온라인으로 사용해보십시오!

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.

apt, 10 바이트

õV
x²aUx ²

시도 해봐

CJam, 17 바이트

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

여기에서 테스트하십시오.

설명

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.

또는 모든 고유 쌍의 곱을 합할 수 있지만 (기본적으로 합의 제곱을 곱하고 제곱을 제거) 바이트는 더 깁니다.

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

PowerShell v2 +, 47 바이트

두 가지 변형

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

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

두 경우 모두 ..연산자 로 범위를 생성 하여 루프로 파이프합니다 |%{...}. 반복 할 때마다, 우리는 축적하고 $o및 $p합계 또는 제곱합 하나있다. 그런 다음 with $o*$o과 빼기 로 제곱합을 계산합니다 $p. 출력은 파이프 라인에 남아 있고 인쇄는 암시 적입니다.

자바 스크립트 (ES6), 67 바이트

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

테스트 스위트

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 바이트

도어 노브의 젤리 답변 포트 .

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

용법

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

>>STDIN은 어디에 <<있고 STDOUT이며 x확장 된 정밀도를위한 것입니다.

파이크, 11 바이트

h1:Ds]MXXs-

여기 사용해보십시오!

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

줄리아, 25 바이트

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

이것은 두 정수를 허용하고 1x1 정수 배열을 반환하는 함수입니다.

접근 방식은 간단하다 다음을 구축 UnitRange끝점에서 a와 b그것을 호출 x한 후 합계 x, 그것을 광장 등과 같은 계산의 규범을 뺍니다 transpose(x) * x.

온라인으로 사용해보십시오! (모든 테스트 케이스 포함)

TI-BASIC, 19 바이트

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

randIntNoRep범위를 가져옵니다 (셔플). 나머지는 꽤 자명하다.

Fith , 52 바이트

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

이것은 스택에서 두 숫자를 가져와 단일 숫자를 남기는 익명 함수입니다.

설명:

{
    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
}

지오 지브라, 91 바이트

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)

e(x,y)원하는 차이를 계산 하는 함수 (아마도 )를 정의합니다 . 와
a(x)사이의 자연수의 합을 계산합니다 . 와 사이의 자연수 제곱의 합을 계산합니다 . 먼저 와 사이의 자연수의 합을 계산 한 다음 그 합을 제곱합니다. 와 사이의 제곱의 합을 계산합니다 . 마지막 줄은 계산을 마치는 다중 변수 함수를 정의합니다. 이 함수에는 이름이 자동으로 할당되어 몇 바이트가 절약됩니다.0x
b(x)0x
c(x,y)xy
d(x,y)b(x)b(y)