एक भारतीय किंवदंती ने शतरंज के खेल के कथित आविष्कारक की कहानी बताई, जिसने भारत के सम्राट को अपने खेल से इतना प्रभावित किया कि उसे किसी भी चीज के साथ पुरस्कृत किया जाता था।

आदमी ने कहा कि वह चावल में भुगतान करना चाहता था। वह शतरंज की बिसात के पहले वर्ग के लिए चावल का एक दाना चाहता था, दूसरे के लिए दो, तीसरे के लिए चार, चौथे के लिए आठ और इतने पर, 64 वें वर्ग तक।

सम्राट चकित था कि उस आदमी ने इतना छोटा इनाम मांगा, लेकिन जैसे-जैसे उसके गणितज्ञों ने गिनती शुरू की, उसने अपने प्रांतों में से एक को खो दिया।

कार्य

काल्पनिक शतरंज की बिसात (जो एक डिफ़ॉल्ट शतरंज की चौकी पर 8 है) और चौकों के बीच गुणक (जो कि किंवदंती में 2 है) की लंबाई को देखते हुए, सम्राट को मनुष्य को चावल के दानों की संख्या की गणना करनी चाहिए।

साइड की लंबाई हमेशा एक सकारात्मक पूर्णांक होगी। गुणक इसके बजाय किसी भी प्रकार की तर्कसंगत संख्या हो सकती है।
यदि आपकी पसंद की भाषा बहुत बड़ी संख्या प्रदर्शित नहीं कर सकती है, तो यह ठीक है जब तक कि आपका कार्यक्रम छोटे इनपुट को सही ढंग से संसाधित कर सकता है।
इसके अलावा अगर आपकी पसंद की भाषा बड़े मान (घातांक संकेतन के साथ) को गोल करती है, तो यह ठीक है यदि वे मान लगभग सही हैं।

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

Input (side length, multiplier) => Output
8, 2                            => 18446744073709551615
3, 6                            => 2015539
7, 1.5                          => 850161998.2854
5, -3                           => 211822152361
256, 1                          => 65536
2, 2                            => 15
2, -2                           => -5

कृपया ध्यान दें कि स्पष्ट सूत्र

result = (multiplier ^ (side ^ 2) - 1) / (multiplier - 1)

के multiplier = 1रूप में गलत परफॉर्म करता है

1 ^ (side ^ 2) - 1 = 0
1 - 1 = 0
0 / 0 != side ^ 2 (as it should be)

स्कोरिंग

यह कोड-गोल्फ है। बाइट्स जीत में सबसे छोटा जवाब।

code-golf math

— user6245072
स्रोत

4

आप शायद एक टेस्ट केस चाहते हैं जहाँ गुणक 1 है और दूसरा जहाँ वह 0 है (दोनों मान्य हैं)। इसके अलावा "कुछ भी" बहुत व्यापक है, क्या नकारात्मक की वर्गमूल गणना करता है? "आलू" के बारे में कैसे? ;) मैं "किसी भी वास्तविक संख्या" या कुछ और की सिफारिश करेंगे।

— FryAmTheEggman

4

If your language of choose can't display too large numbers, it's ok as long as your program can correctly process smaller inputs

सावधान, कि अतीत में समस्याएं पैदा हुई हैं। meta.codegolf.stackexchange.com/a/8245/31716

— DJMcMayhem

24

... यह एक समृद्ध प्रांत रहा होगा, क्योंकि आज भी, चावल का वार्षिक विश्व उत्पादन अभी भी 2 ^ 64 अनाज से कम है।

— विर्ज

1

@vsz वास्तव में, आदमी मारा गया था। वह राशि जो राजा को पूरे राज्य को दे देती थी, इसलिए स्वाभाविक रूप से आसान रास्ता निकाल लिया गया था।

— cst1992

1

@ cst1992 जो संस्करण मैंने पढ़ा है वह कहता है कि उस व्यक्ति ने अपने अनुरोध पर हार मान ली और उसे उपहार के रूप में एक प्रांत मिला।

— user6245072

23

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

²b1ḅ

यह @ APLDude के चतुर APL उत्तर से दृष्टिकोण का उपयोग करता है ।

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें ।

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

²b1ḅ  Main link. Arguments: x (side length), y (multiplier)

²     Square; yield x².
 b1   Convert to base 1 (unary), yielding a list of x² ones.
   ḅ  Convert from base y to real number.
      This yields y^(x²-1) + ... + y + 1.

