How many carries do I need to add these two numbers?

Question

Task

Given two positive integers, output the number of carries needed to add them together in long addition in base 10.

Examples

¹¹¹   <-- carries
 999
+  1
----
1000

Three carries are needed.

 ¹
 348
+ 91
----
 439

One carry is needed.

Testcases

999,   1 -> 3
398,  91 -> 1
348,  51 -> 0
348,  52 -> 2
  5,  15 -> 1
999, 999 -> 3
505, 505 -> 2

Scoring

This is code-golf. Shortest answer in bytes wins. Standard loopholes apply.

Answer 1

Mathematica, 46 39 bytes

x=Tr@*IntegerDigits;(x@#+x@#2-x@+##)/9&

input

[348,51]

-7 bytes from JungHwan

Answer 2

JavaScript (ES6), 50 bytes

Fixed Stolen from ovs' solution

f=(a,b,c=0)=>a|b|c&&c+f(a/10,b/10,a%10+b%10+c>=10)

Explanation

f=(a,b,c=0)=>                                      Function taking two numbers and optional carry
             a|b|c                                 If a number or the carry are nonzero
                  &&                               Then
                    c+f(a/10,b/10,a%10+b%10+c>=10) Return carry plus all other carries

Carry explanation

a%10+b%10+c     Sum of mod 10 of the numbers and c - remember these are not floordiv'ed
           >=10 Greater than or equals to 10 (we can't use greater than 9 here)

f=(a,b,c=0)=>a|b|c&&c+f(a/10,b/10,a%10+b%10+c>=10)
console.log([[999,1],[398,91],[348,51],[348,52],[5,15],[999,999],[256,64],[190192,90909]].map(test=>`${(test[0]+'').padStart(6,' ')}, ${(test[1]+'').padStart(6,' ')} -> ${f(...test)}`).join('\n'));

Answer 3

C (gcc), 65 bytes

i,l;f(a,b){for(i=l=0;a+b;a/=10,b/=10)i+=a%10+b%10+l>9?l=1:0;a=i;}

Try it online!

Answer 4

Jelly,  13 12 11  9 bytes

-1 byte by porting Jenny_mathy's Mathematic answer.
-2 more bytes by better golfing :p

;SN$DFS:9

See the test suite.

How?

;SN$DFS:9 - Main link: list of numbers, [a,b]     e.g.   [348,53]
   $      - last two links as a monad
 S        -   sum                                            401
  N       -   negate                                        -401
;         - concatenate                             [348,53,-401] 
    D     - convert to decimal lists     [[3,4,8],[5,3],[-4,0,-1]]
     F    - flatten                           [3,4,8,5,3,-4,0,-1]
      S   - sum                                               18
       :9 - integer divide by nine                             2

---

My 12 byte solution...

:⁵+
DUSç\>9S

A monadic link taking a pair of integers and returning the number of carries as an integer.

There is probably a shorter way though! There was!

Try it online! or see the test suite.

How

:⁵+ · Link 1: perform a carry: right-column's-digit-sum, a; left-colum's-digit-sum; b
 ⁵  · literal 10
:   · a integer-divided by 10 - the carry amount
  + · add to b

DUSç\>9S · Main link: list of summands        e.g. [348,52]
D        · convert to decimal lists                [[3,4,8],[5,2]]
 U       · upend (reverse each)                    [[8,4,3],[2,5]]
  S      · sum (add the digits up)                 [10,9,3]
    \    · cumulative reduce with:
   ç     ·   last link (1) as a dyad               [10,10,4]
      9  · literal 9
     >   · greater than?                           [ 1, 1,0]
       S · sum                                     2

Answer 5

JavaScript (ES6), 53 45 bytes

f=(a,b,d=1)=>a+b<d?0:(a%d+b%d>=d)+f(a,b,d*10)

Saved 1 byte by adding an extra do-nothing iteration for carries into 1's place. Saved 7 bytes by appropriating @xnor's carry check. I also had a more elegant 45-byte version but it suffers from floating-point inaccuracy; it would work great translated to a language with exact decimal arithmetic:

f=(a,b,c=a+b)=>c<1?0:a%1+b%1-c%1+f(a/10,b/10)

Answer 6

Python, 48 bytes

f=lambda a,b,m=1:m<1e99and(~a%m<b%m)+f(a,b,m*10)

Try it online!

For each place value m=1, 10, 100, ..., 10**99, checks if there is a carry at that place value. The overflow check a%m+b%m>=m is shortened to ~a%m<b%m.

A nicer 45-byte variant where floats a and b shifted down instead

f=lambda a,b:a+b and(a%1+b%1>=1)+f(a/10,b/10)

sadly runs into float precision issues.

Answer 7

Python 2, 55 bytes

f=lambda a,b,c=0:c+a+b and c+f(a/10,b/10,a%10+b%10+c>9)

Try it online!

Answer 8

05AB1E, 11 10 bytes

|DO‚€SOÆ9÷

Try it online!

Answer 9

Neim, 10 bytes

₁₂λ

Explanation:

            ppend the two inputs into a list
             oin them together
             um the characters
   ₁₂         Push the first input, then the second
             Ad.
             um the characters
             ubtract
             Integer diision by
        λ     nine (variable)

Try it!

Alternative solution, also 10 bytes:

DS9

Explanation:

             ppend the two inputs into a list
 D            Duplicate
              oin
              um
    S          Swap
              um
              um the characters
              ubtract
              integer diide by
        λ       nine (variable)

Try it!

Answer 10

PHP>=7.1, 81 Bytes

for([,$x,$y]=$argv,$i=1;($x+$y)/$i|0;$i*=10)$d+=$c=$x/$i%10+$y/$i%10+$c>9;echo$d;

-2 Bytes removing |0 In this case the loop runs until $i is INF

Test Cases

Answer 11

Braingolf, 20 bytes

VR{.M}d<d&+v+d&+c-9/

Try it online!

Uses the same method as everyone else.

Could've saved a byte or 2 had I had the foresight to allow d to use the greedy modifier, then I could've replaced d<d with &d ah well, next time.

Explanation

VR{.M}d<d&+v+d&+c-9/  Implicit input from commandline args
VR                    Create stack2 and return to stack1
  {..}                Foreach loop, runs on each item in stack1
   .M                 Duplicate and move duplicate to stack2
      d<d             Split both items on stack into digits
         &+           Sum entire stack
           v+         Switch to stack2 and sum last 2 items on stack
             d&+      Split result into digits and sum all digits
                c     Collapse stack2 into stack1
                 -    Subtract last item from 2nd to last
                  9/  Divide by 9
                      Implicit output of last item on stack