खैर, यद्यपि यह चुनौती एक बड़ी सफलता थी, लेकिन यह भी हल करने के लिए बहुत तुच्छ थी। इसलिए, एक चुनौती की तलाश में रहने वालों के लिए, मैंने इस चुनौती की अगली कड़ी बनाई, जिसमें अब आपको अद्वितीय आयतों की संख्या गिननी होगी। इसकी जांच - पड़ताल करें!

अब, आप में से जो इस चुनौती को हल करना चाहते हैं, उनके लिए यह यहाँ आता है।

खैर, हमारे पास अभी तक इस तरह की कोई चुनौती नहीं है, इसलिए हम यहां जाते हैं।

3 x 3आयतों के इस ग्रिड पर विचार करें :

कितनी आयतें हैं? ठीक है, नेत्रहीन की गिनती करते हुए, हम देख सकते हैं कि वास्तव 36में पूरे विमान सहित खुद ही आयतें हैं, जो सभी एनिमेटेड जीआईएफ में दिखाए गए हैं:

काम

जैसा कि ऊपर दिखाया गया है आयतों की गिनती कार्य है। दूसरे शब्दों में, दिए गए 2 पूर्णांकों से अधिक या उसके बराबर है 0, mऔर nजहां mचौड़ाई का nप्रतिनिधित्व करता है और ऊंचाई का प्रतिनिधित्व करता है, आयतों की उस m x nग्रिड में आयतों की कुल संख्या को आउटपुट करता है ।

नियम

किसी भी बिल्ट-इन का उपयोग जो इस समस्या को सीधे हल करता है स्पष्ट रूप से अस्वीकृत है।
यह चुनौती सबसे छोटा उत्तर खोजने के बारे में नहीं है, बल्कि हर भाषा में सबसे छोटा उत्तर खोजने की है। इसलिए, कोई जवाब स्वीकार नहीं किया जाएगा।
मानक कमियां निषिद्ध हैं।

परीक्षण के मामलों

प्रारूप में प्रस्तुत Array of Integers Input -> Integer Output:

[0,0] -> 0
[1,1] -> 1
[3,3] -> 36 (Visualized above)
[4,4] -> 100
[6,7] -> 588

संदर्भ

http://oeis.org/A096948

याद रखें, यह कोड-गोल्फ है , इसलिए सबसे छोटा कोड जीतता है!

code-golf math

— आर। कप
स्रोत

मैंने 588आखिरी टेस्ट-केस के लिए गणना की ।

— लीक नून

@LeakyNun तो, मुझे लगता है कि मैं उन्हें गिनते समय कुछ याद किया । यह तय हो चुका है।

— आर। कप

इनपुट का अधिकतम मूल्य क्या है?

— आउटगॉल्फ

प्रासंगिक

— 11

34

पायथन, 22 बाइट्स

lambda m,n:m*~m*n*~n/4

m*n*(m+1)*(n+1)/4बिट-पूरक का उपयोग करके सूत्र को छोटा किया जाता है ~m=-(m+1), (m+1)*(n+1)जैसा कि व्यक्त किया जाता है ~m*~n।

आयतों की संख्या क्यों है m*n*(m+1)*(n+1)/4? प्रत्येक आयत दो क्षैतिज रेखाओं (ऊपर और नीचे) और दो ऊर्ध्वाधर लाइनों (बाएं और दाएं) की पसंद से निर्दिष्ट होती है। कर रहे हैं m+1क्षैतिज लाइनों, जिनमें से हम दो अलग-अलग लोगों के एक सबसेट चुनें। तो विकल्पों की संख्या है choose(m+1,2), जो है m*(m+1)/2। n*(n+1)/2ऊर्ध्वाधर लाइनों के लिए विकल्पों द्वारा गुणा करना परिणाम देता है।

— XNOR
स्रोत

वह +1 ट्रिक शानदार है।

— डेविड लजंग मैडिसन स्टेलर

11

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

RS€P

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

वैकल्पिक रूप से, 4 बाइट्स भी

pP€S

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

— लीक नन
स्रोत

बहुत बढ़िया। थम्स अप। :)

— आर। काप

24

समझाने की परवाह?

— प्योरफ्रेट

वहाँ भी है ×‘HPऔर ‘c2Pऔर शायद अन्य 4 बाइट विकल्प।

— मील

1