— डेनिस
स्रोत

27

MATL , 6 बाइट्स

2^:q^s

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

2^   % Take implicit input, say N, and square it: N^2
:q   % Generate array [0 1 ... N^2-1]
^    % Take implicit input, M, and compute [M^0 M^1 ... M^(N^2-1)]
s    % Sum of the array. Implicit display

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

23

एपीएल, 10 बाइट्स

⎕⊥1+0×⍳⎕*2

⎕उपयोगकर्ता इनपुट को दो बार पढ़ने के लिए उपयोग किया जाता है। अगर हम में पक्ष लंबाई की दुकान रों और में गुणक मीटर , हम निम्नलिखित कोड मिलता है।

m⊥1+0×⍳s*2

और यहां बताया गया है कि APL इस कोड को कैसे पार करता है:

— एपीएल यार
स्रोत

4

या एक फ़ंक्शन ट्रेन के रूप में: ⊣⊥1⍴⍨⊢×⊢(8 बाइट्स) एक इंटरेक्टिव REPL कमांड के रूप में, ⎕⊥×⍳⎕*2(7 बाइट्स) भी काम करता है।

— डेनिस

19

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

lambda n,m:eval('1+m*('*n*n+'0'+')'*n*n)

एक स्ट्रिंग की तरह उत्पन्न करता है और मूल्यांकन करता है

1+m*(1+m*(1+m*(1+m*(0))))

यह राशि को शर्तों के साथ एक सींग वाले बहुपद के रूप में एन्कोड करता है n*n।

बहुत सारे अलग-अलग तरीकों ने बहुत ही समान बाइट की गिनती दी:

#String evaluation
lambda n,m:eval('1+m*('*n*n+'0'+')'*n*n)   #40

#Direct summation
lambda n,m:sum(m**i for i in range(n*n))   #40
lambda n,m:sum(map(m.__pow__,range(n*n)))  #41

#Direct formula
lambda n,m:n*n*(1==m)or(m**n**2-1)/(m-1)   #40

#Iterative sequence
f=lambda n,m,j=0:j<n*n and 1+m*f(n,m,j+1)  #41
def f(n,m):s=0;exec"s=s*m+1;"*n*n;print s  #41

#Recursive expression
#Fails due to float imprecision of square root
f=lambda n,m:n and 1+m*f((n*n-1)**.5,m)    #39*

— XNOR
स्रोत

2

आह ठीक है, मेरा बुरा। वैसे भी, मुझे वास्तव में आपके द्वारा

— उठाए गए

11

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

1 बाइट ने @FryAmTheEggman को धन्यवाद दिया ।

s^Lvz*

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

परीक्षण सूट।

— लीक नन
स्रोत

11

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

n%m=sum$(m^)<$>[0..n*n-1]

सूची तैयार करता है [m^0, m^1, ..., m^(n*n-1)]।

— XNOR
स्रोत

11

जावास्क्रिप्ट (ES2016 / ES7), 31 29 28 बाइट्स

a=>b=>(b**(a*a)-1)/--b||a*a

बस @Bassdrop Cumberwubwubwub और @ Kaizo का ES6 संस्करण है, लेकिन घातांक ऑपरेटर के साथ। :) (मेरे पास टिप्पणी करने के लिए पर्याप्त प्रतिष्ठा नहीं थी।)

संपादित करें: (धन्यवाद @Neil) में /+(b-1)बदल गया /--b।

संपादित करें: अब currying का उपयोग करता है (धन्यवाद @MamaFunRoll)

— gcampbell
स्रोत

PPCG में आपका स्वागत है! आपका उत्तर बहुत अच्छा है!

— NoOneIsHere

स्वागत हे! +ऑपरेटर, ताकि आप इसे छोड़ते हुए द्वारा 1 बाइट बंद दाढ़ी कर सकते हैं एक परीक्षण मैं बाहर संपादित करने के लिए भूल गया था :)

— Bassdrop Cumberwubwubwub

सूत्र m = 1: 3

— user6245072

@ user6245072 आप क्रोम कैनरी पर हैं? या नोड पर? यदि नोड पर, सद्भाव ध्वज सक्षम करें

— NiCk Newman

चाहेंगे /--bआप एक या दो बाइट को बचाने?

— नील

10

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

²R’*@S

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

