बौने और सिक्के

Question

स्थिति:

कई ( M) बौनों ने Nसोने के सिक्कों के साथ एक गॉब्लिन की छाती पाई है और उन्हें विभाजित करना है। वरिष्ठता के क्रम में समुद्री लुटेरों को लूट के आवंटन को नियंत्रित करने वाले प्राचीन नियमों के कारण, सबसे पुराने बौने को अगले सबसे पुराने बौने की तुलना में एक सिक्का अधिक मिलना चाहिए, और इसलिए कि सबसे कम उम्र के बौने M-1को सबसे पुराने बौने की तुलना में कम सिक्के मिलते हैं । इसके अतिरिक्त, किसी भी बौने को किसी भी सिक्के में पिच नहीं करना है (अर्थात किसी भी बौनों के लिए कोई नकारात्मक सिक्के नहीं)

बौनों को इस तरह से सिक्कों को विभाजित करने में मदद करें, या उन्हें बताएं कि यह असंभव है।

विजेता का कोड हमेशा सही उत्तर देना चाहिए (यह चुनौती नियतात्मक है) और सामान्य कोड-गोल्फ नियमों का पालन करें।

इनपुट

आपको सिक्कों की संख्या के लिए एक पूर्णांक N (3 given N ger 1000) और बौनों की संख्या के लिए एक पूर्णांक M (3) M ≤ N), स्थान-पृथक किया गया है।

उत्पादन

यदि बौने चाहते हैं तो सिक्कों को विभाजित करना असंभव है, प्रिंट -1 (माइनस वन)। अन्यथा, सिक्कों की संख्या को प्रिंट करें जो प्रत्येक बौना प्राप्त करेगा, सबसे पुराने से सबसे कम उम्र तक। रिक्त स्थान के साथ संख्याओं को अलग करें।

नमूने :

इनपुट

3 3

उत्पादन

2 1 0

इनपुट

9 3

उत्पादन

4 3 2

इनपुट

7 3

उत्पादन

-1

इनपुट

6 4

उत्पादन

3 2 1 0

Comments

आप एक "समुद्री डाकू" से चूक गए।

— 9

प्रासंगिक

— Raystafarian

अच्छा लगता है, @Raystafarian। शायद जब शिक्षक को केवल 3 के बजाय M बौने के लिए एक सामान्य सॉल्वर मिल जाता है, तो वह / वह पहचान लेगा कि उपयोगकर्ता ने उत्तर को भीड़ दिया :) - खासकर अगर वह सॉल्वर जे में है

— प्रोग्रामरडॉन

होमवर्क या नहीं, यह एक अच्छा सवाल है!

— लेवल रिवर सेंट

Answer 1

जे - 32 29 28 25

नहीं अन्य J समाधान से छोटा, परंतु और एक अलग विचार का उपयोग करता है

(]{.[:i:-:@-.@]-%)/ ::_1:

सिक्कों की संख्या उच्चतम रैंक सूक्ति के लिए हो रही है बस N/M+(M-1)/2(यदि यह एक पूर्णांक है), तो हम इसका नकारात्मक निर्माण करते हैं -:@-.@]-%। फिर तर्क के लिए i:एक सरणी बनाता 2 1 0 _1 _2है _2और हम इसमें से M तत्व लेते हैं।

Comments

के शानदार उपयोग के लिए +1 i:। आप के %बजाय लिखने के [%]द्वारा और के -.@]बजाय का उपयोग करके एक और तीन चार बचा सकते हैं (1-])।

— एल्गोरिद्मशार्क

@al एल्गोरिदमक धन्यवाद साथी जे उत्साही!

— बेंत की मार

+1 नहीं कर सकते क्योंकि @swish हमें सिर्फ लूटे गए gnomes के साथ लगता है। ;)

— TheConstructor

Answer 2

जे - 30 चार

गोल्फ में बहुत मज़ा आता है। बहुत सारी चीजें बड़े करीने से काम करती थीं।