@Pureferret यह OEIS से इस nthऔर mthत्रिकोणीय संख्या के उत्पाद होने के बारे में सूत्र का उपयोग करता है । Rप्रत्येक संख्या को 1 आधारित सूचकांक में परिवर्तित करता है [1, 2, ..., n]:। Sयोग और है €का अर्थ है 'प्रत्येक' इसलिए प्रत्येक सूची अभिव्यक्त किया जाता है, जैसे सूची देते हुए: [nth triangle number, mth triangle number]। फिर Pउस सूची के उत्पाद को लेता है, जो वांछित परिणाम देता है।

— FryAmTheEggman

1

@FryAmTheEggman तो आपका क्या कहना है .... मैजिक

— प्योरफ्रेट

9

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

m=>n=>m*n*~m*~n/4

इस उत्तर का एक कांटा ।

f=m=>n=>m*n*~m*~n/4
alert(f(prompt())(prompt()))

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

— लीक नन
स्रोत

मुझे यकीन नहीं है, भाषाओं में ओके कर रहा है जो डिफ़ॉल्ट रूप से ऐसा नहीं करता है?

— जॉन ड्वोरक

1

@JanDvorak मेटा पोस्ट ।

— लीकी नून

9

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

##(1##+##+1)/4&

यह एक अनाम फ़ंक्शन है जो दो पूर्णांक तर्क ले रहा है और आयतों की संख्या लौटा रहा है।

व्याख्या

कार्यान्वयन मूल रूप से दो त्रिकोणीय संख्याओं के उत्पाद का एक बहुत ही गोल्फ का रूप है। यह विवरण के लिए इस पोस्ट में "तर्क के अनुक्रम" अनुभाग को पढ़ने के लायक हो सकता है , लेकिन मैं यहाँ सार को संक्षेप में प्रस्तुत करने की कोशिश करूँगा।

##सभी तर्कों के एक अनुक्रम में फैलता है । यह अन्य भाषाओं में छींटे के समान है । उदाहरण के लिए, यदि तर्क 3और हैं 4, तो {1, 2, ##, 5}आपको देंगे {1, 2, 3, 4, 5}। लेकिन यह सिर्फ सूचियों में काम नहीं करता है, लेकिन किसी भी तरह से, उदाहरण के f[1, 2, ##, 5]लिए भी होगा f[1, 2, 3, 4, 5]।

यह तब दिलचस्प हो जाता है जब आप ##ऑपरेटरों के साथ गठबंधन करते हैं। Mathematica में सभी ऑपरेटर कुछ f[...]-समान अभिव्यक्ति (संभवतः नेस्टेड) के लिए केवल शॉर्ट- हैंड हैं। जैसे a+bहै Plus[a, b]और a-bवास्तव में प्रतिनिधित्व करता है Plus[a, Times[-1, b]]। अब जब आप ##ऑपरेटरों के साथ गठजोड़ करते हैं, तो गणितज्ञ क्या करता है, पहले ऑपरेटरों का विस्तार करना ##, एक ही ऑपरेंड की तरह व्यवहार करना , और अंत में उनका विस्तार करना। ##इसलिए सही स्थानों पर सम्मिलित करके , हम इसका उपयोग दोनों को गुणा करने और ऑपरेंड को जोड़ने के लिए कर सकते हैं।

उपरोक्त कोड के लिए ऐसा करते हैं:

##(1##+##+1)/4

इसका पूर्ण रूप में विस्तार करते हुए, हम इसे प्राप्त करते हैं:

