Wkład:

Liczba całkowita

Wydajność:

Suma samego wejścia + długość wejścia + każda pojedyncza cyfra wejścia.

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

Przykłady:

Input: 99
Output: 99(nr) + 2(nr-length) + (9 + 9)(cyfry) →119

Wejście: 123
Wyjście: 123 + 3 + (1 + 2 + 3)→132

Zasady konkursu:

• Dane wejściowe mogą również zawierać dane ujemne, które są rozstrzygane w sposób specjalny. Znak -/ minus jest również +1dla długości i jest częścią pierwszego digit.
  Na przykład:

  Wejście: -123
  Wyjście: -123 + 4 + (-1 + 2 + 3)→-115

• Możesz założyć, że wejście ani wyjście nigdy nie będzie poza zakresem (32-bitowej) liczby całkowitej.

Główne zasady:

• To jest golf golfowy , więc wygrywa najkrótsza odpowiedź w bajtach.
  Nie pozwól, aby języki gry w golfa zniechęcały Cię do publikowania odpowiedzi w językach niekodujących golfa. Spróbuj znaleźć możliwie najkrótszą odpowiedź na „dowolny” język programowania.
• Do odpowiedzi mają zastosowanie standardowe reguły , więc możesz używać STDIN / STDOUT, funkcji / metody z odpowiednimi parametrami i zwracanymi typami, pełnych programów. Twoja decyzja.
• Domyślne luki są zabronione.
• Jeśli to możliwe, dodaj link z testem swojego kodu.
• W razie potrzeby dodaj również wyjaśnienie.

Przypadki testowe:

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

Powiązane: Policz sumę wszystkich cyfr

05AB1E, 28 20 18 8 bajtów

ÐgsS'+ýO

Wyjaśnienie

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

Wypróbuj online

Zaoszczędź 10 bajtów dzięki @Adnan

Python 2, 39 bajtów

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

Zestaw testowy

Używam tej samej sztuczki eval jak w mojej Pyth-answer .

Pyth, 11 10 bajtów

Dzięki @LeakyNun za bajt!

++vj\+`Ql`

Zestaw testowy

Wyjaśnienie

++ vj \ + `Ql`QQ # Q = dane wejściowe, dwa ostatnie dodane pośrednio

  vj \ + `Q # Dołącz do wejścia na '+' i wypróbuj je
        l`Q # Długość wejścia
           Q # Samo wejście
++ # Dodaj te trzy wartości, aby uzyskać wynik

CJam, 18 lat

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

Wypróbuj online

Wyjaśnienie:

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 bajtów

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

Wyjaśnienie

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 (bez EXSLT), 673 bajtów

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

Lekko napompowane:

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

Uruchom za pomocą xsltproc:

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

Tak, ild.xsljest przesyłany dwukrotnie: raz jako dokument XSLT, a następnie jako dokument XML do przekształcenia. Dokument wejściowy musi być obecny, ponieważ procesor XSLT zazwyczaj wymaga jego uruchomienia. (XSLT jest zaprojektowany do zdefiniowania transformacji z dokumentu wejściowego do dokumentu wyjściowego; uruchomienie transformacji wyłącznie z parametrami wiersza poleceń, tak jak to tutaj zrobiłem, jest nietypowe.) W tym programie wystarczy dobrze sformatowany dokument XML jako dane wejściowe , a ponieważ XSLT jest aplikacją XML, każda dobrze uformowana transformacja XSLT jest z definicji dobrze uformowanym dokumentem XML.

MATL, 20 bajtów

tVtnw48-PZ}t0<?x_]vs

Wypróbuj online

Wszystkie przypadki testowe

Wyjaśnienie

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

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

Anonimowa funkcja, która konstruuje ciąg, który wygląda (+ -123 4 -1 2 3 )i sprawdza go. Wszystko, co jest dość szczegółowe, konstruuj ciąg znaków na podstawie liczby, jej długości, a następnie zamapuj każdy symbol reprezentujący ciąg znaków liczby oprócz minus do siebie plus spacja i minus pozostają takie same

Możesz zobaczyć, jak działa tutaj: https://ideone.com/FG4lsB

Dyalog APL , 19 17 16 bajtów

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

Pobiera ciąg i zwraca

 ≢długość
+plus
 #w
⍎ocenie głównej przestrzeni nazw
 '\d'⎕R'&+'wyrażeń regularnych dołącz cyfry z plusem,
,po którym
 ⊢następuje niemodyfikowany ciąg

–3 dzięki ngn

Matlab, 76 67 bajtów

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

9 bajtów zapisanych dzięki @Luis Mendo

Wyjaśnienie:

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 bajtów

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

Wyjaśnił:

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

To było o wiele bardziej skomplikowane, niż się spodziewałem! Dobre wyzwanie :)

Bash + coreutils, 36 bajtów

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

Wyjaśnienie:

     $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

W sed \Brównież dopasowuje również dwa kolejne znaki niebędące słowami, więc dla liczby ujemnej pasuje między „^” a „-”. Zwróć uwagę na 0$1sztuczki potrzebne do \Bdać 0-1+2+3, na przykład.

Uruchom przykład: „input.txt” zawiera wszystkie przypadki testowe w instrukcji pytania

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

