योग हमेशा 15 होता है


36

एक प्रोग्राम या फ़ंक्शन लिखिए जो गैर-ऋणात्मक पूर्णांकों की एक सारणी को इनपुट के रूप में लेता है और आदेश में इनपुट सरणी के तत्वों के साथ वैक्टर / सरणियों के एक सेट को आउटपुट करता है, विभाजित करें ताकि प्रत्येक वेक्टर अधिकतम 15 तक हो जाए। यदि पहले का योग एन एलिमेंट्स "15 हिट" नहीं करते हैं, फिर जो संख्या इसे 15 पास करती है उसे काट दिया जाना चाहिए, और शेष अगले वेक्टर का पहला तत्व होगा। यह तब तक चलता है जब तक आप इनपुट ऐरे के अंत तक नहीं पहुँच जाते। यदि अंतिम सदिश का योग 15 से कम है, तो योग को ऊपर जाने के लिए अंत में एक संख्या जोड़ी जानी चाहिए।

मुझे लगता है कि नियमों को उदाहरणों को देखकर आसानी से समझा जा सकता है:

Input: 3 7 5 10
Output:
3 7 5           <- Sum is 15
10 5            <- 5 is added to make the sum 15

Input: 2 4 5 9 2 3 5 0 2 4 5 0 3
Output:
2 4 5 4          <- Sum 15. 9 is split in two. 
5 2 3 5          <- The first 5 is the remainder of 9
0 2 4 5 0 3 1    <- The last number is added to make the sum 15

Input: 1 1 1            
Output:
1 1 1 12         <- The number 12 is added to make the sum 15

Input: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17
Output:
1 2 3 4 5
6 7 2           <- 2 is the first part of 8
6 9             <- 6 is the remainder of 8
10 5            <- 5 is first part of 11
6 9             <- 6 is remainder of 11. 9 is first part of 12
3 12            <- 3 is remainder of 12. 12 is first part of 13
1 14            <- 1 is remainder of 13. 14 is 14
15
15              <- 15 is first part of 16
1 14            <- 1 is remainder of 16. 14 is first part of 17
3 12            <- 3 is remainder of 17. 12 is added to make the sum 15

Input: 20 20
Output:
15
5 10           <- 5 is remainder from the first 20
10 5           <- 10 is remainder from second 20. 5 is added to make the sum = 15.

इनपुट और आउटपुट फॉर्मेट दोनों वैकल्पिक हैं। आपकी भाषा में जो कुछ भी श्रेष्ठ है।

बाइट्स में सबसे छोटा कोड जीतता है।


लीडरबोर्ड

इस पोस्ट के निचले हिस्से में स्टैक स्निपेट उत्तर से सूची बनाता है) क) प्रति भाषा में सबसे छोटे समाधान की सूची के रूप में और बी) एक समग्र लीडरबोर्ड के रूप में।

यह सुनिश्चित करने के लिए कि आपका उत्तर दिख रहा है, कृपया अपना उत्तर शीर्षक मार्कडाउन टेम्पलेट का उपयोग करके शीर्षक के साथ शुरू करें:

## Language Name, N bytes

Nआपके प्रस्तुत करने का आकार कहां है। यदि आप अपने स्कोर में सुधार करते हैं, तो आप पुराने अंकों को हेडलाइन में रख सकते हैं , उनके माध्यम से स्ट्राइक करके। उदाहरण के लिए:

## Ruby, <s>104</s> <s>101</s> 96 bytes

यदि आप अपने हेडर में कई संख्याओं को शामिल करना चाहते हैं (जैसे कि आपका स्कोर दो फ़ाइलों का योग है या आप दुभाषिया ध्वज दंड को अलग से सूचीबद्ध करना चाहते हैं), तो सुनिश्चित करें कि हेडर में वास्तविक अंक अंतिम संख्या है:

## Perl, 43 + 2 (-p flag) = 45 bytes

आप भाषा के नाम को एक लिंक भी बना सकते हैं जो बाद में स्निपेट में दिखाई देगा:

## [><>](http://esolangs.org/wiki/Fish), 121 bytes


'आउटपुट स्वरूप वैकल्पिक है'। क्या इसका मतलब [[3, 7, 5], [10, 5]]यह है कि पहले परीक्षण मामले के लिए एक वैध आउटपुट होगा?
मॉर्गन थ्रैप

@ मॉर्गनट्रैप, हाँ। यह मान्य है।
स्टीवी ग्रिफिन

1
@FlagAsSpam, मैंने आपके द्वारा पूछे जा रहे उदाहरण में और स्पष्टीकरण जोड़ दिए हैं।
स्टीवी ग्रिफिन

3
अच्छा परीक्षण मामला:Input: 100 Output: 15; 15; 15; 15; 15; 15; 10 5
रैंडम डे

3
यह निश्चित रूप से FizzBuzz परीक्षण
CS

जवाबों:


8

पायथ, 37 बाइट्स

K15VQ=+ZNIgZK=-ZK-NZbIZZ)).?N;I>KZ-KZ

व्याख्या की

K15              Store 15 in K (the max) (K is Autoinitializing, no = needed here)
VQ              For N in the evaluated input
  =+ZN           Set Z(Which in pyth defaults to 0) to Z+N
  IgZK           If Z(row total) is greater than or equal to K (row max)
    =-ZK         Set Z to Z-K (How much the max was exceeded)
    -NZ          Implicitly print N-Z
    b            Implicitly print b (in pyth defaults to a newline)
    IZ         If Z > 0 (There was excess to carry to the next row)
      Z          Implicitly print Z (the excess)
  .?N            Else(the current row count is < the max(15)) output the current number
;                Use infinite )'s in place of )) (to save 1 character)
I>KZ             If K > Z (The max is greater than the current row count)
  -KZ           Implicitly print K-Z (The amount needed for the row to equal 15)

यह मेरी पहली चिता थी, इसलिए बेहिचक सुझाव दें।

उदाहरण:

इनपुट

[1, 3, 4, 5, 9, 8]

उत्पादन

1
3
4
5
2


7
8

नोट: आकार में कटौती की सलाह के कई बाइट्स और पहली जगह में अजगर बनाने के लिए बहुत धन्यवाद! कृपया अपनी टिप्पणी नीचे दें :)


2
.?इसके बजाय हाल ही में बदल दिया गया था E, लेकिन मैं डॉक्स अपडेट करना भूल गया। उसके लिए माफ़ करना।
isaacg

@isaacg isaacg धन्यवाद! मुझे अब वह काम करना चाहिए। हालांकि यह केवल 1 बाइट बचाता है क्योंकि बाकी 2 अक्षर हैं।
19ga पर csga5000

1
हम बोलते हुए इसे ठीक कर रहे हैं।
isaacg 19

3
कुछ अन्य सुझाव: =Z+ZNऔर =+ZNसमान हैं। यह पाइथन की तरह एक सा है +=। इसी तरह, =Z-ZK-> =-ZK। इसके अलावा, आपको )अंत में ज़रूरत नहीं है - यह स्वचालित रूप से भर जाता है। अंत में, FNQऔर VQसमान हैं।
isaacg

1
आप की जगह एक और 2 बाइट बचा सकता है I>Z0के साथ IZ- Zनकारात्मक नहीं हो सकता है, तो आप वास्तव में सिर्फ अगर जाँच कर रहे हैं Zशून्य नहीं है, और शून्य falsy है, जबकि अन्य सभी संख्या truthy हैं।
isaacg

16

जावा - 229 200 192 181 172 170 168 बाइट्स

जीत के लिए नहीं बल्कि मस्ती के लिए पहले से ही शुरू किया गया था :)
किसी भी सुझाव का स्वागत है।

सहेजे गए 8 बाइट्स @ThomasKwa के लिए धन्यवाद
20 बाइट्स धन्यवाद @corsiKa
के लिए धन्यवाद 2 बाइट्स सहेजे गए @Ypnypn
के लिए धन्यवाद 2 बाइट्स के लिए धन्यवाद @ user902383