Times[##, Plus[Times[1, ##], ##, 1], Rational[1/4]]

चलो फ़ंक्शन तर्क सम्मिलित करें aऔर b:

Times[a, b, Plus[Times[1, a, b], a, b, 1], Rational[1/4]]

और अब हम इसे मानक गणितीय संकेतन में परिवर्तित करते हैं:

a * b * (a * b + a + b + 1) / 4

थोड़ा पीछे हटने से पता चलता है कि यह त्रिकोणीय संख्याओं का उत्पाद है:

a * b * (a + 1) * (b + 1) / 4
(a * (a + 1) / 2) * (b * (b + 1) / 2)
T(a) * T(b)

मज़ेदार तथ्य: यह कार्यान्वयन बहुत ही गोल्फ है, यह एक ही त्रिकोणीय संख्या की गणना के लिए अंतर्निहित लंबाई के समान है PolygonalNumber।

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

8

सी, 25 बाइट्स

#define r(x,y)x*y*~x*~y/4

शुद्ध संस्करण (27):

r(x,y){return x*y*~x*~y/4;}

आईएसओ-एर संस्करण (35):

#define r(x,y)((x)*(y)*~(x)*~(y)/4)

— आउटग्रॉफर को एरिक करें
स्रोत

आपको कौन सा संस्करण सबसे अच्छा लगता है?

— आउटगॉल्फ

8

जेलिफ़िश , 16 बाइट्स

p|%/**+1
  4  Ei

इनपुट प्रारूप है [x y], आउटपुट सिर्फ परिणाम है।

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

वैकल्पिक समाधान, एक ही बाइट गिनती:

pm%/*[*i
  4  +1

व्याख्या

जेलीफ़िश को परिचय देने का समय इसके योग्य है! :)

जेलिफ़िश अपने 2D सिंटेक्स चैलेंज के आधार पर ज़गारब की भाषा है । शब्दार्थ काफी हद तक J से प्रेरित हैं, लेकिन वाक्य रचना कला का एक काम है। सभी कार्य एकल वर्ण हैं और ग्रिड पर रखे गए हैं। फ़ंक्शंस अगले दक्षिण और पूर्व के टोकन से अपने तर्क लेते हैं और परिणाम को उत्तर और पश्चिम में लौटाते हैं। आइए आप फ़ंक्शन कॉल की एक दिलचस्प वेब बनाते हैं जहाँ आप उन्हें कई दिशाओं से कई कार्यों में पास करके मूल्यों का पुन: उपयोग करते हैं।

यदि हम इस तथ्य को नजरअंदाज करते हैं कि उपरोक्त कार्यक्रम में कुछ टोकन विशेष ऑपरेटर (उच्च-स्तरीय कार्य) हैं, तो उपरोक्त कार्यक्रम को कुछ इस तरह से लिखा जाएगा:

p(|( /*(i*(i+1)) % 4 ))

कोड नीचे-ऊपर के माध्यम से चलते हैं। इनपुट में द्वारा खिलाया जाता है i, इसलिए इसका मूल्यांकन करता है [x y]।

इसके +शीर्ष पर शाब्दिक रूप से इस इनपुट को प्राप्त करता है 1और इसलिए दोनों तत्वों को देने के लिए वेतन वृद्धि होती है [(x+1) (y+1)](अधिकांश ऑपरेशन सूचियों पर स्वचालित रूप से थ्रेडेड होते हैं)।

के अन्य मूल्य को iबाईं ओर भेजा Eजाता है , लेकिन विभाजन पूर्वी तर्क उत्तर और पश्चिम में है। इसका मतलब है कि दाईं ओर इनपुट *वास्तव में हैं [x y]और [(x+1) (y+1)]इसलिए यह गणना करता है [x*(x+1) y*(y+1)]।

अगला *अप वास्तव में पूर्ववर्ती द्वारा संशोधित किया गया है /जो इसे एक गुना ऑपरेशन में बदल देता है। *एक जोड़ी पर तह बस इसे गुणा करता है, ताकि हम प्राप्त करें x*(x+1)*y*(y+1)।

अब %सिर्फ विभाजन है इसलिए यह गणना करता है x*(x+1)*y*(y+1)/4। दुर्भाग्य से, यह एक फ्लोट में परिणाम करता है इसलिए हमें इसे एकजुट के साथ गोल करने की आवश्यकता है |। अंत में, इस मूल्य को खिलाया जाता है pजो अंतिम परिणाम प्रिंट करता है।

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

मैं शपथ ले सकता था कि मैंने पूर्णांक विभाजन के बारे में डॉक्स में कुछ पढ़ा ...

— कॉनर ओ'ब्रायन

7

आर, 40 35 बाइट्स

खैर, गहरे अंत में कूदने का समय! यहाँ मेरा R कोड है, जो @xnor उत्तर से प्रेरित है:

~~a=scan();(n=a[1])*(m=a[2])*(n+1)*(m+1)/4~~

EDIT : इस संस्करण में, आर इनपुट के लिए दो बार पूछेगा।

(n=scan())*(m=scan())*(n+1)*(m+1)/4

— फ़्रेडरिक
स्रोत

cat(prod(choose(scan()+1,2)))29 बाइट्स है।

— ग्यूसेप

6

सीजाम, 12 10 बाइट्स

2 बाइट्स ने मार्टिन को धन्यवाद दिया।

{_:)+:*4/}

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

यह एक ब्लॉक है जो स्टैक से 2 तत्वों की सूची लेता है और स्टैक पर समाधान छोड़ देता है। परीक्षण के लिए प्रयोग करने योग्य पूर्ण कार्यक्रम riari+{_:)+:*4/}~:।

Xnor के बकाया अजगर समाधान के आधार पर।

स्पष्टीकरण:

{_:)+:*4/}
{        } -- Define a block
 _:)       -- Duplicate list, increment all values in new list
    +      -- Join the two lists
     :*    -- Fold multiply over all 4 elements
       4/  -- Divide by 4

— Zwei
स्रोत

2

मुझे लगता है कि यदि आप इनपुट को दो तत्वों की सूची बनाते हैं तो यह 10 के लिए काम करता है? {_:~+:*4/}

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

वास्तव में, ~CJam में उपयोग करने की कोई आवश्यकता नहीं है । बस उपयोग करें )।

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

5

मतलाब, 23 19 बाइट्स

@(x)prod([x/2,x+1])

सूत्र m*n*(m+1)*(n+1)/4
का कार्यान्वयनans([m,n])

— pajonk
स्रोत

4

MATL , 6 बाइट्स

tQ*2/p

इनपुट फॉर्म की एक सरणी है [m,n]।

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

व्याख्या

सूत्र के आधार पर प्रत्यक्ष गणना m*(m+1)*n*(n+1)/4।

t     % Input array [m,n] implicitly. Duplicate
Q     % Add 1 to each entry of the copy: gives [m+1,n+1]
*     % Multiply element-wise: gives [m*(m+1),n*(n+1)]
2/    % Divide each entry by 2: [m*(m+1)/2,n*(n+1)/2]
p     % Product of the two entries: m*(m+1)*n*(n+1)/4. Display implicitly

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

4

जे, 8 बाइट्स

2*/@:!>:

उपयोग:

   f =: 2*/@:!>:
   f 0 0
0
   f 3 3
36

— alephalpha
स्रोत

इस वार्तालाप को बातचीत में स्थानांतरित कर दिया गया है ।

— डेनिस

4

जावा 7, 39 38 बाइट्स

int c(int a,int b){return~a*a*b*~b/4;}

जावा 8, 26 25 19 18 17 बाइट्स

a->b->a*~a*b*~b/4

@Xnor के उत्कृष्ट उत्तर के आधार पर । कई बाइट्स @DavidConrad के लिए धन्यवाद सहेजे गए । इसे यहाँ आज़माएँ।

टेस्ट कोड (जावा 7):

इसे यहाँ आज़माएँ।

class M{
  static int c(int a,int b){return~a*a*b*~b/4;}

  public static void main(String[] a){
    System.out.println(c(0, 0));
    System.out.println(c(1, 1));
    System.out.println(c(3, 3));
    System.out.println(c(4, 4));
    System.out.println(c(6, 7));
  }
}

आउटपुट:

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

1

आपको इसकी आवश्यकता नहीं है returnऔर a->b->एक बाइट से कम है (a,b)->।

— डेविड कॉनराड

2

मुझे नहीं लगता कि आपको अर्धविराम की आवश्यकता है, या तो, क्योंकि यदि आप लैम्बडा को एक विधि में पारित कर रहे थे जो Function<Integer, Function<Integer, Integer>>एक पैरामीटर के रूप में लिया गया था , तो यह अर्धविराम के बाद नहीं होगा।

— डेविड कॉनराड

2

मैं @DavidConrad से सहमत हूं: मैं ;एकल कथन J8 लंबोदा पर समाप्त होने की गिनती नहीं करता हूं ।

— CAD97

@DavidConrad बहुत देर से संपादित करने के लिए क्षमा करें, लेकिन मैंने अभी देखा कि मैंने आपकी टिप्पणी को पढ़ने के लिए अतीत को हटा दिया है return .. इसके अलावा, मैंने जावा 8 में लगभग कभी भी प्रोग्राम नहीं किया है (इसलिए मेरे सभी जावा 7 उत्तर), लेकिन मुझे कैसे a->b->काम करना है? यहाँ वर्तमान मामले के लिए विचारधारा है।

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

1

बहुत देर से उत्तर के लिए क्षमा करें! आपको फ़ंक्शन को करीने की आवश्यकता है, इसलिए आपको MathOperation.operationकेवल एक लेने के लिए बदलने की आवश्यकता है int, एक लौटाएं Function<Integer, Integer>, और जब आप इसे कॉल करते हैं, तो आप शुरू में केवल पहला पैरामीटर पास करते हैं a, और फिर कॉल .apply(b)करते हैं Function। आपको आयात करने की भी आवश्यकता है java.util.function.Function। यहाँ परिवर्तनों के साथ एक विचारधारा है।

— डेविड कॉनराड

3

रूबी, 22 बाइट्स

@ Xnor की चाल चुराना और एक छुरा-मेमना बनाना:

r=->(m,n){m*n*~m*~n/4}

उदाहरण कॉल:

r[6,7]     # => 588

या एक खरीद के रूप में, 22 बाइट्स:

proc{|m,n|m*n*~m*~n/4}

जिसे हम फिर कॉल कर सकते हैं:

proc{|m,n|m*n*~m*~n/4}.call(6,7)     # => 588

— डेविड लजंग मैडिसन स्टेलर
स्रोत

आपको इसे नाम देने की आवश्यकता नहीं है

— कॉनर ओ'ब्रायन

3

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

*?;*_4/!
):

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

