Descrição

Subtraia os próximos números P de um número N. O próximo número de N é N + 1.

Veja os exemplos para entender o que quero dizer.

Exemplos:

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

Entrada:

N : Inteiro, positivo, negativo ou 0

P : Inteiro, positivo ou 0, não negativo

Saída:

Inteiro ou String, 0 inicial permitido, nova linha final permitida

Regras:

Sem brechas
Isso é código-golfe, então o código mais curto em bytes ganha
Entrada e Saída devem ser as descritas

code-golf math arithmetic

— Paul Schmitz
fonte

1

O desafio essencial aqui é calcular os números dos triângulos.

— Peter Taylor

4

Há mais do que apenas números triangulares; o ponto inicial é arbitrário e também o número de subtrações, que podem ser zero.

— JDL

Além disso, para números triangulares, é possível que a soma real seja mais curta do que usar a forma fechada, enquanto você não pode computar números poligonais arbitrários somando um intervalo de 0 a N. outro desafio apenas nos pediu para números triangulares).

— Martin Ender

1

para o Input: N=0,P=3exemplo, sua expansão tem algumas estranhas duplas-negativos

— turbulencetoo

1

@JDL, a parte que é "mais do que números triângulo apenas" é uma multiplicação simples: N * (P-1). Essa é praticamente a definição de trivial .

— Peter Taylor

15

05AB1E , 5 3 bytes

Economizou 2 bytes graças a Adnan

Ý+Æ

Explicação

Toma P e N como entrada.

       # 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, eu quase queria postar minha solução haha. Além disso, por três bytes: Ý+Æ:).

— Adnan

Ele só liga a entrada ( Pvai em primeiro lugar)

— Adnan

@Adnan: Eu nem sabia que 05AB1E tinha Ý... Pensei que existisse apenas um intervalo baseado em 1.

— Emigna

Em qual codificação de caracteres é que apenas 3 bytes? ;-)

— yankee

1

@yankee: CP-1252

— Emigna 02/02

16

Python 2, 26 24 23 bytes

-2 bytes graças a @Adnan (substitua p*(p+1)/2por p*-~p/2)
-1 byte graças a @MartinEnder (substitua -p*-~p/2por+p*~p/2

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

Os testes estão em ideone

— Jonathan Allan
fonte

11

CJam, 8 bytes

{),f+:-}

Suíte de teste.

Pena que a solução de formulário fechado é mais longa. : |

Explicação

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

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

— ThreeFx
fonte

10

Javascript (ES6), 20 19 18 bytes

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

Salva 1 byte ao currying, como sugerido por Zwei
Salva 1 byte graças ao user81655

Teste

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

Expandir snippet

— Arnauld
fonte

Você pode salvar um byte currying a função. n=>p=>...e chamando a função comf(n)(p)

— Zwei 1/16

(n,p)=>n-p*(++p/2+n)também funciona em c #.

— Aloisdg diz Reinstate Monica

1

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

— User81655

8

Gelatina , 4 bytes

r+_/

Experimente online!

Como funciona

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

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

— Dennis
fonte

7

Haskell, 19 18 bytes

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

Soluções anteriores de 19 bytes

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

— Damien
fonte

7

C #, 21 20 bytes

Edit: Salvo um byte graças a TheLethalCoder

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

Experimente online!

Fonte completa, incluindo casos de teste:

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

currying utilizar N=>P=>, em vez (N,P)=>da guardar um byte

— TheLethalCoder

5

Mathematica, 15 bytes

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

Uma função sem nome que recebe Pe ncomo seus parâmetros nessa ordem.

Usa a solução de formulário fechado n - n*p - p(p+1)/2.

— Martin Ender
fonte

5

Perl, 23 22 bytes

Inclui +1 para -p

Dê n e p (nessa ordem) em linhas separadas de STDIN:

subtract.pl
2
3
^D

subtract.pl:

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

(usar ''aspas para salvar \invoca uma penalidade de 2 bytes porque não pode ser combinada com -e)

Mesma ideia e duração:

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

Surpreendentemente, fazer o cálculo real é mais curto do que usar a fórmula direta (isso $realmente prejudica a aritmética)

— Ton Hospel
fonte

5

C ++, 54 51 bytes

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

~~[] (int N, int P) {int F; para (F = N; P; F - = ++ N, P -); retornar F;}~~

Teste:

#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

Bem-vindo ao PPCG! Infelizmente, todos os envios precisam ser programas ou funções que podem ser chamadas , enquanto este é apenas um trecho que pressupõe que a entrada seja armazenada em variáveis predefinidas e armazena a saída em outra.

— Martin Ender

1

@ MartinEnder Mudei para C ++ com lambda. Isso é aceitável?

— VolAnd 01/09/16

1

Sim, lambdas estão bem . :)

— Martin Ender

Você pode fazer isso em C com 40 bytes f;g(n,p){f=n;while(p--)f-=++n;return f;}usando seu algoritmo

— cleblanc

@cleblanc Obrigado pela dica - variável global e declaração sem um tipo explícito são realmente úteis. Que pena que padrão C99 removido implícitoint

— Voland

4

Pyke, 6 bytes

m+mhs-

Experimente aqui!

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

— Azul
fonte

4

Braquilog , 19 17 bytes

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

Explicação

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

— Fatalizar
fonte

4

MATL , 5 bytes

:y+s-

As entradas são Pe então N.

Experimente no MATL Online!

Explicação

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

Lote, 30 bytes

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

Toma ne pcomo parâmetros da linha de comando e imprime o resultado sem uma nova linha à direita.

— Neil
fonte

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

Experimente online com casos de teste:
2,3
100,5
42,0
0,3
0,0

— betseg
fonte

3

R, 17 14 bytes

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

Agradecimentos a billywob por jogar fora 3 bytes. Resposta anterior:

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

Observe que 1: 0 se expande para o vetor (1,0), portanto, precisamos da condição if (P) (ou para usar seq_len, mas isso é mais bytes). Sem a condição, obteríamos a saída errada se P = 0.

Se P é zero, a soma se expande para sum(N+NULL), então para sum(numeric(0)), que é zero.

— JDL
fonte

3

Não tenho certeza se isso se qualifica como um programa completo porque requer que N e P já estejam definidos. De qualquer forma usando n-n*p-sum(0:p)seria mais curto de qualquer maneira :)

— Billywob

Minha interpretação do problema é que N e P já estão definidos (outras respostas parecem seguir essa linha também). Ponto de golfe tomado embora.

— JDL

3

A menos que especificado de outra forma, os envios precisam ser programas completos ou funções de chamada, não apenas trechos. Quais outras respostas assumem que as variáveis já estão definidas?

— Martin Ender

Não sou especialista em javascript, mas parece que a solução javascript está usando as variáveis como já definidas. Esse poderia ser o meu próprio mal-entendido. Como N e P foram nomeados como tal no problema, tomei isso como "especificado de outra forma". Se não, então precisamos de um invólucro function(N,P){...}ouN=scan();P=scan();...

— JDL

@JDL a entrada javascript não leva variáveis pré-definidas #

— Blue

3

PHP, 33 bytes

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

— Jörg Hülsermann
fonte

Eu acho que você precisa usar <?phpou abreviar <?para PHP-Code. Edite sua resposta.

— Paul Schmitz

php.net/manual/de/features.commandline.usage.php não a partir da linha de comando

— Jörg Hülsermann

Desculpe, esqueça o que disse. Eu já vi muitas respostas com isso e, portanto, pensei que existe uma regra para isso, o que não é o caso. Deve haver um, para evitar discussões como esta.

— Paul Schmitz

3

Geléia , 7 bytes

RS+×_×-

Os argumentos são P, N
testá-lo no TryItOnline

Quão?

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

Pitão - 6 bytes

-F}Q+E