String p(int[]a){int c=0,j;String s="";f:for(int i:a){for(j=i;j-->0;)if(++c>14){s+=(i-j)+"\n";c=0;if(j<15){if(j>0)s+=j+" ";c+=j;continue f;}}s+=i+" ";}return s+(15-c);}

170 बाइट्स

String p(int[]a){int c=0,j;String s="";f:for(int i:a){for(j=i;j-->0;){if(++c>14){s+=(i-j)+"\n";c=0;if(j<15){if(j>0)s+=j+" ";c+=j;continue f;}}}s+=i+" ";}return s+(15-c);}

172 बाइट्स

String p(int[]a){int c=0,j;String s="";f:for(int i:a){for(j=i;j>0;){j--;if(++c>14){s+=(i-j)+"\n";c=0;if(j<15){if(j>0)s+=j+" ";c+=j;continue f;}}}s+=i+" ";}return s+(15-c);}

181 बाइट्स

void p(int[]a){int c=0,j;String s="";f:for(int i:a){for(j=i;j>0;){j--;if(++c>14){s+=(i-j)+"\n";c=0;if(j<15){if(j>0)s+=j+" ";c+=j;continue f;}}}s+=i+" ";}System.out.print(s+(15-c));}

192 बाइट्स

void p(int[]a){int c=0,j;String s="";f:for(int i:a){for(j=i;j>0;){j--;c++;if(c==15){s+=(i-j)+"\n";c=0;if(j>=15)continue;if(j>0)s+=j+" ";c+=j;continue f;}}s+=i+" ";}System.out.print(s+(15-c));}

200 बाइट्स

void p(int[]a){int c=0,j;String s="";f:for(int i:a){j=i;while(j>0){j--;c++;if(c==15){s+=(i-j)+"\n";c=0;if(j>=15)continue;else{if(j!=0)s+=j+" ";c+=j;continue f;}}}s+=i+" ";}System.out.print(s+(15-c));}

229 बाइट्स

void p(int[]a){int c=0,j;f:for(int i:a){j=i;while(j>0){j--;c++;if(c==15){System.out.print(i-j+"\n");c=0;if(j>=15){continue;}else{if(j!=0)System.out.print(j+" ");c+=j;continue f;}}}System.out.print(i+" ");}System.out.print(15-c);}

String p(int[] a) {
    int c = 0, j;
    String s = "";
    f: for (int i: a) {
        for (j = i; j-- > 0;)
            if (++c > 14) {
                s += (i - j) + "\n";
                c = 0;
                if (j < 15) {
                    if (j > 0) s += j + " ";
                    c += j;
                    continue f;
                }
            }
        s += i + " ";
    }
    return s + (15 - c);
}

1
वाह, नहीं देखा था वास्तव में एक जावा कार्यक्रम में अब तक इस्तेमाल किया।
मैजिक ऑक्टोपस Urn

7

पायथन 3 - 1̶7̶7on 1̶3̶8̶ 1̶6̶6 3 1̶3̶3̶ 113

s=0
i=15
p=print
for e in eval(input()):
 if s>=i:p()
 s=s%i+e
 if s>i:s-=i;p(e-s);p();e=s
 p(e)
if s!=i:p(i-s%i)

संपादित करें 5 सच में गोल्फ के लिए धन्यवाद @poke * हटाए गए लाइन ब्रेक आदि

एक बाइट को बचाने के लिए 4 अलियासाइड प्रिंट संपादित करें , और एक = = के साथ प्रतिस्थापित किया। @Poke और @elzell को धन्यवाद। इसके अलावा 2 बाइट्स को असाइनमेंट से बचाने के लिए लूप के लिए इनपुट इवाॅल ले जाया गया

संपादित करें 3 अगर दूसरे के अंदर विभिन्न OO में बचत मिली

संपादित 2 फिक्स्ड बग