व्याख्या

यह भी अधिकांश उत्तरों की तरह त्रिकोणीय संख्याओं के उत्पाद की गणना करता है। प्रमुख 2x2 ब्लॉक एक छोटा लूप है:

*?
):

पहली पुनरावृत्ति *कुछ भी नहीं करती है, ताकि वास्तविक लूप ऑर्डर यह हो:

?   Read integer N from STDIN or 0 at EOF and push onto stack. If 0, exit the loop.
:   Duplicate N.
)   Increment.
*   Multiply to get N*(N+1).

शेष कोड केवल रैखिक है:

;   Discard the zero that terminated the loop.
*   Multiply the other two values.
_4  Push a 4.
/   Divide.
!   Print.

भूलभुलैया फिर से निष्पादित करने की कोशिश करता है /, जो शून्य से एक विभाजन के कारण कार्यक्रम को समाप्त करता है।

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

2

Pyke, 6 बाइट्स

mh+Bee

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

mh     -    map(increment, input)
  +    -   ^ + input
   B   -  product(^)
    ee - ^ \ 4

— नीला
स्रोत

यह एक टूटने का उपयोग कर सकता है, लेकिन मुझे यह व्यक्तिगत रूप से कला का काम लगता है।

— corsiKa

2

05AB1E, 4 बाइट्स