Conjunto de Teste .

— Maltysen
fonte

3

Quarto, 36 bytes

Cálculo simples de n - (p*n + (p^2+p) / 2)

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

Experimente online

— mbomb007
fonte

3

Java, 67 , 63 bytes

Golfe:

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

Basicamente, fiz algumas contas na fórmula. A n - p*nparte cuida de tudo nna fórmula. Em seguida, usei uma propriedade super divertida de somar juntos um conjunto de números inteiros linearmente crescentes (séries aritméticas): usei a soma do primeiro e do último número inteiro e multipliquei por set.length / 2(também verifico a paridade e a manipulo adequadamente).

Experimente: https://ideone.com/DEd85A

— peech
fonte

Você pode remover o espaço entre eles int n,int ppara salvar um byte. Além disso, você pode alterar p%2==0para p%2<1para salvar outro byte. - Eu não sabia que você já havia postado uma resposta Java quando publiquei minha variante mais curta com o loop for . Porém, eu gosto da sua fórmula matemática, então +1 de mim. :)

— Kevin Cruijssen 01/09/16

Ótima fórmula! Usando p%2>0e alternando a ordem no ternário, você pode salvar um personagem.

— Frozn 1/09/16

Ah e também p/2 *(p+2)é igual ap*p/2+p

— Frozn 1/09/16

Hehe ótimas melhorias :) na verdade, essa fórmula vem de uma anedota engraçada :) @KevinCruijssen boa resposta, definitivamente melhor que a minha :) +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

Shamelessly roubado de @JonathanAllan surpreendente fórmula do Python 2 .

Resposta original ( 61 60 bytes):

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

Casos não testados e de teste:

Experimente aqui.

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

Saída:

— Kevin Cruijssen
fonte

O que sobre isso requer Java 7?

— mbomb007

@ mbomb007 int c(int n,int p){...}. Se ele teria sido Java 8 (ou 9) poderia ter sido (n,p)->n-p*n+p*~p/2( 19 bytes )

— Kevin Cruijssen

Em seguida, faça isso para salvar esses bytes.

— Mbomb007

3

Fourier , 34 bytes

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

Experimente online!

— Beta Decay
fonte

2

Labirinto , 15 bytes

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

ou

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

Usa a solução de formulário fechado n - n*P - P*(P+1)/2.

— Martin Ender
fonte

2

php, 38 bytes

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

— user59178
fonte

1

Pitão, 11 bytes

Ms+Gm_+GdSH

Uma função gque recebe entrada ne pvia argumento e imprime o resultado. Ele pode ser chamado na forma gn p.

Experimente online

Como funciona

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 bytes

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

Teste em Coliru .

— YSC
fonte

1

Bordo, 19 bytes

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 bytes

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

Explicação:

# 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

Subtrair os próximos números

Descrição

Exemplos:

Entrada:

Saída:

Regras:

05AB1E , 5 3 bytes

Python 2, 26 24 23 bytes

CJam, 8 bytes

Explicação

Haskell, 21 bytes

Javascript (ES6), 20 19 18 bytes

Teste

Gelatina , 4 bytes

Como funciona

Haskell, 19 18 bytes

C #, 21 20 bytes

Mathematica, 15 bytes

Perl, 23 22 bytes

C ++, 54 51 bytes

Teste:

Pyke, 6 bytes

Braquilog , 19 17 bytes

Explicação

MATL , 5 bytes

Explicação

Lote, 30 bytes

SILOS , 80 bytes

R, 17 14 bytes

PHP, 33 bytes

Geléia , 7 bytes

Pitão - 6 bytes

Quarto, 36 bytes

Java, 67 , 63 bytes

Java 7, 43 40 bytes

Java 8, 19 bytes

Fourier , 34 bytes

Labirinto , 15 bytes

php, 38 bytes

Pitão, 11 bytes

C89, 38 , 35 , 33 bytes

Bordo, 19 bytes

Perl 6 , 21 bytes

Explicação: