58

आप संख्या के स्थान मूल्य के बारे में जानने के लिए विस्तारित रूप का उपयोग करके पहली या दूसरी कक्षा में याद कर सकते हैं । उदाहरण के साथ समझाना आसान है, इसलिए संख्या पर विचार करें 123। विस्तारित रूप में इसे इस रूप में दर्शाया गया है 100 + 20 + 3, जो एक युवा दिमाग को स्थान मूल्य की कल्पना करने में मदद करता है। यह याद दिलाता है कि आप इसे कैसे कहते हैं: एक सौ (प्लस) बीस (प्लस) तीन।

हम इसे पिछले इकाइयों को दशमलव के साथ बढ़ा सकते हैं: 2.718 => 2 + 0.7 + 0.01 + 0.008

आपकी चुनौती एक प्रोग्राम या फ़ंक्शन लिखना है जो एक सकारात्मक फ़्लोटिंग पॉइंट नंबर या शून्य लेता है (यह मान लें कि यह भाषा जितनी बड़ी या सटीक है, यह भाषा संभाल सकती है; यह वैज्ञानिक संकेतन में नहीं होगी) या स्ट्रिंग और प्रिंट / इसे विस्तारित रूप में लौटाता है। जैसा कि ऊपर बताया गया है।

आपको +दशमलव बिंदु से पहले न तो शून्य के बीच की जगह चाहिए और न ही ऊपर का उदाहरण 2+.7+.01+.008। वे मान जो शून्य के बराबर होंगे, उन्हें छोड़ दिया जाना चाहिए ( 101.01 => 100 + 1 + 0.01) जब तक कि इनपुट शून्य न हो (नीचे देखें)।

मान दशमलव बिंदु से पहले एक से अधिक शून्य नहीं होना चाहिए या इसके बाद कोई पीछे आने वाला शून्य नहीं होना चाहिए (नहीं-नहीं:) 0060, 0000.2, 30., 30.000, .0400। इनपुट इसके अनुरूप भी होगा।

चूंकि पहले-ग्रेडर में कम ध्यान देने वाले स्पैन होते हैं, इसलिए आपके कोड को जितना संभव हो उतना छोटा होना होगा।

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

0 => 0
6 => 6
0.99 => 0.9 + 0.09
24601 => 20000 + 4000 + 600 + 1
6.283 => 6 + 0.2 + 0.08 + 0.003
9000000.0000009 => 9000000 + 0.0000009

code-golf number arithmetic

— NinjaBearMonkey
स्रोत

22

+1 के लिए "चूंकि पहले-ग्रेडर में कम ध्यान देने वाले स्पैन होते हैं, इसलिए आपका कोड जितना संभव हो उतना छोटा होगा।"

— डाउनगेट

2

@ Do @ खुशी है कि मेम अभी भी चल रही है।

— बिल्ली

4

यह उसी तरह से करना मजेदार होगा जब हम 97 (4 * 20 + 10 + 7) के मामले से जूझ रहे लोगों को देखने के लिए (फ्रेंच) गिनती करेंगे, ^ ^

— केटेनको

2

@ jimmy23013 हाँ, जब तक यह सिद्धांत में काम करता है।

— निन्जाबियरमोंकी

1

@ ओगडे मैं नहीं जानता, यह केवल कुछ किनारे के मामले हैं। शायद NBZ रास्ता बेहतर होगा, लेकिन फिर भी, अगर यह वास्तव में दिलचस्प नहीं होगा

— Katenkyo

6

CJam, 33 26 बाइट्स

r_ee\'0fe<f{\~t~}{},'+*0e|

यह जावा दुभाषिया के साथ काम नहीं करेगा; यह अलग तरह से तैरता है। CJam दुभाषिया के साथ यह कोशिश करो ।

आखिरी टेस्ट केस प्रिंट 9000000+9e-7, जिसे @NjajaBearMonkey द्वारा मान्य माना गया है ।

7 बाइट बंद करने के लिए @ jimmy23013 को धन्यवाद!

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

r_                           Read a token from STDIN and push a copy.
  ee                         Enumerate its characters, i.e., push the array of all
                             [index character] pairs.
    \                        Swap the original input on top of the stack.
     '0fe<                   Perform vectorized minimum with the character '0'.
                             This replaces all digits with '0', but leaves '.'
                             untouched, since `.' < '0'.
          f{    }            For each [index character] pair, push the pair and the
                             string of zeroes and (possibly) a dot; then:
            \                    Swap the pair on top of the stack.
             ~                   Dump index and character on the stack.
              t                  Replace the string's element at that index with
                                 that character.
               ~                 Evaluate the resulting string.
                 {},         Filter the array to remove zeroes.
                    '+*      Join, using '+' as separator.
                       0e|   If the result is empty, replace it with 0.

— डेनिस
स्रोत

उसी विचार के आधार पर r_ee\'0fe<f{\~t~}{},'+*0e|:।

— jimmy23013

@ jimmy23013 वाह, यह छोटा है! धन्यवाद!

— डेनिस

5

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

n=>+n&&[...n.replace(/^\.0*|\./,"")].map(f=d=>10**p--*d,p=Math.floor(Math.log10(n))).filter(f).join`+`

व्याख्या

अग्रणी शून्य (जब तक संख्या के बिना एक स्ट्रिंग के रूप इनपुट होने की संख्या की आवश्यकता है 0 निश्चित रूप से)।

नोट: फ्लोटिंग-पॉइंट अजीबता के कारण कुछ नंबर (जैसे .3) गलत निकलते हैं, लेकिन सैद्धांतिक रूप से यह किसी भी संख्या के लिए काम करता है।

n=>                             // n = input number as string
  +n&&                          // return 0 if n = 0
  [...n.replace(/^\.0*|\./,"")] // remove leading zeroes after the decimal place
  .map(f=d=>                    // for each digit d in n
      10**p--*d,                // raise the digit to the correct power of 10
    p=Math.floor(Math.log10(n)) // p = power of 10 for the first digit, floor needs to be
  )                             //     used instead of |0 due to negative powers of 10 :(
  .filter(f)                    // remove zeroes, the map function is reused
  .join`+`                      // return the output numbers joined with +

परीक्षा

ब्राउज़र संगतता के Math.powबजाय परीक्षण का उपयोग करता **है।

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

var solution = n=>+n&&[...n.replace(/^\.0*|\./,"")].map(f=d=>Math.pow(10,p--)*d,p=Math.floor(Math.log10(n))).filter(f).join`+`

<input type="number" oninput="result.textContent=solution(this.value)">
<pre id="result"></pre>

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

— user81655
स्रोत

Math.floor=> 0|...?

— 22

@ETHproductions यदि इनपुट संख्या इससे कम है 1तो टूट Math.log10(n)जाएगी क्योंकि |0फर्श के बजाय एक ऋणात्मक संख्या और शून्य की ओर गोल हो जाएगी।

— user81655

के 0|Math.log10(n),p-=p<0बजाय आप का उपयोग कर सकते हैं Math.floor(Math.log10(n))?

— डोम हेस्टिंग्स

1

@DomHastings लगभग। यह के लिए विफल रहता है n<1क्योंकि 0|कर देगा pबराबर 0दोनों के लिए 0.1और -0.1। सबसे छोटा तरीका जो मैं सोच सकता हूं, वह p=Math.log10(n),p=p-(p<0)|0है लंबाई का उपयोग करना Math.floor। :(

— user81655

@DomHastings अभी n=0.1भी वैसे भी काम नहीं करेगा ।

— नील

5

रेटिना , 86 77 75 बाइट्स

बाइट गिनती मानती है कि स्रोत आईएसओ 8859-1 के रूप में एन्कोडेड है।

S_`.(?<=(\.\d+))|(?=(\d*)).
Tm`d`0`\..+\B|(?<=^\d).+
¶([.0]+¶)*
+
^0.|\+0$

अनुगामी लाइनफीड महत्वपूर्ण है।

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

व्याख्या

S_`.(?<=(\.\d+))|(?=(\d*)).

हम इनपुट को एक लाइनफीड में अलग घटकों की सूची में बदलकर शुरू करते हैं, हालांकि केवल अग्रणी (या अनुगामी) अंक सही है। यह एक विभाजन चरण का दुरुपयोग करके किया जाता है। इनपुट को विभाजित करने के बजाय हम सभी से मेल खाते हैं, इसलिए शेष खंड सभी खाली हैं। हम उन खाली खंडों को _विकल्प के साथ हटा देते हैं । पकड़ यह है कि विभाजित चरण सभी कैप्चरिंग समूहों के मूल्यों को भी लौटाते हैं। इसलिए हम स्ट्रिंग के सही भाग पर कब्जा करने के लिए प्रत्येक मैच पर एक लुकहेड का उपयोग करते हैं: पहले हम .मैच के बाईं ओर खोजने की कोशिश करते हैं । अगर ऐसा है, तो हम सब कुछ पर कब्जा कर लेते हैं.वर्तमान में हम जो अंक प्राप्त कर रहे हैं, उसमें शामिल हैं। अन्यथा, हमें इनपुट के पूर्णांक भाग में होना चाहिए, इसलिए हम मैच (मैच सहित) के बाद सभी नंबरों पर कब्जा कर लेते हैं। हमें दशमलव बिंदु से भी छुटकारा चाहिए, इसलिए दूसरा कैप्चर वैकल्पिक है। यदि \dकब्जा करने के लिए नहीं हैं, तो यह बस इनपुट से मैच को हटा देगा।

