सरलीकृत गुडस्टीन अनुक्रम आउटपुट

Question

एक संख्या बेस-बी सरलीकृत गुडस्टीन फॉर्म में है यदि यह लिखा जाता है

b + b + ... + b + c,   0 < c ≤ b

किसी संख्या का सरलीकृत गुडस्टोन अनुक्रम आधार -1 में संख्या लिखने के साथ शुरू होता है, फिर गुडस्टेन रूप में सभी 1 को प्रतिस्थापित करता है और 2 को घटाता है। आधार -2 में परिणाम को घटाता है, गुडस्टेन के रूप को सरल बनाता है, फिर सभी 2 को 3 के साथ और 1 घटाता है। , आदि जब तक आप 0 तक नहीं पहुँचते।

आपका कार्यक्रम एक सकारात्मक पूर्णांक इनपुट और आउटपुट लेना / उसके गुडस्टाइन अनुक्रम को प्रिंट करना और समाप्त करना है। आपका कार्यक्रम 100 से कम संख्या को संभालना चाहिए, हालांकि यह उचित समय में समाप्त नहीं हो सकता है।

उदाहरण के लिए, इनपुट के रूप में दिए गए 3, आपका प्रोग्राम आउटपुट होना चाहिए (दाईं ओर सिर्फ स्पष्टीकरण है)

1 + 1 + 1                | 3 = 1 + 1 + 1
2 + 2 + 1                | Change 1's to 2's, then subtract 1. (2 + 2 + 2 - 1 = 2 + 2 + 1)
3 + 3                    | 3 + 3 + 1 - 1 = 3 + 3
4 + 3                    | 4 + 4 - 1 = 4 + 3
5 + 2                    | 5 + 3 - 1 = 5 + 2
6 + 1                    | 6 + 2 - 1 = 6 + 1
7                        | 7 + 1 - 1 = 7
7                        | 8 - 1 = 7
6                        | Numbers are now lower than the base, so just keep subtracting 1.
5                        |
4                        |
3                        |
2                        |
1                        |
0                        | End

रिक्ति कोई फर्क नहीं पड़ता।

---

जीत की कसौटी:

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

Comments

क्या अंतिम 0 को शामिल करना आवश्यक है?

— केएसएबी

@ संक ह्म .... नहीं, मुझे नहीं लगता।

— बस सुंदर कला

Answer 1

05AB1E , 19 बाइट्स

Å1[D'+ý,N>D>:`Ž<)0K

के रूप में भी पुनर्व्यवस्थित किया जा सकता है >Å1[ND>:`Ž<)0KD'+ý,

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

व्याख्या

Å1                    # push a list of 1's the length of the input
  [                   # start a loop
   D                  # duplicate the current list
    '+ý,              # join on "+" and print
        N>D>:         # replace <current_iteration>+1 with <current_iteration>+2
             `        # flatten the list to the stack
              Ž       # break loop if the stack is empty
               <      # decrement the top number
                )     # wrap the stack in a list
                 0K   # remove zeroes

Answer 2

अजगर 2, 77 74 बाइट्स

-3 बाइट्स लिन का धन्यवाद

n=input();b=1
while n:print"+".join(n/b*[`b`]+[`n%b`][:n%b]);n+=n/b-1;b+=1

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

आसानी से n = 100 तक चलता है (हालांकि आउटपुट पूरी तरह से टियो शो के लिए बहुत लंबा है)।

Comments

"रिक्ति से कोई फर्क नहीं पड़ता", इसलिए आप वहां ठीक हैं।

— बस सुंदर कला

STDIN से इनपुट पढ़कर एक बाइट को बचाएं:n=input() b=1 while n:…

— लिन

और दो के साथ n+=n/b-1;b+=1। 74 बाइट्स

— लिन

@SimplyBeautifulArt फिक्स्ड

— केएसएबी

@SimplyBeautifulArt यह जाहिरा तौर पर जबकि पाश के साथ क्या करना है, आप एक whileनिम्नलिखित नहीं डाल सकते हैं ;। मेरा अनुमान है कि ऐसा इसलिए है क्योंकि यदि रेखा को whileप्रत्येक निम्नलिखित कथन (अर्धविराम द्वारा अलग किया गया) के साथ शुरू किया जाता है, तो उसके दायरे के अंदर माना जाता है और व्यवहार अस्पष्ट या कम से कम कुछ हद तक अपारदर्शी होगा

— KSab

Answer 3

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

WQ=hZj\++*]Z/QZ<]J%QZJ=+Qt/QZ

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

Answer 4

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

(s=1~Table~#;i=1;While[s!={},Print@StringRiffle[ToString/@s,"+"];s=s/.i->i+1;s=Join[Most@s,{Last@s}-1]~DeleteCases~0;i++])&

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

Answer 5

पायथन 3, 155 बाइट्स

n=int(input());l=[1]*(n+1);i=0
while l:
    l=[t+1 if t==i else t for t in l];l[-1]-=1;l=l[:-1] if l[-1]==0 else l;print("+".join(list(map(str,l))));i+=1

इसमें सुधार किया जा सकता है

n = int(input())
l = [0]*(n+1)
i = 0
while l:
    l = [t+1 if t==i else t for t in l]
    if l[-1] == 0:
        l = l[:-1]
    print("+".join(list(map(str,l))))
    i += 1

Comments

आप की पहली पंक्ति याद आती है 1+1+..., और ध्यान दें कि आपका प्रोग्राम किसी भी सकारात्मक पूर्णांक इनपुट को संभालने वाला है।

— बस सुंदर कला

हाँ कृपया। इसके अलावा, MathJax इस साइट पर काम नहीं करता है: P

— बस सुंदर कला

मेरे लिए, ऐसा प्रतीत होता है कि आपने एक के बजाय अपने गोल्फ संस्करण में एक स्थान रखा है +।

— बस सुंदर कला

106 बाइट्स

— ovs

@RGS -~xका मान उतना ही है x+1, लेकिन आपको इसे छोटा करने की आवश्यकता नहीं है, क्योंकि unary -(नकार) और unary ~(बिटवाइज़ नेगेटिव) की तुलना में अधिक पूर्वता है *। आपके मामले [1]*-~nमें बराबर है [1]*(n+1)।

— ओट्स

Answer 6

जावास्क्रिप्ट ईएस 6, 121 वर्ण

for(q=1,s=Array(+prompt()).fill(1).join`+`;s!=0;s=s.split(q).join(++q).replace(/\d+$/,x=>x-1).replace(/\+0$/,''))alert(s)

alert=s=>document.write(s+'\n')
document.write("<pre>")

for(q=1,s=Array(+prompt()).fill(1).join`+`;s!=0;s=s.split(q).join(++q).replace(/\d+$/,x=>x-1).replace(/\+0$/,''))alert(s)

Answer 7

पर्ल 5 , 71 बाइट्स

$,='+';for(@a=(++$")x<>;@a;--$a[-1]||pop@a){say@a;$_+=$_==$"for@a;$"++}

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