Descrizione

Sottrai i numeri P successivi da un numero N. Il prossimo numero di N è N + 1.

Guarda gli esempi per capire cosa intendo.

Esempi:

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

Ingresso:

N : intero, positivo, negativo o 0

P : intero, positivo o 0, non negativo

Produzione:

Numero intero o stringa, iniziale 0 consentita, trascinamento della nuova riga consentita

Regole:

Nessuna scappatoia
Questo è code-golf, quindi vince il codice più breve in byte
Input e Output devono essere come descritti

code-golf math arithmetic

— Paul Schmitz
fonte

1

La sfida essenziale qui è il calcolo dei numeri dei triangoli.

— Peter Taylor,

4

C'è di più in questo oltre ai soli numeri triangolari; il punto iniziale è arbitrario così come il numero di sottrazioni, che può essere zero.

— JDL,

Inoltre, per i numeri triangolari è possibile che fare la somma effettiva sia più breve dell'uso della forma chiusa, mentre non si può semplicemente calcolare numeri poligonali arbitrari sommando un intervallo da 0 a N. (Concordo con il voto vicino se il l'altra sfida ha richiesto solo numeri triangolari.)

— Martin Ender,

1

per Input: N=0,P=3esempio, la tua espansione ha alcuni doppi negativi estranei

— turbulencetoo

1

@JDL, la parte che è "più numeri triangolo soli" è una semplice moltiplicazione: N * (P-1). Questa è praticamente la definizione di banale .

— Peter Taylor,

15

05AB1E , 5 3 byte

Salvato 2 byte grazie ad Adnan

Ý+Æ

Spiegazione

Prende P quindi N come input.

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

4

Ahhh, volevo quasi pubblicare la mia soluzione ahah. Inoltre, per tre byte: Ý+Æ:).

— Adnan,

Commuta solo l'ingresso ( Pva per primo)

— Adnan,

@Adnan: non sapevo nemmeno che 05AB1E avesse Ý... Pensavo esistesse solo un intervallo basato su 1.

— Emigna,

In quale codifica dei caratteri sono solo 3 byte? ;-)

— yankee

1

@Yankee: CP-1252

— Emigna

16

Python 2, 26 24 23 byte

-2 byte grazie a @Adnan (sostituisci p*(p+1)/2con p*-~p/2)
-1 byte grazie a @MartinEnder (sostituisci -p*-~p/2con+p*~p/2

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

I test sono su ideone

— Jonathan Allan
fonte

11

CJam, 8 byte

{),f+:-}

Suite di test.

Peccato che la soluzione in forma chiusa sia più lunga. : |

Spiegazione

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

11

Haskell, 21 byte

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

— ThreeFx
fonte

10

Javascript (ES6), 20 19 18 byte

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

Salvato 1 byte dal curry, come suggerito da Zwei
Salvato 1 byte grazie a user81655

Test

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

Espandi frammento

— Arnauld
fonte

È possibile salvare un byte valutando la funzione. n=>p=>...e chiamando la funzione conf(n)(p)

— Zwei

(n,p)=>n-p*(++p/2+n)funzionerà anche in C #.

— aloisdg dice Reinstate Monica,

1

n-p*(++p/2+n)è equivalente a n+p*(~p/2-n).

— user81655

8

Gelatina , 4 byte

r+_/

Provalo online!

Come funziona

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

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

— Dennis
fonte

7

Haskell, 19 18 byte

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

Soluzioni precedenti a 19 byte

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

— Damien
fonte

7

C #, 21 20 byte

Modifica: salvato un byte grazie a TheLethalCoder

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

Provalo online!

Fonte completa, compresi i casi di test:

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
fonte

1

usa il curry N=>P=>invece di (N,P)=>salvare 1 byte

— TheLethalCoder

5

Mathematica, 15 byte

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

Una funzione senza nome che riceve Pe ncome parametri in quell'ordine.

Utilizza la soluzione a forma chiusa n - n*p - p(p+1)/2.

— Martin Ender
fonte

5

Perl, 23 22 byte

Include +1 per -p

