विवरण

N नंबर से अगले P नंबर घटाएं। 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

इनपुट:

एन : पूर्णांक, सकारात्मक, नकारात्मक या 0

P : पूर्णांक, धनात्मक या 0, ऋणात्मक नहीं

आउटपुट:

पूर्णांक या स्ट्रिंग, अग्रणी 0 अनुमति दी, अनुगामी newline अनुमति दी

नियम:

कोई खामियां नहीं
यह कोड-गोल्फ है, इसलिए बाइट्स जीत में सबसे छोटा कोड है
इनपुट और आउटपुट को वर्णित किया जाना चाहिए

code-golf math arithmetic

— पॉल शमित्ज़
स्रोत

1

यहां आवश्यक चुनौती त्रिकोण संख्याओं की गणना है।

— पीटर टेलर

4

इसमें सिर्फ त्रिकोणीय संख्याओं की तुलना में अधिक है; प्रारंभ बिंदु मनमाना है और साथ ही घटाव की संख्या, जो शून्य हो सकती है।

— JDL

इसके अलावा, त्रिकोणीय संख्याओं के लिए यह संभव है कि वास्तविक योग बंद फॉर्म का उपयोग करने की तुलना में कम है, जबकि आप 0 से एन तक की सीमा को जोड़कर मनमाने ढंग से बहुभुज संख्याओं की गणना नहीं कर सकते हैं (मैं करीबी वोट से सहमत हूं अगर अन्य चुनौती सिर्फ त्रिकोणीय संख्या के लिए पूछी गई।)

— मार्टिन एंडर

1

Input: N=0,P=3उदाहरण के लिए, आपके विस्तार में कुछ विलुप्त होने वाले दोहरे-नकारात्मक हैं

— टर्बुलेंसेटू

1

@JDL, वह हिस्सा जो "केवल त्रिभुज संख्याओं से अधिक है" एक सरल गुणन है N * (P-1):। यही कारण है कि लगभग है परिभाषा की तुच्छ ।

— पीटर टेलर

15

05AB1E , 5 3 बाइट्स

अदनान के लिए धन्यवाद 2 बाइट्स बचाए

Ý+Æ

व्याख्या

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

— Emigna
स्रोत

4

आह, मैं लगभग अपने समाधान haha पोस्ट करना चाहता था। इसके अलावा, तीन बाइट्स के लिए: Ý+Æ:)।

— अदनान

यह केवल इनपुट को स्विच करता है ( Pपहले जाता है)

— अदनान

@ अदनान: मुझे यह भी नहीं पता था कि 05AB1E था Ý... मुझे लगा कि केवल 1-आधारित रेंज मौजूद है।

— 11

किस चरित्र में एन्कोडिंग केवल 3 बाइट्स है? ;-)

— यांकी

1

@ अय्यकी: सीपी -१२५२

— एमिग्ना

16

पायथन 2, 26 24 23 बाइट्स

-2 बाइट्स की बदौलत @ अदनान (बदलें p*(p+1)/2से p*-~p/2)
-1 बाइट की बदौलत @MartinEnder ( -p*-~p/2साथ बदलें)+p*~p/2

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

टेस्ट आइडोन पर हैं

— जोनाथन एलन
स्रोत

11

सीजेएम, 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).

— मार्टिन एंडर
स्रोत

11

हास्केल, 21 बाइट्स

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

— ThreeFx
स्रोत

10

जावास्क्रिप्ट (ईएस 6), 20 19 18 बाइट्स

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

सेव करके 1 बाइट को बचाया, जैसा कि 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))

स्निपेट का विस्तार करें

— Arnauld
स्रोत

आप फंक्शन को करीने से बाइट बचा सकते हैं। n=>p=>...और साथ फ़ंक्शन को कॉलf(n)(p)

— Zwei

(n,p)=>n-p*(++p/2+n)C # में भी काम करेगा।

— aloisdg का कहना है कि

1

n-p*(++p/2+n)के बराबर है n+p*(~p/2-n)।

— 14:81 पर user81655

8

जेली , 4 बाइट्स

r+_/

इसे ऑनलाइन आज़माएं!

यह काम किस प्रकार करता है

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

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

— डेनिस
स्रोत

7

हास्केल, 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]

— डेमियन
स्रोत

7

सी #, 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

        }
    }
}

— adrianmp
स्रोत

1

1 बाइट बचाने N=>P=>के (N,P)=>लिए करी का उपयोग करें

— TheLethalCoder

5

मैथेमेटिका, 15 बाइट्स

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

एक अनाम फ़ंक्शन जो उस क्रम में इसके मापदंडों के रूप में प्राप्त करता है Pऔर n।

बंद प्रपत्र समाधान का उपयोग करता है n - n*p - p(p+1)/2।

— मार्टिन एंडर
स्रोत

5

पर्ल, 23 22 बाइट्स

के लिए +1 शामिल है -p

STDIN की अलग-अलग लाइनों पर n और p (उस क्रम में) दें:

subtract.pl
2
3
^D

subtract.pl:

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

