Aufgabe

Geben Sie bei zwei positiven Ganzzahlen die Anzahl der Übertragungen aus, die erforderlich sind, um sie in der Basis 10 als Long-Addition zu addieren.

Beispiele

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

Es werden drei Tragetaschen benötigt.

 ¹
 348
+ 91
----
 439

Ein Carry wird benötigt.

Testfälle

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

Wertung

Das ist Code-Golf . Kürzeste Antwort in Bytes gewinnt. Es gelten Standardlücken .

Mathematica, 46 39 Bytes

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

Eingang

[348,51]

-7 Bytes von JungHwan

JavaScript (ES6), 50 Byte

Feste Stolen aus ovs' Lösung

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

Erläuterung

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

Erklärung mitnehmen

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

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

Probieren Sie es online!

Jelly ,  13 12 11  9 Bytes

-1 Byte durch Portierung der mathematischen Antwort von Jenny_mathy .
-2 mehr Bytes durch besseres Golfen: p

;SN$DFS:9

Siehe die Testsuite .

Wie?

;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

Meine 12-Byte-Lösung ...

:⁵+
DUSç\>9S

Ein monadischer Link, der ein Paar Ganzzahlen aufnimmt und die Anzahl der Überträge als Ganzzahl zurückgibt.

Es gibt aber wahrscheinlich einen kürzeren Weg! Dort war!

Probieren Sie es online! oder sehen Sie sich die Testsuite an .

Wie

:⁵+ · 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

Python , 48 Bytes

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

Probieren Sie es online!

m=1, 10, 100, ..., 10**99Überprüft für jeden Platzierungswert , ob an diesem Platzierungswert ein Übertrag vorhanden ist. Die Überlaufprüfung a%m+b%m>=mwird auf verkürzt ~a%m<b%m.

Eine schönere 45-Byte - Variante in den Schwimmer aund bstattdessen nach unten verschoben

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

leider stößt er auf schwimmergenauigkeitsprobleme.

JavaScript (ES6), 53 - 45 Byte

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

1 Byte gespart durch Hinzufügen einer zusätzlichen Nichtstun-Iteration für Überträge an die Stelle von 1. 7 Bytes durch Anwenden der Übertragsprüfung von @ xnor gespart. Ich hatte auch eine elegantere 45-Byte-Version, die jedoch unter Gleitkommaungenauigkeiten leidet. es würde großartig funktionieren, wenn es in eine Sprache mit exakter Dezimalarithmetik übersetzt wäre:

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

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)

Probieren Sie es online!

05AB1E , 11 10 Bytes

|DO‚€SOÆ9÷

Probieren Sie es online!

Neim , 10 Bytes

𝔸𝐣𝐬₁₂𝔻𝐬𝕊λ𝕍

Erläuterung:

𝔸            𝔸ppend the two inputs into a list
 𝐣            𝐣oin them together
  𝐬           𝐬um the characters
   ₁₂         Push the first input, then the second
     𝔻        A𝔻d.
      𝐬       𝐬um the characters
       𝕊      𝕊ubtract
         𝕍    Integer di𝕍ision by
        λ     nine (variable)

Versuch es!

Alternative Lösung, auch 10 Bytes:

𝔸D𝐣𝐬S𝐬𝐬𝕊9𝕍

Erläuterung:

𝔸             𝔸ppend the two inputs into a list
 D            Duplicate
  𝐣            𝐣oin
   𝐬           𝐬um
    S          Swap
     𝐬         𝐬um
      𝐬        𝐬um the characters
       𝕊       𝕊ubtract
         𝕍     integer di𝕍ide by
        λ       nine (variable)

Versuch es!

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 entfernen |0In diesem Fall läuft die Schleife bis $iistINF

Testfälle

Braingolf , 20 Bytes

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

Probieren Sie es online!

Verwendet die gleiche Methode wie alle anderen.

Hätte ich ein oder zwei Bytes speichern können, hätte ich vorausschauend dden gierigen Modifikator verwenden können, dann hätte ich ihn d<dbeim &dnächsten Mal durch ah gut ersetzen können.

Erläuterung

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