Giriş:

Bir tam sayı

Çıktı:

Girişin kendisinin toplamı + girişin uzunluğu + girişin her basamağı.

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

Örnekler:

Giriş: 99
Çıkış: 99(nr) + 2(nr) + (9 + 9)(rakam) →119

Giriş: 123
Çıkış: 123 + 3 + (1 + 2 + 3)→132

Meydan okuma kuralları:

• Giriş ayrıca özel olarak çözülen negatif girişleri de içerebilir. -/ Eksi işareti aynı zamanda +1uzunluğu ve birinci bir parçasıdır digit.
  Örneğin:

  Giriş: -123
  Çıkış: -123 + 4 + (-1 + 2 + 3)→-115

• Girdi veya çıkışın bir (32 bit) tamsayı aralığının dışında olacağını varsayabilirsiniz.

Genel kurallar:

• Bu kod golf , bayt cinsinden en kısa cevap kazanır.
  Code-golf dillerinin, codegolfing olmayan dillerle cevap göndermekten vazgeçmesine izin vermeyin. Herhangi bir programlama dili için mümkün olduğunca kısa bir cevap bulmaya çalışın.
• Cevabınız için standart kurallar geçerlidir , bu nedenle STDIN / STDOUT fonksiyonlarını, uygun parametrelerle fonksiyonlarını ve geri dönüş tipini, tam programları kullanmanıza izin verilir. Senin çağrı.
• Varsayılan Loopholes yasaktır.
• Mümkünse, lütfen kodunuz için test içeren bir bağlantı ekleyin.
• Ayrıca, lütfen gerekirse bir açıklama ekleyin.

Test durumları:

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

Yarı ilişkili: Tüm Rakamların Sayı Toplamı

05AB1E, 28 20 18 8 bayt

ÐgsS'+ýO

açıklama

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

Çevrimiçi deneyin

@Adnan sayesinde 10 bayt kaydedildi

Python 2,39 bayt

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

Test odası

Pyth cevabımdakiyle aynı değerlendirme numarasını kullanmak .

Pyth, 11 10 bayt

Bir bayt için @LeakyNun teşekkürler!

++vj\+`Ql`

Test odası

açıklama

++ vj \ + `Ql`QQ # Q = giriş, son iki örtülü olarak eklendi

  vj \ + `Q # '+' girdisine katılın ve değerlendirin
        l`Q # Girişin uzunluğu
           Q # Girişin kendisi
++ # Sonucu elde etmek için bu üç değeri ekleyin

CJam, 18

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

Çevrimiçi deneyin

Açıklama:

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 bayt

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

açıklama

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 (EXSLT olmadan), 673 bayt

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

Hafifçe şişirilmiş:

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

Xsltproc kullanarak çalıştırın:

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

Evet, ild.xsliki kez iletilir: Bir kez XSLT belgesi ve daha sonra dönüştürülecek XML belgesi. Bir XSLT işlemci genellikle çalışmaya başlamak için bir tane gerektirdiğinden, bir giriş belgesi bulunmalıdır. (XSLT, bir giriş belgesinden bir çıkış belgesine bir dönüşümü tanımlamak üzere tasarlanmıştır; yalnızca burada yaptığım gibi komut satırı parametreleriyle bir dönüşümü çalıştırmak atipiktir.) Bu program için, iyi biçimlendirilmiş herhangi bir XML belgesi giriş olarak yeterli olacaktır. ve, XSLT bir XML uygulamasıdır, iyi biçimlendirilmiş herhangi bir XSLT dönüşümü tanım olarak iyi biçimlendirilmiş bir XML belgesidir.

MATL, 20 bayt

tVtnw48-PZ}t0<?x_]vs

Çevrimiçi Deneyin

Tüm test durumları

açıklama

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

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

Buna benzeyen (+ -123 4 -1 2 3 )ve ona benzeyen bir dize oluşturan anonim işlev . Oldukça ayrıntılı olan her şey, sayıdan dize, uzunluğa göre dize oluşturur ve ardından sayının dize gösteriminin her sembolünü eksi kendine artı boşluk ve eksi dışında eşler;

Burada çalıştığını görebilirsiniz: https://ideone.com/FG4lsB

Dyalog APL , 19 17 16 bayt

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

Dize alır ve döner

 ≢uzunluk
+artı
 #kök ad alanı
⍎değerlendirmesinde
 '\d'⎕R'&+'regex ekleme rakamlarını artı ile
,takip edin
 ⊢ modifiye edilmemiş dize

–3 ngn sayesinde

Matlab, 76 67 bayt

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

@Luis Mendo sayesinde 9 bayt kurtarıldı

Açıklama:

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 bayt

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

Açıklaması:

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

Bu beklediğimden çok daha karmaşıktı! İyi meydan okuma :)

Bash + coreutils, 36 bayt

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

Açıklama:

     $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

Sed'de, \Barka arkaya iki kelime olmayan karakter arasında eşleşir, bu nedenle negatif bir sayı için '^' ve '-' arasında eşleşir. Örneğin vermek 0$1için gerekli olan numarayı not edin .\B0-1+2+3

Örnek çalıştır: 'input.txt', soru ifadesindeki tüm test durumlarını içerir

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

