입력:

정수

산출:

입력 자체의 합 + 입력 길이 + 입력의 각 개별 숫자.

nr + nr-length + {sum of digits} = output

예 :

입력 : 99
출력 : 99(nr) + 2(nr-length) + (9 + 9)(digits) →119

입력 : 123
출력 : 123 + 3 + (1 + 2 + 3)→132

도전 규칙 :

• 입력에는 음수 입력이 포함될 수 있으며이 입력은 특수하게 해결됩니다. -/ 마이너스 기호 또한 +1길이를 들면, 첫 번째의 일부입니다 digit.
  예를 들면 다음과 같습니다.

  입력 : -123
  출력 : -123 + 4 + (-1 + 2 + 3)→-115

• 입력 및 출력이 (32 비트) 정수 범위를 벗어나는 것으로 가정 할 수 있습니다.

일반적인 규칙:

• 이것은 code-golf 이므로 바이트 단위의 최단 답변이 이깁니다.
  코드 골프 언어가 코드 골프 언어 이외의 언어로 답변을 게시하지 못하게하지 마십시오. '모든'프로그래밍 언어에 대한 가능한 한 짧은 대답을 생각해보십시오.
• 표준 규칙이 답변에 적용 되므로 STDIN / STDOUT, 적절한 매개 변수 및 리턴 유형의 전체 프로그램과 함께 함수 / 방법을 사용할 수 있습니다. 당신의 전화.
• 기본 허점 은 금지되어 있습니다.
• 가능하면 코드 테스트 링크를 추가하십시오.
• 또한 필요한 경우 설명을 추가하십시오.

테스트 사례 :

87901 → 87931
123 → 132
99 → 119
5 → 11
1 → 3
0 → 1
-3 → -4
-123 → -115
-900 → -905
-87901 → -87886

반 관련 : 모든 자릿수의 합계

05AB1E, 28 20 18 8 바이트

ÐgsS'+ýO

설명

Ð           # triplicate input
 g          # get length of input
  sS'+ý     # split input and merge with '+' as separator 
       O    # sum and implicitly display

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

@Adnan 덕분에 10 바이트 절약

파이썬 2, 39 바이트

lambda x:x+len(`x`)+eval("+".join(`x`))

테스트 스위트

내 Pyth-answer 에서와 동일한 평가를 사용합니다 .

Pyth, 11 10 바이트

바이트에 대한 @LeakyNun에게 감사합니다!

++vj\+`Ql`

테스트 스위트

설명

++ vj \ +`Ql`QQ # Q = 입력, 마지막 두 암시 적으로 추가

  vj \ +`Q # '+'의 입력에 참여하여 평가
        l`Q # 입력 길이
           Q # 입력 자체
++ # 그 세 가지 값을 더해 결과를 얻으십시오

CJam, 18

q_,\~__Ab(@g*\~]:+

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

설명:

q_      read the input and make a copy
,\      get the string length and swap with the other copy
~__     evaluate the number and make 2 copies
Ab      convert to base A=10 (array of digits), it uses the absolute value
(       take out the first digit
@g*     get a copy of the number, get its sign and multiply with the digit
\~      dump the other digits on the stack
]:+     add everything together

Brachylog , 35 32 바이트

lL,? : ef + :? : L + I, (0>? h : 2 * : Ir- : 1 + .; I.)
lL, (0>? h : 1--I; I0) ,? b : ef + :? : L : I +.

설명

lL,             L is the length of the Input
(
    0>?         Input < 0
       h:1--I   I is (First digit - 1) * -1
;               Or
    I0          I is 0
),
?b:ef+          Sum all digits of the Input
      :?:L:I+.  Output = sum of digits + (Input minus first digit) + L + I

XSLT 1.0 (EXSLT 제외), 673 바이트

