Entrada:

Um inteiro

Saída:

Soma da entrada em si + o comprimento da entrada + cada dígito individual da entrada.

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

Exemplos:

Entrada: 99
Saída: 99(nr) + 2(comprimento-nr) + (9 + 9)(dígitos) →119

Entrada: 123
Saída: 123 + 3 + (1 + 2 + 3)→132

Regras do desafio:

• A entrada também pode conter uma entrada negativa, que é resolvida como especial. O -sinal / menos também é +1para o comprimento e faz parte do primeiro digit.
  Por exemplo:

  Entrada: -123
  Saída: -123 + 4 + (-1 + 2 + 3)→-115

• Você pode assumir que a entrada nem a saída estarão fora do intervalo de um número inteiro (32 bits).

Regras gerais:

• Isso é código-golfe , então a resposta mais curta em bytes vence.
  Não permita que idiomas com código de golfe o desencorajem a postar respostas com idiomas que não sejam codegolf. Tente encontrar uma resposta o mais curta possível para 'qualquer' linguagem de programação.
• As regras padrão se aplicam à sua resposta, para que você possa usar STDIN / STDOUT, funções / método com os parâmetros adequados e programas completos do tipo retorno. Sua chamada.
• As brechas padrão são proibidas.
• Se possível, adicione um link com um teste para o seu código.
• Além disso, adicione uma explicação, se necessário.

Casos de teste:

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

Semi-relacionado: soma de contagem de todos os dígitos

05AB1E, 28 20 18 8 bytes

ÐgsS'+ýO

Explicação

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

Experimente online

Guardado 10 bytes graças a @Adnan

Python 2, 39 bytes

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

Suíte de teste

Usando o mesmo truque de avaliação que na minha resposta Pyth .

Pitão, 11 10 bytes

Obrigado a @LeakyNun por um byte!

++vj\+`Ql`

Suíte de teste

Explicação

++ vj \ + `Ql`QQ # Q = entrada, as duas últimas adicionadas implicitamente

  vj \ + `Q # Junte a entrada em '+' e avalie-a
        l`Q # Comprimento da entrada
           Q # A própria entrada
++ # Adicione esses três valores para obter o resultado

CJam, 18

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

Experimente online

Explicação:

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

Braquilog , 35 32 bytes

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

Explicação

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

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

Execute usando xsltproc:

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

Sim, ild.xslé passado duas vezes: uma vez como o documento XSLT e depois como o documento XML a ser transformado. Um documento de entrada deve estar presente porque um processador XSLT geralmente requer um para iniciar a execução. (O XSLT foi projetado para definir uma transformação de um documento de entrada em um documento de saída; executar uma transformação apenas com parâmetros de linha de comando, como fiz aqui é atípico.) Para este programa, qualquer documento XML bem formado será suficiente como entrada e, sendo XSLT um aplicativo XML, qualquer transformação XSLT bem formada é, por definição, um documento XML bem formado.

MATL, 20 bytes

tVtnw48-PZ}t0<?x_]vs

Experimente Online

Todos os casos de teste

Explicação

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

Função anônima que constrói uma string que se parece (+ -123 4 -1 2 3 )e a avalia. Tudo bem detalhado, construa string a partir do número, seu comprimento e, em seguida, mapeie cada símbolo da representação de string do número, exceto menos para si mesmo, mais espaço e menos permanece o mesmo

Você pode vê-lo em execução aqui: https://ideone.com/FG4lsB

Dyalog APL , 19 17 16 bytes

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

Toma string e retorna

 ≢avaliação de comprimento
+mais
 #no espaço
⍎de nomes raiz dos
 '\d'⎕R'&+'dígitos de acréscimo de regex com um mais
,seguido pela
 ⊢sequência não modificada

–3 graças 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 salvos graças a @Luis Mendo

Explicação:

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

Isso foi muito mais complicado do que eu esperava! Bom desafio :)

Bash + coreutils, 36 bytes

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

Explicação:

     $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

No sed, \Btambém corresponde entre dois caracteres consecutivos que não são palavras, portanto, para um número negativo, corresponde entre '^' e '-'. Observe o 0$1truque necessário para \Bdar 0-1+2+3, por exemplo.

Exemplo de execução: 'input.txt' contém todos os casos de teste na declaração da pergunta

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

Saída:

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

_{Isso deve funcionar na v2 +, mas eu testei apenas na v4.}

Recebe entrada $n. Cria uma nova matriz com o ,operador consistindo em $ne .lengthquando $né convertido em uma sequência. Concatena com isso que a string seja $nlançada como um array de caracteres. Em seguida, toda essa matriz é -joineditada +antes de ser canalizada para iex(semelhante aeval ). O resultado é deixado no pipeline e a saída está implícita.

Por exemplo, para entrada -123, a matriz seria semelhante (-123, 4, -, 1, 2, 3), ea cadeia após a -joinpareceria -123+4+-+1+2+3. Então Invoke-Expression, isso acontece e o resultado é -115o esperado.

Fator com load-all , 175 bytes

Bem, isso não é muito curto. O tratamento especial de menos unário é realmente irritante; Acho que poderia fazer melhor e talvez o faça.

[ 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 regex de substituição:

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

Podemos transformar os casos de teste do OP em um conjunto de testes do Fator.

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$

Constrói uma string que é executada. Infelizmente EXECUTEnão funciona com a ?abreviação de PRINT, mas TEXTsalvou 1 personagem.

C #, 106 bytes

Eu bato java meu byte, minha 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 (meio)

    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 graças a @LeakyNun .
-15 bytes graças a @cliffroot .

Explicação:

Experimente online.

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

Tão literal quanto possível

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

Use-o como uma função anônima

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

JavaScript (ES6), 38 bytes

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

Usa o antigo truque de junção e avaliação. Salve 4 bytes se eu puder insistir na entrada da string:

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)

A entrada está em $ _

Javascript (usando biblioteca externa) (45 bytes)

Usando uma biblioteca que escrevi para levar o LINQ ao Javascript, consegui escrever o seguinte:

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

A função f()pega a entrada como uma sequência e retorna o resultado como um número inteiro. Versão completa do 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);}

Requer um argumento.

Perl, 27 bytes

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

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

Explicação

Usa a -aopção de divisão automática com um delimitador vazio (-F ), criando uma matriz dos dígitos passados. Usa a variável mágica $"que controla qual caractere é usado para ingressar em uma matriz quando ele é interpolado em uma string (usamos "+"aqui) e o fato de que uma lista usado no contexto escalar retornará o comprimento da lista (o 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.

Solução alternativa, muito mais legível e sem mais bytes. Eu prefiro o outro, pois parece mais enigmático!

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

dc, 56 bytes

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

Não menor que o de Joe acima, mas uma implementação um pouco diferente (e que aceita números negativos como entrada versus um comando de subtração). Provavelmente pode ser jogado mais, mas o almoço dura tanto tempo.

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

Um pouco tarde para a festa novamente, mas aqui vai:

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 geralmente dividir os dígitos de qualquer número (por exemplo, somar), R exige que primeiro convertamos em uma sequência e subseqüentemente divida a sequência em um vetor de sequência. Para resumir os elementos, o vetor de string deve ser convertido em numérico ou inteiro. Isso, junto com a exceção da soma dos dígitos de um número negativo, consome muitos bytes.

A exceção pode ser alterada um pouco (até 96 bytes) se forem permitidas mensagens de aviso.

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

Nesse caso, o vetor string é convertido em número inteiro diretamente usando as.integer. No entanto, para números negativos o primeiro elemento no vector será um sinal de menos: "-". Isso causa alguns problemas, por exemplo: as.numeric(c("-",1,2,3))retornará NA 1 2 3e uma mensagem de aviso. Para contornar isso, remova o NA e multiplique o primeiro elemento -1antes de pegar a soma.

RProgN, 30 bytes

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

Explicação

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

Experimente Online!

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

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

Experimente online!

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

Experimente online!

O link TIO possui 6 bytes extras s=j=0;para permitir a entrada de várias linhas. Este é o método mais curto que eu poderia inventar. Estou curioso para saber se isso pode ser feito mais curtoAWK .

Salvo 2 bytes, obrigado Kevin