Đầu vào:

Một số nguyên

Đầu ra:

Tổng của đầu vào chính + độ dài của đầu vào + mỗi chữ số riêng của đầu vào.

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

Ví dụ:

Đầu vào: 99
Đầu ra: 99(nr) + 2(nr-length) + (9 + 9)(chữ số) →119

Đầu vào: 123
Đầu ra: 123 + 3 + (1 + 2 + 3)→132

Quy tắc thử thách:

• Đầu vào cũng có thể chứa đầu vào tiêu cực, được giải quyết đặc biệt. Dấu -/ dấu trừ cũng +1dành cho độ dài và là một phần của dấu đầu tiên digit.
  Ví dụ:

  Đầu vào: -123
  Đầu ra: -123 + 4 + (-1 + 2 + 3)→-115

• Bạn có thể giả sử rằng đầu vào cũng như đầu ra sẽ nằm ngoài phạm vi của một số nguyên (32 bit).

Quy tắc chung:

• Đây là môn đánh gôn , vì vậy câu trả lời ngắn nhất bằng byte thắng.
  Đừng để ngôn ngữ mã-golf ngăn cản bạn đăng câu trả lời với các ngôn ngữ không mã hóa. Cố gắng đưa ra một câu trả lời càng ngắn càng tốt cho ngôn ngữ lập trình 'bất kỳ'.
• Các quy tắc chuẩn áp dụng cho câu trả lời của bạn, vì vậy bạn được phép sử dụng STDIN / STDOUT, các hàm / phương thức với các tham số thích hợp và kiểu trả về, các chương trình đầy đủ. Cuộc gọi của bạn.
• Lỗ hổng mặc định bị cấm.
• Nếu có thể, vui lòng thêm một liên kết với một bài kiểm tra cho mã của bạn.
• Ngoài ra, xin vui lòng thêm một lời giải thích nếu cần thiết.

Các trường hợp thử nghiệm:

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

Bán liên quan: Tổng số tất cả các chữ số

05AB1E, 28 20 18 8 byte

ÐgsS'+ýO

Giải trình

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

Dùng thử trực tuyến

Đã lưu 10 byte nhờ @Adnan

Python 2, 39 byte

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

Bộ kiểm tra

Sử dụng cùng một thủ thuật như trong câu trả lời Pyth của tôi .

Bình thường, 11 10 byte

Cảm ơn @LeakyNun cho một byte!

++vj\+`Ql`

Bộ kiểm tra

Giải trình

++ vj \ + `Ql`QQ # Q = đầu vào, hai cuối cùng được thêm vào

  vj \ + `Q # Tham gia đầu vào trên '+' và đánh giá nó
        l`Q # Độ dài của đầu vào
           Q # Đầu vào chính nó
++ # Thêm ba giá trị đó để có kết quả

CJam, 18

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

Dùng thử trực tuyến

Giải trình:

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 byte

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

Giải trình

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 (không có EXSLT), 673 byte

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

Thổi phồng nhẹ:

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

Chạy bằng xsltproc:

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

Có, ild.xslđược thông qua hai lần: Một lần là tài liệu XSLT và sau đó là tài liệu XML được chuyển đổi. Phải có tài liệu đầu vào vì bộ xử lý XSLT thường yêu cầu một bộ để bắt đầu chạy. (XSLT được thiết kế để xác định chuyển đổi từ tài liệu đầu vào sang tài liệu đầu ra; chạy một biến đổi chỉ với các tham số dòng lệnh như tôi đã thực hiện ở đây là không điển hình.) Đối với chương trình này, mọi tài liệu XML được định dạng tốt sẽ đủ làm đầu vào và, XSLT là một ứng dụng của XML, bất kỳ biến đổi XSLT nào được định dạng tốt đều theo định nghĩa là một tài liệu XML được định dạng tốt.

MATL, 20 byte

tVtnw48-PZ}t0<?x_]vs

Dùng thử trực tuyến

Tất cả các trường hợp thử nghiệm

Giải trình

        % 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

Clojure, 102 byte

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

Hàm ẩn danh xây dựng một chuỗi trông giống (+ -123 4 -1 2 3 )và đánh bại nó. Mọi thứ đều đẹp như vậy, xây dựng chuỗi từ số, độ dài của nó, và sau đó ánh xạ từng ký hiệu biểu diễn chuỗi của số trừ trừ chính nó cộng với không gian và dấu trừ vẫn như cũ

Bạn có thể thấy nó chạy ở đây: https://ideone.com/FG4lsB

APL Dyalog , 19 17 16 byte

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

Lấy chuỗi và trả về

 ≢độ dài
+cộng
 #trong
⍎đánh giá không gian tên gốc của các
 '\d'⎕R'&+'chữ số regex nối ​​với dấu cộng
,theo sau là
 ⊢chuỗi không thay đổi

Khoan3 cảm ơn ngn

Matlab, 76 67 byte

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

9 byte được lưu nhờ @Luis Mendo

Giải trình:

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 byte

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

Giải thích:

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

Điều này phức tạp hơn nhiều so với tôi dự kiến! Thử thách tốt :)

Bash + coreutils, 36 byte

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

Giải trình:

     $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

Trong sed, \Bcũng khớp giữa hai ký tự không từ liên tiếp, do đó, đối với số âm, nó khớp giữa '^' và '-'. Lưu ý các 0$1mẹo cần thiết \Bđể đưa ra 0-1+2+3, ví dụ.

Chạy ví dụ: 'input.txt' chứa tất cả các trường hợp kiểm tra trong câu lệnh của câu hỏi

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

Đầu ra:

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 byte

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

