Ingresso:

Un numero intero

Produzione:

Somma dell'ingresso stesso + la lunghezza dell'ingresso + ogni singola cifra dell'ingresso.

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

Esempi:

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

Ingresso: 123
Uscita: 123 + 3 + (1 + 2 + 3)→132

Regole della sfida:

• L'input può contenere anche input negativi, che vengono risolti in modo speciale. Il -segno / meno è anche +1per la lunghezza e fa parte del primo digit.
  Per esempio:

  Ingresso: -123
  Uscita: -123 + 4 + (-1 + 2 + 3)→-115

• Si può presumere che l'input e l'output non saranno mai al di fuori dell'intervallo di un numero intero (a 32 bit).

Regole generali:

• Questo è code-golf , quindi vince la risposta più breve in byte.
  Non lasciare che le lingue di code-golf ti scoraggino dal pubblicare risposte con lingue non codegolfing. Prova a trovare una risposta il più breve possibile per "qualsiasi" linguaggio di programmazione.
• Per la tua risposta valgono regole standard , quindi puoi usare STDIN / STDOUT, funzioni / metodo con i parametri corretti e tipo di ritorno, programmi completi. La tua chiamata.
• Sono vietate le scappatoie predefinite .
• Se possibile, aggiungi un link con un test per il tuo codice.
• Inoltre, si prega di aggiungere una spiegazione, se necessario.

Casi test:

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

Semi-correlati: conteggio della somma di tutte le cifre

05AB1E, 28 20 18 8 byte

ÐgsS'+ýO

Spiegazione

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

Provalo online

10 byte salvati grazie a @Adnan

Python 2, 39 byte

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

Suite di test

Usando lo stesso trucco di valutazione della mia risposta Pyth .

Pyth, 11 10 byte

Grazie a @LeakyNun per un byte!

++vj\+`Ql`

Suite di test

Spiegazione

++ vj \ + `Ql`QQ # Q = input, ultimi due aggiunti implicitamente

  vj \ + `Q # Unisci l'input su '+' ed eseguilo
        l`Q # Lunghezza dell'input
           Q # L'input stesso
++ # Aggiungi questi tre valori per ottenere il risultato

CJam, 18 anni

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

Provalo online

Spiegazione:

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 byte

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

Spiegazione

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

Leggermente gonfiato:

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

Esegui usando xsltproc:

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

Sì, ild.xslviene passato due volte: una volta come documento XSLT e poi come documento XML da trasformare. Un documento di input deve essere presente perché un processore XSLT richiede generalmente uno per iniziare l'esecuzione. (XSLT è progettato per definire una trasformazione da un documento di input a un documento di output; eseguire una trasformazione esclusivamente con i parametri della riga di comando come ho fatto qui è atipico.) Per questo programma, qualsiasi documento XML ben formato sarà sufficiente come input e, essendo XSLT un'applicazione di XML, qualsiasi trasformazione XSLT ben formata è per definizione un documento XML ben formato.

MATL, 20 byte

tVtnw48-PZ}t0<?x_]vs

Provalo online

Tutti i casi di test

Spiegazione

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

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

Funzione anonima che costruisce una stringa che assomiglia (+ -123 4 -1 2 3 )e la elimina. Tutto quanto è prolisso così com'è, costruisci la stringa dal numero, la sua lunghezza, e quindi mappa ogni simbolo della rappresentazione della stringa del numero tranne meno a se stesso più spazio e meno rimane lo stesso

Puoi vederlo in esecuzione qui: https://ideone.com/FG4lsB

Dyalog APL , 19 17 16 byte

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

Prende la stringa e restituisce

 ≢lunghezza
+plus
 #nella
⍎valutazione dello spazio dei nomi radice delle
 '\d'⎕R'&+'cifre di regex append con un plus
,seguito dalla
 ⊢stringa non modificata

–3 grazie a ngn

Matlab, 76 67 byte

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

9 byte salvati grazie a @Luis Mendo

Spiegazione:

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 byte

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

Ha spiegato:

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

Questo è stato molto più complicato di quanto mi aspettassi! Bella sfida :)

Bash + coreutils, 36 byte

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

Spiegazione:

     $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, \Bcorrisponde anche tra due caratteri consecutivi non di parole, quindi per un numero negativo corrisponde tra '^' e '-'. Nota il 0$1trucco necessario per \Bdare 0-1+2+3, per esempio.

Esempio di esecuzione: "input.txt" contiene tutti i casi di test nell'istruzione della domanda

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