<transform xmlns="http://www.w3.org/1999/XSL/Transform" version="1.0"><output method="text"/><param name="i"/><template match="/"><variable name="d"><variable name="s">0<if test="0>$i">1</if></variable><variable name="d"><call-template name="d"><with-param name="i" select="substring($i,$s+2)"/></call-template></variable><value-of select="substring($i,1,$s+1)+$d"/></variable><value-of select="$i+string-length($i)+$d"/></template><template name="d"><param name="i"/>0<if test="$i!=''"><variable name="d"><call-template name="d"><with-param name="i" select="substring($i,2)"/></call-template></variable><value-of select="substring($i,1,1)+$d"/></if></template></transform>

가볍게 팽창 :

<transform xmlns="http://www.w3.org/1999/XSL/Transform" version="1.0">
    <output method="text"/>
    <param name="i"/>
    <template match="/">
        <variable name="d">
            <variable name="s">0<if test="0&gt;$i">1</if></variable>
            <variable name="d">
                <call-template name="d">
                    <with-param name="i" select="substring($i,$s+2)"/>
                </call-template>
            </variable>
            <value-of select="substring($i,1,$s+1)+$d"/>
        </variable>
        <value-of select="$i+string-length($i)+$d"/>
    </template>
    <template name="d">
        <param name="i"/>0<if test="$i!=''">
            <variable name="d">
                <call-template name="d">
                    <with-param name="i" select="substring($i,2)"/>
                </call-template>
            </variable>
            <value-of select="substring($i,1,1)+$d"/>
        </if>
    </template>
</transform>

xsltproc을 사용하여 실행하십시오.

xsltproc --param i -87901 ild.xsl ild.xsl

예, ild.xsl두 번 전달됩니다. XSLT 문서로 한 번 , 변환 할 XML 문서로 한 번. XSLT 프로세서는 일반적으로 실행을 시작하기 위해 입력 문서가 필요하므로 입력 문서가 있어야합니다. (XSLT는 입력 문서에서 출력 문서로의 변환을 정의하도록 설계되었습니다. 여기서 수행 한 명령 행 매개 변수만으로 변환을 실행하는 것은 비정형입니다.)이 프로그램의 경우, 잘 구성된 XML 문서는 입력으로 충분합니다. XSLT는 XML의 응용 프로그램이므로 잘 구성된 XSLT 변환은 정의에 따라 잘 구성된 XML 문서입니다.

MATL, 20 바이트

tVtnw48-PZ}t0<?x_]vs

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

모든 테스트 사례

설명

        % Implicitly grab the input
tV      % Duplicate the input and convert to a string
tn      % Duplicate and find the length of this string
w       % Flip the top two stack elements to get us the string again
48-     % Subtract 48 (ASCII 'O'). Yields a negative number for a negative sign
        % and digits otherwise
P       % Flip the resulting array
Z}      % Break the array up so each element is pushed to the stack
t0<?    % If the first character was a negative sign
  x_    % Pop the negative sign off the stack and negate the first digit
]       % End of if
vs      % Vertically concatenate and sum all stack contents
        % Implicitly display the result

클로저, 102 바이트

(fn[n](load-string(str"(+ "n" "(count(str n))" "(apply str(map #(if(= % \-)%(str %" "))(str n)))")")))

문자열처럼 보이고 (+ -123 4 -1 2 3 )회피 하는 익명 함수 . 모든 것이 그 자체로 꽤 장황하고 숫자에서 길이로 문자열을 구성 한 다음 빼기를 제외한 숫자의 문자열 표현의 각 기호를 공백과 뺄셈으로 매핑합니다.

https://ideone.com/FG4lsB에서 실행중인 것을 볼 수 있습니다.

Dyalog APL , 19 17 16 바이트

≢+#⍎'\d'⎕R'&+',⊢

문자열을 받아서 리턴

 ≢정규식 추가 숫자 의 루트 네임 스페이스 평가 에서 길이
+플러스 + 뒤에 수정되지 않은 문자열
 #
⍎
 '\d'⎕R'&+'
,
 ⊢

ngn 덕분에 –3

Matlab, 76 67 바이트

n=input('');t=num2str(n)-48;if(n<0)t(1)=0;t(2)=-t(2);end
n+sum(t+1)

@Luis Mendo 덕분에 9 바이트 절약

설명:

n=input('');     -- takes input
t=num2str(n)-48; -- makes it a string and then array of digits with "-" becoming -3 (48 is code for 0)
if(n<0)
t(1)=0;          -- set first element (-3) to 0
t(2)=-t(2);      -- the second element is the most significant digit, so we have to negate it
end
n+sum(t+1)       -- take sum of n, sum of all digits and length of t
                    (guaranteed by +1 of every element)

dc, 57 바이트

dc -e"0 1?rdsc*d[1r]s+d0>+dZr[+la10~lc*rdsaZ1<A]sAdsaZ1<Ala+++f"

설명 :

0 1      # Push 0, then 1 on the stack
?        # Wait for input from stdin
         # If input is negative, the leading minus will subtract 1 from 0
r        # Swap (rotate) top two items on stack.
         # Stack status if input (`$') was...
         #       positive                    negative
         # TOP       1     <- coefficient ->    -1
         #           $                           $
         #           0
dsc      # Store a copy of coefficient in `c'
*        # Multiply input by coefficient:
         #  If input was positive, it stays positive.
         #  If input was negative, it's actually interpreted as positive.
         #   In this case, multiply by -1 to make it negative.
d        # Duplicate signed input
[1r]s+   # Define a function `+': Push 1 and rotate
d 0>+    # If input is negative, push 1 underneath the top of the stack
         # This 1 represents the length of the `-` in the input
         # Note that the stack now has 3 items on it, regardless of input sign
dZ       # Push the length of the input (not including leading minus)
r        # Rotate, moving a copy of the input to the top
[        # Begin function definition
 +       # Add top two items of stack
 la      # Load value from `a' (which holds nothing at time of function definition)
 10~     # Slice the last digit off `a' (spoiler: `a' is going to hold the input while
         #  we gather its digits)
 lc*     # Multiply digit by coefficient
         #  Since the input is signed, the input modulo 10 will have the same sign.
         #  We want all digits to be positive, except the leftmost digit, which should
         #   have the sign of the input.
         #  This ensures that each digit is positive.
 r       # Rotate: move remaining digits to top of stack
 dsa     # Store a copy of the remaining digits in `a'
 Z 1<A   # Count the number of digits left; if more than 1, execute A
]sA      # Store the function as `A'
d sa     # Store a copy of the input in `a'
         #  Props to you if you're still reading this
Z 1<A    # Count the number of digits left; if more than 1, execute A
la       # Load leftmost digit of input (still signed appropriately)
+++      # Add the top four items on the stack
f        # Dump stack

이것은 내가 예상했던 것보다 훨씬 더 복잡했습니다! 좋은 도전 :)

배쉬 + coreutils, 36 바이트

bc<<<$1+${#1}+$(sed s:\\B:+:g<<<0$1)

설명:

     $1+                      # the input number (+)
     ${#1}+                   # the length of the number, the '-' sign included (+)
     $(sed s:\\B:+:g<<<0$1)   # insert '+' between two consecutive word characters
                              #A word character is any letter, digit or underscore.
bc<<<                         # calculate the sum

sed에서는 \B두 개의 연속 비 단어 문자도 일치하므로 음수의 경우 '^'와 '-'가 일치합니다. 예를 들어, 제공하는 0$1데 필요한 트릭에 주목하십시오 .\B0-1+2+3

실행 예 : 'input.txt'는 질문의 진술에 모든 테스트 사례를 포함합니다.

while read N;do echo "$N -> "$(./ILD_sum.sh "$N");done < input.txt

산출:

87901 -> 87931
123 -> 132
99 -> 119
5 -> 11
1 -> 3
0 -> 1
-3 -> -4
-99 -> -96
-123 -> -115
-900 -> -905
-87901 -> -87886

PowerShell v4, 48 바이트

param($n)$n,"$n".length+[char[]]"$n"-join'+'|iex

_{이것은 해야 V2의 +에서 작동하지만 난 단지 V4에서 테스트.}

입력을 $n받습니다. ,연산자로 구성 $n되고 .lengthwhen $n가 문자열로 변환 된 새 배열을 만듭니다 . 문자열을 $n문자 배열로 캐스트 한 것과 연결 합니다. 그런 다음 전체 배열은 (와 유사하게 ) 파이프되기 전에 -join함께 +연결됩니다 . 결과는 파이프 라인에 남고 출력은 암시 적입니다.iexeval

예를 들어 input -123의 경우 배열은와 같고 (-123, 4, -, 1, 2, 3)뒤에 문자열 -join은와 같습니다 -123+4+-+1+2+3. 그런 다음 Invoke-Expression발생하고 결과는 -115예상대로입니다.

load-all, 175 바이트로 인수 분해

글쎄, 이것은 짧지 않습니다. 단항 빼기의 특수 처리는 실제로 성가시다. 나는 그것을 더 잘할 수 있다고 생각합니다.

[ dup [ 10 >base length ] [ [ 10 >base >array [ 48 - ] V{ } map-as ] [ 0 < ] bi [ reverse dup pop* dup pop swap [ neg ] dip dup [ push ] dip ] [ ] if 0 [ + ] reduce ] bi + + ]

이 대체 정규식 사용 :

s/(-?[\d]+)\s*->\s*(-?[\d]+)/{ $2 } [ $1 calculate-ild ] unit-test/g

OP 테스트 케이스를 Factor 테스트 스위트로 바꿀 수 있습니다.

USING: arrays kernel math math.parser sequences ;
IN: sum-ild

: sum-digits ( n -- x )
    [ number>string >array [ 48 - ] V{ } map-as ]
    [ 0 < ]
    bi
    [
      reverse dup pop* dup pop swap [ neg ] dip dup [ push ] dip
    ]
    [ ] if
    0 [ + ] reduce ;

: calculate-ild ( n -- x )
  dup
  [ number>string length ]
  [ sum-digits ]
  bi + + ;

USING: tools.test sum-ild ;
IN: sum-ild.tests

{ 87931 } [ 87901 calculate-ild ] unit-test
{ 132 } [ 123 calculate-ild ] unit-test
{ 119 } [ 99 calculate-ild ] unit-test
{ 11 } [ 5 calculate-ild ] unit-test
{ 3 } [ 1 calculate-ild ] unit-test
{ 1 } [ 0 calculate-ild ] unit-test
{ -4 } [ -3 calculate-ild ] unit-test
{ -115 } [ -123 calculate-ild ] unit-test
{ -905 } [ -900 calculate-ild ] unit-test
{ -87886 } [ -87901 calculate-ild ] unit-test

C #, 118 바이트

int k(int a){var s=a.ToString();for(int i=0;i<s.Length;a+=s[i]<46?-(s[++i]-48)+ ++i-i:(s[i++]-48));return a+s.Length;}

SpecBAS-147 바이트

1 INPUT a$: l=LEN a$: b$="text "+a$+"+"+STR$ l+"+": FOR i=1 TO l: b$=b$+a$(i)+("+" AND i<l): NEXT i: EXECUTE b$

그런 다음 실행되는 문자열을 작성합니다. 불행하게도 EXECUTE작동하지 않습니다 ?속기 PRINT만 TEXT한 문자를 저장.

C #, 106 바이트

나는 자바 바이트를 이길, 내 인생은 완료

int r(int n){var s=n+"";return n+s.Length+s.Select((k,j)=>int.Parse(s[k==45?1:j]+"")*(k==45?-2:1)).Sum();}

언 골프 (킨다)

    public static int r(int n)
    {
            var s = n + "";
            return n + s.Length + s.Select((k, j) =>int.Parse(s[k==45?1:j]+"")*(k==45?-2:1)).Sum();
    }

자바 (8) 174 136 122 107 105 93 78 바이트

i->{int f=0;for(int j:(i+"").getBytes())i+=j<48?f++:f-->0?50-j:j-47;return i;}

@LeakyNun 덕분에 -14 바이트 .
-15 덕분에 바이트 @cliffroot .

설명:

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

i->{                   // Method with integer as both parameter and return-type
  int f=0;             //  Integer-flag, starting at 0
  for(int j:(i+"").getBytes())
                       //  Loop over the digits as bytes
    i+=                //   Increase the input with:
       j<48?           //    If the current byte is '-':
        f++            //     Increase the input with the flag-integer `f` (which is 0),
                       //     and increase the flag-integer `f` by 1 afterwards
       :               //    Else:
        f-->0?         //     If the flag-integer `f` is 1,
                       //     and decrease the flag-integer `f` back to 0 afterwards
         50-j          //      Increase it with 50 minus the current byte
        :              //    Else
         j-47;         //     Increase it with the byte as digit
                       //      + 1 to cover for the length part in ILD
  return i;}           //  Return the modified input as result

Perl 6-30 바이트

그대로 문자 그대로

{$^a+$^a.chars+[+]($^a.comb)}

익명 함수로 사용

> {$^a+$^a.chars+[+]($^a.comb)}(99)
119 

자바 스크립트 (ES6), 38 바이트

n=>eval([n+=``,n.length,...n].join`+`)

이전 조인 및 평가 트릭을 사용합니다. 문자열 입력을 주장 할 수 있다면 4 바이트를 절약하십시오.

f=
n=>eval([n,n.length,...n].join`+`)
;

<input type=number oninput=o.value=f(this.value)><input id=o readonly>

C ++, 255 바이트

#include <iostream>
#include <string>
#include <stdlib.h>
using namespace std;
int main(){
    string input;
    cin >> input;
    int sum = atoi(input.c_str()) + input.length();
    for(unsigned i = 0; i < input.length(); ++i)
        sum += input.at(i) - 48;
    return 0;
}

펄 5-37 바이트

warn eval(join'+',/./g)+($_+=()=/./g)

입력이 $ _에 있습니다

자바 스크립트 (외부 라이브러리 사용) (45 바이트)

LINQ를 Javascript로 가져 오기 위해 작성한 라이브러리를 사용하여 다음을 작성할 수있었습니다.

(i)=>i+(i+"").length+_.From(i+"").Sum(x=>x|0)

C, 132 (116) 113 80

t,c;f(char*v){for(c=atoi(v+=t=*v==45);*v;t=0,++v)c+=t?50-*v-2*c:*v-47;return c;}

함수 f()는 입력을 문자열로 받아서 결과를 정수로 반환합니다. 전체 프로그램 버전 (113 바이트) :

t;main(int c,char**v){char*p=v[1];c=atoi(p+=t=*p==45);for(c=t?-c:c;*p;++p,t=0)c+=t?50-*p:*p-47;printf("%d\n",c);}

하나의 인수가 필요합니다.

펄, 27 바이트

22 바이트 코드 + 5 -paF .

$"="+";$_+=@F+eval"@F"

설명

-a빈 분리 문자와 함께 자동 분할 옵션을 사용합니다 (-F ) 전달 된 자릿수 배열을 만듭니다. $"문자열에 삽입 될 때 배열을 결합하는 데 사용되는 char을 제어하는 magic 변수 를 사용합니다 (우리는"+" 여기서는 여기에 ). 스칼라 컨텍스트에서 사용하면 목록의 길이 (자릿수)가 반환됩니다.

용법

echo -n 99 | perl -paF -e'$"="+";$_+=@F+eval"@F"'
119

펄, 27 바이트

22 바이트 코드 + 5 -paF .

대체 솔루션으로 더 이상 바이트를 읽을 수 없습니다. 나는 더 비밀스럽게 보이기 때문에 다른 것을 선호합니다!

$_+=@F+eval join"+",@F

dc, 56 바이트

?dZrdd1sa[1+r0r-_1sa]sb0>b[A~rd0<x]dsxxrla*[+z1<y]dsyxp

Joe의 것보다 짧지는 않지만 다소 다른 구현 (및 입력으로 빼기 명령과 음수를 취하는 것). 아마도 더 많은 골프를 타실 수 있지만 점심은 너무 오래 지속됩니다.

?                #input
dZrdd            #find no. of digits, rotate to bottom of stack, dup input twice
1sa              #coefficient for first digit stored in register 'a'
[1+r0r-_1sa]sb   #macro 'b' executes on negative numbers. add one (for the neg. sign)
                 #rotate this value out of the way, leave a positive copy on top
0>b              #run the above macro if negative
[A~rd0<x]dsxx    #create and run macro 'x'; mod 10 to grab least significant digit
                 #keep doing it if quotient is greater than zero
rla*             #a zero remains in the way of our most significant digit, rotate it down
                 #and multiply said digit by our coefficient 'a' from earlier
[+z1<y]dsyx      #add two top stack values (we left that zero there to ensure this always
                 #works), check stack depth and keep doing it while there's stack
p                #print!

R, 108 바이트

파티에 다시 조금 늦었지만 여기에 간다.

s=strsplit(paste(n<-scan()),"")[[1]];n+nchar(n)+sum(as.integer(if(n<0)c(paste0(s[1],s[2]),s[1:2*-1])else s))

일반적으로 임의의 숫자를 자릿수로 나누려면 (예 : 합계) R은 먼저 문자열로 변환 한 다음 문자열을 문자열 벡터로 분할해야합니다. 요소를 요약하려면 문자열 벡터를 숫자 또는 정수로 변환해야합니다. 음수의 자릿수 합계와 함께 예외와 함께 많은 바이트를 차지합니다.

경고 메시지가 허용되면 예외는 약간 (96 바이트까지) 골프를 칠 수 있습니다.

s=as.integer(strsplit(paste(n<-scan()),"")[[1]]);if(n<0){s[2]=s[2]*-1;s=s[-1]};n+nchar(n)+sum(s)

이 경우 문자열 벡터는을 사용하여 직접 정수로 변환됩니다 as.integer. 그러나 음수의 경우 벡터의 첫 번째 요소는 빼기 기호 "-"입니다. 이로 인해 문제가 발생합니다. 예 : as.numeric(c("-",1,2,3))will return NA 1 2 3and warning message. 이를 피하려면 NA를 제거한 다음 -1합을 취하기 전에 첫 번째 요소에 곱하십시오 .

RProgN, 30 바이트

] '' . ] '-?.' | sum _ \ L + +

설명

]               # Clone the input
                #
'' . ]          # Convert it to a string, then clone it again.
'-?.' | sum     # Split it into chunks via the pattern '-?.' (A - if there is one, followed by a single character). Sum the resulting array.
_               # Floor the value, purely because I hate floats.
\ L + +         # Swap the top value with the value underneith it, to work with the string again. Get it's length, add the top, middle, and bottom, which is now the length, the sum and the input respectively.

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

펄 5 , 22 + 1 (-p) = 23 바이트

$_+=eval s//+/gr.y///c

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

AWK , 64 63 61 바이트

{s=j=0;for(;j++<n=split($1,a,"");s+=$1>0||j-2?a[j]:-a[j]);$0+=n+s}1

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

TIO 링크에는 6 개의 추가 바이트 s=j=0;가있어 다중 라인 입력이 가능합니다. 이것은 내가 생각해 낼 수있는 가장 짧은 방법입니다. 에서 더 짧게 수행 할 수 있는지 궁금합니다 AWK.

Kevin 덕분에 2 바이트 절약