€LOP

व्याख्या

A096948 में वर्णित सूत्र का उपयोग करता है

      # Implicit input, ex: [7,6]
€L    # Enumerate each, [[1,2,3,4,5,6,7],[1,2,3,4,5,6]]
  O   # Sum, [28,21]
   P  # Product, 588
      # Implicit display

इनपुट को [n, m] के रूप में लेता है ।

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

— Emigna
स्रोत

1

पायथ, 8 6 बाइट्स

@DenkerAffe की बदौलत दो बाइट बच गईं।

*FmsSd

इनपुट सूची की तरह की उम्मीद है [m,n]। इसे यहाँ आज़माएँ ।

स्पष्टीकरण:

          Implicit assignment of Q to eval(input).
*         Multiplication.
 F        Splat the following sequence onto the arguments of the previous function.
  m       Map the following function of d over Q (Q is implicitly added to the end).
   s      Reduce the following list with addition, initial value of 0.
    Sd    Return range(1,d+1).

— Rhyzomatic
स्रोत

1

आप Fइसके स्थान पर उपयोग कर सकते हैं .*और हटा सकते हैं Qक्योंकि इसे अंतर्निहित रूप से जोड़ा गया है।

— डेनकर

मुझे पता था, Fलेकिन मैं इसका इस्तेमाल नहीं कर पाया और सोचा कि मुझे .*इसके बजाय उपयोग करने की आवश्यकता है ... धन्यवाद!

— ऋजोमैटिक

1

सी #, 19 बाइट्स

(n,m)=>m*n*~m*~n/4;

अनाम फ़ंक्शन @ xnor के उत्तर पर आधारित है।

— TheLethalCoder
स्रोत

1

लुआ, 74 63 बाइट्स

x,y=...n=0 for i=1,y do for j=i,i*x,i do n=n+j end end print(n)

फंक्शन नंबर पैरामीटर के रूप में इनपुट लेता है।

लुआ को लागू करने के तरीके के कारण, यह तकनीकी रूप से एक फ़ंक्शन है, चर आर्ग के साथ, जिसे इसे "फ़ंक्शन" स्टेटमेंट में लपेटकर या "लोडस्ट्रिंग" का उपयोग करके स्रोत कोड से लोड करने के लिए कहा जा सकता है।