Tm`d`0`\..+\B|(?<!=\d).+

अब हम सभी को चालू करने के लिए एक लिप्यंतरण चरण का उपयोग करते हैं लेकिन अग्रणी / अनुगामी अंक को शून्य में बदल देते हैं। हम या तो एक घटक से मेल खाते हैं जो 1 से कम है \..+\Bजहां यह \Bसुनिश्चित करता है कि हम अंत से पहले एक अंक को रोकते हैं, या हम एक पूर्णांक भाग से मेल खाते हैं (?<=^\d).+जहां लुकहैंड सुनिश्चित करता है कि हम एक अंक को अंक में शुरू करते हैं। लिप्यंतरण चरण तब किसी भी अंक ( d) को मैचों के अंदर शून्य से बदल देगा ।

¶([.0]+¶)*
+

अब वास्तविक आउटपुट स्वरूप +को विभाजकों के रूप में नहीं करना चाहिए । ¶मैचों में एक linefeed कि प्रतिस्थापन करना है। जब हम इस पर होते हैं, हम उन पंक्तियों को भी हटा देते हैं जिनमें केवल 0s और .s होते हैं।

^0.|\+0$

पिछला चरण एक अग्रणी या अनुगामी नहीं हटाता है 0(क्योंकि जिनके पास पहले और बाद में उन्हें लाइनफीड नहीं है), इसलिए हम स्पष्ट रूप से उन्हें हटा देते हैं।

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

4

पायथन 2, 216 210 196 175 बाइट्स

यहाँ कुछ थोड़ा गोल्फ कोड है जो मुझे समय मिलने पर आगे गोल्फ देगा। यह स्ट्रिंग विश्लेषण का उपयोग करता है।

i=input().split(".")
I=i[0]
e=enumerate
o=[(k+len(I[j+1::])*"0") for j,k in e(I) if k!="0"] 
try:o+=["."+l*"0"+m for l,m in e(i[1]) if m!="0"]
except:0
print "+".join(o or"0")

व्याख्या

तो, इनपुट को पूर्णांक और दशमलव भाग में अलग किया जाता है। फिर, लूप सूची समझ के लिए है। पूर्णांक भाग पर, दशमलव में एक चरित्र के बाद स्ट्रिंग की लंबाई "0" से गुणा की जाती है ताकि उस चरित्र के अंत में कई शून्य मिल सकें।

दशमलव भाग के लिए, वर्तमान वर्ण का सूचकांक इसके पहले शून्य की संख्या है और इसलिए यह भाग सरल है।

कोशिश और सिवाय यह निर्धारित करने के लिए उपयोग किया जाता है कि इसमें दशमलव भाग है या नहीं (त्रुटि का उपयोग करके)।

अंतिम परिणाम प्लस साइन्स के साथ जुड़ जाता है।

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

— TanMath
स्रोत

2

मुझे लगता है कि o if o else ["0"]हो सकता है o or["0"]।

— lirtosiast

आपके पास पंक्ति चार पर एक अनुगामी स्थान है जो आपके बाइट की संख्या में जोड़ता है। लाइन चार पर आपको केवल एक बृहदान्त्र की आवश्यकता होती है। : आप निम्नलिखित स्निपेट में स्थानों को हटा सकते o=[(...)] for, e(I) if, e(i[1]) if, print "+", और में बाहरी कोष्ठक o=[(...), वास्तव में रूप में अच्छी तरह। अंत में, आप अंतिम सशर्त को इस तरह से जुड़ने वाले फ़ंक्शन से बाहर ले जा सकते हैं: print"+".join(o)or"0"क्योंकि शामिल होने पर खाली सूची वापस आ जाएगी यदि oखाली है तो सशर्त उसी तरह का मूल्यांकन करेगा जो आपको एक बाइट बचाता है।

— ओगादे

3

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

L.xvbytb|j\+fT.eyXXzjkUT\0kbzz

परीक्षण सूट

यहां मूल समाधान इनपुट के सभी अंकों को बदलने के लिए है 0, फिर प्रत्येक अंक को उचित स्थान पर डालें, eval करें, शून्य को फ़िल्टर करें, और pluses पर जुड़ें। दुर्भाग्य से, पायथ का निष्कासन समारोह वर्तमान में अग्रणी शून्य को स्वीकार नहीं करता है। मैं इसे ठीक करने के लिए काम करूंगा।

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

साथ ही, इनपुट के लिए एक विशेष मामले की आवश्यकता थी 0।

सब सब में, मुझे लगता है कि कोड बहुत अच्छा है, लेकिन भाषा सुविधाएं बेहतर हो सकती हैं। त्रुटियों को कौन चाहता है?

— isaacg
स्रोत

3

पायथन 3, 138

यह तानमथ / ओगडे की संख्या को एक स्ट्रिंग के रूप में पढ़ने और इसे इस तरह से पार्स करने के दृष्टिकोण पर आधारित है। मुझे स्टार असाइनमेंट का उपयोग करना होगा iताकि यह सही ढंग से पूर्णांक को संभाल सके।

j,*i=input().split(".")
e=enumerate
z="0"
print("+".join([(x+len(j[y+1:])*z)for y,x in e(j)if x>z]+["."+o*z+p for o,p in e(i)if p>z]or z))

— मॉर्गन थ्रैप
स्रोत

3

पायथन, 141 132 128 बाइट्स

यह अभी भी अपेक्षाकृत पठनीय है। स्ट्रिंग में कनवर्ट करें और >1अंकों को अलग से <1अंकों से संभालें । हमारे पास शून्य के लिए एक विशेष मामला भी है। मैं नीचे दो और रिक्त स्थान निकाल सकता हूं, लेकिन मुझे इसे सुंदर रखना पसंद है।

नकारात्मक पक्ष यह है कि यह 9 से अधिक दशमलव स्थानों के साथ तैरने के लिए टूट जाएगा।

x=str(int(a*1e9))
l=len(x)-10
z="0"
print"+".join([(j+z*(l-i))if l>=i
 else"."+z*(i-l-1)+j
 for i,j in enumerate(x)if j!=z]or z)

नीचे मूल है। पहला संपादन शून्य विशेष मामले को छोटा करने के लिए था, दूसरा संपादन दशमलव से पहले 0 को हटाने के लिए था, तीसरा कुछ अतिरिक्त कोष्ठक और रिक्त स्थान को हटाने के लिए था।

x=str(int(a*1e9))
l=len(x)-10
z="0"
print "+".join([(j+z*(l-i)) if l>=i
 else ("0."+z*(i-l-1)+j)
 for i,j in enumerate(x) if j!=z]) if a else z

स्पष्टीकरण:

x=str(int(a*1e9)) # Convert into a string with nine decimals
l=len(x)-10
z="0"
print "+".join([
 (j+z*(l-i)) if l>=i       # Print numbers greater than 1
 else ("0."+z*(i-l-1)+j)   # Print less than one
 for i,j in enumerate(x) if j!=z
]) if a else z             # Special case zero

— speedplane
स्रोत

आपको अपने कोड के प्रत्येक संशोधन को शामिल करने की आवश्यकता नहीं है; अगर हम आपकी गोल्फ की प्रगति को देखना चाहते हैं तो हम संशोधन इतिहास को देख सकते हैं। वैसे, PPCG में आपका स्वागत है!

— ०१:३२

1

बस यह पता चला ... मैं इस साइट पर बहुत अधिक समय बिताने की कोशिश नहीं करने जा रहा हूँ!

— स्पीडप्लेन

2

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

Inactive@Plus@@(10.^Range[#2-1,#2-Length@#,-1]#/.{0.->Nothing[]})&@@RealDigits@#&

परीक्षण का मामला:

%[101.01]
(* 100. + 1. + 0.01 *)

— njpipeorgan
स्रोत

3

मुझे नहीं लगता कि पूर्णांक भागों पर दशमलव बिंदु होने की अनुमति है।

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

2

CJam, 44 बाइट्स

r:TdLT'.-{'0f+IaaI~g*+}fI:dATW%'.##m]f/'+*e&

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

यह अंतिम परीक्षण मामले में विफल रहता है, और निम्न आउटपुट करता है:

9000000+9e-7

लेकिन मान लें कि यह बहुत सटीक है कि सीजेएम इसे संभाल नहीं सकता है।

व्याख्या

r:Td
LT'.-         e# Remove the period if any.
{             e# For each character I:
  '0f+        e# Append 0 to each previous string.
  IaaI~g*+    e# Append I as a string if I isn't '0.
}fI
:d            e# Convert each string to float.
ATW%'.##      e# 10 to the kth power where k is the position of the period from the end.
m]            e# Round up, so it becomes 1 if no periods are found.
f/            e# Divide each float by this number.
'+*e&         e# Format and the 0 special case.

— jimmy23013
स्रोत

2

पायथन 3, 187 180 173 154 बाइट्स

प्रबंधित करने के लिए @Thomas Kwa के सुझावों के बारे में ऊपर से 19 अच्छे बाइट्स का प्रबंधन करने के लिए प्रबंधित result or['0'], साथ ही कुछ बीजगणित ( 154 बाइट्स ) को पुन: व्यवस्थित करना :

def f(n):
 *m,=n;o='0'
 try:p=m.index('.');m.pop(p)
 except:p=len(m)
 return'+'.join([['.'+o*(i-p)+d,d+o*(p-i-1)][p>i]for i,d in enumerate(m)if d!=o])or o

~~मेरा अब तक का सबसे अच्छा प्रयास~~ ( 173 बाइट्स )। नए दृष्टिकोण के आधार पर, पोस्ट के नीचे देखें:

def f(n):
 *m,=n;o='0'
 try:p=m.index('.');m.pop(p)
 except:p=len(m)
 return(o,'+'.join([['.'+o*(-1*(p-i))+d,d+o*(p-i-1)][p-i>0]for i,d in enumerate(m)if d!=o]))[eval(n)!=0]

180 बाइट्स में मेरा मूल नीचे गिरा :

def f(n):x=n.split('.');a,b=(x+[''],x)[len(x)-1];e=enumerate;return('0',"+".join([d+'0'*i for i,d in e(a[::-1])if d!='0'][::-1]+['.'+'0'*i+d for i,d in e(b)if d!='0']))[eval(n)!=0]

मैंने ऐसा करते हुए आज एक नई भाषा सुविधा सीखी! बूलियन इंडेक्सिंग के माध्यम से सशर्त। मैं इसे थोड़ा ज़्यादा कर सकता हूँ।

मैंने समझ को खत्म करने की कोशिश की, लेकिन मैं इसे कम नहीं कर पाया ( 196 बाइट्स )

e=lambda s:[d+'0'*(len(s)-i-1) for i,d in enumerate(s) if eval(d)]
def f(n):x=n.split('.');a,b=(x+[''],x)[len(x)-1];return['0',"+".join(e(a)+['.'+d[::-1]for d in e(b[::-1])][::-1])][bool(eval(n))]

(अनुक्रमण अनुक्रम महंगा है!)

जब तक मेरा अभी के लिए छोटा है, मुझे लगता है कि तानमथ अपने खदान को मैच करने के लिए नीचे गिरा सकता है: उपयोग करना e=enumerate, passसाथ बदलना 0, और वापसी बयान के '0'स्थान पर ['0']4 + 3 + 2 = 9 बाइट बचाना चाहिए! इसे 187 तक नीचे ले जाना। मुझे यकीन है कि कुछ और बाइट्स कहीं से काटे जा सकते हैं ...

नया दृष्टिकोण ( 156 बाइट्स ) संपादित करें । हालांकि, यह केवल @ jimmy23013 की CJam प्रविष्टि के समान 6dp तक की सटीकता के साथ सौदा कर सकता है, इसलिए यह अंतिम परीक्षा में विफल रहता है। मैं इसे अधिक 0 छापने के लिए ज़बरदस्ती नहीं कर सकता, शायद कोई और कर सकता है। इसके बजाय मैंने इसे अपने सर्वश्रेष्ठ प्रयास के आधार के रूप में अभी तक उपयोग किया है, शीर्ष देखें (इसके अलावा, यह दृष्टिकोण दशमलव स्थान से पहले 0 प्रिंट करता है, लेकिन यह मान्य भी लगता है।) try:... except:...तनमठ से दृष्टिकोण लिया :

def f(n):
 *m,=n
 try:p=m.index('.');m.pop(p)
 except:p=len(m)
 return('0','+'.join([str(eval(d)*10**(p-i-1))for i,d in enumerate(m)if d!='0']))[eval(n)!=0]

— Ogaday
स्रोत

यदि आप मेरी मदद करने के लिए गोल्फिंग देने की कोशिश कर रहे हैं, तो कृपया उन्हें मेरे उत्तर में टिप्पणियों के रूप में शामिल करें, आपके उत्तर में नहीं। मैं हमेशा आपके उत्तर नहीं देखता हूं, इसलिए एक टिप्पणी लिखकर, मैं एक अधिसूचना प्राप्त करूंगा और इसे निश्चित रूप से देखूंगा।

— तन्माथ

2

हाय @ तन्माथ। मैं करूँगा, लेकिन मेरे पास अभी तक अन्य लोगों के पोस्ट पर टिप्पणी करने के लिए पर्याप्त प्रतिनिधि नहीं है। एक बार जब मुझे कुछ और upboats मिलेंगे तो मैं टिप्पणियों में प्रतिक्रिया छोड़ना सुनिश्चित करूँगा।

— ओगाडे

2

शुद्ध बैश, 210

o= a=${1%.*} b=${1#$a};while [ "$a" ];do c=${a:1};((${a%$c}>0))&&o+=${a%$c}${c//?/0}+;a=$c;done;[ "$b" ]&&{ b=${b#.} a=;while [ "$b" ];do c=${b:0:1};((c>0))&&o+=.$a$c+;b=${b:1};a+=0;done;};o=${o%+};echo ${o:-0}

या

o= a=${1%.*} b=${1#$a};while [ "$a" ];do c=${a:1};((${a%$c}>0))&&
o+=${a%$c}${c//?/0}+;a=$c;done;[ "$b" ]&&{ b=${b#.} a=;while [ "$b" ]
do c=${b:0:1};((c>0))&&o+=.$a$c+;b=${b:1};a+=0;done;};o=${o%+};echo ${o:-0}

परीक्षा:

exp() {
    o= a=${1%.*} b=${1#$a};while [ "$a" ];do c=${a:1};((${a%$c}>0))&&
    o+=${a%$c}${c//?/0}+;a=$c;done;[ "$b" ]&&{ b=${b#.} a=;while [ "$b" ]
    do c=${b:0:1};((c>0))&&o+=.$a$c+;b=${b:1};a+=0;done;};o=${o%+};echo ${o:-0}
}
while read num;do
    printf "%-12s => " $num
    exp $num
done <<<$'0\n6\n0.99\n24601\n6.283\n9000000.0000009\n3.1415\n.99'
0            => 0
6            => 6
0.99         => .9+.09
24601        => 20000+4000+600+1
6.283        => 6+.2+.08+.003
9000000.0000009 => 9000000+.0000009
3.1415       => 3+.1+.04+.001+.0005
.99          => .9+.09

— एफ। होरी
स्रोत

2

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

f=lambda s,k=0,i=0,o="",z="0":s and f(s[1:],(s<z)+k,i+k,o+(s>="1")*([s[0]+~-(s+".").find(".")*z,"."+z*i+s[0]][k]+"+"))or o[:-1]or z

वास्तव में, वास्तव में गड़बड़ पुनरावर्ती कार्य, इस बारे में जाने का सबसे अच्छा तरीका नहीं है। इनपुट की तरह f("10.0203")।

— Sp3000
स्रोत

क्या यह भी पायथन है? इसे प्यार करना।

— ओगादे

2

सी, 155 153 153 161 बाइट्स

गणित पुस्तकालय में लिंक करने के लिए +2 (स्रोत स्वयं 159) है।

main(d,v,p,q)char**v,*p,*q;{for(p=strchr(q=v[1],46),d=p?p-q:strlen(q);*q;++q)*q^46?printf(*q^48|q==v[1]?"%.*f%c":"",d<0?-d:0,(*q-48)*pow(10,--d),q[1]?43:0):0;}

Ungolfed

int main(int d, char **v, char *p, char *q)
{
    for(q = v[1], /* Cache the input string */
        p = strchr(q,'.'), /* find the decimal */
        d = p ? p-q : strlen(q); /* calculate number of digits before decimal */
        *q; /* loop while still input data */
        ++q) /* iterate to next character */
    {
        *q^46 /* if not at the decimal point... */
            ? printf(*q^48 || q == v[1] /* if not a zero, or if the string itself is zero... */
                ? "%.f%c" /* print the digit */
                : "", /* else print nothing */
                d<0 ? -d : 0, /* Calculate number of places after decimal to print */
                (*q-48)*pow(10,--d), /* Calculate the digit at the desired power of 10 */
                q[1]?43:0) /* If the next character is still valid input, print the '+' */
            : 0 /* else, do nothing */
    }
}

— कोल कैमरून
स्रोत

2

दिल्लोग एपीएल , 47 बाइट्स

{×⍎⍵:1↓∊'+',¨0~⍨(⍎¨w)×10*(⍵⍳'.')-1+⍳≢w←⍵~'.'⋄0}

चरित्र वेक्टर रूप में संख्या लेता है, जैसे '123'।

उदाहरण:

      f←{×⍎⍵:1↓∊'+',¨0~⍨(⍎¨w)×10*(⍵⍳'.')-1+⍳≢w←⍵~'.'⋄0} 
      ↑⍕¨f¨,¨'0' '6' '0.99' '24601' '6.283' '900000.000009'
0                     
6                     
0.9 + 0.09            
20000 + 4000 + 600 + 1
6 + 0.2 + 0.08 + 0.003
900000 + 0.000009

_{नोट्स:

example संशोधित अंतिम उदाहरण का कारण यह है कि एपीएल, कुछ अन्य सबमिशन की तरह, डिफ़ॉल्ट रूप से ऐसे चरम संख्याओं के लिए वैज्ञानिक संकेतन पर स्विच करेगा।

Once वाक्यांश ↑⍕¨f¨,¨को केवल एक बार में सभी उदाहरणों को संसाधित करने के लिए आवश्यक है।}

— एडम
स्रोत

1

रेटिना, 113 बाइट्स

वर्तमान में मार्टिन के समाधान की तुलना में बहुत लंबा है लेकिन एक अलग तरीके का उपयोग करता है इसलिए मैंने इसे पोस्ट करने का फैसला किया।

^
x
S_`(?<=(.*)).(?=(.*))
x