Produzione:

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 byte

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

_{Questo dovrebbe funzionare in v2 +, ma ho provato solo in v4.}

Accetta input $n. Crea un nuovo array con l' ,operatore costituito da $ne il .lengthmomento in cui $nviene convertito in una stringa. Concatena con ciò la stringa $ngenerata come char-array. Quindi, l'intero array viene -joineditato insieme +prima di essere reindirizzato iex(simile a eval). Il risultato viene lasciato sulla pipeline e l'output è implicito.

Ad esempio, per l'input -123, l'array sarebbe simile (-123, 4, -, 1, 2, 3)e la stringa dopo l' -joinaspetto sarebbe simile -123+4+-+1+2+3. Quindi Invoke-Expressionsuccede, e il risultato è -115come previsto.

Fattore con load-all, 175 byte

Bene, questo non è molto breve. La gestione speciale del meno unario è davvero fastidiosa; Immagino di poterlo fare meglio e forse lo farò.

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

Utilizzando questa regex di sostituzione:

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

Possiamo trasformare i casi di test del PO in una suite di test fattoriali.

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 byte

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 byte

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$

Costruisce una stringa che viene quindi eseguita. Sfortunatamente EXECUTEnon funziona con la ?scorciatoia per PRINT, ma ha TEXTsalvato 1 carattere.

C #, 106 byte

Ho battuto java my a byte, la mia vita è 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 (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 byte

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

-14 byte grazie a @LeakyNun .
-15 byte grazie a @cliffroot .

Spiegazione:

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

Il più letterale possibile

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

Usalo come una funzione anonima

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

JavaScript (ES6), 38 byte

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

Usa il vecchio trucco join-and-eval. Salva 4 byte se posso insistere sull'input della stringa:

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

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

C ++, 255 byte

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

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

L'input è in $ _

Javascript (utilizzando una libreria esterna) (45 byte)

Utilizzando una libreria che ho scritto per portare LINQ in Javascript, sono stato in grado di scrivere quanto segue:

(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 funzione f()accetta l'input come stringa e restituisce il risultato come intero. Versione completa del programma (113 byte):

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

Richiede un argomento.

Perl, 27 byte

22 byte codice + 5 per -paF.

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

Spiegazione

Utilizza l' -aopzione autosplit con un delimitatore vuoto ( -F) creando un array delle cifre passate. Utilizza la variabile magica $"che controlla quale carattere viene utilizzato per unire un array quando viene interpolato in una stringa (usiamo"+" qui ) e il fatto che un elenco utilizzato nel contesto scalare restituirà la lunghezza dell'elenco (il numero di cifre).

uso

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

Perl, 27 byte

22 byte codice + 5 per -paF.

Soluzione alternativa, molto più leggibile per non più byte. Preferisco l'altro in quanto sembra più criptico!

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

dc, 56 byte

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

Non più breve di quello di Joe sopra, ma un'implementazione leggermente diversa (e una che accetta numeri negativi come input rispetto a un comando di sottrazione). Probabilmente si può giocare a golf di più, ma il pranzo dura solo così 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 byte

Ancora un po 'tardi alla festa, ma eccola qui:

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

Al fine di dividere generalmente le cifre di qualsiasi numero (ad esempio per sommarle), R richiede prima di tutto di convertire in una stringa e successivamente di dividere la stringa in un vettore di stringa. Per riassumere gli elementi, il vettore di stringa deve essere convertito in numerico o intero. Questo insieme all'eccezione con la somma delle cifre di un numero negativo consuma molti byte.

L'eccezione può essere risolta un po '(fino a 96 byte) se sono consentiti messaggi di avviso.

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 questo caso il vettore di stringa viene convertito in intero direttamente utilizzando as.integer. Tuttavia, per i numeri negativi il primo elemento nel vettore sarà un segno meno: "-". Ciò causa alcuni problemi, ad es .: as.numeric(c("-",1,2,3))restituirà NA 1 2 3un messaggio di avviso. Per aggirare questo, rimuovere il NA e quindi moltiplicare il primo elemento con -1prima di prendere la somma.

RProgN, 30 byte

] '' . ] '-?.' | 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.

Provalo online!

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

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

Provalo online!

AWK , 64 63 61 byte

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

Provalo online!

Il collegamento TIO ha 6 byte extra s=j=0;per consentire l'input multi-linea. Questo è il metodo più breve che ho potuto inventare. Sono curioso di sapere se si può fare in menoAWK .

Salvato 2 byte, grazie Kevin