1 संपादित करें इनपुट को '[1,2,3,4,5 ...]' रूप में होने के लिए बदल दिया है, और पहले दो टिप्पणियों को लागू किया है, @ मॉर्गन थ्राप को बड़ा धन्यवाद

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


3
आप इसे 15 से एक चर में 15 असाइन करके और केवल इंडेंटेशन के लिए एक स्थान का उपयोग करके प्राप्त कर सकते हैं।
मॉर्गन थ्रैप

इसके अलावा, आप दूसरे टेस्ट केस में फेल हो जाते हैं, मुझे 2 3 5 मिलते हैं, लेकिन यह 5 2 3 5. होना चाहिए
Morgan Thrapp

1
@AdamMartin आपको अपने कोड के मेरे पायथ संस्करण में दिलचस्पी हो सकती है
सीएसजीए 5000

1
चूंकि आप printइतनी बार उपयोग कर रहे हैं , इसलिए आपको इसे एक चर के रूप में सहेजना चाहिए p=print:। आपको एक और 14 अक्षर बचाता है।
प्रहार

2
करंट काउंट 132 है, लेकिन यदि आप कुछ लाइन ब्रेक को हटाते हैं तो आप इसे 113 तक ले जा सकते हैं। आप एक पंक्ति में हर जोड़ सकते हैं, जैसे if s>i:s-=i;p(e-s);p();e=sदूसरे के लिए। यह आपको लाइन ब्रेक और इंडेंटेशन वर्ण बचाता है।
प्रहार

7

हास्केल, 126 107 102 100 बाइट्स