((+/@s~i.[){ ::_1:s=.+/&i.&-)/

स्पष्टीकरण:

• /- अंतरिक्ष-पृथक पूर्णांकों को तर्क के रूप में लें, और उनके बीच फ़ंक्शन को पर्ची करें। यह कहना है, कोष्ठक में फ़ंक्शन के लिए बाएं तर्क पर विचार करें (...)और सही तर्क में एम।

• i.&-- नेगेट ( -) और फिर पूर्णांक ( i.) लें। आम तौर पर, जब आप कुछ ऐसा करते हैं, जैसे i.5आपको मिलता है 0 1 2 3 4। जब भी i.एक नकारात्मक संख्या प्राप्त होती है, हालांकि, यह उस आउटपुट सूची को उलट देती है। इसलिए जैसे i._5देंगे 4 3 2 1 0।

• s=.+/&- प्रत्येक तर्क पर उपरोक्त कार्रवाई करें ( &) और फिर +/इन सरणियों में से एक अतिरिक्त तालिका ( ) बनाएं । अब हमारे पास एक मेज है जहां प्रत्येक पंक्ति एम बौनों के लिए एक संभावित सिक्का वितरण है, हालांकि शायद नहीं जब एन सिक्के हैं। अंत में, यह टेबल बनाने वाली क्रिया इतनी उपयोगी है कि हम इसे कॉल करने जा रहे हैं sऔर बाद में इसे फिर से उपयोग करेंगे।

• +/@s~- अब, हम sफिर से उपयोग करते हैं, लेकिन हम ~तर्कों का क्रम स्वैप ( ) करते हैं, ताकि हम तालिका को स्थानांतरित करें। यह तालिका ( +/@) बनाने के बाद प्रत्येक पंक्ति का योग लेने का एक गोल्फ़ तरीका है , जिस तरह से जम्मू बहुआयामी सूचियों के साथ किया जाता है।

• i.[ - रकम की इस सूची में, हम क्रिया के लिए बाएं तर्क की खोज करते हैं, अर्थात यदि कोई आइटम N है, तो हमें वह इंडेक्स मिलता है: अन्यथा हमें सूची की लंबाई मिलती है, जो विशेष रूप से एक अमान्य इंडेक्स है।

• { ::_1:- अब हम तालिका में एक पंक्ति को बाहर निकालने के लिए सूचकांक का उपयोग करने का प्रयास करते हैं s। {यदि डोमेन अमान्य था, तो एक डोमेन त्रुटि को फेंक देगा, इसलिए उस स्थिति में हम त्रुटि ( ::) और रिटर्न -1 ( _1:) को पकड़ते हैं । यह सब कुछ संभालता है। चूंकि हम i.&-पहले उपयोग करते हैं , सिक्का वितरण अवरोही क्रम में होगा, जैसा कि आवश्यक था।

उपयोग:

   ((+/@s~i.[){ ::_1:s=.+/&i.&-)/ 9 3
4 3 2
   ((+/@s~i.[){ ::_1:s=.+/&i.&-)/ 7 3
_1
   ((+/@s~i.[){ ::_1:s=.+/&i.&-)/ 6 4
3 2 1 0
   ((+/@s~i.[){ ::_1:s=.+/&i.&-)/ 204 17
20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4

Comments

इनपुट 9 3वापस चाहिए 4 3 2, नहीं -1। लगता है कि आपके उदाहरण के उपयोग में एक स्थानान्तरण है?

— प्रोग्रामरडान

@ProgrammerDan धन्यवाद, इसे नहीं पकड़ा। मैंने उदाहरण गलत लिखे। उम्मीद के मुताबिक 9 3देता है 4 3 2और 7 3देता _1है।

— एल्गोरिथमशार्क

फिक्स को देखा और उचित रूप से +1 किया: D। मुझे जम्मू में देखना चाहिए, निफ्टी दिखता है।

— प्रोग्रामरडान

Answer 3

आर - 71 70 67 66 65 वर्ण

s=scan();m=s[2];x=s[1]-sum(1:m);cat(if(x%%m|-m>x)-1 else x/m+m:1)

Ungolfed:

s = scan()    # Reads N and M by stdin.
m = s[2]
x = s[1] - m*(m-1)/2
cat(if (x %% m | x < -m) -1 else x/m + m:1)

समाधान:

यदि एम बौनों की संख्या है, तो भुगतान किए गए सोने का क्रम दो विलक्षण श्रृंखलाओं तक विघटित हो सकता है। पहले शून्य में समाप्त होने वाली श्रृंखला: एम -1, ..., 2, 1, 0 और सी, सी, ..., सी की एक निरंतर श्रृंखला। पहली श्रृंखला का योग हमेशा M * (M-1) / 2 होता है। इसलिए यदि शेष (x = N - M * (M-1) / 2) को शेष के बिना विभाजित किया जा सकता है (modulo बराबर 0), प्रत्येक बौना को x / M प्लस घटती श्रृंखला का हिस्सा मिलता है।

उपयोग:

> s=scan()
1: 10 4
3: 
Read 2 items
> m=s[2]
> x = s[1] - m*(m-1)/2
> cat(if (x %% m || x<0) -1 else x/m + (m-1):0)
4 3 2 1

Comments

-1, प्रश्न के लिए एक पूरा कार्यक्रम लिखना होता है, न कि एक फंक्शन। देखें meta.codegolf.stackexchange.com/a/1146/8766

— user80551

@ user80551 आप सही हैं। अब मैंने स्निपेट को ठीक किया: अब यह अंतरिक्ष से अलग हुए इनपुट को लेता है; आउटपुट भी '[1]' नहीं दिखाता है।

— lambruscoAcido

आप एक और चरित्र की जगह बचा सकता है m*(m+1)/2के साथsum(1:m)

— ब्रायन Diggs

@ ब्रायन Thx, मैं अपना कोड संशोधित करूंगा!

— lambruscoAcido

Answer 4

PHP (187)

यह गोल्फ में मेरा पहला प्रयास है, और मुझे पता है कि यह बेहतर हो सकता है, लेकिन फिर भी :)

golfed:

<?php
$b=fgets(STDIN);list($c,$d)=explode(' ',$b);if((($d&1)AND($c%$d==0))OR($c%$d==$d/2)){for($e=floor($c/$d)+floor($d/2);$e>floor($c/$d)-round($d/2);$e--){echo"$e ";}}else{die('-1');}?>

Ungolfed:

<?php
$a = fgets(STDIN);
list($coins, $dwarves) = explode(' ', $a);
if ((($dwarves & 1) AND ($coins % $dwarves == 0)) OR ($coins % $dwarves == $dwarves / 2)) {
    for (
        $i = floor($coins / $dwarves) + floor($dwarves / 2);
        $i > floor($coins / $dwarves) - round($dwarves / 2);
        $i--
    ) {
        echo "$i ";
    }
}
else { 
  die('-1');
}
?>

एक खोल में निष्पादित करें

मूल विचार:

यदि इन में से एक सत्य है, तो इन नियमों से सिक्के अलग किए जा सकते हैं:

1. बौने विषम संख्या में होते हैं, और सिक्के बौनों द्वारा बिना किसी अवशेष के विभाज्य होते हैं
2. बौने भी संख्या में हैं, और सिक्के / बौने को विभाजित करने के बाद शेष सिक्के बौनों की संख्या के आधे के बराबर हैं

यदि हां, तो हम प्रति बौने (एसीपीडी) औसत सिक्कों को आधार के लिए लेते हैं। लेकिन हमें उच्चतम और आउटपुट से शुरू करना होगा जब तक कि हम निम्नतम तक नहीं पहुंचते। इसलिए हम एसीपीडी से शुरू होने वाले काउंटर के साथ एक लूप बनाते हैं + उच्च बौनों की ओर बाकी बौनों की गिनती, और जब तक हम एसीपीडी तक नहीं पहुंच जाते, तब तक बाकी बौनों की गिनती निचले सिरे की ओर होती है।

यह मूल रूप से एक ही है यदि बौने विषम हैं (यानी 5 बौने - मध्य वाला 3 है, और दोनों सिरों में 2 रहते हैं), लेकिन नहीं अगर वे भी हैं - यही कारण है कि हम फर्श और गोल पर भरोसा करते हैं।

अब तक की समस्याएं: बहुत कम सिक्कों की संख्या के साथ काम करता है, जिसका अर्थ है कि कुछ बौनों को उनकी कीमती कमाई को लूट लिया जाएगा। और यह दुखद है। या कम से कम अगर आपको बौने पसंद हैं।

समाधान :

1. सिक्कों की सबसे कम मात्रा की गणना करने का एक तरीका सोचें ताकि गणना धूल में बौनों के साथ समाप्त न हो।
2. डिजाइन नहीं तो लालची बौने।

होशियार समाधान :

सिक्के धातु हैं। बौनों को उन सभी को पिघला दें, और फिर उन्हें सिक्कों की छोटी / बड़ी मात्रा में डाल दें, इसलिए वे किसी भी मामले में विभाज्य हैं।

सबसे अच्छा समाधान :

उनका पहाड़ चुराओ, खुद का नाम बदलकर स्मॉग कर लो और यह सब अपने लिए रख लो। आखिर क्यों, आपको बौने बौनों से परेशान होना पड़ता है?

Answer 5

पायथन 3 (100)

@Geobits के समान विचार का उपयोग करना लेकिन इनपुट और आउटपुट आवश्यकताओं के अनुरूप।

n,m=map(int,input().split())
κ,ρ=divmod(n-m*(m-1)//2,m)
x=[-1]if ρ else range(κ,κ+m)[::-1]
print(*x)

Comments

सर उठाने के लिए धन्यवाद। इनपुट-रे में जोड़े गए स्थान-पृथक्करण पर ध्यान नहीं दिया गया।

— भूतकाल

वे 100 वर्ण हो सकते हैं, लेकिन ग्रीक चर नामों के कारण, इसके लिए 105 बाइट्स की आवश्यकता होती है।

— जोनाथन फ्रीच

Answer 6

पायथन 3 - 109 107 103 102 90 93

एवपोक के रूप में एक ही विचार का उपयोग करना, लेकिन कई सुधारों के साथ।

n,m=map(int,input().split())
k=n/m+m/2
a=int(k)
print(*(range(a,a-m,-1),[-1])[k-a-.5or~a>-m])

सुधार हैं:

1. बाद में और '' से पहले अंतरिक्ष को खत्म करना। 1 वर्ण
2. विभाजन के अंदर '' को खत्म करना, क्योंकि रिक्त स्थान पर विभाजन एक डिफ़ॉल्ट है। 3 अक्षर
3. Divmod के अंदर -1 को -1 से +1 में कम करके x को कम करना, और फिर रेंज के उलट क्रम विकल्प का उपयोग करने के लिए रेंज फ़ंक्शन को बदलना। 3 अक्षर।
4. संपादित करें: ... अगर ... और ... ... और ... या ... 2 वर्णों में बदल गया।
5. संपादित करें: Divmod ने स्पष्ट, r को हटा दिया। 4 अक्षर।
6. संपादित करें: एक्स हटाया, एम // एन स्पष्ट रूप से इस्तेमाल किया। 1 वर्ण
7. EDIT: ने '' .join (मैप (str, ...)) के बजाय तारांकित अभिव्यक्तियों का उपयोग किया, दोहराए जाने वाले प्रिंट () से बचने के लिए x जोड़ा। 12 अक्षर।
8. संपादित करें: मुझे एहसास हुआ कि मैं सिक्कों की नकारात्मक संख्या को बौनों को देने की अनुमति दे रहा था। मैंने इससे बचने के लिए कोड बदल दिया।

Comments

अच्छी तरह से किया गया था, यह शिक्षाप्रद था :) मैंने अनावश्यक स्थान को छीनने के लिए अपना उत्तर बदल दिया, लेकिन बचाने के लिए आपकी चाल [::-1]मेरे समाधान से बेहतर है। +1

— एवपोक

मुझे कुछ याद आ रहा होगा, लेकिन मैंने 94 के बजाय 93 बाइट्स गिना।

— जोनाथन फ्रीच

Answer 7

पायथन 3 - 114

n,m=map(int,input().split(' '))
r=range(m);n-=sum(r)
if n%m<1:
 for x in r:print(m-x+n//m-1,end=' ')
else:print -1

यदि N-(M*(M-1)/2)समान रूप से विभाज्य है, तो जाँच करके काम करता है M। अजगर के लिए नया, इसलिए किसी भी सुझाव की सराहना की।

Ideone.com उदाहरण है

Input:
735 30
Output:
39 38 37 36 35 34 33 32 31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10

Comments

क्या कभी पायथन 3 संस्करण था जिसने पायथन 2 की printकथन शैली का समर्थन किया था ? या अंतिम पंक्ति ( else:print -1) में त्रुटि कैसे होती है?

— जोनाथन फ्रीच

Answer 8

सी # - 322

using System;using System.Linq;namespace D{class P{static void Main(string[]args){int n=Convert.ToInt16(args[0]);int m=Convert.ToInt16(args[1]);bool b=false;int q=n/2+1;g:b=!b;int[]z=new int[m];for(int i=0;i<m;i++){z[i]=q-i;}if(z.Sum()==n)foreach(int p in z)Console.Write(p+" ");else{q--;if(b)goto g;Console.Write(-1);}}}}

भयानक स्कोर लेकिन मैंने एक अलग दृष्टिकोण लिया और उपयोग करने के लिए मिला goto:)

मैं इसे बाद में छोटा करूंगा।

Comments

आप निश्चित रूप से उन सभी Convert.ToInt16कॉल को छोटा कर सकते हैं int.Parse। आप किसी भी पूर्व-नियत चर var(जैसे के बजाय int[]) की घोषणा कर सकते हैं । आपके कमांड-लाइन परम्स को कॉल करने की आवश्यकता नहीं है args। और आप अक्सर इस्तेमाल किए जाने वाले प्रकारों को उर्फ ​​कर सकते हैं using C = Console। मैं यह भी सोचता हूं कि इस समाधान के लिए, लाइन के अंतर को बेहतर तरीके से पेश करना बेहतर है, न कि केवल कुछ पात्रों को बचाने के बजाय। ओह, और मुझे वास्तव में यकीन नहीं है कि gotoयहां विकल्पों में से बेहतर क्यों है, या तो ...

— आरोहण

Answer 9

जावा 210

class A { public static void main(String[] a){int d=Integer.parseInt(a[0]),c=Integer.parseInt(a[1]);if (2*c%d==0) for (int i=0;i<d;i++) System.out.print((((1+(2*c/d)-d)/2)+i)+" "); else System.out.print(-1);}}

Comments

PPCG में आपका स्वागत है, मैंने देखा कि आपके पास बहुत सारे व्हाट्सएप हैं जिन्हें हटाया जा सकता है।

— pastebin.com 0mr8spkT

आप अपने उत्तर को थोड़ा और आगे बढ़ाने के लिए और अधिक स्थान खाली कर सकते हैं - उदाहरण के लिए, class A{public static void main(String[]a)वैध है, और आपको 3 वर्ण बचाता है। प्रत्येक के बाद if, और प्रत्येक के आसपास for, व्हाट्सएप को हटा दें ... आदि

— प्रोग्रामरडान

यह पागल है कि "सार्वजनिक स्थैतिक शून्य मुख्य (S) भाग पूरे J समाधान के रूप में लंबे समय तक है :)

— रॉबर्ट ग्रांट

Answer 10

आर: 77 73 70 चार्ट

a=scan();r=a[2]:1-1;while((n=sum(r))<a[1])r=r+1;cat(`if`(n>a[1],-1,r))

एक वेक्टर बनाएं (M-1) से 0 पर जा रहे हैं और प्रत्येक संख्या में 1 जोड़ते हैं जब तक कि योग N से नीच नहीं है। यदि यह बेहतर है, तो आउटपुट -1 और वेक्टर का उत्पादन करता है।

इंडेंटेड और थोड़ा अनगढ़

a=scan()   #Reads in stdin (by default numeric, space-separated)
r=a[2]:1-1 #Creates vector (M-1) to 0
while(sum(r)<a[1])r=r+1 #Increments all member of vector by 1 until sum is not inferior to N
cat( #Outputs to stdout
    `if`(sum(r)>a[1], -1, r) #If superior to N: impossible, returns -1
    )

उदाहरण का उपयोग:

> a=scan();r=a[2]:1-1;while((n=sum(r))<a[1])r=r+1;cat(`if`(n>a[1],-1,r))
1: 9 3
3: 
Read 2 items
4 3 2
> a=scan();r=a[2]:1-1;while((n=sum(r))<a[1])r=r+1;cat(`if`(n>a[1],-1,r))
1: 7 3
3: 
Read 2 items
-1
> a=scan();r=a[2]:1-1;while((n=sum(r))<a[1])r=r+1;cat(`if`(n>a[1],-1,r))
1: 204 17
3: 
Read 2 items
20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4

Answer 11

जूलिया, ४५

f(n,m)=(x=n/m-m/2+1/2;x%1==0?[x+m-1:-1:x]:-1)
julia> f(6,4)'
1x4 Array{Float64,2}:
 3.0  2.0  1.0  0.0

बस थोड़ा सा बीजगणित, मुझे इससे अधिक समय लगना चाहिए था, जितना होना चाहिए था।

Answer 12

जावास्क्रिप्ट - 76

ध्यान दें कि k + (k - 1) + ... + (k - (M - 1)) = M (k - (M - 1) / 2) इसको N के बराबर सेट करना k = N / M + (M) -1) / 2 उच्चतम राशि के लिए। यदि यह पूर्णांक है, तो k% 1 == 0 और हम जिन राशियों की तलाश कर रहे हैं वे k, k - 1, ..., k - (M - 1) हैं।

मैं शायद इसे दूसरी भाषा में लिख सकता था, लेकिन अभी तक यहाँ कोई जेएस समाधान नहीं था:

N=3;M=3;if((r=N/M+(M-1)/2)%1)console.log(-1);else while(M--)console.log(r--)

कंसोल में चलाएं।

उदाहरण इनपुट:

N=3;M=3;if((r=N/M+(M-1)/2)%1)console.log(-1);else while(M--)console.log(r--)

आउटपुट:

3
2
1 

इनपुट:

N=6;M=4;if((r=N/M+(M-1)/2)%1)console.log(-1);else while(M--)console.log(r--)

आउटपुट:

3
2
1
0

इनपुट:

N=7;M=3;if((r=N/M+(M-1)/2)%1)console.log(-1);else while(M--)console.log(r--)

आउटपुट: -1

बहुत बुरा कंसोल। वर्तनी के लिए इतना लंबा समय है :) दुर्भाग्य से घोषित करने से l=console.log.bind(console)यह कोई छोटा नहीं होता है, और बसl=console.log काम नहीं करता है।

इनपुट:

"N=3;M=3;if((r=N/M+(M-1)/2)%1)console.log(-1);else while(M--)console.log(r--)".length

आउटपुट:

76

Comments

आप इसका उपयोग कर सकते हैं c=consoleऔर c.log()इसे छोटा कर सकते हैं ।

— user2428118

Answer 13

गोल्फ, 35

~:M.(*2/-.M%{;-1}{M/M+,-1%M<' '*}if

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

निम्नलिखित उदाहरण में, इनपुट है 9 3।

          # STACK: "9 3"
~         # Interpret the input string.
          # STACK: 9 3
:M        # Store the top of the stack (number of dwarves) in variable `M'.
.         # Duplicate the top of the stack.
          # STACK: 9 3 3
(         # Decrement the top of the stack.
          # STACK: 9 3 2
*         # Multiply the topmost elements of the stack.
          # STACK: 9 6
2/        # Divide the top of the stack by `2'.
          # STACK: 9 3
          # So far, we've transformed `M' into `M*(M-1)/2', which is the minimum amount of
          # coins all dwarves together will get. This number comes from the fact that the
          # youngest dwarf will get at least 0 coins, the next at least 1 coin, etc., and
          # 0 + 1 + ... + (M - 1) = M*(M-1)/2.
-         # Subtract the topmost elements of the stack.
          # STACK: 6
          # The remaining coins have to get reparted evenly to all dwarves.
.         # Duplicate the top of the stack.
          # STACK: 6 6
M%        # Calculate the top of the stack modulus `M'.
          # STACK: 6 0
{         # If the modulus is positive, the remaining coins cannot get reparted evenly.
    ;-1   # Replace the top of the stack by `-1'.
}
{         # If the modulus is zero, the remaining coins can get reparted evenly.
    M/    # Divide the top of the stack by `M'.
          # STACK: 2
          # This is the number of coins all dwarves will get after giving 1 to the second
          # youngest, etc.
    M+    # Add `M' to the top of the stack.
          # STACK: 5
    ,     # Replace the top of the stack by an array of that many elements.
          # STACK: [ 0 1 2 3 4 ]
          # The rightmost element is the number of coins the oldest dwarf will get.
    -1%   # Reverse the array.
          # STACK: [ 4 3 2 1 0 ]
    M<    # Keep the leftmost `M' elements.
          # STACK: [ 4 3 2 ]
          # There are only `M' dwarves.
    ' '*  # Join the array, separating by spaces.
          # STACK: "4 3 2"
}if

Answer 14

डेल्फी एक्सई 3 (176)

uses SysUtils;var d,c,i:integer;begin read(c,d);for I:=1to d-1do c:=c-i;if c mod d>0then writeln(-1)else begin c:=c div d;for I:=d-1downto 0do write(IntToStr(i+c)+' ');end;end.

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

2 पूर्णांक, सिक्के और बौने पढ़ता है।
बौना प्रति अंतर को प्रतिस्थापित करता है।
यदि शेष मॉड बौना> 0 इसके असंभव है।
बौनों को प्रति बौने के लूप में 1 से 0 के बराबर और प्रिंट्स को बौनेइंडैक्स + के बराबर शेयर मिलते हैं

Ungolfed

uses SysUtils;
var
  d,c,i:integer;
begin
  read(c,d);
  for I:=1to d-1do
    c:=c-i;
  if c mod d>0then
    writeln(-1)
  else
  begin
    c:=c div d;
    for I:=d-1downto 0do
      write(IntToStr(i+c)+' ');
  end;
end.

Answer 15

गणितज्ञ ६५

कार्यक्रम, g लंबाई के सभी बढ़ते-बढ़ते एक-एक क्रम को उत्पन्न 0 से n तक और जाँच करता है कि उनमें से कोई भी मी के लिए योग करता है। यदि सफल, अनुक्रम वापस आ गया है; अन्यथा, -1 लौटा है।

क्रम से बनते हैं Partition सूची के {0,1,2,3… m} n सन्निहित पूर्णांकों के सभी संभव उपविभागों में।

बेशक, एक ही प्रभाव को प्राप्त करने के लिए अधिक कुशल तरीके हैं, लेकिन जो मैंने पाया है उन्हें अधिक कोड की आवश्यकता है।

n_~g~m_:=If[(s=Select[Partition[0~Range~n,m,1],Tr@#==n&])=={},-1,s]

उदाहरण

g[9, 3]

{{2, 3, 4}}

---

g[3, 3]

{{0, 1, 2}}

---

g[7, 3]

-1

---

g[705, 3]

{{234, 235, 236}}

---

g[840, 16]

{{45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60}}

---

g[839, 16]

-1

Answer 16

C 131

#include <edk.h>
main(int a,char **v){int j=atoi(*++v),k=atoi(*++v)-j*(j-1)/2;k<0||k%j?j=1,k=-1:k/=j;while(j--)printf("%d ",k+j);}

Ungolfed

#include <edk.h> //Shortest standard header including stdio.h and stdlib.h
main(int a,char **v)
{
    int j=atoi(*++v),k=atoi(*++v)-j*(j-1)/2;

    k<0||k%j?j=1,k=-1:k/=j;  // If youngest dwarf gets < 0 or amount not equally divisible then set values such that ...

    while(j--)printf("%d ",k+j); // ... loop prints out correct values
}

यह चेतावनी के साथ संकलित करता है क्योंकि मुख्य का कोई प्रकार नहीं है। यदि यह गोल्फ के नियमों में मान्य नहीं है, तो मुझे पांच चरित्र जोड़ने होंगे।

Answer 17

कोबरा - 198

कोबरा वेबसाइट

class P
    def main
        x,y=Console.readLine.split
        a,b=x to int,y to int
        l=[]
        t=n=0
        for i in b,t+=i
        while (t+=b)<=a,n+=1
        for i in b,l.insert(0,i+n)
        print if(t-b<>a,-1,l.join(" "))

व्याख्या की:

class P
    def main

कोड चलाने के लिए आवश्यक है

        x,y=Console.readLine.split
        a,b=x to int,y to int

इनपुट और दुकानों ले जाता है के रूप में aऔरb

        l=[]
        t=n=0

आउटपुट सूची को lआरम्भ करता है, और tप्रत्येक बौने ढेर में जोड़ने के लिए कुल आवश्यक धन और सिक्कों की संख्या को आरंभ करता हैn

        for i in b,t+=i

सबसे कम संभव पैसे का मूल्य पाता है जिसके परिणामस्वरूप सभी बौनों के पास उनके ढेर में सिक्कों की स्वीकार्य संख्या होगी

        while (t+=b)<=a,n+=1

निर्धारित करता है कि प्रत्येक ढेर में कितने सिक्के जोड़ने हैं ताकि कुल उपलब्ध धन> = = हो

        for i in b,l.insert(0,i+n)

पैसे के विभिन्न आकार के ढेर के साथ सूची को भरता है

        print if(t-b<>a,-1,l.join(" "))

आउटपुट या तो -1या lआधार पर कुल आवश्यक पैसा कुल उपलब्ध पैसे के बराबर है कि क्या

Answer 18

पर्ल 5 , 78 + 1 (एन) = 79 बाइट्स

($d)=/ (.*)/;$,=$";say(($b=$_-($d**2-$d)/2)%$d?-1:map$_+$b/$d,reverse 0..$d-1)

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

Answer 19

अजगर ( 100 96 94):

एक अच्छा, गोल-गोल जवाब। कोई और नहीं, लेकिन यह अब कम है।

def f(n,m):a=range(m)[::-1];b=n-sum(a);c=b/m;d=[i+c for i in a];return(d,-1)[-1in d or c*m!=b]

Ungolfed:

def f(n,m):
 a = range(m)[::-1]
 b = sum(a)
 c = (n-b)/m
 if c * m != n-b: return -1
 d = [i+c for i in a]
 return (d,-1)[-1 in d or c!=n-b]
 if -d in d or c*m!=n-b:
  return -1
 return d

आउटपुट:

def f(n,m):a=range(m)[::-1];b=sum(a);c=(n-b)/m;d=[i+c for i in a];return (d,-1)[-1 in d or c*m!=n-b]

f(3,3)
Out[2]: [2, 1, 0]

f(9,3)
Out[3]: [4, 3, 2]

f(7,3)
Out[4]: -1

f(6,4)
Out[5]: [3, 2, 1, 0]

Comments

यह इनपुट आवश्यकता का पालन नहीं करता है।

— ऑस्टिन हेनले

-1, प्रश्न के लिए एक पूरा कार्यक्रम लिखना होता है, न कि एक फंक्शन। देखें meta.codegolf.stackexchange.com/a/1146/8766

— user80551