সংখ্যাটি প্রসারিত করুন

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
@ দো- মেম এখনও চলছে বলে খুশি ।
— বিড়াল
4
আমরা (ফরাসি) গণনা করা একইভাবে এটি করা মজার বিষয় হবে, 97 জন (4 * 20 + 10 + 7) এর ক্ষেত্রে লোকেরা ঝগড়া দেখছে ^^
— কেটেনকিয়ো
2
@ জিমি 23013 হ্যাঁ, যতক্ষণ না এটি তত্ত্বটিতে কাজ করে।
— নিনজাবিয়ারমুনকি
1
@ ওগাদে আমি জানি না, এটি কেবল কয়েকটি প্রান্তের ঘটনা। হয়তো এনবিজেডের উপায় আরও ভাল হতে পারে তবে এটি এখনও আকর্ষণীয় হবে না
— কাটেনকিয়ো

উত্তর:

6

সিজেম, 33 26 বাইট

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

এটি জাভা দোভাষী দিয়ে কাজ করবে না; এটি প্রিন্ট আলাদাভাবে। সিজেএম ইন্টারপ্রেটার দিয়ে এটি ব্যবহার করে দেখুন ।

সর্বশেষ পরীক্ষার কেস প্রিন্টস 9000000+9e-7, যা @ নিনজাবিয়ারমনকি দ্বারা বৈধ রায় দেওয়া হয়েছে ।

7 জ্যাকেট বন্ধ করে দেওয়ার জন্য @ জিমি 23013 কে ধন্যবাদ!

কিভাবে এটা কাজ করে

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

জাভাস্ক্রিপ্ট (ES7), 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পরিবর্তে পরীক্ষাগুলি ব্যবহার করে **।

কোড স্নিপেট দেখান

