숫자의 장소 가치에 대해 배우기 위해 확장 된 양식 을 사용하여 1 학년 또는 2 학년에 기억할 수 있습니다 . 예를 들어 설명하기가 더 쉬우므로 number를 고려하십시오 123. 확장 된 형태로는로 표시되며 100 + 20 + 3이는 어린 마음이 장소 가치를 시각화하는 데 도움이됩니다. 당신의 말을 떠올리게합니다 : 백 (십) 플러스 이십 (플러스) 셋.

소수점 이하로 단위 자리를 지나서 이것을 확장 할 수 있습니다. 2.718 => 2 + 0.7 + 0.01 + 0.008

당신의 과제는 양의 부동 소수점 숫자 또는 0 (언어가 처리 할 수있는만큼 크거나 정확하다고 가정하고 과학적 표기법이 아닐 것입니다) 또는 문자열을 확장하고 양식을 인쇄 / 반환하는 프로그램이나 함수를 작성하는 것입니다 위에서 설명한대로.

+소수점 앞에 0과 0 사이에 공백이 필요하지 않으므로 위의 예는입니다 2+.7+.01+.008. 101.01 => 100 + 1 + 0.01입력이 0이 아닌 경우 0과 같은 값은 생략해야합니다 ( ).

값은 소수점 앞에 두 개 이상의 선행 0이 있거나 뒤에 0이 없어야합니다 (no-no 's :) 0060, 0000.2, 30., 30.000, .0400. 입력도 이것과 일치합니다.

1 학년 학생들은주의 집중 기간이 짧기 때문에 코드는 가능한 짧아야합니다.

테스트 사례

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

CJam, 33 26 바이트

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

Java 인터프리터에서는 작동하지 않습니다. 인쇄가 다르게 뜹니다. CJam 통역사 와 함께 사용해보십시오 .

@NinjaBearMonkey에 의해 유효9000000+9e-7 하게 판명 된 마지막 테스트 케이스가 인쇄 됩니다 .

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.

자바 스크립트 (ES7), 102 바이트

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

설명

앞에 0이없는 문자열로 숫자를 입력해야합니다 ( 물론 숫자 가 아닌 한 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>

망막 , 86 77 75 바이트

바이트 수는 소스가 ISO 8859-1로 인코딩 된 것으로 가정합니다.

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

후행 줄 바꿈이 중요합니다.

온라인으로 사용해보십시오.

설명

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

시작 (또는 후행) 숫자 만 정확하지만 입력을 줄 바꿈 별도의 구성 요소 목록으로 바꾸는 것으로 시작합니다. 이것은 스플릿 스테이지를 남용하여 수행됩니다. 입력을 나누는 대신 모든 입력과 일치하므로 나머지 세그먼트는 모두 비어 있습니다. _옵션으로 빈 세그먼트를 제거합니다 . 캐치 스플릿 단계는 모든 캡처 그룹의 값을 반환한다는 것입니다. 따라서 각 일치 항목을 살펴보고 문자열의 올바른 부분을 캡처합니다. 먼저 .일치 항목 의 왼쪽 을 찾습니다 . 이 경우 우리는.현재 일치하는 숫자까지 포함합니다. 그렇지 않으면 입력의 정수 부분에 있어야하므로 일치 이후의 모든 숫자 (일치 포함)를 캡처합니다. 소수점 자체도 제거해야하므로 두 번째 캡처는 선택 사항입니다. \d캡처 하지 않으면 입력에서 일치 항목을 제거하기 만하면됩니다.

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

이제 음역 단계를 사용하여 선행 / 후행 숫자를 제외한 모든 숫자를 0으로 바꿉니다. 우리 중 하나와 함께 미만 1의 구성 요소와 일치하는 \..+\B곳에 \B우리가 한 자리가 끝나기 전에 경기를 중지하거나 우리가 가진 정수 부분 일치 보장하지만 (?<=^\d).+lookbehind 우리는 숫자에 한 자리를 시작하는 것이 보장 곳입니다. 음역 단계는 d일치 하는 숫자 ( )를 0으로 바꿉니다.

¶([.0]+¶)*
+

이제 실제 출력 형식은 +줄 바꿈을 구분 기호로 사용 하지 않아야합니다 . ¶경기는 라인 피드는 치환을합니다. 우리가있는 동안 0s와 .s 만 포함하는 줄을 제거합니다 .

^0.|\+0$

이전 단계는 선행 또는 후행을 제거하지 않습니다 0( 앞뒤 에 줄 바꿈이 없기 때문에 명시 적으로 제거).

파이썬 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")

설명

따라서 입력은 정수와 소수점으로 분리됩니다. 그런 다음 for 루프 목록 이해가 있습니다. 정수 부분에서 10 진수 문자 뒤의 문자열 길이에 "0"을 곱하면 해당 문자의 끝에 많은 0이 생깁니다.

소수 부분의 경우 현재 문자의 색인은 그 앞의 0 수이므로 그 부분은 단순합니다.

try 및 except는 소수 부분이 있는지 여부를 판별하는 데 사용됩니다 (오류 사용).

최종 결과는 더하기 부호와 결합됩니다.

여기 사용해보십시오!

Pyth, 30 바이트

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

테스트 스위트

여기서 기본적인 해결책은 입력의 모든 숫자를로 바꾸고 0각 자리를 적절한 위치에 삽입하고 평가하고 0을 필터링 한 다음 플러스를 결합하는 것입니다. 불행히도, Pyth의 eval 함수는 현재 선행 0을 허용하지 않습니다. 이 문제를 해결하기 위해 노력할 것입니다.

이 문제를 극복하기 위해 y오류가 발생하지 않을 때까지 eval을 재 시도하여 재 시도 하는 도우미 함수를 추가했습니다 . 이 함수는 유효하지 않은 입력에서 무한 반복됩니다.

또한 입력에 특별한 경우가 필요했습니다 0.

대체로 코드가 꽤 좋다고 생각하지만 언어 기능이 더 좋을 수 있습니다. 누가 오류를 원합니까?

파이썬 3, 138

이것은 TanMath / Ogaday의 숫자를 문자열로 읽고 파싱하는 방식에 기반을두고 있습니다. 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))

파이썬 141 132 128 바이트

이것은 여전히 ​​비교적 읽을 수 있습니다. 문자열로 변환하고 >1숫자와 별도로 숫자를 처리하십시오 <1. 우리는 또한 0에 대한 특별한 경우가 있습니다. 아래에서 두 개의 공백을 더 제거 할 수는 있지만 예쁘게 유지하는 것이 좋습니다.

단점은 소수점 이하 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

Mathematica, 81 바이트

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

테스트 사례 :

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

CJam, 44 바이트

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

여기에서 시도하십시오.

마지막 테스트 케이스에 실패하고 다음을 출력합니다.

9000000+9e-7

그러나 CJam이 처리 할 수없는 것이 너무 정확하다고 가정 해 봅시다.

설명

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.

파이썬 3 187 180 173 154 바이트

위의 @Thomas Kwa의 제안 result or['0']과 대수 ( 154 바이트 ) 재 배열 덕분에 좋은 19 바이트를 골프로 처리했습니다 .

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 바이트를 저장해야 return 문에! 187로 줄였습니다. 어딘가에서 몇 바이트를 면도 할 수 있다고 확신합니다 ...

새 접근 방법을 편집하십시오 ( 156 바이트 ). 그러나 @ jimmy23013의 CJam 항목과 유사한 최대 6dp의 정밀도 만 처리 할 수 ​​있으므로 최종 테스트에 실패합니다. 더 많은 0을 인쇄하도록 강요 할 수 없었습니다. 아마도 다른 사람이 할 수 있습니다. 대신 나는 그것을 최선의 시도의 기초로 사용했지만 top을 참조하십시오 (또한이 방법은 소수점 이하 자릿수 앞에 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] 

순수한 배쉬, 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

파이썬, 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").

C, 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;}

언 골프

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 */
    }
}

Dyalog APL , 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     

_{참고 :
○ 마지막 예를 수정 한 이유는 다른 제출과 마찬가지로 APL이 기본적으로 이러한 극단 숫자에 대해 과학적 표기법으로 전환하기 때문입니다.
○ 문구 ↑⍕¨f¨,¨는 모든 예제를 한 번에 처리하는 데만 필요합니다.}

레티 나, 113 바이트

현재 Martin의 솔루션 보다 훨씬 길지만 다른 방법을 사용하므로 게시하기로 결정했습니다.

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

¶\..*¶.*

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

여기에서 온라인으로 사용해보십시오.

펄, 132 바이트

131 +1 -p스위치

이것은 내 이전 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

파워 쉘 - 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' + '

언 골프 드 :

$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>

펄, 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;

여기에서 시도하십시오.

자바, 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 바이트를 줄일 수있었습니다.

편집 : indexOfint를 사용하므로로 바꿀 수 '.'있습니다 46. 불행히도 이것은로 가능하지 않은 것 같습니다 replace.

파이썬, 125 바이트

머신 엡실론 문제로 인해 작은 숫자를 처리 할 수없는 첫 번째 답변 (sry!)을 삭제 한 후 다른 해결책을 찾았습니다. 부동 소수점뿐만 아니라 정수, 후행 0 (!)을 처리하고 함수로 작성됩니다.

유용한 힌트와 컴팩트 한 '0'수정에 대한 @ogaday에 감사드립니다!

골프 :

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'

언 골프 드 :

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'

CoffeeScript, 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>

Stax , 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마지막 테스트 사례를 위해 생성 됩니다. 확립 된 선례에 따르면, 테스트 케이스가 언어에 대해 너무 정확하기 때문에 이것이 허용됩니다.

루아, 350 바이트

골프를 더 내리는 두 가지 방법이 있다고 생각합니다.

• macro.define일부 공통 표현식을 대체하는 데 사용할 수 있습니다 (지금 테스트 할 수는 없으며 바이트를 얻을 수 있는지 확실하지 않습니다)

• 전체 문자열을 반복하는 대신 점에 split을 사용하십시오. 루아에서 문자열을 조작하는 것이 상당히 고통 스럽기 때문에이 기능의 크기를 줄일 것이라고 확신하지 못합니다.

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

lua를 온라인으로 테스트하고 다음 소스 코드를 사용하여 일부 테스트 케이스에서 실행할 수 있습니다.

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"))

C, 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);

sed, 136128 바이트

공백을 없애고 쓸모없는 문자를 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

자바 스크립트 (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

언 골프 드 :

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;
}

R-133 바이트

견고성, 머신 Epsilon을 무시하고 후행 0 과도 작동합니다.

a) 골프 :

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=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")