— brianush1
स्रोत

1

मैं देखता हूं कि आपके पास सिर्फ I / O के लिए काफी कोड हैं। शायद यह केवल एक फ़ंक्शन बनाने के लिए छोटा होगा जो दो नंबर लेता है और उत्तर देता है, और इस सभी अनावश्यक I / O कोड को हटा दें?

— Zwei

@ ज़ेवी मैं भूल गया कि फ़ंक्शंस को मापदंडों द्वारा इनपुट लेने की अनुमति है। यह बात बताने के लिए धन्यवाद।

— brianush1

इस फंक्शन को 7 और बाइट्स को बचाने के लिए पूरे नाम "फंक्शन" के बजाय "f" जैसे नाम दिया जा सकता है

— ZUI

लुआ में, फ़ंक्शन को घोषित करने के लिए कीवर्ड "फ़ंक्शन" की आवश्यकता होती है। यदि कोई नाम निर्दिष्ट नहीं है (उदाहरण के लिए: "function f ()"), तो यह एक अनाम फ़ंक्शन है। (पूर्व: "फ़ंक्शन ()")। इसलिए, कोड को काम करने के लिए "फ़ंक्शन" आवश्यक है।

— brianush1

ओह, मैं भूल गया कि लुआ उसी तरह काम करता है। मेरी गलती!

— ज़ेवी

1

चेडर , 23 बाइट्स

m->n->m*(m+1)*n*(n+1)/4

— लीक नन
स्रोत

n*(n+1)करने के लिए golfed किया जा सकता हैn^2+n

— Downgoat

@Downgoat कोष्ठक के बारे में क्या?

— लीक नून

ओह> _> हाँ। क्षमा करें, एनवीएम, सोच नहीं रहा था

— 20

फ़ंक्शन करीने की कोशिश करें। m->n->...

— कोनोर ओ ब्रायन

1

ब्रेन-फ्लैक , 84 80 बाइट्स

({}<>)({({})<({}[()])>}{})<>({({})<({}[()])>}{}[()]){<>(({}))<>({}[()])}<>({{}})

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

शायद बहुत उप-इष्टतम, विशेष रूप से त्रिकोण संख्याओं के संबंध में कोड के पुन: उपयोग के कारण, लेकिन कम से कम हमारे पास एक ब्रेन-फ्लैक समाधान है जो काम करता है।

अफसोस की बात है कि यह 0 0अंडकोष के साथ असीम रूप से लूप करने में विफल होता है लेकिन अन्य सभी ठीक काम करते हैं।

— Zwei
स्रोत

0

उत्तल, 7 बाइट्स

मुझे पता है कि यह छोटा हो सकता है, मैं अभी तक यह पता नहीं लगा सकता हूं ...

_:)+×½½

इसे ऑनलाइन आज़माएं! । CP-1252 एन्कोडिंग का उपयोग करता है।

— GamrCorps
स्रोत

0

एपीएल (डायलॉग) , 9 बाइट्स

×/+/∘⍳¨∘⊢

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

— Uriel
स्रोत

0

Pyt , 3 बाइट्स

←△Π

स्पष्टीकरण:

←       Get input
 △      Get triangle numbers
  Π     Array product
        Implicit output

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

— mudkip201
स्रोत

ग्रिड में कितने आयतें?

काम

नियम

परीक्षण के मामलों

संदर्भ

पायथन, 22 बाइट्स

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

वैकल्पिक रूप से, 4 बाइट्स भी

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

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

व्याख्या

सी, 25 बाइट्स

जेलिफ़िश , 16 बाइट्स

व्याख्या

आर, 40 35 बाइट्स

सीजाम, 12 10 बाइट्स

मतलाब, 23 19 बाइट्स

MATL , 6 बाइट्स

व्याख्या

जे, 8 बाइट्स

जावा 7, 39 38 बाइट्स

जावा 8, 26 25 19 18 17 बाइट्स

रूबी, 22 बाइट्स

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

व्याख्या

Pyke, 6 बाइट्स

05AB1E, 4 बाइट्स

पायथ, 8 6 बाइट्स

सी #, 19 बाइट्स

लुआ, 74 63 बाइट्स

चेडर , 23 बाइट्स

ब्रेन-फ्लैक , 84 80 बाइट्स

उत्तल, 7 बाइट्स

एपीएल (डायलॉग) , 9 बाइट्स

Pyt , 3 बाइट्स