— user81655
সূত্র
Math.floor=> 0|...?
— ETH প্রোডাকশনগুলি
@ ইথ প্রডাকশনগুলি যদি ইনপুট নম্বরটি এর চেয়ে কম হয় তবে 1এটি ভাঙার পরিবর্তে Math.log10(n)একটি নেতিবাচক সংখ্যা এবং গোলকে |0শূন্যের দিকে ফিরবে ।
— ব্যবহারকারী 81655
আপনি কি 0|Math.log10(n),p-=p<0পরিবর্তে ব্যবহার করতে পারেন Math.floor(Math.log10(n))?
— ডম হেস্টিংস
1
নিবন্ধন করুন এটি ব্যর্থ হয় n<1কারণ উভয়ই এবং উভয়ের 0|জন্য pসমান হবে । আমি সবচেয়ে সংক্ষিপ্তভাবে ভাবতে পারি যা ব্যবহারের সমান দৈর্ঘ্য । :(00.1-0.1p=Math.log10(n),p=p-(p<0)|0Math.floor
— ব্যবহারকারী 81655
@ ডোমহাস্টিংস এখনও n=0.1কোনওভাবেই কাজ করবে না ।
— নিল
5

রেটিনা , 86 77 75 বাইট

বাইট গণনা অনুমান করে যে উত্সটি আইএসও 8859-1 হিসাবে এনকোড হয়েছে।

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

পেছনের লাইনফিডটি তাৎপর্যপূর্ণ।

এটি অনলাইনে চেষ্টা করুন।

ব্যাখ্যা

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

আমরা ইনপুটটি উপাদানগুলির একটি লাইনফিডের পৃথক তালিকায় পরিণত করে শুরু করি, যদিও কেবলমাত্র শীর্ষস্থানীয় (বা পিছনের) সংখ্যাটি সঠিক। এটি একটি বিভক্ত পর্যায়ে আপত্তিজনকভাবে করা হয়। ইনপুট বিভক্ত করার পরিবর্তে আমরা এটির সাথে সব মিলিয়ে চলেছি, তাই বাকী অংশগুলি খালি। আমরা _বিকল্পটি দিয়ে খালি খণ্ডগুলি সরিয়ে ফেলি । ক্যাচটি হ'ল বিভক্ত পর্যায়ে সমস্ত ক্যাপচারিং গ্রুপের মানগুলিও ফিরে আসে। সুতরাং স্ট্রিংয়ের সঠিক অংশটি ক্যাপচার করার জন্য আমরা প্রতিটি ম্যাচে একটি নজরদারি ব্যবহার করি: প্রথমে আমরা .ম্যাচের একটি বাম সন্ধান করার চেষ্টা করি । যদি এটি হয় তবে আমরা সমস্ত কিছু ক্যাপচার করি.বর্তমানে আমরা যে অঙ্কটি মিলে চলেছি তার সাথে যুক্ত including অন্যথায়, আমাদের অবশ্যই ইনপুটটির পূর্ণসংখ্যার অংশে থাকতে হবে, তাই আমরা ম্যাচের পরে সমস্ত নম্বর ক্যাপচার করি (ম্যাচ সহ)। আমাদের অবশ্যই দশমিক পয়েন্টটি থেকে মুক্তি দিতে হবে, সুতরাং দ্বিতীয় ক্যাপচারটি isচ্ছিক। যদি \dক্যাপচার করার মতো কিছু না থাকে, এটি কেবল ইনপুট থেকে ম্যাচটি সরিয়ে ফেলবে।

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

শীর্ষস্থানীয় / পিছনের অঙ্কগুলি বাদে অন্য সবগুলিকে শূন্যে পরিণত করতে এখন আমরা একটি লিপ্য লিখনের স্টেজ ব্যবহার করি। আমরা হয় এমন 1 টিরও কম অংশের সাথে মেলে \..+\Bযেখানে এটি \Bনিশ্চিত করে যে আমরা ম্যাচটি শেষের আগে এক (?<=^\d).+অঙ্কে থামিয়ে দেব , বা আমরা যেখানে একটি সংখ্যার সাথে মিল করব যেখানে লুকবাইন্ড নিশ্চিত করে যে আমরা সংখ্যায় একটি অঙ্ক শুরু করব। লিপ্যন্তরকরণের পর্যায়ে dম্যাচের অভ্যন্তরে শূন্যের সাথে কোনও অঙ্ক ( ) প্রতিস্থাপন করা হবে ।

¶([.0]+¶)*
+

এখন আসল আউটপুট ফর্ম্যাটটিতে +বিভাজক হিসাবে লাইনফিড ব্যবহার করা উচিত নয়। ম্যাচ একটি লাইনফীড যে প্রতিকল্পন না। আমরা এটির সময়ে, আমরা কেবলমাত্র 0গুলি এবং .গুলি সমেত লাইনগুলি সরিয়ে ফেলি ।

^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, তারপরে প্রতিটি অঙ্ক যথাযথ স্থানে সন্নিবেশ করা, জিরোগুলি ফিল্টার আউট করা এবং প্লাসগুলিতে যোগদান করা। দুর্ভাগ্যক্রমে, পাইথের alভাল ফাংশনটি বর্তমানে শীর্ষস্থানীয় জিরোগুলিকে গ্রহণ করে না। আমি এটি ঠিক করার জন্য কাজ করব।

এই সমস্যাটি থেকে yবেরিয়ে আসার জন্য , আমি একটি সহায়ক ফাংশন যুক্ত করেছি , যা ত্রুটি না ছোঁড়া পর্যন্ত প্রতিটি সময় প্রথম অঙ্কটি সরিয়ে না দেওয়া পর্যন্ত পুনরুক্তভাবে চেষ্টা করে al নোট করুন যে এই ফাংশনটি অবৈধ ইনপুটটিতে লুপ হবে।

এছাড়াও, ইনপুটটির জন্য একটি বিশেষ কেসের প্রয়োজন ছিল 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
সূত্র
আপনার কোডের প্রতিটি সংশোধনী অন্তর্ভুক্ত করার দরকার নেই; আমরা যদি আপনার গল্ফিং অগ্রগতি দেখতে চাই তবে আমরা পুনর্বিবেচনার ইতিহাসটি দেখতে পারি। যাইহোক, পিপিসিজিতে আপনাকে স্বাগতম!
— lirtosiast
1
সবেমাত্র এটি আবিষ্কার হয়েছে ... আমাকে এই সাইটে খুব বেশি সময় ব্যয় না করার চেষ্টা করতে হবে!
— স্পিড প্লেন
2

গণিত, 81 বাইট

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

পরীক্ষা ক্ষেত্রে:

%[101.01]
(* 100. + 1. + 0.01 *)
— njpipeorgan
সূত্র
3
আমি মনে করি না যে পূর্ণসংখ্যার অংশগুলির সাথে দশমিক পয়েন্ট থাকা অনুমোদিত।
— মার্টিন এন্ডার
2

সিজেম, 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 বাইট

উপরের উপরে থমাস কোয়ার পরামর্শ অনুসারে ভাল 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))]

(বিপরীত ক্রম ব্যয়বহুল!)

যতক্ষণ খনি এখন জন্য খাটো, আমি মনে করি TanMath গলফ পারেন তার নিচে খনি মেলে: ব্যবহার e=enumerate, প্রতিস্থাপন passসঙ্গে 0, এবং ব্যবহার '0'স্থানে ['0']আগমন বিবৃতিতে 4 + 3 + 2 = 9 বাইট সংরক্ষণ করা উচিৎ! এটি 187 এ নেমেছে। আমি নিশ্চিত যে আরও কিছু বাইট কোথাও বন্ধ করে দেওয়া যায় ...

