Beschreibung

Subtrahieren Sie die nächsten P-Zahlen von einer N-Zahl. Die nächste Zahl von N ist N + 1.

Schauen Sie sich die Beispiele an, um zu verstehen, was ich meine.

Beispiele:

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

Eingang:

N : Ganzzahlig, positiv, negativ oder 0

P : Ganzzahl, positiv oder 0, nicht negativ

Ausgabe:

Ganzzahl oder Zeichenfolge, führende 0 zulässig, nachfolgende Newline zulässig

Regeln:

• Keine Lücken
• Das ist Code-Golf, also gewinnt der kürzeste Code in Bytes
• Ein- und Ausgang müssen wie beschrieben sein

05AB1E , 5 3 Bytes

2 Bytes gespart dank Adnan

Ý+Æ

Erläuterung

Nimmt P und dann N als Eingabe.

       # 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 Bytes

-2 Bytes dank @Adnan (ersetzen p*(p+1)/2durch p*-~p/2)
-1 Bytes dank @MartinEnder (ersetzen -p*-~p/2durch+p*~p/2

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

Tests sind auf ideone

CJam, 8 Bytes

{),f+:-}

Testsuite.

Schade, dass die geschlossene Lösung länger ist. : |

Erläuterung

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

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

Javascript (ES6), 20 19 18 Bytes

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

1 Byte durch Currying gespeichert, wie von Zwei vorgeschlagen
1 Byte dank user81655 gespeichert

Prüfung

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

Gelee , 4 Bytes

r+_/

Probieren Sie es online!

Wie es funktioniert

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

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

Haskell, 19 18 Bytes

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

Vorherige 19-Byte-Lösungen

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

C #, 21 - 20 Bytes

Bearbeiten: Dank TheLethalCoder ein Byte gespeichert

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

Probieren Sie es online!

Vollständige Quelle, einschließlich Testfällen:

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 Bytes

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

Eine unbenannte Funktion, die Pund nals Parameter in dieser Reihenfolge empfängt .

Verwendet die geschlossene Lösung n - n*p - p(p+1)/2.

Perl, 23 22 Bytes

Beinhaltet +1 für -p

Geben Sie n und p (in dieser Reihenfolge) in separaten Zeilen von STDIN an:

subtract.pl
2
3
^D

subtract.pl:

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

(Verwenden von ''Anführungszeichen zum Speichern von \Aufrufen mit einer 2-Byte-Strafe, da diese nicht mit kombiniert werden kann. -e)

Gleiche Idee und Länge:

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

Überraschenderweise ist die eigentliche Berechnung kürzer als die Verwendung der direkten Formel (dies ist $für die Arithmetik wirklich schmerzhaft).

C ++, 54 51 Bytes

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

[] (int N, int P) {int F; für (F = N; P; F - = ++ N, P -); Rückgabe F;}

Prüfung:

#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 Bytes

m+mhs-

Probieren Sie es hier aus!

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

Brachylog , 19 17 Bytes

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

Erläuterung

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 Bytes

:y+s-

Eingänge sind Pund dann N.

Probieren Sie es bei MATL Online!

Erläuterung

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

Batch, 30 Bytes

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

Übernimmt nund pals Kommandozeilenparameter und druckt das Ergebnis ohne nachfolgende Newline.

SILOS , 80 Bytes

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

Probieren Sie es online mit Testfällen:
2,3
100,5
42,0
0,3
0,0

R, 17-14 Bytes

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

Vielen Dank an billywob für die 3 Bytes. Vorherige Antwort:

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

Beachten Sie, dass 1: 0 zum Vektor (1,0) expandiert, sodass wir die if (P) -Bedingung benötigen (oder verwenden müssen seq_len, aber das sind mehr Bytes). Ohne die Bedingung würden wir die falsche Ausgabe erhalten, wenn P = 0 ist.

Wenn P Null ist, dann expandiert die Summe zu sum(N+NULL), dann zu sum(numeric(0)), was Null ist.

PHP, 33 Bytes

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

Gelee , 7 Bytes

RS+×_×-

Argumente sind P, N
Testen Sie es auf TryItOnline

Wie?

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 Bytes

-F}Q+E

Test Suite .

Viertens 36 Bytes

Einfache Berechnung von n - (p*n + (p^2+p) / 2)

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

Probieren Sie es online aus

Java, 67 , 63 Bytes

Golf gespielt:

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

Grundsätzlich habe ich ein bisschen nachgerechnet. Das n - p*nTeil kümmert sich um das All nin der Formel. Dann habe ich eine super lustige Eigenschaft verwendet, um eine linear ansteigende Menge von Ganzzahlen zu summieren (arithmetische Reihe): Ich habe die Summe aus erster und letzter Ganzzahl verwendet und dann mit multipliziert set.length / 2(ich überprüfe auch die Parität und behandle sie entsprechend).

Probieren Sie es aus: https://ideone.com/DEd85A

Java 7, 43 40 Bytes

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

Java 8, 19 Bytes

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

Schamlos aus @ JonathanAllans erstaunlicher Python 2-Formel gestohlen .

Ursprüngliche Antwort ( 61 60 Bytes):

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

Ungolfed & Testfälle:

Probieren Sie es hier aus.

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

Ausgabe:

-10
-415
42
-6
0

Fourier , 34 Bytes

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

Probieren Sie es online!

Labyrinth , 15 Bytes

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

oder

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

Verwendet die geschlossene Lösung n - n*P - P*(P+1)/2.

PHP, 38 Bytes

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

Pyth, 11 Bytes

Ms+Gm_+GdSH

Eine Funktion g, die Eingaben von nund püber Argumente entgegennimmt und das Ergebnis ausgibt. Es kann im Formular aufgerufen werden gn p.

Probieren Sie es online aus

Wie es funktioniert

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 Bytes

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

Teste es auf Coliru .

Ahorn, 19 Bytes

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

Verwendung:

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

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

Erläuterung:

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