Entrada:

Un entero

Salida:

Suma de la entrada en sí + la longitud de la entrada + cada dígito individual de la entrada.

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

Ejemplos:

Entrada: 99
Salida: 99(nr) + 2(nr-length) + (9 + 9)(dígitos) →119

Entrada: 123
Salida: 123 + 3 + (1 + 2 + 3)→132

Reglas de desafío:

• La entrada también puede contener entrada negativa, que se resuelve especial. El -signo / menos también es +1para la longitud y es parte del primero digit.
  Por ejemplo:

  Entrada: -123
  Salida: -123 + 4 + (-1 + 2 + 3)→-115

• Puede suponer que la entrada o la salida alguna vez estarán fuera del rango de un entero (32 bits).

Reglas generales:

• Este es el código de golf , por lo que la respuesta más corta en bytes gana.
  No permita que los lenguajes de código de golf lo desalienten de publicar respuestas con idiomas que no sean de código. Trate de encontrar una respuesta lo más breve posible para 'cualquier' lenguaje de programación.
• Se aplican reglas estándar para su respuesta, por lo que puede usar STDIN / STDOUT, funciones / método con los parámetros adecuados y programas completos de tipo retorno. Tu llamada.
• Las lagunas predeterminadas están prohibidas.
• Si es posible, agregue un enlace con una prueba para su código.
• Además, agregue una explicación si es necesario.

Casos de prueba:

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

Semi-relacionado: Cuenta de suma de todos los dígitos

05AB1E, 28 20 18 8 bytes

ÐgsS'+ýO

Explicación

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

Pruébalo en línea

Guardado 10 bytes gracias a @Adnan

Python 2, 39 bytes

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

Banco de pruebas

Usando el mismo truco eval que en mi respuesta Pyth .

Pyth, 11 10 bytes

¡Gracias a @LeakyNun por un byte!

++vj\+`Ql`

Banco de pruebas

Explicación

++ vj \ + `Ql`QQ # Q = input, los dos últimos agregados implícitamente

  vj \ + `Q # Unir la entrada en '+' y evaluarla
        l`Q # Longitud de la entrada
           Q # La entrada en sí
++ # Agregar esos tres valores para obtener el resultado

CJam, 18

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

Pruébalo en línea

Explicación:

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 bytes

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

Explicación

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 (sin EXSLT), 673 bytes

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

Ligeramente inflado:

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

Ejecutar usando xsltproc:

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

Sí, ild.xslse pasa dos veces: una vez como documento XSLT y luego como documento XML para transformar. Un documento de entrada debe estar presente porque un procesador XSLT generalmente requiere uno para comenzar a ejecutarse. (XSLT está diseñado para definir una transformación de un documento de entrada a un documento de salida; ejecutar una transformación únicamente con parámetros de línea de comandos como lo he hecho aquí es atípico). Para este programa, cualquier documento XML bien formado será suficiente como entrada. y, siendo XSLT una aplicación de XML, cualquier transformación XSLT bien formada es, por definición, un documento XML bien formado.

MATL, 20 bytes

tVtnw48-PZ}t0<?x_]vs

Pruébalo en línea

Todos los casos de prueba

Explicación

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

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

Función anónima que construye una cadena que se parece a (+ -123 4 -1 2 3 ) y la evalúa. Todo es bastante detallado como es, construya una cadena a partir del número, su longitud y luego asigne cada símbolo de la representación de cadena del número, excepto menos a sí mismo más espacio y menos sigue siendo el mismo

Puede verlo ejecutándose aquí: https://ideone.com/FG4lsB

Dyalog APL , 19 17 16 bytes

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

Toma una cuerda y regresa

 ≢longitud
+más
 #en la
⍎evaluación del espacio de nombres raíz de
 '\d'⎕R'&+'dígitos regex anexar con un signo más
,seguido de
 ⊢ la cadena no modificada

–3 gracias a ngn

Matlab, 76 67 bytes

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

9 bytes guardados gracias a @Luis Mendo

Explicación:

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)

cc, 57 bytes

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

Explicado:

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

¡Esto fue mucho más complicado de lo que esperaba! Buen reto :)

Bash + coreutils, 36 bytes

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

Explicación:

     $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

En sed, \Btambién coincide entre dos caracteres consecutivos sin palabras, por lo que para un número negativo coincide entre '^' y '-'. Nota la0$1 truco necesario para \Bdar 0-1+2+3, por ejemplo.

Ejecute el ejemplo: 'input.txt' contiene todos los casos de prueba en la declaración de la pregunta

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

