ลักษณะ

ลบหมายเลข P ถัดไปออกจากหมายเลข N จำนวนถัดไปของ N คือ N + 1

ดูตัวอย่างเพื่อรับสิ่งที่ฉันหมายถึง

ตัวอย่าง:

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

การป้อนข้อมูล:

N : เลขจำนวนเต็มบวกค่าลบหรือ 0

P : จำนวนเต็มบวกหรือ 0 ไม่ใช่ลบ

เอาท์พุท:

จำนวนเต็มหรือสตริงนำ 0 อนุญาตการขึ้นบรรทัดใหม่ที่ได้รับอนุญาต

กฎ:

• ไม่มีช่องโหว่
• นี่คือ code-golf ดังนั้นรหัสที่สั้นที่สุดในหน่วยไบต์ชนะ
• อินพุตและเอาต์พุตต้องเป็นไปตามที่อธิบายไว้

05AB1E , 5 3 ไบต์

บันทึก 2 ไบต์ต้องขอบคุณAdnan

Ý+Æ

คำอธิบาย

ใช้ P แล้ว N เป็นอินพุต

       # 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 ไบต์

-2 ไบต์ขอขอบคุณ @Adnan (แทนที่p*(p+1)/2ด้วยp*-~p/2)
-1 ไบต์ขอบคุณ @MartinEnder (แทนที่-p*-~p/2ด้วย)+p*~p/2

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

การทดสอบอยู่บนideone

CJam, 8 ไบต์

{),f+:-}

ชุดทดสอบ

น่าเสียดายที่โซลูชันแบบปิดมีความยาวกว่า : |

คำอธิบาย

),  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 ไบต์

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

Javascript (ES6), 20 19 18 ไบต์

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

บันทึก 1 ไบต์โดย currying ตามคำแนะนำของ Zwei
บันทึก 1 ไบต์ขอบคุณ user81655

ทดสอบ

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

วุ้นขนาด 4 ไบต์

r+_/

ลองออนไลน์!

มันทำงานอย่างไร

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

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

Haskell, 19 18 ไบต์

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

โซลูชันขนาด 19 ไบต์ก่อนหน้า

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

C #, 21 20 ไบต์

แก้ไข: บันทึกหนึ่งไบต์ด้วยTheLethalCoder

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

ลองออนไลน์!

แหล่งที่มาเต็มรูปแบบรวมถึงกรณีทดสอบ:

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

        }
    }
}

Mathematica ขนาด 15 ไบต์

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

ฟังก์ชั่นที่ไม่มีชื่อที่ได้รับPและnเป็นพารามิเตอร์ในลำดับที่

n - n*p - p(p+1)/2ใช้วิธีการแก้ปัญหาแบบปิด

Perl, 23 22 ไบต์

รวม +1 สำหรับ -p

ให้ n และ p (ตามลำดับนั้น) บนบรรทัดแยกของ STDIN:

subtract.pl
2
3
^D

subtract.pl:

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

(ใช้''เครื่องหมายคำพูดเพื่อบันทึกการ\เรียกใช้การลงโทษ 2 ไบต์เนื่องจากไม่สามารถใช้ร่วมกับ-e )

ความคิดและความยาวเดียวกัน:

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

น่าแปลกที่ทำการคำนวณที่เกิดขึ้นจริงจะสั้นกว่าโดยใช้สูตรโดยตรง (เหล่านี้$'s เจ็บจริงๆสำหรับคณิตศาสตร์)

C ++, 54 51 ไบต์

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

[] (int N, int P) {int F; สำหรับ (F = N; P; F - = ++ N, P -); return F;}

ทดสอบ:

#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 ไบต์

m+mhs-

ลองที่นี่!

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

Brachylog , 19 17 ไบต์

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

คำอธิบาย

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 ไบต์

:y+s-

ปัจจัยการผลิตที่มีแล้วPN

ลองที่ MATL Online!

คำอธิบาย

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

แบตช์ 30 ไบต์

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

รับnและpเป็นพารามิเตอร์บรรทัดคำสั่งและพิมพ์ผลลัพธ์โดยไม่ต้องขึ้นบรรทัดใหม่

SILOS , 80 ไบต์

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

ลองออนไลน์กับกรณีทดสอบ:
2,3
100,5
42,0
0,3
0,0

R, 17 14 ไบต์

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

ขอบคุณ billywob สำหรับการเล่นกอล์ฟที่ห่างออกไป 3 ไบต์ คำตอบก่อนหน้า:

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

โปรดทราบว่า 1: 0 ขยายไปยังเวกเตอร์ (1,0) ดังนั้นเราจึงจำเป็นต้องมีเงื่อนไข if (P) (หรือใช้seq_lenแต่เป็นไบต์ที่มากกว่า) หากไม่มีเงื่อนไขเราจะได้ผลลัพธ์ที่ผิดถ้า P = 0

ถ้า P เป็นศูนย์ผลรวมจะขยายเป็นsum(N+NULL)แล้วsum(numeric(0))ซึ่งเป็นศูนย์

PHP, 33 ไบต์

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

เยลลี่ขนาด 7 ไบต์

RS+×_×-

ข้อโต้แย้งคือP, N
ทดสอบบนTryItOnline

อย่างไร?

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 ไบต์

-F}Q+E

Test Suite

ไปมา 36 ไบต์

การคำนวณอย่างง่ายของ n - (p*n + (p^2+p) / 2)

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

ลองออนไลน์

ชวา 67 , 63 ไบต์

แข็งแรงเล่นกอล์ฟ:

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

Ungolfed:

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

โดยทั่วไปฉันทำคณิตศาสตร์เกี่ยวกับสูตร n - p*nส่วนหนึ่งจะดูแลทั้งหมดn 's ในสูตร จากนั้นฉันใช้คุณสมบัติที่สนุกสุด ๆ ของการรวมจำนวนเต็ม (ชุดเลขคณิต) เชิงเส้นเพิ่มขึ้นเชิงเส้น: ฉันใช้ผลรวมของจำนวนเต็มแรกและสุดท้ายแล้วคูณด้วยset.length / 2(ฉันตรวจสอบความเท่าเทียมกันและจัดการมันอย่างเหมาะสม)

ลองใช้: https://ideone.com/DEd85A

Java 7, 43 40 ไบต์

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

Java 8, 19 ไบต์

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

ขโมยลงคอจาก@JonathanAllanที่น่าตื่นตาตื่นใจงูหลาม 2 สูตร

คำตอบเดิม ( 61 60 ไบต์):

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

กรณีที่ไม่ได้รับการทดสอบ &:

ลองที่นี่

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));
  }
}

เอาท์พุท:

-10
-415
42
-6
0

ฟูริเยร์ 34 ไบต์

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

ลองออนไลน์!

เขาวงกต 15 ไบต์

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

หรือ

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

n - n*P - P*(P+1)/2ใช้วิธีการแก้ปัญหาแบบปิด

php, 38 ไบต์

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

Pyth, 11 ไบต์

Ms+Gm_+GdSH

ฟังก์ชั่นgที่รับอินพุตnและpผ่านการโต้แย้งและพิมพ์ผลลัพธ์ gn pจะสามารถเรียกว่าในรูปแบบ

ลองออนไลน์

มันทำงานอย่างไร

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 ไบต์

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

ทดสอบบนColiru

Maple ขนาด 19 ไบต์

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

การใช้งาน:

> 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 ไบต์

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

คำอธิบาย:

# 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)
}