[]#c=[]
(h:t)#c|s<0=t#u|s<1=u:t#[]|1<2=(c++[h-s]):(s:t)#[]where s=sum c+h-15;u=c++[h]
(#[]).(++[14])

उपयोग उदाहरण: (#[]).(++[14]) $ [1..17]->[[1,2,3,4,5],[6,7,2],[6,9],[10,5],[6,9],[3,12],[1,14],[15],[15],[1,14],[3,12]]

संपादित करें: @Stewie ग्रिफिन ने मुझे 19 बाइट बचाने में मदद की। धन्यवाद!


4

CJam, 39 बाइट्स

q~0af*Sf*N*30/{S-N/:,F1$:+-+0+e`W<e~p}/

इसका परीक्षण यहां करें।

यह बहुत ही अडॉप्टिमल लगता है, लेकिन अब तक एक छोटे से समाधान में मेरे सभी प्रयासों को इनपुट में शून्य की उपस्थिति से नाकाम कर दिया गया है।


4

RegEx द्वारा संचालित पायथन 2 : 158 155 बाइट्स

प्यार और लगभग कोई गणित के साथ अजगर में बनाया गया।
या रेगेक्स मैथ अगर आप करेंगे, तो मैथ्स।
'रियल' गणित का उपयोग केवल अंतिम आवश्यकता को 'ठीक' करने के लिए किया जाता है:

यदि अंतिम सदिश का योग 15 से कम है, तो योग को ऊपर जाने के लिए अंत में एक संख्या जोड़ी जानी चाहिए।

Codegolfed:

import re
def f(i):o=[map(len,p.split())for p in re.findall('((?:x *){15}|.+)',' '.join(['x'*c for c in i]))];l=sum(o[-1]);o[-1]+=([],[15-l])[l<15];print o

जिस तरह से यह काम करता है वह प्रत्येक संख्या एन को लंबाई एन के एक स्ट्रिंग में परिवर्तित करके होता है ( एक्स को स्ट्रिंग को भरने के लिए चार के रूप में चुना जाता है) और उन सभी को एक अलग अंतरिक्ष में शामिल किया जाता है string। परिणामी स्ट्रिंग RegEx BLACK MAGIC के माध्यम से कुछ इस तरह विभाजित की जाती है:

['x xx xxx xxxx xxxxx ', 'xxxxxx xxxxxxx xx', 'xxxxxx xxxxxxxxx', 'x']

एक इनपुट के लिए जैसे: f([1, 2, 3, 4, 5, 6, 7, 8, 10])
कि फिर से विभाजित है, और लगातार xes की लंबाई फिर से संख्या बनाने के लिए उपयोग किया जाता है, सब कुछ एक सूची समझ में अच्छी तरह से पैक।

Ungolfed:

import re
o = [map(len, p.split()) for p in re.findall('((?:x *){15}|.+)', ' '.join(['x'*c for c in i]))]
l = sum(o[-1])
o[-1] += ([], [15-l])[l<15]
print o

आउटपुट:

>>> f([30, 1, 2, 3, 4, 5, 6, 7, 8, 9, 16])
[[15], [15], [1, 2, 3, 4, 5], [6, 7, 2], [6, 9], [15], [1, 14]]

नोट: 0 के लिए पर्याप्त जादू नहीं था इसलिए यह प्रविष्टि अयोग्य घोषित कर देती है

शून्य शामिल होना चाहिए। दूसरा उदाहरण देखें


उन सभी फ़ंक्शन नाम बल्कि महंगे हैं। कोड गोल्फ में लगभग असंभव की तरह कुछ का उपयोग कर बनाता है। फिर भी, आपके बाइट का आकार बुरा नहीं है
csga5000

4

गंभीरता से, 88 बाइट्स

,`'!*'0`M' j0╗`;;;'|ε35*('!=╜+;╗%(' =|('0=|I)`Mεj'|@s`ôl`╝`ö'0@s╛M`Md;Σ35*-;`X``@q`Iƒ@q.

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

यह मेरा पहला गंभीर जवाब है! अब मैं सभी भाषा की कमियों से परिचित हूँ!

हेक्स डंप:

2c6027212a2730604d27206a30bb603b3b3b277cee33352a2827213dbd2b3bbb252827203d7c2827303d7c49
29604dee6a277c407360936c60bc609427304073be4d604d643be433352a2d3b60586060407160499f40712e

स्पष्टीकरण:

,`'!*'0`M' j         Replace all the numbers by "0"+"!"*n, separated by " "
0╗                   Initialize an accumulator in register 0
` ... `M             Map the string with the following function:
   ;;;'|ε                Put three extra copies of the character, a pipe, an empty string
   35*                   and a 15 on the stack.
   ('!=                  Move one copy of the character to the top and push 1 if it's a !
   ╜+                    Load the accumulator, add the 1 or 0 from the preceding test
   ;╗                    Make a copy, and save it back to register 0
   %                     Modulo the sum by 15
   (' =|                 Or the result with whether the dug-up character is " "
   ('0=|                 Or the result with whether the dug-up character is "0"
   I                     If we're at " " or "0" or the current sum is not divisible by 15,
                         push empty string, else push "|"
   )                     Bury the new character under the original character.
εj                   Join the list that resulted from the map into a single string.
'|@s                 Resplit the string on occurrences of "|" (after every 15 "!"s)
`ôl`╝                Store a function in register 1 which trims whitespace
                     and returns the length of the remaining string
` ... `M             Map the list with the following function:
   ö                     Trim leading spaces.
   '0@s                  Split the string on occurrence of "0"
   ╛M                    Map the resulting list with the function stored in register 1
d;                   Push the last sublist from the resulting list and make a copy.
Σ                    Find the sum of the list.
35*-                 Subtract it from 15
;`X``@q`Iƒ           Duplicate it, drop it if it's zero, put it in the list otherwise.
@q.                  Put the list back in the big list and print it.

यदि यूनिकोड कोड बिंदु का उपयोग किया जाता है, तो क्या उन वर्णों को 2 बाइट्स के रूप में गिना जाता है? : पी
दान

मैं यूनिकोड को चित्रित स्रोत में उपयोग कर रहा हूं ताकि इसे देखने के तरीके के रूप में पढ़ा जा सके। अन्यथा यह बिना किसी अवरोध के भरा हुआ कचरा जैसा लगेगा। आधिकारिक स्रोत हेक्स डंप है।
क्विंटोपिया

इसका मतलब एक हास्य प्रश्न था
दान

1
यह एक वाजिब सवाल भी था कि कोई दूसरा पाठक आश्चर्यचकित हो जाए, इसलिए मैंने इसे हास्यप्रद ढंग से उत्तर दिया।
क्विंटोपिया

@quintopia +1 एक नई गोल्फ भाषा आज़माने के लिए! नई भाषाएं मज़ेदार हैं;) मैंने इस प्रश्न पर पहली बार अपने लिए अजगर की कोशिश की।
csga5000

3

जावास्क्रिप्ट, 138 128 बाइट्स

i=>eval("for(o=z=n='',m=15,t=q=0;q<i.length;q++)(t+=c=+i[q])>=m?(t-=m,z+=c-t,o+=z+`\n`,z=t>0?t+' ':n):z+=c+' ';t<m?o+z+(m-t):o")

व्हॉट्सएप के साथ:

i => eval("
  for(o=z=n='', m=15, t=q=0; q < i.length; q++)
    (t+=c=+i[q])>=m
      ?(
        t-=m,
        z+=c-t,
        o+=z+`\n`,
        z=t>0?t+' ':n)
      :
        z+=c+' '
    ;
  t<m ? o+z+(m-t) : o
")

उदाहरण:

फ़ंक्शन को एक चर पर असाइन करें

sumFifteen=i=>eval("for(o=z=n='',m=15,t=q=0;q<i.length;q++)(t+=c=+i[q])>=m?(t-=m,z+=c-t,o+=z+`\n`,z=t>0?t+' ':n):z+=c+' ';t<m?o+z+(m-t):o")

फिर इसका मूल्यांकन करें:

console.log(sumFifteen([1,4,11,4,5]))

1 4 10
1 4 5 5

संशोधन इतिहास:

12/3/2015 00:02 - 10 बाइट सुधार के लिए user81655 (टिप्पणियों में उन्हें +1) के लिए धन्यवाद

12/2/2015 21:44 - आकार कम करने के लिए कार्यात्मक शैली का उपयोग करने के लिए स्विच किया गया।


3
आप इसके साथ इसे सुधार सकते हैं: f=साइट नियमों के अनुसार इसकी आवश्यकता नहीं है, कोष्ठक को हटा दें (i), चारों ओर से घेरें evalताकि आपको returnया ब्रैकेट की आवश्यकता न हो और ifएक टर्नरी के साथ बदल दिया जाए ताकि oबदल '\n'जाए और हटाने के लिए `\n`मर्ज t+=...करें t>=mपाश कोष्ठक। यहाँ इन सभी सुधारों के साथ 127 बाइट्स में आपका समाधान है:i=>eval("for(o=z=n='',m=15,t=q=0;q<i.length;q++)(t+=c=+i[q])>=m?(t-=m,z+=c-t,o+=z+`\n`,z=t>0?t+' ':n):z+=c+' ';t<m?o+z+(m-t):o")
user81655

@ user81655 मैं उनमें से कुछ परिवर्तनों को लागू करूँगा! जब मैं तुम्हारी कोशिश करता हूं तो मुझे एक SytaxError मिलती है: अप्रत्याशित टोकन ILLEGAL (...)। ध्यान दें, फ़ंक्शन का परीक्षण करने के लिए मैंने f = जोड़ा
csga5000

1
SO o+पंक्ति के अंत में कुछ प्रतीक जोड़ता है । हटाएं o+=zऔर इसे फिर से लिखें और यह काम करेगा। : पी
user81655

@ user81655 मैं नहीं देखता कि कैसे \n कोई फर्क पड़ता है
csga5000

1
आप मतलब है `\n`? यह इसके बिना काम नहीं करेगा क्योंकि कोड अंदर "..."होने के कारणeval
user81655

2

पायथन 3: 139 बाइट्स

अन्य उत्तर की तुलना में थोड़ा अलग दृष्टिकोण। प्रश्न से वास्तविक उत्पादन का उत्पादन करता है क्योंकि मैंने शुरू में यह मान लिया था कि यह एक आवश्यकता थी।

def f(l):
 m=15;r,s=sum(l)%m,0
 if r:l+=[m-r]
 while l:
  x=l.pop(0)
  if s+x>m:y=m-s;l[0:0]=[x-y];x=y
  s+=x;print(x,end=' \n'[s==m]);s%=m

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

>>> f([2, 4, 5, 9, 2, 3, 5, 0, 2, 4, 5, 0, 3])
2 4 5 4
5 2 3 5
0 2 4 5 0 3 1

2

पर्ल, 86 बाइट्स

#!perl -p
s|\d+( ?)|($i+=$&)<15?$&:($a=$&-($i%=15)).$/.($&>$a&&$&-$a.$1)|ge;$\=$".(15-$i)if$i

शेबंग को तीन के रूप में गिना, इनपुट को स्टडिन से लिया गया, अंतरिक्ष अलग हो गया।


नमूना उपयोग

$ echo -n 2 4 5 9 2 3 5 0 2 4 5 0 3 | perl sum15.pl
2 4 5 4
5 2 3 5
0 2 4 5 0 3 1

2

आर, 155 बाइट्स

n=scan();while(S<-sum(n)){C=cumsum(n);if(S>14){w=which(C>14)[1];N=n[1:w];n=n[-(1:w)];r=C[w]-15;N[w]=N[w]-r;if(r)n=c(r,n);cat(N,"\n")}else{cat(n,15-S);n=0}}

इंडेंट और लाइनब्रेक के साथ:

n=scan()
while(S<-sum(n)){
     C=cumsum(n)
     if(S>14){
         w=which(C>14)[1]
         N=n[1:w]
         n=n[-(1:w)]
         r=C[w]-15
         N[w]=N[w]-r
         if(r) n=c(r,n)
         cat(N,"\n")
         }else{
            cat(n,15-S)
             n=0
             }
      }

उपयोग:

> n=scan();while(S<-sum(n)){C=cumsum(n);if(S>14){w=which(C>14)[1];N=n[1:w];n=n[-(1:w)];r=C[w]-15;N[w]=N[w]-r;if(r)n=c(r,n);cat(N,"\n")}else{cat(n,15-S);n=0}}
1: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17
18: 
Read 17 items
1 2 3 4 5 
6 7 2 
6 9 
10 5 
6 9 
3 12 
1 14 
15 
15 
1 14 
3 12
> n=scan();while(S<-sum(n)){C=cumsum(n);if(S>14){w=which(C>14)[1];N=n[1:w];n=n[-(1:w)];r=C[w]-15;N[w]=N[w]-r;if(r)n=c(r,n);cat(N,"\n")}else{cat(n,15-S);n=0}}
1: 20 20
3: 
Read 2 items
15 
5 10 
10 5
> n=scan();while(S<-sum(n)){C=cumsum(n);if(S>14){w=which(C>14)[1];N=n[1:w];n=n[-(1:w)];r=C[w]-15;N[w]=N[w]-r;if(r)n=c(r,n);cat(N,"\n")}else{cat(n,15-S);n=0}}
1: 10 5
3: 
Read 2 items
10 5 
> n=scan();while(S<-sum(n)){C=cumsum(n);if(S>14){w=which(C>14)[1];N=n[1:w];n=n[-(1:w)];r=C[w]-15;N[w]=N[w]-r;if(r)n=c(r,n);cat(N,"\n")}else{cat(n,15-S);n=0}}
1: 2 4 5 9 2 3 5 0 2 4 5 0 3
14: 
Read 13 items
2 4 5 4 
5 2 3 5 
0 2 4 5 0 3 1

2

पायथन 2, 117 बाइट्स

i=input()
while i:
 s=15;r=[]
 while s>0:n=i.pop(0)if i else s;s-=n;r+=[n]if s>=0 else[n+s]
 if s<0:i=[-s]+i
 print r

सूची के रूप में इनपुट लेता है:

>>[2,4,5,9,2,3,5,0,2,4,5,0,3]
[2, 4, 5, 4]
[5, 2, 3, 5]
[0, 2, 4, 5, 0, 3, 1]

1

पर्ल, 76 बाइट्स

+3 के लिए -p(सामान्य रूप से +1, लेकिन +3 अन्य पर्ल समाधान के साथ निष्पक्ष खेलने के लिए) शामिल है

STDIN पर इनपुट के साथ चलाएं (इनपुट पर अंतिम नई पंक्ति वैकल्पिक है, लेकिन खाली इनपुट के लिए अनुपस्थित होना चाहिए )

sum15.pl <<< "1 2 3"

sum15.pl:

#!/usr/bin/perl -p
s/$/ 15/;s/\d+/1x$&/eg;s/( *1){15}\K ?/
/g;s/
1*
*$//;s/1+|\B/length$&/eg

देखो मा, कोई गणना नहीं ...


देर आए दुरुस्त आए! बहुत अच्छा समाधान हालांकि :)
दादा

0s इस समाधान में अधिक मुश्किल हैं (अतिरिक्त स्थानों द्वारा दर्शाया गया है) और मुझे 0s की संख्या को सही रखने के लिए रिक्त स्थान को ठीक से संभालने के लिए बहुत सावधान रहना होगा । विशेष रूप से उन इनपुटों पर विचार करें जहां एक आंशिक राशि 15 बिल्कुल पसंद है 1 14 2 13। `` के बिना उन्हें आज़माएं और देखें कि क्या होता है
टन इंस्पिरेशन

हां, मैंने इसे आज़माया और देखा कि 0 की जहाँ कुछ पंक्तियों की शुरुआत में जोड़ा गया है, जैसे आप कहते हैं (इसीलिए मैंने इसे पोस्ट करने के 30 सेकंड बाद अपनी टिप्पणी हटा दी)। धन्यवाद
दादा

0

जावा - 158 155 बाइट्स

यसिन-हाजाज द्वारा https://codegolf.stackexchange.com/a/65590/46866 का लैम्ब्डा संस्करण , निश्चित रूप से वैध जमा होने पर निश्चित नहीं है, लेकिन लिंक किए गए उत्तर पर टिप्पणी जोड़ने के लिए पर्याप्त प्रतिनिधि नहीं है। Http://meta.codegolf.stackexchange.com/questions/4944/byte-counter-nnippet का उपयोग करके गिना गया

a->{int c=0,j;String s="";f:for(int i:a){for(j=i;j-->0;)if(++c>14){s+=(i-j)+"\n";c=0;if(j<15){if(j>0)s+=j+" ";c+=j;continue f;}}s+=i+" ";}return s+(15-c);}

158 बाइट्स

a->{int c=0,j;String s="";f:for(int i:a){for (j=i;j-->0;)if(++c>14){s+=(i-j)+ "\n";c=0;if(j<15){if(j>0)s+=j+" ";c+=j;continue f;}}s+=i+ " ";}return s+(15-c);}

Ungolfed

a ->
    {
        int c=0, j;
        String s = "";
        f:
        for (int i : a) {
            for (j = i; j-- > 0; )
                if (++c > 14) {
                    s += (i - j) + "\n";
                    c = 0;
                    if (j < 15) {
                        if (j > 0) s += j + " ";
                        c += j;
                        continue f;
                    }
                }
            s += i + " ";
        }
        return s + (15 - c);
    }

की तरह इस्तेमाल किया जा सकता है

Function<int[], String> func =a->{int c=0,j;String s="";f:for(int i:a){for (j=i;j-->0;)if(++c>14){s+=(i-j)+ "\n";c=0;if(j<15){if(j>0)s+=j+" ";c+=j;continue f;}}s+=i+ " ";}return s+(15-c);};
System.out.println(func.apply(new int[]{2, 4, 5, 9, 2, 3, 5, 0, 2, 4, 5 ,0 ,3}));
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.