Dare n e p (in questo ordine) su righe separate di STDIN:

subtract.pl
2
3
^D

subtract.pl:

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

(usare le ''virgolette per salvare gli \invoca una penalità di 2 byte perché non può essere combinato con -e)

Stessa idea e lunghezza:

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

Sorprendentemente, il calcolo effettivo è più breve rispetto all'utilizzo della formula diretta (questi $sono davvero dolorosi per l'aritmetica)

— Ton Hospel
fonte

5

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

Test:

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

2

Benvenuti in PPCG! Sfortunatamente, tutti gli invii devono essere programmi o funzioni richiamabili , mentre questo è solo uno snippet che presuppone che l'input sia archiviato in variabili predefinite e memorizza l'output in un altro.

— Martin Ender,

1

@MartinEnder Ho cambiato in C ++ con lambda. È accettabile?

— Vol

1

Sì, le lambda vanno bene . :)

— Martin Ender,

Puoi farlo in C con 40 byte f;g(n,p){f=n;while(p--)f-=++n;return f;}usando il tuo algoritmo

— cleblanc

@cleblanc Grazie per il suggerimento: la variabile globale e la dichiarazione senza un tipo esplicito sono davvero utili. Peccato che lo standard C99 abbia rimosso implicitamenteint

— VolAnd

4

Pyke, 6 byte

m+mhs-

Provalo qui!

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

— Blu
fonte

4

Brachylog , 19 17 byte

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

Spiegazione

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

— Fatalize
fonte

4

MATL , 5 byte

:y+s-

Gli input sono Pe quindi N.

Provalo su MATL Online!

Spiegazione

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

3

Lotto, 30 byte

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

Prende ne pcome parametri da riga di comando e stampa il risultato senza una nuova riga finale.

— Neil
fonte

3

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

Provalo online con i casi di test:
2,3
100,5
42,0
0,3
0,0

— betseg
fonte

3

R, 17 14 byte

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

Grazie a billywob per giocare a golf a 3 byte. Risposta precedente:

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

Nota che 1: 0 si espande nel vettore (1,0), quindi abbiamo bisogno della condizione if (P) (o da usare seq_len, ma che è più byte). Senza la condizione, otterremmo un output errato se P = 0.

Se P è zero, la somma si espande in sum(N+NULL), quindi in sum(numeric(0)), che è zero.

— JDL
fonte

3

Non sono sicuro se questo si qualifica come un programma completo perché richiede che N e P siano già definiti. Ad ogni modo l'uso n-n*p-sum(0:p)sarebbe più breve :)

— Billywob,

La mia interpretazione del problema è che N e P sono già definiti (anche altre risposte sembrano prendere questa linea). Punto da golf preso però.

— JDL

3

Se non diversamente specificato, gli invii devono essere programmi completi o funzioni richiamabili non solo frammenti. Quali altre risposte danno per scontato che le variabili siano già definite?

— Martin Ender,

Non sono un esperto di JavaScript, ma sembra che la soluzione JavaScript stia prendendo le variabili come già definite. Questo potrebbe essere il mio malinteso però. Dato che N e P sono stati nominati come tali nel problema, l'ho preso come "specificato diversamente". In caso contrario, abbiamo bisogno di un wrapper function(N,P){...}oN=scan();P=scan();...

— JDL

@JDL la voce javascript non accetta variabili predefinite

— Blue

3

PHP, 33 byte

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

— Jörg Hülsermann
fonte

Penso che sia necessario utilizzare <?phpo abbreviazione <?di PHP-Code. Modifica la tua risposta

— Paul Schmitz,

php.net/manual/de/features.commandline.usage.php non dalla riga di comando

— Jörg Hülsermann

Scusa, dimentica quello che ha detto. Ho visto molte risposte con questo, e quindi ho pensato, che esiste una regola per questo, che non è il caso. Dovrebbe essercene uno, per evitare discussioni come questa.

— Paul Schmitz,

3

Gelatina , 7 byte

RS+×_×-

Gli argomenti vengono testatiP, N
su TryItOnline

Come?

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
fonte

3