( इनवॉइस 2 बाइट पेनल्टी ''को बचाने के लिए उद्धरणों का उपयोग करके \क्योंकि इसे संयुक्त नहीं किया जा सकता है -e)

एक ही विचार और लंबाई:

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

आश्चर्यजनक रूप से वास्तविक गणना प्रत्यक्ष सूत्र का उपयोग करने से कम है (ये $अंकगणित के लिए वास्तव में आहत हैं)

— टन हास्पेल
स्रोत

5

सी ++, 54 51 बाइट्स

  [](int N,int P){int F=N;while(P--)F-=++N;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;
}

— VOLAND
स्रोत

2

PPCG में आपका स्वागत है! दुर्भाग्य से, सभी सबमिशन को प्रोग्राम या कॉल करने योग्य फ़ंक्शन होने की आवश्यकता होती है , जबकि यह सिर्फ एक स्निपेट है जो इनपुट को पूर्व-निर्धारित चर में संग्रहीत करने और दूसरे में आउटपुट को संग्रहीत करने की अनुमति देता है।

— मार्टिन एंडर

1

@MartinEnder मैं लैम्ब्डा के साथ C ++ में बदल गया हूं। क्या यह स्वीकार्य है?

— VolAnd

1

हां, लंबोदर ठीक हैं । :)

— मार्टिन एंडर

आप इसे f;g(n,p){f=n;while(p--)f-=++n;return f;}अपने एल्गोरिथ्म का उपयोग करके सी के साथ 40 बाइट्स में कर सकते हैं

— क्लेब्लैंक

@cleblanc टिप के लिए धन्यवाद - एक स्पष्ट प्रकार के बिना वैश्विक चर और घोषणा वास्तव में उपयोगी हैं। क्या अफ़सोस है कि C99 मानक ने निहितार्थ को हटा दियाint

— VolAnd

4

Pyke, 6 बाइट्स

m+mhs-

यहाँ कोशिश करो!

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

— नीला
स्रोत

4

ब्रेकीलॉग , 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

— Fatalize
स्रोत

4

MATL , 5 बाइट्स

:y+s-

इनपुट हैं Pऔर उसके बाद N।

MATL ऑनलाइन पर यह कोशिश करो!

व्याख्या

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

— लुइस मेंडो
स्रोत

3

बैच, 30 बाइट्स

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

कमांड-लाइन मापदंडों के रूप में लेता है nऔर pएक अनुगामी न्यूलाइन के बिना परिणाम प्रिंट करता है।

— नील
स्रोत

3

एसआईओएस , 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

— betseg
स्रोत

3

आर, 17 14 बाइट्स

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

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))शून्य होता है।

— JDL
स्रोत

3

सुनिश्चित नहीं है कि यह एक पूर्ण कार्यक्रम के रूप में योग्य है क्योंकि इसे पहले से ही एन और पी को परिभाषित करने की आवश्यकता है। किसी भी तरह से उपयोग n-n*p-sum(0:p)करना कम हो जाएगा :)

— बिलीवॉब

समस्या की मेरी व्याख्या यह है कि N और P पहले से ही परिभाषित हैं (अन्य उत्तर इस पंक्ति को भी लगते हैं)। गोल्फ पॉइंट हालांकि लिया गया।

— JDL

3

जब तक निर्दिष्ट नहीं किया जाता है अन्यथा सबमिशन के लिए पूर्ण कार्यक्रम या कॉल करने योग्य कार्य होना चाहिए न कि केवल स्निपेट। कौन से अन्य उत्तर यह धारणा बनाते हैं कि चर पहले से ही परिभाषित हैं?

— मार्टिन एंडर

मैं एक जावास्क्रिप्ट विशेषज्ञ नहीं हूं, लेकिन ऐसा लगता है कि जावास्क्रिप्ट समाधान चर को पहले से ही परिभाषित रूप में ले रहा है। हालांकि मेरी अपनी गलतफहमी हो सकती है। चूंकि समस्या में एन और पी को इस तरह नामित किया गया था, इसलिए मैंने इसे "अन्यथा निर्दिष्ट" के रूप में लिया। यदि नहीं, तो हम एक आवरण की जरूरत है function(N,P){...}याN=scan();P=scan();...

— JDL

@JDL जावास्क्रिप्ट प्रविष्टि पूर्वनिर्धारित चर को नहीं लेती है

— ब्लू '

3

PHP, 33 बाइट्स

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

— जार्ग हुल्सरमन
स्रोत

मुझे लगता है कि आपको PHP-Code का उपयोग करने <?phpया छोटा करने की आवश्यकता है <?। कृपया अपना उत्तर संपादित करें।

— पॉल शमिताज

php.net/manual/de/features.commandline.usage.php कमांड लाइन से नहीं

— Jörg Hülsermann

क्षमा करें, जो कहा, उसे भूल जाइए। मैंने इसके साथ कई उत्तर देखे हैं, और इसलिए सोचा, कि इसके लिए एक नियम है, जो कि ऐसा नहीं है। इस तरह की चर्चाओं से बचने के लिए एक होना चाहिए।

— पॉल शमित्ज़

3

जेली , 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)

— जोनाथन एलन
स्रोत