— लीक नन
स्रोत

8

MATLAB, 23 बाइट्स

@(n,k)sum(k.^(0:n^2-1))

इसे यहाँ टेस्ट करें !

— स्टीवी ग्रिफिन
स्रोत

8

जावास्क्रिप्ट ईएस 6, 59 37 35 34 बाइट्स

a=>b=>(Math.pow(b,a*a)-1)/--b||a*a`

धन्यवाद @ 19a बाइट्स को शेव करने के लिए @Kao, 2 अन्य के लिए @ नील और 1 से अधिक @gcampbell!

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

कोड स्निपेट दिखाएं

f=
a=>b=>(Math.pow(b,a*a)-1)/--b||a*a

a.innerHTML='<pre>'+
  [[8,2],
   [3,6],
   [7,1.5],
   [5,-3],
   [256,1],
   [2,2],
   [2,-2]].map(b=>`${b[0]}, ${b[1]} => ${f(b[0])(b[1])}`).join('<br>')+'</pre>'

<div id=a>

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

वैकल्पिक टूटे हुए संस्करण

32 बाइट्स

(a,b)=>(Math.pow(b,a*a)-1)/(b-1)

का कारण बनता NaNहै b==1।

30 बाइट्स

(a,b)=>(Math.pow(b,a*a)-1)/~-b

का कारण बनता Infinityहै b==1.5।

28 बाइट्स

(a,b)=>~-Math.pow(b,a*a)/~-b

1कुछ मान्य टेस्टकेस के लिए आउटपुट ।

59 बाइट्स के लिए पुराना संस्करण

(a,b)=>Array(a*a).fill``.reduce((c,d,i)=>c+Math.pow(b,i),0)

— बैसब्रांड कंबरवुबवबब
स्रोत

आपने 32 बाइट्स केस में सिर्फ b == 1 केस का इलाज क्यों नहीं किया है? 40 बाइट्स: (ए, बी) => बी -1? (मैथ.पॉ (बी, ए * ए -1) / (बी -1): ए *

— ए

@ काइज़ो यू आर राइट, आई एम

— ए इडियट

/~-bस्पष्ट रूप से भिन्नात्मक के लिए अच्छा नहीं है b, लेकिन /--bकाम करना चाहिए, नहीं?

— नील

वैसे, मैंने पुराने संस्करण को 47 बाइट्स तक नीचे कर दिया है:(a,b)=>[...Array(a*a-1)].reduce(s=>s+=p*=b,p=1)

— नील

@ आप ठीक कह रहे हैं, बिल्कुल। जब आप अपना जवाब देते हैं तो आपको यही मिलता है: धन्यवाद!

— बैसड्रॉप कंबरवुबवबूब

6

जावा, 132 बाइट्स

import java.math.*;Object e(int n,BigDecimal m){BigDecimal r=BigDecimal.ONE,a=r;for(n*=n;n>1;n--)r=r.add(a=a.multiply(m));return r;}

Ungolfed

import java.math.*;

Object e(int n, BigDecimal m) {
    BigDecimal r = BigDecimal.ONE, a = r;
    for (n *= n; n > 1; n--)
        r = r.add(a = a.multiply(m));
    return r;
}

यह ओपी द्वारा आवश्यक रूप से बड़े आउटपुट के लिए काम करेगा (बहुत बुरा जावा बड़ी संख्या का समर्थन करता है, यह अन्यथा छोटा होगा)।

आउटपुट

Input:      8 2.0
Expected:   18446744073709551615
Actual:     18446744073709551615

Input:      3 6.0
Expected:   2015539
Actual:     2015539

Input:      7 1.5
Expected:   850161998.2854
Actual:     850161998.285399449204543742553141782991588115692138671875

Input:      5 -3.0
Expected:   211822152361
Actual:     211822152361

Input:      256 1.0
Expected:   65536
Actual:     65536

Input:      2 2.0
Expected:   15
Actual:     15

Input:      2 -2.0
Expected:   -5
Actual:     -5

Input:      263 359.9
Expected:   ?
Actual:     9709...[176798 digits]...7344.7184...[69160 digits]...6291

— मार्व
स्रोत

6

आर, 18 बाइट्स

sum(m^(1:s^2-1))

स्पष्टीकरण:

sum(               # Calculate sum
    m              # Multiplier
     ^             # Exponentiate
      (1:s^2-1))   # Generate sequence from 1 to s(ide)^2-1

— Forgottenscience
स्रोत

5

05AB1E , 5 बाइट्स

कोड:

nL<mO

स्पष्टीकरण:

n      # Compute i ** 2
 L     # Push the list [1, ..., i ** 2]
  <    # Decrement by 1, [0, ..., i ** 2 - 1]
   m   # Power function with implicit input, [0 ** j, ..., (i ** 2 - 1) ** j]
    O  # Sum that all up

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

— अदनान
स्रोत

4

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

n#m=sum$take(n^2)$iterate(*m)1

या उतना ही लंबा

n%1=n^2
n%m=(m**(n*n)-1)/(m-1)

पहले संस्करण के साथ 1बार-बार गुणा शुरू होता है m। फिर यह n^2इस क्रम की पहली संख्याओं को गाता है। दूसरा संस्करण स्पष्ट सूत्र है जैसा कि अन्य उत्तरों में देखा गया है।

— nimi
स्रोत

तुम बस नहीं कर सकते n#m=sum$(m^)<$>[0..n*n-1]?

— xnor

@ xnor: ओह, यह अच्छा है। मुझे लगता है कि अलग जवाब के लिए यह काफी अलग है। कृपया इसे स्वयं पोस्ट करें।

— निमि

4

जे, 10 बाइट्स

+/@:^i.@*:

प्रयोग

मैं xसटीक परिणाम प्राप्त करने के लिए विस्तारित पूर्णांक का उपयोग करने के लिए प्रत्यय के साथ कुछ पूर्णांक चिह्नित करता हूं ।

   f =: +/@:^i.@*:
   2x f 8
18446744073709551615
   3x f 6
75047317648499560
   6x f 3
2015539
   1.5 f 7
8.50162e8
   _3x f 5
211822152361
   1 f 256
65536
   2 f 2
15
   _2 f 2
_5

व्याख्या

+/@:^i.@*:
        *:  Square the value s to get s^2
     i.@    Make a range from 0 to s^2 exclusive, [0, 1, ..., s^2-1]
    ^       Using m as the base, calculate the power with the range
            [m^0, m^1, ..., m^(s^2-1)]
+/@:        Sum the entire list and return it

— मील की दूरी पर
स्रोत

#.*:$*एपीएल ड्यूड के अनुसार 6 बाइट्स ।

— फ्रॉन्फ्रॉग में

4

मठकाद, [tbd] बाइट्स (~ 11)

मैथैड के निर्मित समन ऑपरेटर में उपयोग करता है। सटीक सूत्र उत्पन्न करने के लिए प्रतीकात्मक प्रोसेसर सरलीकरण भी प्रदर्शित करता है।

Mathcad समानांतर में दो प्रसंस्करण इंजनों को प्रभावी ढंग से चलाता है - एक मानक IEEE 64/80 बिट फ़्लोटिंग पॉइंट, और दूसरा एक मनमानी संख्या लंबाई प्रतीकात्मक प्रक्रिया (MuPad)। मानक संख्यात्मक मूल्यांकन को बराबर चिह्न (=) द्वारा दर्शाया गया है, जबकि एक दाहिना तीर प्रतीकात्मक मूल्यांकन को दर्शाता है।

मथकड काउंटिंग स्कीम अभी तक निर्धारित नहीं की गई है इसलिए कोई बाइट काउंट नहीं दिया गया है।

ctl- $ समन ऑपरेटर (सिग्मा) में प्रवेश करता है, जिसमें समरेशन वेरिएबल, प्रारंभिक मूल्य, अंतिम मूल्य और अभिव्यक्ति को डालने के लिए खाली प्लेसहोल्डर्स शामिल हैं। अनुमानित बाइट-समतुल्य गणना = ११।

— स्टुअर्ट ब्रुफ़
स्रोत

कोड कहां है

— अब्राहम

1

वास्तविक चुनौती के लिए "कोड" पहला सारांश संकेत (राजधानी सिग्मा) है जिसे आप "चुनौती समाधान" शीर्षक के तहत देखते हैं। "समाधान" के अन्य बिट्स "समाधान वेरिएंट" शीर्षक के तहत दिए गए हैं। आप छवि में जो देख रहे हैं, वह ठीक उसी प्रकार है जो एक मैथेकड वर्कशीट पर लिखा गया है - मैथकाड विभिन्न परिचालनों के लिए गणितीय प्रतीकों का उपयोग करता है, जैसे कि सदिश राशि या उत्पाद, फंक्शन इंटीग्रेशन या भेदभाव या लॉजिकल ऑपरेशंस। अधिकांश ऑपरेटर एक प्रमुख संयोजन (उदाहरण के लिए, ctl-4 एक अंतर्निहित वेक्टर राशि या ctl- & एक पुनरावृत्त राशि के लिए), या एक मेनू या टूलबार के माध्यम से इनपुट कर सकते हैं।

— स्टुअर्ट ब्रुफ़

4

PostgreSQL, 67 66 बाइट्स

SELECT SUM(m^v)FROM(VALUES(3,6))t(s,m),generate_series(0,s*s-1)s(v)

SqlFiddleDemo

इनपुट: VALUES(side, multiplier)

संपादित करें:

इनपुट टेबल पर चला गया, सभी मामलों में एक बार:

SELECT s,m,SUM(m^v)FROM i,generate_series(0,s*s-1)s(v)GROUP BY s,m

SqlFiddleDemo

आउटपुट:

╔══════╦══════╦══════════════════════╗
║  s   ║  m   ║         sum          ║
╠══════╬══════╬══════════════════════╣
║   7  ║ 1.5  ║ 850161998.2853994    ║
║   2  ║ 2    ║ 15                   ║
║   2  ║ -2   ║ -5                   ║
║ 256  ║ 1    ║ 65536                ║
║   5  ║ -3   ║ 211822152361         ║
║   8  ║ 2    ║ 18446744073709552000 ║
║   3  ║ 6    ║ 2015539              ║
╚══════╩══════╩══════════════════════╝

— lad2025
स्रोत

3

टीआई-बेसिक, 19 बाइट्स

Sसाइड की लंबाई है, और Mगुणक है।

Prompt S,M:Σ(M^I,I,0,S²-1

— Timtech
स्रोत

3

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

lambda l,m:sum(m**i for i in range(l*l))

— orlp
स्रोत

1

lambda l,m:(m**(l*l)-1)/(m-1)

— लीक नून

नियमित भाषाओं में सूत्र का उपयोग कम होगा। मैंने मानचित्र का उपयोग किया क्योंकि esolangs में नक्शे छोटे होंगे।

— लीक नून

स्ट्राइकथ्रू कहाँ है?

— लीक नून

@ केनीलाऊ मैं अभी भी अपने जवाब पर काम कर रहा था, मैंने आपकी टिप्पणी देखने से पहले यह पोस्ट किया।

— orlp 14

ठीक है, (7 और जाने के लिए ...)

— लीक नून

3

रूबी: 39 बाइट्स

->s,m{(0...s*s).reduce(0){|a,b|a+m**b}}

परीक्षा:

f = ->s,m{(0...s*s).reduce(0){|a,b|a+m**b}}

f[8,2]   # 18446744073709551615
f[3,6]   # 2015539
f[7,1.5] # 850161998.2853994
f[5,-3]  # 211822152361
f[256,1] # 65536
f[2,2]   # 15
f[2,-2]  # -5
f[1,1]   # 1

— br3nt
स्रोत

रूबी को sumफंक्शन कब मिला ??? यह गेमचेंजिंग है

— वैल्यू इंक

अरे नहीं! मुझे लगा कि एक माणिक कोर विधि वास्तव में एक रेल विधि उदास चेहरा है । मैंने जवाब अपडेट कर दिया है।

— br3nt

क्या आप अपनी भाषा को केवल रेल में बदल सकते हैं? मुझे उस आयात के बारे में कोई जानकारी नहीं है जो आपके लिए हो सकता है

— वैल्यू इंक

3

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

इस गोल्फिंग बात पर पूरी तरह से नया, आलोचना का स्वागत है!

lambda n,m:sum(m**i for i in range(n**2))

— लैंग ट्रान
स्रोत

यह वास्तव में काफी अच्छा है; )

— उपयोगकर्ता ६२४५० May२

हा हा धन्यवाद। मुझे Google को फिर से अजगर में लैम्बडास कैसे करना है, क्योंकि मैंने थोड़ी देर में अजगर को नहीं छुआ।

— लैंग ट्रान

प्रोग्रामिंग पहेलियाँ और कोड गोल्फ में आपका स्वागत है! यह एक अच्छा जवाब है, लेकिन यह इस एक के समान है ।

— डेनिस

आह, मैंने देखा नहीं कि कोई अन्य समाधान थे। क्या l**lमैंने जो किया उसके बजाय एक बाइट बचाकर किया?

— लैंग ट्रान

l*lवास्तव में, जो इससे छोटा है l**2।

— डेनिस

2

जोल्फ, 18 15 10 बाइट्स

3 बाइट बचाने और मैपिंग की ओर इशारा करने के लिए C and O'Bʀɪᴇɴ का धन्यवाद

uΜzQjd^JwH

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

 ΜzQj       Map over an array of 1 -> square(side length)
     d^JwH  Set the current array value to multiplier^(current value - 1)
u           Sum the array

— फूल जाती है
स्रोत

अच्छा काम! आप जीटा से पहले एक को हटा सकते हैं, जैसा कि अंतर्निहित रूप से बाहर है। आप प्रत्येक के लिए म्यू (मानचित्र) का उपयोग भी कर सकते हैं, और मुझे लगता है कि आप विज्ञापन के साथ डी को प्रतिस्थापित कर सकते हैं और समाप्ति को हटा सकते हैं}।

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

1

@ C @ O'Bᴏɴᴏʀ नीट, जोल्फ के निहित भागों के बारे में भूल जाते हैं, वे निश्चित रूप से कुछ बाइट्स को शेव करने के सर्वोत्तम तरीकों में से कुछ हैं।

— सूज

2

CJam , 9 बाइट्स

q~2#,f#:+

इनपुट्स रिवर्स ऑर्डर में एक नई रेखा या एक स्थान से अलग होते हैं।

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

q~    e# Read input. Evaluate: pushes the two numbers, M and N, onto the stack
2#    e# Square: compute N^2
,     e# Range: generates array [0 1 ... N^2-1]
f#    e# Compute M raised to each element of the array [0 1 ... N^2-1]
:+    e# Fold addition: compute sum of the array [M^0 M^1 ... M^(N^2-1)]

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

2

PHP, 58 54 बाइट्स

<?function a($n,$m){$n*=$n;echo(1-$m**$n)/(1-$m)?:$n;}

यह सिर्फ मान को दर्शाने के लिए समन सूत्र का उपयोग करता है, जाँचने के बाद कि यदि गुणक 1 है (जो सूत्र में NAN लौटाता है)।

— Xanderhall
स्रोत

2

गणितज्ञ, 22 बाइट्स

Tr[#^(Range[#2^2]-1)]&

की एक श्रृंखला बनाता है {1, 2, ... s^2}, इसे बनाने के लिए 1 से घटाता है {0, 1, ..., s^2-1}। फिर प्रत्येक को mबनाने की शक्ति को बढ़ाएं {m^0, m^1, ..., m^(s^2-1)}और उसका योग लौटाएं।

वैकल्पिक रूप से, गणितज्ञ अपनी सीमा लेकर स्पष्ट सूत्र का उपयोग कर सकता है। इसके लिए 29 बाइट्स की आवश्यकता होती है ।

Limit[(s^#^2-1)/(s-1),s->#2]&

— मील की दूरी पर
स्रोत

आप अपना पहला संस्करण लिख सकते हैंTr[#^Range[#2^2]/#]&

— साइमन वुड्स

1

PARI / GP , 25 बाइट्स

f(s,m)=sum(i=0,s^2-1,m^s)

लंबा लेकिन तेज (35 बाइट्स):

f(s,m)=if(m==1,s^2,(m^s^2-1)/(m-1))

प्यारा (30 बाइट्स):

f(s,m)=vecsum(powers(m,s^2-1))

— चार्ल्स
स्रोत

1

सी #, 56 बाइट्स

double f(int n,double q){return(Math.Pow(q,n*n)-1)/--q;}

— downrep_nation
स्रोत

टेस्टकेस 256, 1?

— user6245072

क्या यह 256 ^ 2 नहीं है?

— downrep_nation

1

(Math.Pow(1, 256 * 256) - 1) / --1= 0/0।

— user6245072

1

आपको या तो सिस्टम का उपयोग करने की आवश्यकता है; या System.Math.Pow। और आपका कोड काम नहीं करता है, जब q = 1, जैसा कि @ user6245072 द्वारा कहा गया है।

— होरवथ दाविद

1

लुआ, 54 47 बाइट्स

r=0l,m=...for i=0,l^2-1 do r=r+m^i end print(r)

पहले तर्क के रूप में बोर्ड की ओर की लंबाई के साथ कमांड लाइन से भागो और दूसरे के रूप में गुणक।

6 बाइट्स बचाने के लिए user6245072 और अतिरिक्त 1 को बचाने के लिए कैटेन्को का धन्यवाद।

मूल 54 बाइट संस्करण:

a,b=...c=1 d=1 for i=2,a^2 do c=c*b d=d+c end print(d)

— kidfrommars
स्रोत

नमस्कार, और PPCG में आपका स्वागत है! बहुत बढ़िया जवाब!

— NoOneIsHere

l,m=...r=0 for i=0,l^2 do r=r+m^i end print(r)

— user6245072

यह कुछ बाइट्स को बचाना चाहिए।

— user6245072

d नाम बदलने से एक बाइट बचती है क्योंकि यह c=1 d=1=> में स्थान को छोड़ने की अनुमति देता है a,b=...c=1g=1 for i=2,a^2 do c=c*b g=g+c end print(g)। अगर @ user6245072 का सुझाव काम करता है, तो आप उसी सिद्धांत पर एक बाइट बचा सकते हैं =>r=0l,m=...for i=0,l^2 do r=r+m^i end print(r)

— काटनकेयो

बीच में व्हाट्सएप r=0और l,m=...वैसे भी अनिवार्य है, इसलिए यह बदलता नहीं है। इसके अलावा लूप होना चाहिए for i=0,l^2-1लेकिन यह मेरी गलती है।

— user6245072

1

S, 11 चार्ट / 14 बाइट्स

⨭⩥ î²)ⓜⁿ⁽í$

Try it here (Firefox/WebKit Nightly only).

हां, Web अब वेबकीट नाइटली में काम करता है! क्रोम समर्थन अगला है।

व्याख्या

⨭⩥ î²)ⓜⁿ⁽í$ // implicit: î = input1, í = input2
   ⩥ î²)       // generate a range [0..î^2)
                     ⓜ      // map over range ($ is mapitem):
        ⁿ⁽í$  //   í^$
⨭            // sum resulting range
              // implicit output

— मामा फन रोल
स्रोत

1

RETURN , 32 बाइट्स

[a:2^0\
{[$¥][a;\^]#[¤¥][+]#]!

Try it here.

अनाम लैम्ब्डा जो स्टैक 2 पर परिणाम देता है। उपयोग:

8 2[a:2^0\
{[$¥][a;\^]#[¤¥][+]#]!

व्याख्या

[                              ]!  lambda
 a:                                store multiplier to a
   2^                              square side-length
     0\␊                           create range [0..result)
        {                          set current stack to range
         [  ][     ]#              while loop
          $¥                         check if TOS is truthy
              a;\^␌                  if so, push a^TOS to Stack2
                     ␁            set current stack to Stack2
                       [¤¥][+]#    sum Stack2

— मामा फन रोल
स्रोत

चावल और शतरंज की समस्या

कार्य

टिप्पणियाँ

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

स्कोरिंग

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

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

MATL , 6 बाइट्स

एपीएल, 10 बाइट्स

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

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

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

जावास्क्रिप्ट (ES2016 / ES7), 31 29 28 बाइट्स

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

MATLAB, 23 बाइट्स

जावास्क्रिप्ट ईएस 6, 59 37 35 34 बाइट्स

वैकल्पिक टूटे हुए संस्करण

59 बाइट्स के लिए पुराना संस्करण

जावा, 132 बाइट्स

Ungolfed

टिप्पणियाँ

आउटपुट

आर, 18 बाइट्स

05AB1E , 5 बाइट्स

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

जे, 10 बाइट्स

प्रयोग

व्याख्या

मठकाद, [tbd] बाइट्स (~ 11)

PostgreSQL, 67 66 बाइट्स

टीआई-बेसिक, 19 बाइट्स

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

रूबी: 39 बाइट्स

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

जोल्फ, 18 15 10 बाइट्स

CJam , 9 बाइट्स

PHP, 58 54 बाइट्स

गणितज्ञ, 22 बाइट्स

PARI / GP , 25 बाइट्स

सी #, 56 बाइट्स

लुआ, 54 47 बाइट्स

S, 11 चार्ट / 14 बाइट्स

व्याख्या

RETURN , 32 बाइट्स

व्याख्या