Pyth - 6 byte

-F}Q+E

Test Suite .

— Maltysen
fonte

3

Avanti, 36 byte

Calcolo semplice di n - (p*n + (p^2+p) / 2)

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

Provalo online

— mbomb007
fonte

3

Java, 67 , 63 byte

golfed:

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

Fondamentalmente ho fatto un po 'di matematica sulla formula. La n - p*nparte si occupa di tutto nnella formula. Quindi ho usato una proprietà super divertente di sommare insieme in modo lineare un insieme di numeri interi (serie aritmetiche): ho usato la somma del primo e dell'ultimo numero intero e poi lo moltiplico per set.length / 2(controllo anche la parità e la gestisco in modo appropriato).

Provalo: https://ideone.com/DEd85A

— Peech
fonte

È possibile rimuovere lo spazio tra int n,int pper salvare un byte. Inoltre, è possibile modificare p%2==0in p%2<1per salvare un altro byte. - Non sapevo che tu avessi già pubblicato una risposta Java quando ho pubblicato la mia variante più breve con for-loop . Mi piace la tua formula matematica, quindi +1 da me. :)

— Kevin Cruijssen,

Ottima formula! Usando p%2>0e cambiando l'ordine nel ternario puoi salvare un personaggio.

— Frozn,

Oh, e anche p/2 *(p+2)uguale ap*p/2+p

— Frozn

Hehe grandi miglioramenti :) in realtà questa formula viene da un aneddoto divertente :) @KevinCruijssen bella risposta, sicuramente migliore della mia :) +1

— peech

3

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

Spudoratamente rubato dalla straordinaria formula Python 2 di @JonathanAllan .

Risposta originale ( 61 60 byte):

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

Casi non testati e test:

Provalo qui.

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

Produzione:

— Kevin Cruijssen
fonte

Che dire di questo richiede Java 7?

— mbomb007,

@ mbomb007 int c(int n,int p){...}. Se fosse stato Java 8 (o 9) avrebbe potuto essere (n,p)->n-p*n+p*~p/2( 19 byte )

— Kevin Cruijssen,

Quindi farlo per salvare quei byte.

— mbomb007,

3

Fourier , 34 byte

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

Provalo online!

— Decadimento beta
fonte

2

Labirinto , 15 byte

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

o

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

Utilizza la soluzione a forma chiusa n - n*P - P*(P+1)/2.

— Martin Ender
fonte

2

php, 38 byte

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

— user59178
fonte

1

Pyth, 11 byte

Ms+Gm_+GdSH

Una funzione gche accetta input ne ptramite argomento e stampa il risultato. Può essere chiamato nel modulo gn p.

Provalo online

Come funziona

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
fonte

1

C89, 38 , 35 , 33 byte

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

Provalo su Coliru .

— YSC
fonte

1

Acero, 19 byte

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

Uso:

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

— DSkoog
fonte

1

Perl 6 , 21 byte

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

Spiegazione:

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

Sottrai i numeri successivi

Descrizione

Esempi:

Ingresso:

Produzione:

Regole:

05AB1E , 5 3 byte

Python 2, 26 24 23 byte

CJam, 8 byte

Spiegazione

Haskell, 21 byte

Javascript (ES6), 20 19 18 byte

Test

Gelatina , 4 byte

Come funziona

Haskell, 19 18 byte

C #, 21 20 byte

Mathematica, 15 byte

Perl, 23 22 byte

C ++, 54 51 byte

Test:

Pyke, 6 byte

Brachylog , 19 17 byte

Spiegazione

MATL , 5 byte

Spiegazione

Lotto, 30 byte

SILOS , 80 byte

R, 17 14 byte

PHP, 33 byte

Gelatina , 7 byte

Pyth - 6 byte

Avanti, 36 byte

Java, 67 , 63 byte

Java 7, 43 40 byte

Java 8, 19 byte

Fourier , 34 byte

Labirinto , 15 byte

php, 38 byte

Pyth, 11 byte

C89, 38 , 35 , 33 byte

Acero, 19 byte

Perl 6 , 21 byte

Spiegazione: