Tâche

Étant donné deux entiers positifs, affichez le nombre de portages nécessaires pour les additionner ensemble en long addition dans la base 10.

Exemples

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

Trois portages sont nécessaires.

 ¹
 348
+ 91
----
 439

Un portage est nécessaire.

Cas de test

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

Notation

C'est du code-golf . La réponse la plus courte en octets l'emporte. Des échappatoires standard s'appliquent.

code-golf arithmetic

— Leaky Nun
source

Connexes .

— Leaky Nun

14

Cas de test suggéré: 190192, 90909(a une pause dans les portages).

— Jonathan Allan

5

D' après la réponse de @Jenny_mathy : le nombre de portées est égal à la différence entre (1) la somme de la somme des chiffres des deux entrées et (2) la somme des chiffres de la somme des deux entrées, divisée par neuf. En effet, quand il y a un report, vous soustrayez 10 et ajoutez 1 à la somme des chiffres. Par exemple, 9+9vous donne 18, mais la somme des chiffres est 9+9-10+1parce qu'il y a un report.

— JungHwan Min

Défi sans fin lié à l'anarchie

— xnor

Pouvons-nous supposer que les nombres correspondent au type int de notre langue? En particulier pour Python 2, devrions-nous traiter avec l' reprajout d'un Lpour les nombres ci 2**63-1- dessus ?

— xnor

21

Mathematica, 46 39 octets

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

contribution

[348,51]

-7 octets de JungHwan

— J42161217
source

Dang, j'aime vraiment cette méthode. La différence entre (1) la somme de la somme des chiffres des deux entrées et (2) la somme des chiffres de la somme des deux entrées est de neuf fois le nombre de portées car lorsqu'il y a une retenue, vous soustrayez 10 de la somme des chiffres et ajoutez 1 à la somme des chiffres.

— JungHwan Min

Moi aussi! merci pour les conseils de golf

— J42161217

Les tests indiquent que [348,51] devrait retourner 0 mais je reçois 56/3 lorsque j'exécute ceci ...?

— numbermaniac

Welp, on dirait que ça marche maintenant. Je ne sais pas ce que Mathematica faisait avant ...

— numbermaniac

6

JavaScript (ES6), 50 octets

~~Correction~~ de la solution volée aux ovules

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

Explication

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

Porter l'explication

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

Développer l'extrait

— ASCII uniquement
source

1

348 , 52devrait être2

— Toto

Comment cela marche-t-il? Pourriez-vous ajouter une explication?

— Arjun

5

C (gcc) , 65 octets

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

Essayez-le en ligne!

— Kritixi Lithos
source

Vous n'avez pas besoin d'initialiser les variables globales.

— user1502040

@ user1502040 vous devez, s'ils sont utilisés à l'intérieur de la fonction sans être initialisés.

— Leaky Nun

1

Je me concentre sur l'initialisation ici: les variables sont initialisées à zéro automatiquement, mais une seule fois, donc parce que les soumissions de fonctions sur PPCG doivent fonctionner si la fonction s'exécute plus d'une fois, elles doivent être réinitialisées manuellement au profit de la seconde et les exécutions suivantes.

5

Gelée , 13 12 11 9 octets

-1 octet en portant la réponse mathématique de Jenny_mathy .
-2 octets de plus par un meilleur golf: p

;SN$DFS:9

Voir la suite de tests .

Comment?

;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

Ma solution à 12 octets ...

:⁵+
DUSç\>9S

Un lien monadique prenant une paire d'entiers et renvoyant le nombre de portées sous forme d'entier.

~~Il y a probablement un chemin plus court cependant!~~ Il y avait!

Essayez-le en ligne! ou consultez la suite de tests .

Comment

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

— Jonathan Allan
source

Les nombreuses utilisations de Det S...

— Erik the Outgolfer

4

Python , 48 octets

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

Essayez-le en ligne!

Pour chaque valeur de position m=1, 10, 100, ..., 10**99, vérifie s'il y a un report à cette valeur de position. Le contrôle de débordement a%m+b%m>=mest raccourci à ~a%m<b%m.

Une variante plus agréable de 45 octets où flotte aet brétrograde à la place

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

se heurte malheureusement à des problèmes de précision de flottement.

— xnor
source

Ne pouvez-vous pas utiliser a+b<mvotre condition de résiliation?

— Neil

@Neil Il faut que <=ce soit plus long.

— xnor

1e99andest méchant.

— Jonas Schäfer

4

JavaScript (ES6), 53 45 octets

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

Sauvegardé 1 octet en ajoutant une itération supplémentaire de ne rien faire pour les transporter à la place de 1. Sauvegardé 7 octets en s'appropriant la vérification de report de @ xnor. J'avais aussi une version plus élégante de 45 octets mais elle souffre d'une imprécision en virgule flottante; cela fonctionnerait très bien traduit dans une langue avec une arithmétique décimale exacte:

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

— Neil
source

3

Python 2 , 55 octets

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

Essayez-le en ligne!

— ovs
source

1

Comme l'a souligné @JonathanAllan, si vous avez utilisé un appel à votre fonction, vous devez également le déclarer. Cela étant dit, votre réponse est de 55 octets

— M. Xcoder

@ Mr.Xcoder a corrigé

— ovs

2

05AB1E , 11 10 octets

|DO‚€SOÆ9÷

Essayez-le en ligne!

— Okx
source

@JonathanAllan Fixed.

— Okx

|DO‚€SOÆ9÷pour 10 octets.

— Emigna

@Emigna C'est plutôt cool.

— Okx

2

Neim , 10 octets

𝔸𝐣𝐬₁₂𝔻𝐬𝕊λ𝕍

Explication:

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

Essayez!

Solution alternative, également 10 octets:

𝔸D𝐣𝐬S𝐬𝐬𝕊9𝕍

Explication:

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

Essayez!

— Okx
source

1

PHP> = 7.1, 81 octets

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 Octets suppression de |0la boucle court Dans ce cas , jusqu'à $ic'est -INF

Cas de test

— Jörg Hülsermann
source

Quand $idevient-il INF?

— cat

@cat Je ne sais pas pourquoi c'est important. Je ne l'ai pas utilisé. 1.0E+309est la première INFvaleur Essayez-le en ligne!

— Jörg Hülsermann

0

Braingolf , 20 octets

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

Essayez-le en ligne!

Utilise la même méthode que tout le monde.

J'aurais pu économiser un octet ou 2 si j'avais eu la prévoyance de permettre dd'utiliser le modificateur gourmand, alors j'aurais pu le remplacer d<dpar &dah bien, la prochaine fois.

Explication

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

— Skidsdev
source

Combien de portages dois-je ajouter ces deux nombres?

Tâche

Exemples

Cas de test

Notation

Mathematica, 46 39 octets

JavaScript (ES6), 50 octets

Explication

Porter l'explication

C (gcc) , 65 octets

Gelée , 13 12 11 9 octets

Comment?

Comment

Python , 48 octets

JavaScript (ES6), 53 45 octets

Python 2 , 55 octets

05AB1E , 11 10 octets

Neim , 10 octets

PHP> = 7.1, 81 octets

Braingolf , 20 octets

Explication