নতুন পদ্ধতির সম্পাদনা করুন ( 156 বাইট )। তবে এটি @ জিমি 23013 এর সিজেএম এন্ট্রির অনুরূপ 6 ডিপি পর্যন্ত যথার্থতার সাথে ডিল করতে পারে, সুতরাং এটি চূড়ান্ত পরীক্ষায় ব্যর্থ। আমি এটি আরও 0 টি মুদ্রণের জন্য জোর করতে পারি নি, অন্য কেউ হতে পারে। পরিবর্তে আমি এটিকে এখনও আমার সেরা প্রয়াসের ভিত্তি হিসাবে ব্যবহার করেছি, শীর্ষগুলি দেখুন (এছাড়াও, এই পদ্ধতিটি দশমিক স্থানের আগে 0 টি প্রিন্ট করে তবে সেটিও বৈধ বলে মনে হয়))। টুক try:... except:...TanMath থেকে দৃষ্টীকোণ:

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
হাই @ ট্যানম্যাথ আমি চাই, তবে আমার কাছে এখনও অন্য লোকের পোস্টগুলিতে মন্তব্য করার মতো যথেষ্ট সংবাদ নেই। আমি আরও কয়েকটি আপবোট পেলে মন্তব্যে প্রতিক্রিয়া জানাতে নিশ্চিত করব।
— ওগাদে
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 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

নোটস:
last সংশোধিত সর্বশেষ উদাহরণের কারণ হ'ল এপিএল, অন্যান্য কয়েকটি জমা দেওয়ার মতো, ডিফল্টরূপে এ জাতীয় চরম সংখ্যার জন্য বৈজ্ঞানিক স্বরলিপিতে স্যুইচ করবে।
○ বাক্যাংশটি ↑⍕¨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
— বাইটও
— ভেস্কাহ
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;

এখানে চেষ্টা করুন।

— পল পিকার্ড
সূত্র
এটি পূর্ণসংখ্যার সংখ্যা নিয়ে কাজ করে না বলে মনে হচ্ছে।
— এফ। হাউরি
আমি ভুল আইডিয়ন লিঙ্কটি রেখেছি। এটি সম্পাদনা মোডে করা অ্যাকাউন্ট পরিবর্তনগুলিতে গ্রহণ করে না। :( এটি এখনই কাজ করা উচিত
— পল পিকার্ড
আপনার কোথাও একটি ত্রুটি রয়েছে: আমি প্রবেশ করার পরে 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যাতে এটি সংক্ষিপ্ত করা যেতে পারে

@ খালেদ এ খুুনাইফারের অনুপ্রেরণায় আমি 40 বাইট ছাঁটাই করতে পারি।

সম্পাদনা: indexOfএকটি int লাগে, তাই আমি এটির '.'সাথে প্রতিস্থাপন করতে পারি 46। দুর্ভাগ্যক্রমে, এটি সম্ভব হবে বলে মনে হয় না replace।

— ইসিএস
সূত্র
আমি এটিকে 250 এ ডাউন করে সঙ্কুচিত করতে পেরেছি
— হিউএইচএলএনমো
@ খালেদ এ খুনাইফার আপনার সমাধানটি একক ডিজিট পরীক্ষার ক্ষেত্রে সমস্যা বলে মনে হচ্ছে। তবে আমি আপনার শূন্যগুলি উত্পন্ন করার পদ্ধতি পছন্দ করি।
— ইসিএস
এই স্থির .replace('\0','0')ফাংশন প্রতিস্থাপন আশা Stringনা char, এটা করা উচিত.replace("\0","0")
— Khaled.K
@ খালেদ এ খুনাইফার এটি আমার পরীক্ষার কেসগুলিতেও কাজ করে, ডকস.ওরাকল.com
— ইসিএস
1

পাইথন, 125 বাইট

আমার 1 ম উত্তর (sry!) মুছে ফেলার পরে যা মেশিনের অ্যাপসিলনের সমস্যার কারণে অল্প সংখ্যক পরিচালনা করতে পারে না, আমি একটি আলাদা সমাধান পেয়েছি। এটি ভাসমান পাশাপাশি পূর্ণসংখ্যার পাশাপাশি চলমান শূন্যগুলি (!) পরিচালনা করে এবং এটি ফাংশন হিসাবে লেখা হয়।

দরকারী ইঙ্গিতগুলির জন্য এবং কমপ্যাক্ট '0'-ফিক্সের জন্য @ ওপাদে ধন্যবাদ!

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

সম্পাদনযোগ্য:

কোড স্নিপেট দেখান

— 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

জাভাস্ক্রিপ্ট (ES7), 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;
}
— নিল
সূত্র
যতদুর আমি জানি, এই নতুন অ্যারে ধী সিনট্যাক্স 7. নাম ECMAScript থেকে
— 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
সূত্র
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.