Salida:

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 bytes

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

_{Esto debería funcionar en v2 +, pero solo lo probé en v4.}

Toma entrada $n. Crea una nueva matriz con el ,operador formado por $ny .lengthcuándo $nse convierte en una cadena. Concatena con eso la cadena $nemitida como una matriz de caracteres. Luego, toda esa matriz se -joinedita +antes de ser canalizada aiex (similar a eval). El resultado se deja en la tubería y la salida es implícita.

Por ejemplo, para la entrada -123, la matriz se vería así (-123, 4, -, 1, 2, 3), y la cadena después de que la -joinvería así -123+4+-+1+2+3. Entonces Invoke-Expressionsucede, y el resultado es el -115esperado.

Factorizar con load-all 175 bytes

Bueno, esto no es muy corto. El manejo especial de unario menos es realmente molesto; Creo que podría hacerlo mejor y lo haré, tal vez.

[ 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 + + ]

Usando esta expresión regular de sustitución:

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

Podemos convertir los casos de prueba del OP en un conjunto de pruebas de 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 bytes

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 bytes

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$

Construye una cadena que luego se ejecuta. Desafortunadamente EXECUTEno funciona con la ?taquigrafía para PRINT, pero TEXTsalvó 1 personaje.

C #, 106 bytes

Le gané a Java mi byte, mi vida está completa

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 (un poco)

    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 bytes

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

-14 bytes gracias a @LeakyNun .
-15 bytes gracias a @cliffroot .

Explicación:

Pruébalo en línea.

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 bytes

Tan literal como se pone

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

Úselo como una función anónima

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

JavaScript (ES6), 38 bytes

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

Utiliza el viejo truco de unir y evaluar. Ahorre 4 bytes si puedo insistir en la entrada de cadena:

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

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

C ++, 255 bytes

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

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

La entrada está en $ _

Javascript (usando una biblioteca externa) (45 bytes)

Usando una biblioteca que escribí para traer LINQ a Javascript, pude escribir lo siguiente:

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

La función f()toma la entrada como una cadena y devuelve el resultado como un entero. Versión completa del programa (113 bytes):

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

Requiere un argumento.

Perl, 27 bytes

Código de 22 bytes + 5 para -paF.

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

Explicación

Utiliza la -aopción de división automática con un delimitador vacío ( -F) que crea una matriz de los dígitos pasados. Utiliza la variable mágica$" que controla qué carácter se usa para unir una matriz cuando se interpola en una cadena (usamos "+"aquí) y el hecho de que una lista usado en contexto escalar devolverá la longitud de la lista (el número de dígitos).

Uso

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

Perl, 27 bytes

Código de 22 bytes + 5 para -paF.

Solución alternativa, que es mucho más legible para no más bytes. ¡Prefiero el otro ya que parece más críptico!

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

cc, 56 bytes

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

No más corto que el anterior de Joe, pero una implementación algo diferente (y una que toma números negativos como entrada frente a un comando de resta). Probablemente se pueda jugar más al golf, pero el almuerzo solo dura tanto tiempo.

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

Un poco tarde para la fiesta nuevamente, pero aquí va:

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

Para dividir generalmente los dígitos de cualquier número (por ejemplo, para sumarlos), R requiere que primero se convierta en una cadena y luego se divida la cadena en un vector de cadena. Para resumir los elementos, el vector de cadena se debe convertir a numérico o entero. Esto, junto con la excepción con la suma de los dígitos de un número negativo, consume muchos bytes.

La excepción se puede jugar un poco (a 96 bytes) si se permiten mensajes de advertencia.

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

En este caso, el vector de cadena se convierte a entero directamente usando as.integer. Sin embargo, para los números negativos el primer elemento en el vector será un signo menos: "-". Esto causa algunos problemas, por ejemplo: as.numeric(c("-",1,2,3))volverá NA 1 2 3y aparecerá un mensaje de advertencia. Para evitar esto, elimine el NA y luego multiplique el primer elemento -1antes de tomar la suma.

RProgN, 30 Bytes

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

Explicacion

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

Pruébalo en línea!

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

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

Pruébalo en línea!

AWK , 64 63 61 bytes

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

Pruébalo en línea!

El enlace TIO tiene 6 bytes adicionales s=j=0;para permitir la entrada de varias líneas. Este es el método más corto que se me ocurrió. Tengo curiosidad si se puede hacer más corto AWK.

Guardado 2 bytes, gracias Kevin