¶\..*¶.*

$
¶
T`d`0`(?<=\d).*¶.*¶
(.*)¶(.*)¶
$2$1¶
(\..*?)0*¶
$1¶
\.?¶0*
¶
¶+
+
\+$
[empty line]

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

— randomra
स्रोत

1

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

-pस्विच के लिए 131 +1 ।

यह मेरे पिछले sedउत्तर पर आधारित है :

1while s/^([1-9]\d*)([1-9])(0*)([+.].*|)$/${1}0$3+$2$3$4/||s/([1-9]0*)\.([0-9])/$1+.$2/||s/\.(0*)([1-9])(\d*[1-9])$/.$1$2+.${1}0$3/

परीक्षण सूट:

perl -pe'1while s/^([1-9]\d*)([1-9])(0*)([+.].*|)$/${1}0$3+$2$3$4/||
    s/([1-9]0*)\.([0-9])/$1+.$2/||s/\.(0*)([1-9])(\d*[1-9])$/.$1$2+.${1}0$3/
' <<<$'0\n6\n0.99\n24601\n6.283\n9000000.0000009\n3.1415'
0
6
0.9+.09
20000+4000+600+1
6+.2+.08+.003
9000000+.0000009
3+.1+.04+.001+.0005

— एफ। होरी
स्रोत

1

पॉवर्सशेल - 172 166 193 बाइट्स

सभी एक लाइन पर:

$z=([string]$args[0])-split"\.";$y=$z[0].length-1+0.6;($z|%{$x=[char[]]$_;if($y-gt0){($x|%{$_+"0"*(-1+$y--)})}else{($x|%{"0."+"0"*[math]::abs($y--)+$_})}}|?{-not($_-match'^[0.]+$')})-join' + '

Ungolfed:

$z=([string]$args[0]) -split "\."
$y=$z[0].length-1+0.6
($z | %{
    $x=[char[]]$_
    if($y -gt 0) {
        ($x | %{$_+"0"*(-1+$y--)})
    } else {
        ($x | %{"0."+"0"*[math]::abs($y--)+$_})
    }
} | ?{ -not($_ -match '^[0.]+$')}) -join ' + '

परीक्षण के मामले, एक अतिरिक्त:

PS> (0, 6, 0.99, 24601, 6.283, 9000000.0000009, [math]::pi) | %{.\expand.ps1 $_}

6
0.9 + 0.09
20000 + 4000 + 600 + 1
6 + 0.2 + 0.08 + 0.003
9000000 + 0.0000009
3 + 0.1 + 0.04 + 0.001 + 0.0005 + 0.00009 + 0.000002 + 0.0000006 + 0.00000005 + 0.000000003 + 0.0000000005 + 0.00 000000008 + 0.000000000009 + 0.0000000000007 + 0.00000000000009    
PS>

— क्रिस जे
स्रोत

आपका रेगेक्स फ़िल्टर करता है $args = 0। यहाँ एक साधारण बग फिक्स है जो 3 बाइट्स बचाता है

— Veskah

एक छोटे से सुधार के बाद 172 बाइट्स

— Veskah

1

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

ईव, मैं पर्ल गोल्फिंग में नोबीश हूं।

@a=split/\./,<>;
@b=split``,$a[1];
@c=split``,$a[0];
for($i=0;$i<length$a[0];$i++){
   $_.=($c[$i]!=0)?$c[$i]."0"x((length$a[0])-$i-2)."+":"";
}
for($i=1;$i<=length$a[1];$i++){
   $_.=($b[$i-1]!=0)?"0."."0"x($i-1).$b[$i-1]."+":"";
}
chop;
($_=="")?print"0 ":print;

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

— पॉल पिकार्ड
स्रोत

यह पूर्णांक संख्याओं के साथ काम नहीं करता है।

— फ.हौरी

मैंने गलत Ideone लिंक डाला। यह संपादन मोड में किए गए परिवर्तनों को ध्यान में नहीं रखता है। :( इसे अब काम करना चाहिए।

— पॉल पिकार्ड

आपके पास एक त्रुटि है: जब मैं 5इसे वापस दर्ज करता हूं 50।

— एफ। होरी

अजीब बात है, क्योंकि आपने अपनी पहली टिप्पणी डालने के बाद मैंने कल दिए गए लिंक के साथ 5 का परीक्षण किया था। मन अब कोशिश कर रहा है? (मैंने फिर से लिंक बदल दिया)

— पॉल पिकार्ड

मैंने सिर्फ आपकी लिपि को मेरे पर्ल दुभाषिया (v5.20.2) पर परीक्षण किया है

— एफ।

1

जावा, 284 244 243 बाइट्स

String x(String s){int b=s.length(),d=(d=s.indexOf(46))<0?b:d,i=-1,k=0;String o="";for(char c;++i<b;)o+=(c=s.charAt(i))>48?(k++>0?" + ":"")+(d-i>0?c:"0.")+new String(new char[Math.abs(d-i)-1]).replace('\0','0')+(d-i>0?"":c):"";return b<2?s:o;}

~~दुर्भाग्य से, मैं स्ट्रिंग्स को दोहराने का एक छोटा तरीका नहीं ढूंढ सका:~~

~~char[]आवश्यक लंबाई का निर्माण~~
~~Arrays.fillवर्ण सेट करने के लिए उपयोग करें~~
~~इसका उपयोग करें, new Stringइसलिए इसे संघटित किया जा सकता है~~

@Khaled A Khunaifer की प्रेरणा से, मैं 40 बाइट्स से दाढ़ी बना सकता था।

संपादित करें: indexOfकिसी पूर्णांक लेता है, तो मैं बदल सकते '.'के साथ 46। दुर्भाग्य से, यह संभव नहीं लगता है replace।

— ईसीएस
स्रोत

मैं इसे 250 तक सिकोड़ने में कामयाब रहा, ideone.com/HqLnMo

— खालिद.के

@ खालिद ए खुनीफर आपका समाधान एकल अंकों के परीक्षण मामलों की समस्या है। लेकिन मुझे शून्य उत्पन्न करने का आपका तरीका पसंद है।

— ईसीएस

इस .replace('\0','0')फ़ंक्शन को ठीक करने की अपेक्षा करें , यह Stringनहीं charहोना चाहिए.replace("\0","0")

— खालिद.के।

@ खालिद ए ख़ुनीफ़र यह मेरे परीक्षण के मामलों में भी काम करता है, डॉक्स.कोरल.com

— ECS

1

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

मेरे 1 उत्तर (sry!) को हटाने के बाद जो मशीन एप्सिलॉन मुद्दों के कारण छोटी संख्या को संभाल नहीं सका, मुझे एक अलग समाधान मिला। यह फ्लोट के साथ-साथ पूर्णांक, अनुगामी शून्य (!) को संभालता है और इसे फ़ंक्शन के रूप में लिखा जाता है।

उपयोगी संकेत के लिए और कॉम्पैक्ट '0'- फिक्स के लिए @ogaday के लिए धन्यवाद!

golfed:

def f(x):x+='.';i=x.find('.');z=list(x);del z[i];return'+'.join([str(int(o)*10**(i-j-1))for j,o in enumerate(z)if'0'<o])or'0'

Ungolfed:

def f(x):
  x+='.'
  i=x.find('.')
  z=list(x)
  del z[i]   
  return '+'.join([str(int(o)*10**(i-j-1)) for j,o in enumerate(z) if '0'<o]) or '0'

उपयोग:

>>> f("0")
'0'

>>> f("32.005")
'30+2+0.005'

>>> f("100020003000009000000.0007")
'100000000000000000000+20000000000000000+3000000000000+9000000+0.0007'

>>> f("1000000000009000000.0007000000000000000002")
'1000000000000000000+9000000+0.0007+2e-22'

>>> f("0001.99")
'1+0.9+0.09'

— lambruscoAcido
स्रोत

1

अच्छा लगा। f('0')हालांकि, परीक्षण के मामले में विफल रहता है , और जब मैं अपने दुभाषिया में सीधे कॉपी और पेस्ट करता हूं तो मुझे वैज्ञानिक अंकन मिलता है (जो मुझे लगता है कि ठीक है)। इसके अलावा, list(c)कम है। यदि आप '.'इसे सूची में बदलने से पहले संक्षिप्त करते हैं []तो आपको या तो जोड़ने की आवश्यकता नहीं है । findसूची में बदलने से पहले स्ट्रिंग पर सूचकांक के बजाय का उपयोग करना , जोड़ने के बाद '.'भी आपको एक बाइट बचाता है। असमानता को

def f(x):x+='.';i=x.find('.');z=list(x);del z[i];return"+".join([str(int(o)*10**(i-j-1))for j,o in enumerate(z)if"0"<o])or'0'

— पुन

1

कॉफ़ीस्क्रिप्ट, 144 बाइट्स

सीधे आगे समाधान:

X=(n)->[m,k]="#{n}".split '.';(c+Array(m.length-i).join 0for i,c of m when+c).concat(".#{Array(++i).join 0}"+c for i,c of k when+c).join('+')||0

निष्पादन:

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

<script src="http://coffeescript.org/extras/coffee-script.js"></script>
<script type="text/coffeescript">
X=(n)->[m,k]="#{n}".split '.';(c+Array(m.length-i).join 0for i,c of m when+c).concat(".#{Array(++i).join 0}"+c for i,c of k when+c).join('+')||0

# Tests follow
tests = [
  0
  6
  0.99
  24601
  6.283
  9000000.0000009
]

window.solution = X
result.textContent=("#{n} => #{X n}" for n in tests).join '\n'
</script>
<input type="number" oninput="result.textContent=solution(this.value)">
<pre id="result"></pre>

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

— metalim
स्रोत

1

स्टैक्स , 18 बाइट्स

ºî≤FlφLfÜG→\ΦUq╜♥←

इसे चलाएं और डीबग करें

अनपैक्ड, अनगुल्फेड और टिप्पणी की गई, यह ऐसा दिखता है।

c           copy input
!C          terminate if input is falsy
y{          for each character in the string input...
  y.\d'0R   replace each digit in the input with "0"
  ia&       then replace the nth character back to its original value
  e         eval as float
m           map using block to produce array
{f          filter out zeroes
'+*         join with "+"

इसको चलाओ

पोस्ट किए गए अन्य समाधानों में से कई की तरह, यह 9000000+9e-7अंतिम परीक्षण मामले के लिए पैदा करता है । स्थापित मिसाल के अनुसार इसकी अनुमति है क्योंकि परीक्षण का मामला भाषा के लिए बहुत सटीक है।

— पुनरावर्ती
स्रोत

0

लुआ, 350 बाइट्स

मुझे लगता है कि इसे और नीचे ले जाने के दो तरीके हैं:

मैं macro.defineकुछ कॉमन्स एक्सप्रेशंस को बदलने का उपयोग कर सकता हूं (अभी परीक्षण नहीं कर सकता, और यह सुनिश्चित नहीं है कि इससे मुझे कुछ बाइट्स मिलेंगे)
पूरे स्ट्रिंग पर चलने के बजाय डॉट पर विभाजन का उपयोग करें। एक बार फिर, मुझे यकीन नहीं है कि यह इस समारोह के आकार को कम करेगा, क्योंकि लू में स्ट्रिंग में हेरफेर काफी दर्दनाक है।

function f(s)v,r=s:find("%.")or#s+1,""if #s==1 then return s end for i=1,#s do a=""(v>i and s:sub(i,v-1)or s:sub(v,i)):gsub(".",function(c)a=a..(not a:find(c)and(c==s:sub(i,i)or c==".")and c or 0)end)s,r=v<i and s:sub(0,i-1).."0"..s:sub(i+1,#s)or s,r..((#a==a:find("%.")or tonumber(a)==0)and""or a:gsub("%.","0.")..(i~=#s and"+"or""))end return r end

स्पष्टीकरण

function f(s)
  v=s:find("%.")or #s+1               -- v=index of the dot in a decimal number
  r=""                                -- v=#s+1 when s is an integer(v=0 would screw sub())
  if #s==1 then return s end          -- exit if s is a single digit
  for i=1,#s                          -- iterate over s
  do
    a=""

    (v>i and s:sub(i,v-1)or s:sub(v,i)-- only send the integer OR decimal part to gsub
      ):gsub(".",function(c)          -- iterate over each character of s:sub()

    -- a contains the next number to be concatenated to the string r(the one to be returned)
      a=a..(not a:find(c)             -- we concatenate a with c if a doen't contains
        and(c==s:sub(i,i)or c==".")   -- c, and c is either a dot, or the next number
             and c or 0)              -- to be add, we put a 0 otherwise
    end)
    -- we concatenate the new a with the string already formed
    r=r..((#a==a:find("%.")           -- if a=="." or a's value is 0
            or tonumber(a)==0)and""   -- we concatenate an empty string
      or a:gsub("%.","0.")            -- else, we replace the (possible) leading dot by "0."
      ..(i~=#s and"+"or""))           -- and concatenate a "+" if it isn't the last number to be added

    s=v<i and s:sub(0,i-1)            -- We then replace the digit we have worked with
      .."0"..s:sub(i+1,#s)or s        -- to prevent duplicates
  end
  return r
end

आप ऑनलाइन लुआ का परीक्षण कर सकते हैं और इसे कुछ परीक्षण मामलों के साथ चलाने के लिए निम्न स्रोत कोड का उपयोग कर सकते हैं

function f(s)v,r=s:find("%.")or#s+1,""if #s==1 then return s end for i=1,#s do a=""(v>i and s:sub(i,v-1)or s:sub(v,i)):gsub(".",function(c)a=a..(not a:find(c)and(c==s:sub(i,i)or c==".")and c or 0)end)s,r=v<i and s:sub(0,i-1).."0"..s:sub(i+1,#s)or s,r..((#a==a:find("%.")or tonumber(a)==0)and""or a:gsub("%.","0.")..(i~=#s and"+"or""))end return r end

print(f("3123.12333"))
print(f("9545"))
print(f("9000000.0000009"))
print(f("6"))

— Katenkyo
स्रोत

0

सी, 253 बाइट्स

m(char*i){int k,j=0,s=0,d=0;while(i[s])s++;while(i[d]!=46)d++;while(j<d){if(i[j]!=48){for(k=0;k<(d-j);k++)putchar(k?48:i[j]);putchar(43);}j++;}while(++j<s)if(i[j]!=48){putchar(46);for(k=0;k<(j-d);k++)putchar(k==(j-d-1)?i[j]:48);putchar(43);}putchar(8);}

नोट: putchar(8)एक बैकस्पेस प्रदर्शन करना चाहिए।

 Input: 1230.0456
Output: 1000+200+30+.04+.005+.0006

विस्तृत , यहां देखें

while(i[s]) s++;
while(i[d]!=46) d++;

while (j<d)
{
    if (i[j]!='0')
    {
        for(k=0;k<(d-j);k++) putchar(k? '0': i[j]);
        putchar(43);
    }
    j++;
}

while (++j<s)
if (i[j]!='0')
{
    putchar(46);
    for(k=0; k<(j-d); k++) putchar(k==(j-d-1)? i[j]: '0');
    putchar(43);
}

putchar(8);

— Khaled.K
स्रोत

0

एसईडी, 136 128 बाइट्स

रिक्त स्थान और बेकार छोड़ने से 8 वर्णों से कम 0।

:;s/^([1-9][0-9]*)([1-9])(0*)([+.].*|)$/\10\3+\2\3\4/;s/([1-9]0*)\.([0-9])/\1+.\2/;s/\.(0*)([1-9])([0-9]*[1-9])$/.\1\2+.\10\3/;t

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

sed -r ':;
    s/^([1-9][0-9]*)([1-9])(0*)([+.].*|)$/\10\3+\2\3\4/;
    s/([1-9]0*)\.([0-9])/\1+.\2/;
    s/\.(0*)([1-9])([0-9]*[1-9])$/.\1\2+.\10\3/;
    t' <<<$'0\n6\n0.99\n24601\n6.283\n9000000.0000009\n3.1415'
0
6
0.9+.09
20000+4000+600+1
6+.2+.08+.003
9000000+.0000009
3+.1+.04+.001+.0005

— एफ। होरी
स्रोत

0

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

s=>(p=s.search(/.\b/),i=-1,[for(c of s)if((i++,c>0))(z=s.substring(i,p).replace(/d/g,0),i<p?c+z:z+c)].join`+`||s

मनमाने ढंग से लंबाई की संख्या के साथ काम करता है क्योंकि यह स्ट्रिंग हेरफेर का उपयोग करता है।

सरणी समझ के बिना (122 बाइट्स):

s=>[...s].map((c,i)=>c<'1'?'':(z=s.substring(i,p).replace(/\d/g,0),i<p?c+z:z+c),p=s.search(/.\b/)).filter(x=>x).join`+`||s

Ungolfed:

function expand(s) {
    zeros = s.replace(/\d/g, "0");
    point = s.indexOf(".");
    if (point < 0) point = s.length;
    result = [];
    for (i = 0; i < s.length; i++) {
        if (s[i] > "0") {
            if (i < point) result.push(s[i] + zeros.slice(i, point - 1));
            else result.push(zeros.slice(point - 1, i) + s[i]);
         }
     }
     return result.length ? result.join("+") : s;
}

— नील
स्रोत

जहाँ तक मुझे पता है, यह नया एरे कॉम्प्रिहेंशन सिंटैक्स ECMAScript 7. से है

— मैनटवर्क

@manatwork धन्यवाद, मैंने इसे अद्यतन किया था जब मैं अनऑर्गलाइज्ड संस्करण जोड़ रहा था।

— नील

0

आर - 133 बाइट्स

रोबस्ट, मशीन एप्सिलॉन को नजरअंदाज करता है और ट्रेलिंग जीरो के साथ भी काम करता है।

क) गोल्फ:

f=function(x)if(x=='0')x else{z=strsplit(x,'')[[1]];i=which(z=='.');n=as.numeric(z[-i])*10^(i-seq(z)[-1]);paste(n[n>0],collapse='+')}

Ungolfed:

f=function(x)
  if(x=='0') 
    x 
  else {
    z=strsplit(x,'')[[1]]
    i=which(z=='.')   
    n=as.numeric(z[-i])*10^(i-seq(z)[-1])  
    paste(n[n>0],collapse='+')
  }

उपयोग:

f("900.008")

— lambruscoAcido
स्रोत

संख्या का विस्तार करें

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

CJam, 33 26 बाइट्स

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

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

व्याख्या

परीक्षा

रेटिना , 86 77 75 बाइट्स

व्याख्या

पायथन 2, 216 210 196 175 बाइट्स

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

पायथन 3, 138

पायथन, 141 132 128 बाइट्स

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

CJam, 44 बाइट्स

व्याख्या

पायथन 3, 187 180 173 154 बाइट्स

शुद्ध बैश, 210

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

सी, 155 153 153 161 बाइट्स

Ungolfed

दिल्लोग एपीएल , 47 बाइट्स

रेटिना, 113 बाइट्स

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

पॉवर्सशेल - 172 166 193 बाइट्स

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

जावा, 284 244 243 बाइट्स

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

कॉफ़ीस्क्रिप्ट, 144 बाइट्स

निष्पादन:

स्टैक्स , 18 बाइट्स

लुआ, 350 बाइट्स

स्पष्टीकरण

सी, 253 बाइट्स

एसईडी, 136 128 बाइट्स

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

आर - 133 बाइट्स