Çıktı:

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 bayt

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

_{Bu gerektiğini v2 + çalışmak, ama sadece v4 test.}

Giriş alır $n . Bir ,operatörden oluşan $nve .lengthne zaman $nbir dizeye dönüştürüldüğü ile yeni bir dizi oluşturur . $nBir char-array olarak atanan dizeyle bitiştirilir . Daha sonra, bu bütün dizi -joinile birlikte ed +olmak için borulu önce iex(benzer eval). Sonuç, boru hattında bırakılır ve çıktı kesindir.

Örneğin, giriş için -123 için dizi benzeyecek ve diziden (-123, 4, -, 1, 2, 3)sonraki -joingibi görünecektir -123+4+-+1+2+3. Sonra Invoke-Expressionolur ve sonuç -115beklendiği gibi olur .

Faktör load-all, 175 bayt

Bu çok kısa değil. Düzensiz eksi özel işlem gerçekten can sıkıcıdır; Sanırım daha iyisini yapabilirim ve belki de yaparım.

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

Bu ikame regex'in kullanılması:

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

OP'nin test durumlarını bir Faktör test grubuna dönüştürebiliriz.

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 bayt

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 bayt

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$

Daha sonra çalıştırılan bir dize oluşturur. Ne yazık ki EXECUTE, ?steno ile çalışmıyor PRINT, ancak TEXT1 karakter kaydedildi.

C #, 106 bayt

Java'yı yenerim baytım, hayatım tamamlandı

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

    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 bayt

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

-14 bayt sayesinde @LeakyNun . @Cliffroot
sayesinde -15 bayt .

Açıklama:

Çevrimiçi deneyin.

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 bayt

Olabildiğince hazır

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

Anonim bir işlev olarak kullanın

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

JavaScript (ES6), 38 bayt

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

Eski katılma-değerlendirme hilesini kullanır. Dize girişinde ısrar edersem, 4 bayt'ı kaydedin:

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

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

C ++, 255 Bayt

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

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

Giriş $ _

Javascript (harici kütüphaneyi kullanarak) (45 bayt)

LINQ’u Javascript’e getirmek için yazdığım bir kütüphaneyi kullanarak şunları yazabildim:

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

İşlev f()girişi bir dize olarak alır ve sonucu bir tamsayı olarak döndürür. Tam program sürümü (113 bayt):

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

Bir argüman gerektirir.

Perl, 27 bayt

İçin 22 bayt kodu + 5 -paF.

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

açıklama

Kullanımları -a(boş bir sınırlayıcısıyla otomatik bölme seçeneği -F. Geçirilen basamak dizisi oluşturma) sihirli değişkeni kullanır $"hangi karakter kontroller bir dizeye yansıtılmadan ne zaman bir dizi katılmak için kullanılır (Kullandığımız "+"burada) ve gerçeğini bir liste olduğunu Skaler bağlamda kullanıldığında listenin uzunluğu (hane sayısı) döndürülür.

kullanım

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

Perl, 27 bayt

İçin 22 bayt kodu + 5 -paF.

Alternatif çözüm, daha fazla bayt için okunamayan bir şey. Daha şifreli göründüğü için diğerini tercih ederim!

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

dc, 56 bayt

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

Joe, yukarıdakilerden daha kısa değil, fakat biraz daha farklı bir uygulama (ve girdi veya çıkarma komutu olarak negatif sayılar alır). Muhtemelen daha çok golf oynayabilir, ancak öğle yemeği sadece çok uzun sürer.

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

Partiye biraz geç kaldım ama işte başlıyor:

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

Genel olarak herhangi bir sayının basamağını bölmek için (örneğin onları toplamak için), R ilk önce bir dizgeye dönüşmemizi ve daha sonra dizgiyi bir dize vektörüne bölmemizi gerektirir. Öğeleri özetlemek için, dize vektörünün sayısal veya tam sayıya dönüştürülmesi gerekir. Bu, bir istisna dışında bir negatif sayının rakamının toplamıyla birlikte çok fazla bayt yer.

Uyarı mesajlarına izin veriliyorsa istisna biraz golf oynayabilir (96 bayta kadar).

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

Bu durumda, dize vektör doğrudan kullanılarak tamsayısına dönüştürülür as.integer. Ancak, negatif sayılar için vektör ilk eleman eksi işareti olacaktır: "-". Bu, bazı sorunlara neden olur, örneğin: as.numeric(c("-",1,2,3))geri dönecek NA 1 2 3ve bir uyarı mesajı verecektir . Bunu atlatmak için, NA'yı çıkartın ve sonra -1toplamı almadan önce ilk elemanı ile çarpın .

RProgN, 30 Bayt

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

Çevrimiçi Deneyin!

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

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

Çevrimiçi deneyin!

AWK , 64 63 61 bayt

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

Çevrimiçi deneyin!

TIO bağlantısında s=j=0;çok hatlı giriş yapabilmek için 6 ekstra bayt vardır . Bu bulabildiğim en kısa yöntem. Daha kısa sürede yapılabilir mi merak ediyorum AWK.

2 bayt kaydedildi, teşekkürler Kevin