_{Điều này sẽ hoạt động trong v2 +, nhưng tôi chỉ thử nghiệm trong v4.}

Đưa đầu vào $n. Tạo một mảng mới với ,toán tử bao gồm $nvà .lengthkhi $nđược chuyển đổi thành một chuỗi. Kết hợp với chuỗi đó $nlà một mảng char. Sau đó, toàn bộ mảng đó được -joined cùng với +trước khi được dẫn đến iex(tương tự eval). Kết quả còn lại trên đường ống và đầu ra là ẩn.

Ví dụ, đối với đầu vào -123, mảng sẽ trông như thế nào (-123, 4, -, 1, 2, 3)và chuỗi sau -joinđó sẽ trông như thế nào -123+4+-+1+2+3. Sau đó, Invoke-Expressionxảy ra, và kết quả là -115như mong đợi.

Yếu tố với load-all, 175 byte

Chà, cái này không ngắn lắm. Việc xử lý đặc biệt của trừ unary thực sự gây phiền nhiễu; Tôi đoán tôi có thể làm điều đó tốt hơn và tôi sẽ, có thể.

[ 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ụng biểu thức thay thế này:

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

Chúng tôi có thể biến các trường hợp thử nghiệm của OP thành một bộ thử nghiệm 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 byte

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 byte

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$

Xây dựng một chuỗi mà sau đó được chạy. Thật không may EXECUTE, không hoạt động với tốc ?ký PRINT, nhưng TEXTđã lưu 1 ký tự.

C #, 106 byte

Tôi đánh bại java một byte của tôi, cuộc sống của tôi đã hoàn tất

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

Ungolfed (kinda)

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

Java 8, 174 136 122 107 105 93 78 byte

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

-14 byte nhờ @LeakyNun .
-15 byte nhờ @cliffroot .

Giải trình:

Hãy thử trực tuyến.

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 byte

Theo nghĩa đen

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

Sử dụng nó như một chức năng ẩn danh

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

JavaScript (ES6), 38 byte

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

Sử dụng thủ thuật tham gia cũ và cũ. Lưu 4 byte nếu tôi có thể nhấn mạnh vào đầu vào chuỗi:

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

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

C ++, 255 byte

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

Perl 5 - 37 byte

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

Đầu vào là $ _

Javascript (sử dụng thư viện bên ngoài) (45 byte)

Sử dụng một thư viện tôi đã viết để đưa LINQ lên Javascript, tôi có thể viết như sau:

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

Hàm f()lấy đầu vào dưới dạng chuỗi và trả về kết quả dưới dạng số nguyên. Phiên bản chương trình đầy đủ (113 byte):

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

Yêu cầu một đối số.

Perl, 27 byte

Mã 22 byte + 5 cho -paF.

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

Giải trình

Sử dụng -atùy chọn autosplit với một dấu phân cách trống ( -F) tạo ra một mảng các chữ số được truyền vào. Sử dụng biến ma thuật $"điều khiển char nào được sử dụng để nối một mảng khi nó được nội suy thành một chuỗi (chúng tôi sử dụng"+" ở đây) và thực tế là một danh sách được sử dụng trong ngữ cảnh vô hướng sẽ trả về độ dài của danh sách (số chữ số).

Sử dụng

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

Perl, 27 byte

Mã 22 byte + 5 cho -paF.

Giải pháp thay thế, đó là dễ đọc hơn rất nhiều cho không có nhiều byte. Tôi thích cái khác vì nó có vẻ khó hiểu hơn!

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

dc, 56 byte

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

Không ngắn hơn Joe ở trên, nhưng cách triển khai hơi khác (và một cách lấy số âm làm đầu vào so với lệnh trừ). Có lẽ có thể chơi golf nhiều hơn, nhưng bữa trưa chỉ kéo dài quá lâu.

?                #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 byte

Một chút muộn để tiệc tùng một lần nữa nhưng ở đây nó đi:

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

Để phân chia các chữ số của bất kỳ số nào (ví dụ để tính tổng chúng), R yêu cầu chúng tôi trước tiên chuyển đổi thành một chuỗi và sau đó phân tách chuỗi thành một vectơ chuỗi. Để tổng hợp các phần tử, vectơ chuỗi phải được chuyển đổi thành số hoặc số nguyên. Điều này cùng với ngoại lệ với tổng các chữ số của một số âm ăn hết rất nhiều byte.

Ngoại lệ có thể được đánh một chút (đến 96 byte) nếu các thông báo cảnh báo được cho phép.

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

Trong trường hợp này, vectơ chuỗi được chuyển đổi thành số nguyên trực tiếp bằng cách sử dụng as.integer. Tuy nhiên, đối với các số âm, phần tử đầu tiên trong vectơ sẽ là dấu trừ : "-". Điều này gây ra một số rắc rối, ví dụ: as.numeric(c("-",1,2,3))sẽ trở lại NA 1 2 3và một thông báo cảnh báo. Để phá vỡ điều này, loại bỏ NA và sau đó nhân phần tử đầu tiên với -1trước khi lấy tổng.

RProgN, 30 byte

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

Giải thích

]               # 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.

Hãy thử trực tuyến!

Perl 5 , 22 + 1 (-p) = 23 byte

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

Hãy thử trực tuyến!

AWK , 64 63 61 byte

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

Hãy thử trực tuyến!

Liên kết TIO có thêm 6 byte s=j=0;để cho phép nhập nhiều dòng. Đây là phương pháp ngắn nhất tôi có thể nghĩ ra. Tôi tò mò nếu nó có thể được thực hiện ngắn hơn trong AWK.

Đã lưu 2 byte, cảm ơn Kevin