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

code-golf math arithmetic

— Paul Schmitz
quelle

1

Die wesentliche Herausforderung hierbei ist die Berechnung von Dreieckszahlen.

— Peter Taylor

4

Das beinhaltet mehr als nur Dreieckszahlen. Der Startpunkt ist beliebig, ebenso die Anzahl der Subtraktionen, die Null sein können.

— JDL

Bei Dreieckszahlen kann es auch sein, dass die tatsächliche Summe kürzer ist als bei der geschlossenen Form, während Sie nicht einfach beliebige polygonale Zahlen berechnen können, indem Sie einen Bereich von 0 bis N summieren andere Herausforderung nur nach Dreieckszahlen gefragt.)

— Martin Ender

1

Für das Input: N=0,P=3Beispiel hat Ihre Erweiterung einige irrelevante Doppel-Negative

— turbulencetoo

1

@JDL, der Teil, der „mehr als nur Dreieckszahlen“ ist eine einfache Multiplikation ist: N * (P-1). Das ist quasi die Definition von Trivialität .

— Peter Taylor

15

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

— Emigna
quelle

4

Ahhh, ich wollte fast meine Lösung posten haha. Auch für drei Bytes: Ý+Æ:).

— Adnan

Es schaltet nur den Eingang ( Pgeht zuerst)

— Adnan

@Adnan: Ich wusste nicht mal, dass 05AB1E Ý... Ich dachte, es gibt nur 1-basierten Bereich.

— Emigna

In welcher Zeichenkodierung sind das nur 3 Bytes? ;-)

— Yankee

1

@yankee: CP-1252

— Emigna

16

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

— Jonathan Allan
quelle

11

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

— Martin Ender
quelle

11

Haskell, 21 Bytes

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

— ThreeFx
quelle

10

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

Erweitern Sie das Snippet

— Arnauld
quelle

Sie können ein Byte speichern, indem Sie die Funktion aufrufen. n=>p=>...und Aufruf der Funktion mitf(n)(p)

— Zwei

(n,p)=>n-p*(++p/2+n)funktioniert auch in C #.

— aloisdg sagt Reinstate Monica

1

n-p*(++p/2+n)ist äquivalent zu n+p*(~p/2-n).

— user81655

8

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.

— Dennis
quelle

7

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]

— Damien
quelle

7

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

        }
    }
}

— adrianmp
quelle

1

Verwenden Sie currying N=>P=>anstelle von (N,P)=>1 Byte zu speichern

— TheLethalCoder

5

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.

— Martin Ender
quelle

5

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

— Tonne Hospel
quelle

5

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

— VolAnd
quelle

2

Willkommen bei PPCG! Leider müssen alle Übermittlungen Programme oder aufrufbare Funktionen sein , während dies nur ein Ausschnitt ist, der davon ausgeht, dass die Eingabe in vordefinierten Variablen gespeichert wird und die Ausgabe in einer anderen.

— Martin Ender

1

@MartinEnder Ich habe mit Lambda auf C ++ umgestellt. Ist das akzeptabel?

— VolAnd

1

Ja, Lambdas sind in Ordnung . :)

— Martin Ender

Sie können dies in C mit 40 Bytes f;g(n,p){f=n;while(p--)f-=++n;return f;}mit Ihrem Algorithmus

— tun

@cleblanc Danke für den Tipp - globale Variable und Deklaration ohne expliziten Typ sind wirklich nützlich. Wie schade, dass C99-Standard implizit entferntint

— VolAnd

4

Pyke, 6 Bytes

m+mhs-

Probieren Sie es hier aus!

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

— Blau
quelle

4

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

— Tödlich
quelle

4

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

— Luis Mendo
quelle

3

Batch, 30 Bytes

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

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

— Neil
quelle

3

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

— betseg
quelle

3

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.

— JDL
quelle

3

Ich bin mir nicht sicher, ob dies ein vollständiges Programm ist, da N und P bereits definiert sein müssen. In jedem Fall n-n*p-sum(0:p)wäre die Verwendung kürzer :)

— Billywob

Meine Interpretation des Problems ist, dass N und P bereits definiert sind (andere Antworten scheinen diese Linie ebenfalls zu nehmen). Golfing Point obwohl genommen.

— JDL

3

Sofern nicht anders angegeben, müssen die Einsendungen vollständige Programme oder aufrufbare Funktionen sein, nicht nur Ausschnitte. Welche anderen Antworten gehen davon aus, dass die Variablen bereits definiert sind?

— Martin Ender

Ich bin kein Javascript-Experte, aber es sieht so aus, als würde die Javascript-Lösung die Variablen wie bereits definiert verwenden. Das könnte allerdings mein eigenes Missverständnis sein. Da N und P im Problem als solche benannt wurden, habe ich das als "anders angegeben" angenommen. Wenn nicht, dann brauchen wir einen Wrapper function(N,P){...}oderN=scan();P=scan();...

— JDL

@JDL der Javascript-Eintrag nimmt nicht vordefinierte variablen

— Blue

3

PHP, 33 Bytes

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

— Jörg Hülsermann
quelle

Ich denke, Sie müssen <?phpoder kurz <?für PHP-Code verwenden. Bitte bearbeiten Sie Ihre Antwort.

— Paul Schmitz

php.net/manual/de/features.commandline.usage.php nicht von der Kommandozeile

— Jörg Hülsermann

Sorry, vergiss was gesagt wurde. Ich habe damit viele Antworten gesehen und deshalb gedacht, dass es dafür eine Regel gibt, was nicht der Fall ist. Es sollte eine geben, um Diskussionen wie diese zu vermeiden.

— Paul Schmitz

3

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)

— Jonathan Allan
quelle

3

Pyth - 6 Bytes

-F}Q+E

Test Suite .

— Maltysen
quelle

3

Viertens 36 Bytes

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

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

Probieren Sie es online aus

— mbomb007
quelle

3

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

— peech
quelle

Sie können das Leerzeichen dazwischen entfernen int n,int p, um ein Byte zu speichern. Außerdem können Sie die Änderung p%2==0auf p%2<1ein anderes Byte zu speichern. - Ich wusste nicht, dass Sie bereits eine Java-Antwort gepostet hatten, als ich meine kürzere Variante mit for-loop gepostet habe . Ich mag deine mathematische Formel, also +1 von mir. :)

— Kevin Cruijssen

Tolle Formel! Durch Verwenden p%2>0und Ändern der Reihenfolge im Ternär können Sie ein Zeichen speichern.

— Frozn

Oh und p/2 *(p+2)ist auch gleichp*p/2+p

— Frozn

Hehe große Verbesserungen :) tatsächlich kommt diese Formel aus einer lustigen Anekdote :) @ KevinCruijssen schöne Antwort, definitiv besser als meine :) +1

— Peech

3

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:

— Kevin Cruijssen
quelle

Wie sieht es damit aus, dass Java 7 erforderlich ist?

— mbomb007

@ mbomb007 int c(int n,int p){...}. Wenn es Java 8 (oder 9) gewesen wäre, hätte es (n,p)->n-p*n+p*~p/2( 19 Bytes ) sein können

— Kevin Cruijssen

Tun Sie dies dann, um diese Bytes zu speichern.

— mbomb007

3

Fourier , 34 Bytes

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

Probieren Sie es online!

— Beta-Zerfall
quelle

2

Labyrinth , 15 Bytes

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

oder

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

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

— Martin Ender
quelle

2

PHP, 38 Bytes

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

— user59178
quelle

1

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

— TheBikingViking
quelle

1

C89, 38 , 35 , 33 Bytes

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

Teste es auf Coliru .

— YSC
quelle

1

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

— DSkoog
quelle

1

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

— Brad Gilbert b2gills
quelle

Subtrahiere die nächsten Zahlen

Beschreibung

Beispiele:

Eingang:

Ausgabe:

Regeln:

05AB1E , 5 3 Bytes

Python 2, 26 24 23 Bytes

CJam, 8 Bytes

Erläuterung

Haskell, 21 Bytes

Javascript (ES6), 20 19 18 Bytes

Prüfung

Gelee , 4 Bytes

Wie es funktioniert

Haskell, 19 18 Bytes

C #, 21 - 20 Bytes

Mathematica, 15 Bytes

Perl, 23 22 Bytes

C ++, 54 51 Bytes

Prüfung:

Pyke, 6 Bytes

Brachylog , 19 17 Bytes

Erläuterung

MATL , 5 Bytes

Erläuterung

Batch, 30 Bytes

SILOS , 80 Bytes

R, 17-14 Bytes

PHP, 33 Bytes

Gelee , 7 Bytes

Pyth - 6 Bytes

Viertens 36 Bytes

Java, 67 , 63 Bytes

Java 7, 43 40 Bytes

Java 8, 19 Bytes

Fourier , 34 Bytes

Labyrinth , 15 Bytes

PHP, 38 Bytes

Pyth, 11 Bytes

C89, 38 , 35 , 33 Bytes

Ahorn, 19 Bytes

Perl 6 , 21 Bytes

Erläuterung: