Eingang:

Eine ganze Zahl

Ausgabe:

Summe der Eingabe selbst + Länge der Eingabe + jede einzelne Ziffer der Eingabe.

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

Beispiele:

Eingabe: 99
Ausgabe: 99(nr) + 2(nr-Länge) + (9 + 9)(Ziffern) →119

Eingabe: 123
Ausgabe: 123 + 3 + (1 + 2 + 3)→132

Herausforderungsregeln:

• Die Eingabe kann auch negative Eingaben enthalten, die speziell aufgelöst werden. Das -/ Minus-Zeichen steht auch +1für die Länge und ist Teil des ersten digit.
  Beispielsweise:

  Eingabe: -123
  Ausgabe: -123 + 4 + (-1 + 2 + 3)→-115

• Sie können davon ausgehen, dass die Eingabe oder Ausgabe jemals außerhalb des Bereichs einer (32-Bit-) Ganzzahl liegen wird.

Allgemeine Regeln:

• Das ist Code-Golf , also gewinnt die kürzeste Antwort in Bytes.
  Lassen Sie sich von Code-Golf-Sprachen nicht davon abhalten, Antworten mit Nicht-Codegolf-Sprachen zu veröffentlichen. Versuchen Sie, für jede Programmiersprache eine möglichst kurze Antwort zu finden.
• Für Ihre Antwort gelten Standardregeln. Daher dürfen Sie STDIN / STDOUT, Funktionen / Methoden mit den richtigen Parametern und vollständige Programme vom Rückgabetyp verwenden. Ihr Anruf.
• Standardlücken sind verboten.
• Fügen Sie nach Möglichkeit einen Link mit einem Test für Ihren Code hinzu.
• Fügen Sie ggf. auch eine Erklärung hinzu.

Testfälle:

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

Halbverwandt: Summe aller Ziffern zählen

05AB1E, 28 20 18 8 Bytes

ÐgsS'+ýO

Erläuterung

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

Probieren Sie es online aus

Dank @Adnan 10 Bytes gespart

Python 2, 39 Bytes

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

Testsuite

Mit dem gleichen Auswertungs-Trick wie in meiner Pyth-Antwort .

Pyth, 11 10 Bytes

Danke an @LeakyNun für ein Byte!

++vj\+`Ql`

Testsuite

Erläuterung

++ vj \ + `Ql`QQ # Q = Eingabe, die letzten beiden implizit hinzugefügt

  vj \ + `Q # Verbinde die Eingabe mit '+' und bewerte sie
        l`Q # Länge der Eingabe
           Q # Die Eingabe selbst
++ # Addiere diese drei Werte, um das Ergebnis zu erhalten

CJam, 18

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

Probieren Sie es online aus

Erläuterung:

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

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

Erläuterung

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

Leicht aufgeblasen:

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

Mit xsltproc ausführen:

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

Ja, ild.xslwird zweimal übergeben: Einmal als XSLT-Dokument und dann als zu transformierendes XML-Dokument. Ein Eingabedokument muss vorhanden sein, da ein XSLT-Prozessor in der Regel einen Start benötigt. (XSLT wurde entwickelt, um eine Umwandlung von einem Eingabedokument in ein Ausgabedokument zu definieren. Eine Umwandlung ausschließlich mit Befehlszeilenparametern durchzuführen, wie ich es hier getan habe, ist untypisch.) Für dieses Programm reicht jedes wohlgeformte XML-Dokument als Eingabe aus Und da XSLT eine Anwendung von XML ist, ist jede wohlgeformte XSLT-Transformation per Definition ein wohlgeformtes XML-Dokument.

MATL, 20 Bytes

tVtnw48-PZ}t0<?x_]vs

Probieren Sie es online

Alle Testfälle

Erläuterung

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

Anonyme Funktion, die einen String erstellt, der aussieht (+ -123 4 -1 2 3 )und ihn auswertet. Alles ziemlich ausführlich wie es ist, konstruiere eine Zeichenfolge aus der Zahl und ihrer Länge und ordne dann jedes Symbol der Zeichenfolgendarstellung der Zahl mit Ausnahme des Minus für sich selbst zu, plus Leerzeichen und Minus bleiben gleich

Sie können es hier sehen: https://ideone.com/FG4lsB

Dyalog APL , 19 17 16 Bytes

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

Nimmt String und kehrt zurück

 ≢length
+plus
 #in der Root-Namespace-
⍎Auswertung von
 '\d'⎕R'&+'Regex-Append-Ziffern mit einem Plus,
,gefolgt von
 ⊢der nicht geänderten Zeichenfolge

–3 danke an 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 gespart dank @Luis Mendo

Erläuterung:

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)

Gleichstrom, 57 Bytes

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

Erklärt:

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

Das war weitaus komplizierter als ich erwartet hatte! Gute Herausforderung :)

Bash + Coreutils, 36 Bytes

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

Erläuterung:

     $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

In sed werden \Bauch Übereinstimmungen zwischen zwei aufeinanderfolgenden Nicht-Wort-Zeichen gefunden. Bei einer negativen Zahl wird also eine Übereinstimmung zwischen '^' und '-' gefunden. Beachten Sie zum Beispiel den 0$1Trick, den Sie \Bzum Geben brauchen 0-1+2+3.

Beispiel ausführen : 'input.txt' enthält alle Testfälle in der Anweisung der Frage

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

Ausgabe:

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

_{Dies sollte in v2 + funktionieren, aber ich habe es nur in v4 getestet.}

Übernimmt die Eingabe $n. Erstellt ein neues Array mit dem ,Operator aus $nund dem .lengthZeitpunkt, zu dem $nes in eine Zeichenfolge konvertiert wird. Verkettet damit den String $n, der als char-Array umgewandelt wurde. Dann wird das gesamte Array -joinzusammen mit +editiert, bevor es weitergeleitet wird iex(ähnlich wie eval). Das Ergebnis verbleibt in der Pipeline und die Ausgabe ist implizit.

Bei der Eingabe -123würde das Array beispielsweise so aussehen (-123, 4, -, 1, 2, 3), und der String nach dem -joinwürde so aussehen -123+4+-+1+2+3. Dann Invoke-Expressionpassiert das und das Ergebnis ist -115wie erwartet.

Faktor mit load-all175 Bytes

Nun, das ist nicht sehr kurz. Die spezielle Behandlung von unärem Minus ist wirklich ärgerlich; Ich denke, ich könnte es besser machen und werde es vielleicht tun.

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

Verwenden dieses Ersetzungsregex:

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

Wir können die Testfälle des OP in eine Faktor-Testsuite verwandeln.

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$

Baut einen String auf, der dann ausgeführt wird. Funktioniert leider EXECUTEnicht mit der ?Kurzschrift für PRINT, hat aber TEXT1 Zeichen gespeichert.

C # 106 Bytes

Ich habe Java geschlagen, mein Leben ist abgeschlossen

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

    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 dank @LeakyNun .
-15 Bytes dank @cliffroot .

Erläuterung:

Probieren Sie es online aus.

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

So wörtlich wie es nur geht

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

Verwenden Sie es als anonyme Funktion

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

JavaScript (ES6), 38 Byte

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

Verwendet den alten Join-and-Eval-Trick. Sparen Sie 4 Bytes, wenn Sie auf einer Zeichenketteneingabe bestehen können:

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)

Eingabe erfolgt in $ _

Javascript (mit externer Bibliothek) (45 Bytes)

Mit einer Bibliothek, die ich geschrieben habe, um LINQ auf Javascript zu bringen, konnte ich Folgendes schreiben:

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

Function f()nimmt die Eingabe als Zeichenfolge und gibt das Ergebnis als Ganzzahl zurück. Vollversion des Programms (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);}

Erfordert ein Argument.

Perl, 27 Bytes

22 Byte Code + 5 für -paF.

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

Erläuterung

Verwendet die -aAutosplit-Option mit einem leeren Trennzeichen ( -F), um ein Array der übergebenen Ziffern zu erstellen. Verwendet die magische Variable, $"die steuert, welches Zeichen zum Verbinden eines Arrays verwendet wird, wenn es in einen String interpoliert wird (wir verwenden es)"+" hier), und die Tatsache, dass eine Liste Im skalaren Kontext wird die Länge der Liste (die Anzahl der Stellen) zurückgegeben.

Verwendung

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

Perl, 27 Bytes

22 Byte Code + 5 für -paF.

Alternative Lösung, das ist viel lesbarer für keine Bytes mehr. Ich bevorzuge die andere, da sie kryptischer aussieht!

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

Gleichstrom, 56 Bytes

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

Nicht kürzer als Joes oben, aber eine etwas andere Implementierung (und eine, die negative Zahlen als Eingabe im Vergleich zu einem Subtraktionsbefehl verwendet). Kann wahrscheinlich mehr golfen werden, aber das Mittagessen dauert nur so lange.

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

Ein bisschen zu spät zur Party aber hier geht es weiter:

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

Um die Ziffern einer beliebigen Zahl im Allgemeinen zu teilen (z. B. um sie zu summieren), muss R zuerst in eine Zeichenfolge konvertiert und anschließend in einen Zeichenfolgenvektor aufgeteilt werden. Um die Elemente zusammenzufassen, muss der Zeichenfolgenvektor in numerisch oder ganzzahlig konvertiert werden. Dies zusammen mit der Ausnahme mit der Summe der Ziffern einer negativen Zahl verbraucht eine Menge Bytes.

Die Ausnahme kann ein wenig (auf 96 Byte) golfen werden, wenn Warnmeldungen zulässig sind.

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

In diesem Fall wird der Zeichenfolgenvektor direkt mit in eine Ganzzahl konvertiert as.integer. Doch für negative Zahlen das erste Element in dem Vektor wird ein Minuszeichen: "-". Dies verursacht einige Probleme, z. B .: as.numeric(c("-",1,2,3))wird zurückgegeben NA 1 2 3und eine Warnmeldung. Um dies zu umgehen, entfernen Sie die NA und multiplizieren Sie das erste Element mit, -1bevor Sie die Summe berechnen.

RProgN, 30 Bytes

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

Explination

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

Probieren Sie es online!

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

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

Probieren Sie es 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

Probieren Sie es online!

Die TIO-Verbindung verfügt über 6 zusätzliche Bytes s=j=0;, um eine mehrzeilige Eingabe zu ermöglichen. Dies ist die kürzeste Methode, die ich finden konnte. Ich bin gespannt, ob es in kürzer gemacht werden kann AWK.

2 Bytes gespeichert, danke Kevin