Wydajność:

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 bajtów

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

_{To powinno działać w v2 +, ale tylko przetestowane w V4.}

Pobiera dane wejściowe $n. Tworzy nową tablicę z ,operatorem składającym się z $ni .lengthkiedy $njest konwertowany na ciąg. Łączy się z tym, że ciąg $nrzutowany jako tablica znaków . Następnie cała tablica jest -joinedytowana razem z, +zanim zostanie potokowana iex(podobnie do eval). Wynik pozostawia się w potoku, a dane wyjściowe są niejawne.

Na przykład dla danych wejściowych -123tablica wyglądałaby (-123, 4, -, 1, 2, 3), a łańcuch po niej -joinwyglądałby -123+4+-+1+2+3. Potem Invoke-Expressiontak się dzieje, a wynik jest -115zgodny z oczekiwaniami.

Po uwzględnieniu load-all175 bajtów

To nie jest bardzo krótkie. Specjalna obsługa pojedynczego minus jest naprawdę denerwująca; Myślę, że mógłbym to zrobić lepiej i może zrobię to.

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

Za pomocą tego wyrażenia regularnego podstawienia:

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

Możemy zamienić przypadki testowe OP w zestaw testów 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 bajtów

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 bajtów

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$

Tworzy ciąg, który następnie uruchamia się. Niestety EXECUTEnie działa ze ?skrótem PRINT, ale TEXTuratował 1 postać.

C #, 106 bajtów

Pokonałem java moim bajtem, moje życie jest kompletne

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 bajtów

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

-14 bajtów dzięki @LeakyNun .
-15 bajtów dzięki @cliffroot .

Wyjaśnienie:

Wypróbuj 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 bajtów

Tak dosłownie, jak to możliwe

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

Użyj go jako funkcji anonimowej

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

JavaScript (ES6), 38 bajtów

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

Wykorzystuje starą sztuczkę łączenia i ewaluacji. Zapisz 4 bajty, jeśli mogę nalegać na ciąg znaków:

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

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

C ++, 255 bajtów

#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 bajtów

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

Dane wejściowe są w $ _

JavaScript (przy użyciu zewnętrznej biblioteki) (45 bajtów)

Korzystając z biblioteki, którą napisałem, aby przenieść LINQ do Javascript, mogłem napisać:

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

Funkcja f()przyjmuje dane wejściowe jako ciąg znaków i zwraca wynik jako liczbę całkowitą. Pełna wersja programu (113 bajtów):

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

Wymaga jednego argumentu.

Perl, 27 bajtów

Kod 22 bajtów + 5 dla -paF.

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

Wyjaśnienie

Używa -aopcji autosplit z pustym separatorem ( -F), tworząc tablicę przekazywanych cyfr. Używa magicznej zmiennej, $"która kontroluje, który znak jest używany do łączenia tablicy, gdy jest ona interpolowana w łańcuch (używamy"+" tutaj) i fakt, że lista użyte w kontekście skalarnym zwróci długość listy (liczbę cyfr).

Stosowanie

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

Perl, 27 bajtów

Kod 22 bajtów + 5 dla -paF.

Alternatywne rozwiązanie, które jest o wiele bardziej czytelne dla nie więcej bajtów. Wolę drugi, ponieważ wygląda bardziej tajemniczo!

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

dc, 56 bajtów

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

Nie krótszy niż Joe powyżej, ale nieco inna implementacja (i taka, która przyjmuje liczby ujemne jako dane wejściowe vs. polecenie odejmowania). Prawdopodobnie można grać w golfa więcej, ale lunch trwa tak długo.

?                #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 bajtów

Trochę późno na imprezę, ale oto:

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

Aby ogólnie podzielić cyfry dowolnej liczby (np. Je zsumować), R wymaga od nas najpierw konwersji na ciąg, a następnie podzielenia ciągu na wektor ciągów. Podsumowując elementy, wektor łańcucha należy przekonwertować na liczbę lub liczbę całkowitą. To wraz z wyjątkiem z sumą cyfr liczby ujemnej zjada wiele bajtów.

Wyjątek może być nieco golfowy (do 96 bajtów), jeśli dozwolone są komunikaty ostrzegawcze.

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

W tym przypadku wektor łańcucha jest konwertowany bezpośrednio na liczbę całkowitą za pomocą as.integer. Jednak dla liczb ujemnych pierwszy element w wektorze będzie znak minus: "-". Powoduje to pewne problemy, np .: as.numeric(c("-",1,2,3))powróci NA 1 2 3i pojawi się komunikat ostrzegawczy. Aby to obejść, usuń NA, a następnie pomnóż pierwszy element -1przed pobraniem sumy.

RProgN, 30 bajtów

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

Wyjaśnienie

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

Wypróbuj online!

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

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

Wypróbuj online!

AWK , 64 63 61 bajtów

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

Wypróbuj online!

Łącze TIO ma 6 dodatkowych bajtów, s=j=0;aby umożliwić wprowadzanie wielu wierszy. To najkrótsza metoda, jaką mogłem wymyślić. Jestem ciekawy, czy można to zrobić krócej AWK.

Zaoszczędzono 2 bajty, dzięki Kevin