Contribution:

Un nombre entier

Sortie:

Somme de l'entrée elle-même + la longueur de l'entrée + chaque chiffre individuel de l'entrée.

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

Exemples:

Entrée: 99
Sortie: 99(nr) + 2(nr-longueur) + (9 + 9)(chiffres) →119

Entrée: 123
Sortie: 123 + 3 + (1 + 2 + 3)→132

Règles du défi:

• L'entrée peut également contenir une entrée négative, qui est résolue spéciale. Le -signe / moins correspond également +1à la longueur et fait partie du premier digit.
  Par exemple:

  Entrée: -123
  Sortie: -123 + 4 + (-1 + 2 + 3)→-115

• Vous pouvez supposer que l'entrée ou la sortie ne seront jamais hors de la plage d'un entier (32 bits).

Règles générales:

• C'est le code-golf , donc la réponse la plus courte en octets l'emporte.
  Ne laissez pas les langues de golf de code vous décourager de publier des réponses avec des langues autres que le golf de code. Essayez de trouver une réponse aussi courte que possible pour «n'importe quel» langage de programmation.
• Des règles standard s'appliquent à votre réponse, vous êtes donc autorisé à utiliser STDIN / STDOUT, fonctions / méthode avec les paramètres appropriés et des programmes complets de type retour. Ton appel.
• Les failles par défaut sont interdites.
• Si possible, veuillez ajouter un lien avec un test pour votre code.
• Veuillez également ajouter une explication si nécessaire.

Cas de test:

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

Semi-apparenté: compte somme de tous les chiffres

05AB1E, 28 20 18 8 octets

ÐgsS'+ýO

Explication

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

Essayez-le en ligne

10 octets enregistrés grâce à @Adnan

Python 2, 39 octets

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

Suite de tests

Utiliser le même eval-trick que dans ma réponse Pyth .

Pyth, 11 10 octets

Merci à @LeakyNun pour un octet!

++vj\+`Ql`

Suite de tests

Explication

++ vj \ + `Ql`QQ # Q = entrée, les deux derniers ajoutés implicitement

  vj \ + `Q # Rejoignez l'entrée sur '+' et évaluez-la
        l`Q # Longueur de l'entrée
           Q # L'entrée elle-même
++ # Ajoutez ces trois valeurs pour obtenir le résultat

CJam, 18 ans

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

Essayez-le en ligne

Explication:

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 octets

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

Explication

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 (sans EXSLT), 673 octets

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

Légèrement gonflé:

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

Exécutez à l'aide de xsltproc:

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

Oui, ild.xslest passé deux fois: une fois en tant que document XSLT puis en tant que document XML à transformer. Un document d'entrée doit être présent car un processeur XSLT en requiert généralement un pour démarrer. (XSLT est conçu pour définir une transformation d'un document d'entrée en un document de sortie; l'exécution d'une transformation uniquement avec des paramètres de ligne de commande comme je l'ai fait ici est atypique.) Pour ce programme, tout document XML bien formé suffira comme entrée , et, XSLT étant une application de XML, toute transformation XSLT bien formée est par définition un document XML bien formé.

MATL, 20 octets

tVtnw48-PZ}t0<?x_]vs

Essayez-le en ligne

Tous les cas de test

Explication

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

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

Fonction anonyme qui construit une chaîne qui ressemble à (+ -123 4 -1 2 3 ) et l'évale. Tout est assez verbeux, construisez une chaîne à partir du nombre, de sa longueur, puis mappez chaque symbole de la représentation sous forme de chaîne du nombre, sauf le moins à lui-même plus l'espace et le moins reste le même

Vous pouvez le voir fonctionner ici: https://ideone.com/FG4lsB

Dyalog APL , 19 17 16 octets

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

Prend la chaîne et retourne

 ≢longueur
+plus
 #dans l'
⍎évaluation de l' espace de noms racine des
 '\d'⎕R'&+'chiffres de l'addition regex avec un plus
,suivi de
 ⊢la chaîne non modifiée

–3 grâce à ngn

Matlab, 76 67 octets

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

9 octets enregistrés grâce à @Luis Mendo

Explication:

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 octets

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

Expliqué:

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

C'était bien plus compliqué que ce à quoi je m'attendais! Bon défi :)

Bash + coreutils, 36 octets

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

Explication:

     $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

Dans sed, \Bcorrespond également entre deux caractères non verbaux consécutifs, donc pour un nombre négatif, il correspond entre '^' et '-'. Notez l' 0$1astuce nécessaire pour \Bdonner 0-1+2+3, par exemple.

Exemple d'exécution : 'input.txt' contient tous les cas de test dans l'énoncé de la question

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

Sortie:

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 octets

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

_{Cela devrait fonctionner en v2 +, mais je n'ai testé qu'en v4.}

Prend des informations $n. Crée un nouveau tableau avec l' ,opérateur composé de $net le .lengthquand $nest converti en chaîne. Concatène avec cela la chaîne $ntranstypée en un tableau de caractères. Ensuite, l'ensemble de ce tableau est -joinédité avec +avant d'être redirigé versiex (similaire à eval). Le résultat est laissé sur le pipeline et la sortie est implicite.

Par exemple, pour l'entrée -123, le tableau ressemblerait (-123, 4, -, 1, 2, 3)et la chaîne après le -joinressemblerait -123+4+-+1+2+3. Ensuite Invoke-Expression, cela se produit et le résultat est -115comme prévu.

Facteur avec load-all , 175 octets

Eh bien, ce n'est pas très court. La gestion spéciale du moins unaire est vraiment ennuyeuse; Je suppose que je pourrais faire mieux et je le ferai peut-être.

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

En utilisant cette expression régulière de substitution:

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

Nous pouvons transformer les cas de test de l'OP en une suite de tests 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 octets

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 octets

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$

Construit une chaîne qui est ensuite exécutée. Malheureusement, EXECUTEne fonctionne pas avec le ?raccourci pour PRINT, mais a TEXTenregistré 1 caractère.

C #, 106 octets

Je bat java mon un octet, ma vie est terminée

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

Non golfé (un peu)

    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 octets

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

-14 octets grâce à @LeakyNun .
-15 octets grâce à @cliffroot .

Explication:

Essayez-le en ligne.

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 octets

Aussi littéral que possible

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

Utilisez-le comme une fonction anonyme

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

JavaScript (ES6), 38 octets

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

Utilise l'ancienne astuce join-and-eval. Économisez 4 octets si je peux insister sur l'entrée de chaîne:

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

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

C ++, 255 octets

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

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

L'entrée est en $ _

Javascript (en utilisant une bibliothèque externe) (45 octets)

En utilisant une bibliothèque que j'ai écrite pour apporter LINQ à Javascript, j'ai pu écrire ce qui suit:

(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 fonction f()prend l'entrée sous forme de chaîne et renvoie le résultat sous forme d'entier. Version complète du programme (113 octets):

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

Nécessite un argument.

Perl, 27 octets

Code de 22 octets + 5 pour -paF.

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

Explication

Utilise l' -aoption autosplit avec un délimiteur vide ( -F) créant un tableau des chiffres transmis. Utilise la variable magique$" qui contrôle le caractère utilisé pour joindre un tableau lorsqu'il est interpolé dans une chaîne (nous utilisons"+" ici) et le fait qu'une liste utilisé dans un contexte scalaire retournera la longueur de la liste (le nombre de chiffres).

Usage

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

Perl, 27 octets

Code de 22 octets + 5 pour -paF.

Solution alternative, qui est beaucoup plus lisible pour plus d'octets. Je préfère l'autre car il semble plus cryptique!

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

dc, 56 octets

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

Pas plus court que Joe ci-dessus, mais une implémentation quelque peu différente (et une qui prend des nombres négatifs en entrée par rapport à une commande de soustraction). Peut probablement être joué au golf plus, mais le déjeuner ne dure que si longtemps.

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

Un peu tard pour la fête encore une fois mais c'est parti:

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

Afin de diviser généralement les chiffres de n'importe quel nombre (par exemple, pour les additionner), R nous oblige à convertir d'abord en chaîne, puis à diviser la chaîne en un vecteur de chaîne. Pour résumer les éléments, le vecteur chaîne doit être converti en numérique ou entier. Ceci, à l'exception de la somme des chiffres d'un nombre négatif, consomme beaucoup d'octets.

L'exception peut être jouée un peu (jusqu'à 96 octets) si les messages d'avertissement sont autorisés.

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

Dans ce cas, le vecteur chaîne est converti en entier directement à l'aide de as.integer. Cependant, pour les nombres négatifs le premier élément dans le vecteur sera un signe moins: "-". Cela provoque des problèmes, par exemple: as.numeric(c("-",1,2,3))reviendra NA 1 2 3et un message d'avertissement. Pour contourner cela, supprimez le NA puis multipliez le premier élément par -1avant de prendre la somme.

RProgN, 30 octets

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

Explication

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

Essayez-le en ligne!

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

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

Essayez-le en ligne!

AWK , 64 63 61 octets

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

Essayez-le en ligne!

La liaison TIO a 6 octets supplémentaires s=j=0;pour permettre une entrée multiligne. C'est la méthode la plus courte que j'ai pu trouver. Je suis curieux de savoir si cela peut être fait plus rapidement AWK.

Enregistré 2 octets, merci Kevin