3

पायथ - 6 बाइट्स

-F}Q+E

टेस्ट सूट ।

— Maltysen
स्रोत

3

फोर्थ, 36 बाइट्स

की सरल संगणना n - (p*n + (p^2+p) / 2)

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

इसे ऑनलाइन आज़माएं

— mbomb007
स्रोत

3

जावा, 67 , 63 बाइट्स

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

मूल रूप से मैंने सूत्र पर कुछ गणित किया। n - p*nभाग में सभी का ख्याल रखता है nसूत्र में की। फिर मैंने पूर्णांक (अंकगणितीय श्रृंखला) के रैखिक रूप से बढ़ते हुए सेट के साथ समन की एक सुपर मज़ेदार संपत्ति का उपयोग किया: मैंने पहले और अंतिम पूर्णांक के योग का उपयोग किया और फिर इसे set.length / 2(मैं समता के लिए भी जांचता हूं और इसे उचित रूप से संभालता हूं)।

इसे आज़माएं: https://ideone.com/DEd85A

— peech
स्रोत

आप int n,int pएक बाइट को बचाने के लिए के बीच की जगह को हटा सकते हैं । इसके अलावा, आप एक और बाइट को बचाने के p%2==0लिए बदल सकते हैं p%2<1। - मुझे नहीं पता था कि आपने पहले ही जावा उत्तर पोस्ट कर दिया था जब मैंने अपने छोटे संस्करण को लूप के साथ पोस्ट किया था । मुझे आपका गणितीय सूत्र पसंद है, हालाँकि, मुझसे +1 है। :)

— केविन क्रूज़सेन

महान सूत्र! p%2>0टर्नरी में आदेश का उपयोग करना और स्विच करना आप एक चरित्र को बचा सकते हैं।

— फ्रोजन

ओह और यह भी p/2 *(p+2)बराबर हैp*p/2+p

— फ्रोज़न

हेह महान सुधार :) वास्तव में यह सूत्र एक अजीब उपाख्यान से आता है :) @KevinCruijssen अच्छा जवाब, निश्चित रूप से मेरा से बेहतर है :) +1

— पीच

3

जावा 7, 43 40 बाइट्स

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

जावा 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));
  }
}

आउटपुट:

— केविन क्रूज़सेन
स्रोत

इसके बारे में जावा 7 की क्या आवश्यकता है?

— mbomb007

@ mbomb007 int c(int n,int p){...}। अगर यह जावा 8 (या 9) होता तो यह (n,p)->n-p*n+p*~p/2( 19 बाइट्स ) हो सकता था

— केविन क्रूज़सेन

फिर उन बाइट्स को बचाने के लिए ऐसा करें।

— mbomb007

3

फूरियर , 34 बाइट्स

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

इसे ऑनलाइन आज़माएं!

— बीटा डिके
स्रोत

2

भूलभुलैया , 15 बाइट्स

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

या

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

बंद प्रपत्र समाधान का उपयोग करता है n - n*P - P*(P+1)/2।

— मार्टिन एंडर
स्रोत

2

php, 38 बाइट्स

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

— user59178
स्रोत

1

अजगर, 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

— TheBikingViking
स्रोत

1

C89, 38 , 35 , 33 बाइट्स

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

कोलिरु पर इसका परीक्षण करें ।

— YSC
स्रोत

1

मेपल, 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

— DSkoog
स्रोत

1

पर्ल 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)
}

— ब्रैड गिल्बर्ट b2gills
स्रोत

अगले नंबरों को घटाएं

विवरण

उदाहरण:

इनपुट:

आउटपुट:

नियम:

05AB1E , 5 3 बाइट्स

पायथन 2, 26 24 23 बाइट्स

सीजेएम, 8 बाइट्स

व्याख्या

हास्केल, 21 बाइट्स

जावास्क्रिप्ट (ईएस 6), 20 19 18 बाइट्स

परीक्षा

जेली , 4 बाइट्स

यह काम किस प्रकार करता है

हास्केल, 19 18 बाइट्स

सी #, 21 20 बाइट्स

मैथेमेटिका, 15 बाइट्स

पर्ल, 23 22 बाइट्स

सी ++, 54 51 बाइट्स

परीक्षा:

Pyke, 6 बाइट्स

ब्रेकीलॉग , 19 17 बाइट्स

व्याख्या

MATL , 5 बाइट्स

व्याख्या

बैच, 30 बाइट्स

एसआईओएस , 80 बाइट्स

आर, 17 14 बाइट्स

PHP, 33 बाइट्स

जेली , 7 बाइट्स

पायथ - 6 बाइट्स

फोर्थ, 36 बाइट्स

जावा, 67 , 63 बाइट्स

जावा 7, 43 40 बाइट्स

जावा 8, 19 बाइट्स

फूरियर , 34 बाइट्स

भूलभुलैया , 15 बाइट्स

php, 38 बाइट्स

अजगर, 11 बाइट्स

C89, 38 , 35 , 33 बाइट्स

मेपल, 19 बाइट्स

पर्ल 6 , 21 बाइट्स

स्पष्टीकरण: