Sự miêu tả

Trừ các số P tiếp theo từ một số N. Số tiếp theo của N là N + 1.

Nhìn vào các ví dụ để có được những gì tôi muốn nói.

Ví dụ:

Input: N=2,P=3
Calculate: n - (n+1) - (n+2) - (n+3)     //Ending with 3, because P=3
Calculate: 2 -  2+1  -  2+2  - 2+3       //Replacing N with 2 from Input
Calculate: 2 -  3    -  4    - 5
Output: -10


Input: N=100,P=5
Calculate: n - (n+1) - (n+2) - (n+3) - (n+4) - (n+5)
Calculate: 100-  101 -  102  -  103  -  104  - 105
Output: -415


Input: N=42,P=0
Calculate: n
Calculate: 42
Output: 42


Input: N=0,P=3
Calculate: n - (n+1) - (n+2) - (n+3)
Calculate: 0 -  1    -  2    -  3
Output: -6


Input: N=0,P=0
Calulate: n
Calculate: 0
Output: 0

Đầu vào:

N : Số nguyên, dương, âm hoặc 0

P : Số nguyên, dương hoặc 0, không âm

Đầu ra:

Số nguyên hoặc Chuỗi, dẫn đầu 0 được phép, theo dõi dòng mới được phép

Quy tắc:

• Không sơ hở
• Đây là mã golf, vì vậy mã ngắn nhất tính bằng byte thắng
• Đầu vào và đầu ra phải được mô tả

05AB1E , 5 3 byte

Đã lưu 2 byte nhờ Adnan

Ý+Æ

Giải trình

Lấy P rồi N làm đầu vào.

       # implicit input, ex 5, 100
Ý      # range(0,X): [0,1,2,3,4,5]
 +     # add: [100,101,102,103,104,105]
  Æ    # reduced subtraction: 100-101-102-103-104-105

Python 2, 26 24 23 byte

-2 byte nhờ @Adnan (thay thế p*(p+1)/2bằng p*-~p/2)
-1 byte nhờ @MartinEnder (thay thế -p*-~p/2bằng+p*~p/2

lambda n,p:n-p*n+p*~p/2

Các bài kiểm tra là trên ideone

CJam, 8 byte

{),f+:-}

Bộ thử nghiệm.

Quá tệ là giải pháp dạng đóng dài hơn. : |

Giải trình

),  e# Get range [0 1 ... P].
f+  e# Add N to each value to get [N N+1 ... N+P].
:-  e# Fold subtraction over the list, computing N - (N+1) - (N+2) - ... - (N+P).

Haskell, 21 byte

a#b=foldl1(-)[a..a+b]

Javascript (ES6), 20 19 18 byte

n=>p=>n+p*(~p/2-n)

Đã lưu 1 byte bằng cách currying, như được đề xuất bởi Zwei
Đã lưu 1 byte nhờ người dùng81655

Kiểm tra

let f =
n=>p=>n+p*(~p/2-n)

console.log(f(2)(3))
console.log(f(100)(5))
console.log(f(42)(0))
console.log(f(0)(3))
console.log(f(0)(0))

Thạch , 4 byte

r+_/

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

r+_/  Main link. Arguments: n, p

 +    Yield n+p.
r     Range; yield [n, ..., n+p].
  _/  Reduce by subtraction.

Haskell, 19 18 byte

n#p=n+sum[-n-p..n]

Các giải pháp 19 byte trước đó

n#p=n-n*p-(p*p+p)/2
n#p=n-sum[n+1..n+p]

C #, 21 20 byte

Chỉnh sửa: Đã lưu một byte nhờ TheLethalCoder

N=>P=>N-P++*(N+P/2);

Hãy thử trực tuyến!

Nguồn đầy đủ, bao gồm các trường hợp thử nghiệm:

using System;

namespace substract
{
    class Program
    {
        static void Main(string[] args)
        {
            Func<int,Func<int,int>>s=N=>P=>N-P++*(N+P/2);
            Console.WriteLine(s(2)(3));     //-10
            Console.WriteLine(s(100)(5));   //-415
            Console.WriteLine(s(42)(0));    //42
            Console.WriteLine(s(0)(3));     //-6
            Console.WriteLine(s(0)(0));     //0

        }
    }
}

Toán học, 15 byte

#2-##-#(#+1)/2&

Một hàm không tên nhận Pvà nlà tham số của nó theo thứ tự đó.

Sử dụng giải pháp dạng đóng n - n*p - p(p+1)/2.

Perl, 23 22 byte

Bao gồm +1 cho -p

Cho n và p (theo thứ tự đó) trên các dòng STDIN riêng biệt:

subtract.pl
2
3
^D

subtract.pl:

#!/usr/bin/perl -p
$_-=eval"+2+\$_++"x<>

(sử dụng ''dấu ngoặc kép để lưu \hình phạt 2 byte vì không thể kết hợp với -e)

Cùng một ý tưởng và độ dài:

#!/usr/bin/perl -p
$_+=eval"-1-++\$_"x<>

Đáng ngạc nhiên khi thực hiện tính toán thực tế ngắn hơn so với sử dụng công thức trực tiếp (những điều này $thực sự gây tổn hại cho số học)

C ++, 54 51 byte

  [](int N,int P){int F=N;while(P--)F-=++N;return F;}

[] (int N, int P) {int F; for (F = N; P; F - = ++ N, P -); return F;}

Kiểm tra:

#include <iostream>
int main(void)
{
    int N, P;
    std::cin >> N >> P;
    auto f = [](int N,int P){int F=N;while(P--)F-=++N;return F;};
    std::cout << f(N,P) << std::endl;
    return 0;
}

Pyke, 6 byte

m+mhs-

Hãy thử nó ở đây!

m+     -    map(range(input_2), +input_1)
  mh   -   map(^, +1)
    s  -  sum(^)
     - - input_1 - ^

Brachylog , 19 17 byte

hHyL,?+y:Lx+$_:H+

Giải trình

hH                  Input = [H, whatever]
 HyL,               L = [0, …, H]
     ?+             Sum the two elements in the Input
       y            Yield the range from 0 to the result of the sum
        :Lx         Remove all elements of L from that range
           +        Sum the remaining elements
            $_      Negate the result
              :H+   Add H

MATL , 5 byte

:y+s-

Đầu vào là Pvà sau đó N.

Hãy thử nó tại MATL Online!

Giải trình

:     % Take P implicitly. Range [1 2 ... P]
      %     Stack: [1 2 ... P]
y     % Take N implicitly at the bottom of the stack, and push another copy
      %     Stack: N, [1 2 ... P], N
+     % Add the top two arrays in the stack , element-wise
      %     Stack: N, [N+1 N+2 ... N+P]
s     % Sum of array
      %     Stack: N, N+1+N+2+...+N+P
-     % Subtract the top two numbers
      %     Stack: N-(N+1+N+2+...+N+P)
      % Implicitly display

Hàng loạt, 30 byte

@cmd/cset/a%1-(%1*2+%2+1)*%2/2

Lấy nvà plàm tham số dòng lệnh và in kết quả mà không có dòng mới.

Silos , 80 byte

GOTO b
lbla
n+1
m-n
i-1
GOTO d
lblb
readIO
n=i
m=n
readIO
lbld
if i a
printInt m

Dùng thử trực tuyến với các trường hợp thử nghiệm:
2,3
100,5
42,0
0,3
0,0

R, 17 14 byte

N-N*P-sum(0:P)

Cảm ơn billywob vì đã chơi golf 3 byte. Câu trả lời trước:

N-sum(N+if(P)1:P)

Lưu ý rằng 1: 0 mở rộng đến vectơ (1,0) vì vậy chúng ta cần điều kiện if (P) (hoặc để sử dụng seq_len, nhưng đó là nhiều byte hơn). Nếu không có điều kiện, chúng ta sẽ nhận được đầu ra sai nếu P = 0.

Nếu P bằng 0, thì tổng mở rộng thành sum(N+NULL), sau đó sum(numeric(0)), bằng không.

PHP, 33 byte

$n-=$n*$p+array_sum(range(0,$p));

Thạch , 7 byte

RS+×_×-

Các đối số đang P, N
kiểm tra nó trên TryItOnline

Làm sao?

RS+×_×-  - takes two arguments: P, N
R        - range(P): [1,2,3, ... ,P]
 S       - sum: 1+2+3+ ... +P
   ×     - multiply: P*N
  +      - add: 1+2+3+ ... +P + P*N
    _    - subtract: 1+2+3+ ... +P + P*N - N
      -  - -1
     ×   - multiply: (1+2+3+ ... +P + P*N - N)*-1
                   = -1-2-3- ... -P - P*N + N
                   = N - (N+1) - (N+2) - (N+3) - ... - (N+P)

Pyth - 6 byte

-F}Q+E

Phòng thử nghiệm .

Forth, 36 byte

Tính toán đơn giản của n - (p*n + (p^2+p) / 2)

: f 2dup dup dup * + 2/ -rot * + - ;

Dùng thử trực tuyến

Java, 67 , 63 byte

Chơi gôn

int x(int n,int p){return-((p%2<1)?p*p/2+p:p/2*(p+2)+1)+n-p*n;}

Ung dung:

int x(int n, int p)
{
    return -((p%2<1) ? p*p/2+p : p/2 * (p+2) + 1) + n - p*n;
}

Về cơ bản tôi đã làm một số toán về công thức. Phần n - p*nnày chăm sóc tất cả ncác công thức. Sau đó, tôi đã sử dụng một thuộc tính siêu thú vị để tổng hợp các số nguyên tăng tuyến tính (chuỗi số học): Tôi đã sử dụng tổng của số nguyên đầu tiên và cuối cùng và sau đó nhân nó với set.length / 2(Tôi cũng kiểm tra tính chẵn lẻ và xử lý nó một cách thích hợp).

Hãy dùng thử: https://ideone.com/DEd85A

Java 7, 43 40 byte

int c(int n,int p){return n-p*n+p*~p/2;}

Java 8, 19 byte

(n,p)->n-p*n+p*~p/2

Bị đánh cắp một cách đáng xấu hổ từ công thức Python 2 tuyệt vời của @Jonathan ALLan .

Câu trả lời gốc ( 61 60 byte):

int c(int n,int p){int r=n,i=1;for(;i<p;r-=n+++i);return r;}

Các trường hợp bất ngờ & thử nghiệm:

Hãy thử nó ở đây.

class M{
  static int c(int n, int p){
    return n - p*n + p*~p / 2;
  }

  public static void main(String[] a){
    System.out.println(c(2, 3));
    System.out.println(c(100, 5));
    System.out.println(c(42, 0));
    System.out.println(c(0, 3));
    System.out.println(c(0, 0));
  }
}

Đầu ra:

-10
-415
42
-6
0

Fourier , 34 byte

I~No~OI~P>0{1}{@P+N(N^~NO-N~ON)Oo}

Hãy thử trực tuyến!

Mê cung , 15 byte

?:?:}*-{:)*#/-!

hoặc là

??:}`)*{:)*#/-!

Sử dụng giải pháp dạng đóng n - n*P - P*(P+1)/2.

php, 38 byte

<?=$argv[1]*(1-$a=$argv[2])-$a++*$a/2;

Bình thường, 11 byte

Ms+Gm_+GdSH

Một hàm glấy đầu vào nvà pthông qua đối số và in kết quả. Nó có thể được gọi trong mẫu gn p.

Dùng thử trực tuyến

Làm thế nào nó hoạt động

Ms+Gm_+GdSH  Function g. Inputs: G, H
M            g=lambda G,H:
         SH   1-indexed range, yielding [1, 2, 3, ..., H]
    m_+Gd     Map lambda d:-(G+d) over the above, yielding [-(G+1), -(G+2), -(G+3),
              ..., -(G+H)]
  +G          Add G to the above, yielding [G, -(G+1), -(G+2), -(G+3), ..., -(G+H)]
 s            Reduce on addition with base case 0, yielding G-(G+1)-(G+2)-(G+3)...
              -(G+H)
              Implicitly print

C89, 38 , 35 , 33 byte

h(n,p,r)int*r;{*r=n-p++*(n+p/2);}

Kiểm tra nó trên Coliru .

Maple, 19 byte

n-sum(i,i=n+1..n+p)

Sử dụng:

> f:=(n,p)->n-sum(i,i=n+1..n+p);
> f(2, 3);
  -10
> f(100,5);
  -415
> f(42,0);
  42

Perl 6 , 21 byte

{$^n-[+] $n^..$n+$^p}

Giải trình:

# bare block lambda with two placeholder parameters ｢$n｣ and ｢$p｣
{
  $^n -
      # reduce using ｢&infix:<+>｣
      [+]
          # a Range that excludes ｢$n｣ and has ｢$p｣ values after it
          $n ^.. ($n + $^p)
}