Défi:

Il y a un puzzle stupide circulant sur les réseaux sociaux qui se lit comme suit:

8 + 2 = 16106
5 + 4 = 2091
9 + 6 = ?

Implémentez une fonction ou un opérateur qui, lorsqu'il reçoit deux nombres entiers positifs xet ytels que x > y > 0, donne la bonne réponse sous forme d' entier , où les chiffres de la réponse sont les chiffres de x * ysuivi par les chiffres de x + ysuivi par les chiffres de x - y. Très simple.

Règles:

• Les failles standard ne sont pas autorisées.
• C'est le code-golf donc le code le plus court en octets gagne.
• La validation des données d'entrée n'est pas requise. Ce programme peut se bloquer ou retourner des ordures lorsqu'il reçoit une entrée non valide.
• Vous êtes autorisé à utiliser des fonctions et des opérateurs numériques (y compris des nombres entiers et à virgule flottante, des fonctions de bibliothèque mathématique et d'autres fonctions qui acceptent et renvoient des nombres).
• Vous êtes autorisé à utiliser une fonction qui renvoie le nombre de chiffres d'un nombre, le cas échéant.
• Vous n'êtes pas autorisé à utiliser des chaînes ou tout type de concaténation n'importe où dans votre code.
• Le résultat peut être renvoyé ou poussé vers la pile, selon ce qui s'applique dans la langue. Le résultat doit être un nombre entier, pas une chaîne.

Exemple de code:

Dyalog APL :

Le code suivant crée un opérateur dyadique nommé X.

X ← {(⍺-⍵) + ((⍺ + ⍵) × 10 * 1 + ⌊10⍟⍺-⍵) + ⍺ × ⍵ × 10 * (2 + ⌊10⍟⍺ + ⍵) + ⌊10⍟⍺- ⍵}

Explication:

• Dans APL, vous évaluez de droite à gauche.

• ⍺ and ⍵ sont l'opérande gauche et droite, respectivement

• ⌊10⍟⍺-⍵lit comme suit: floor of log10(⍺-⍵). Effectue d'abord la soustraction puis le logarithme puis le sol. De droite à gauche. log10 est fait afin de compter les chiffres de ⍺-⍵(vous devez additionner 1 par la suite).

• ⍺×⍵×10*(...) lit: 10 to the (...)th power, multiplied by ⍵, multiplied by ⍺

• Par conséquent, ⍺×⍵×10*(2+⌊10⍟⍺+⍵)+⌊10⍟⍺-⍵est le produit, décalé vers la gauche de la somme du nombre de chiffres de la somme et de la différence. La multiplication par une puissance de 10 décale un entier vers la gauche.

• ((⍺+⍵)×10*1+⌊10⍟⍺-⍵) est la somme, décalée vers la gauche du nombre de chiffres de la différence.

• (⍺-⍵)est la différence. Aucun décalage n'est nécessaire ici.

• X←{...} est la façon dont vous définissez un opérateur dans APL.

Exemples:

      8 X 2
16106
      5 X 4
2091
      9 X 6
54153

GNU dc:

Le code suivant crée une macro nommée a:

[sysx10lxly-dseZdsclxly+dsd+Z1+^lxly**10lc^ld*+le+]sa

Explication:

• sxet sypop un élément de la pile et enregistrez-le sur les registres xet y, respectivement.

• lxet lycharger un élément à partir des registres xet yrespectivement et le pousser vers la pile.

• d duplique le dernier élément de la pile.

• ^ calcule la puissance de deux nombres.

• Zsaute un nombre et renvoie son nombre de chiffres. Cela se fait car dcn'a pas de fonction logarithme.

• [...]sastocke une macro dans le registre a. lale charge. xexécute la macro en haut de la pile.

Exemples:

8 2 laxn
16106
5 4 laxn
2091
9 6 laxn
54153

JavaScript (ES7), 63 61 59 octets

Enregistré 4 octets grâce à Neil .

(a,b)=>[a*b,a+b,a-b].reduce((p,c)=>p*10**-~Math.log10(c)+c)

<input id=a type=number oninput="c.innerText=((a,b)=>[a*b,a+b,a-b].reduce((p,c)=>p*10**-~Math.log10(c)+c))(+a.value,+b.value)">
<input id=b type=number oninput="c.innerText=((a,b)=>[a*b,a+b,a-b].reduce((p,c)=>p*10**-!Math.log10(c)+c))(+a.value,+b.value)">
<p id=c>

C, 79 75 octets

Merci à @GB pour avoir économisé 4 octets!

#define X for(c=1;(c*=10)<=a
c,d;f(a,b){X+b;);d=c*a*b+a+b;X-b;);a=d*c+a-b;}

Essayez-le en ligne!

Bash, 66

• 2 octets enregistrés grâce à @chepner.

f()(s=$[$1+$2]
d=$[$1-$2]
echo $[($1*$2*10**${#s}+s)*10**${#d}+d])

Essayez-le en ligne .

EXCEL, 61 octets

=A1-B1+(A1+B1)*10^LEN(A1-B1)+A1*B1*10^(LEN(A1-B1)+LEN(A1+B1))

Excel, 18 octets non valides

=A1*B1&A1+B1&A1-B1

Empilés , 36 octets

,@A$(*+-){!A...n!}"!{%y#'10\^x*y+}#\

Essayez-le en ligne!

Précédemment: ,@A$(-+*){!A...n!}"!:inits$#'"!$summap:pop@.10\^1\,\*sum

Je vais essayer d'extraire un octet ou deux avant d'écrire une explication. ( #'= taille de, et" est "faire sur chacun", aucune chaîne n'est attachée ici.)

À 26 octets non concurrentes: $(*+-)#!!:{%y#'10\^x*y+}#\.

TI-Basic, 34 33 octets

Prompt A,B
A-B+(A+B)10^(1+int(log(A-B
Ans+AB10^(1+int(log(Ans

GNU dc, 36

Définit une macro mqui prend les deux premiers membres de la pile, applique la macro et laisse le résultat sur la pile (comme dans l'exemple de la question):

[sadsbla-dZAr^lalb+*+dZAr^lalb**+]sm

Essayez-le en ligne .

Perl 6 ,  81 61  58 octets

->\x,\y{($/=($/=x- y)+(x+y)*({10**$++}...*>$/).tail)+x*y*({10**$++}...*>$/).tail}

Essayez-le

->\x,\y{(x*y,x+y,x- y).reduce:{$^a*10**Int(1+log10($^b))+$b}}

Essayez-le

->\x,\y{[[&({$^a*10**Int(1+$^b.log10)+$b})]] x*y,x+y,x- y}

Essayez-le

Gelée , 27 octets

+,ạ,.1Fl⁵Ḟ‘€Ṛ+\⁵*
ạ,+,×Fæ.ç

Définit un lien / fonction dyadique, appelable avec ç. Prend deux entiers en entrée et renvoie un entier. Il a l'avantage supplémentaire de pouvoir prendre x <y ou x >y en utilisant la différence absolue.

Essayez-le en ligne!

Explication:

+,ạ,.1Fl⁵Ḟ‘€Ṛ+\⁵* -- Create link which computes what order of magnitude
                        to multiply the difference, sum, and product by
ạ,+,×Fæ.ç         -- Main link, applies this using dot product

Détails:

+,ạ,.1Fl⁵Ḟ‘€Ṛ+\⁵* -- Create dyadic like which does the following:
       l⁵Ḟ‘       -- Create operation which computes number of digits
                       (log base 10 (⁵ is the literal 10), floored, incremented)
           €      -- Apply this to each element in
+,ạ,.1F           -- ... the list [sum,difference,.1]
            R     -- Reverse the list
             +\   -- Add up first n elements to get list.
               ⁵* -- Raise 10 (⁵ is literal 10) to the power of each element

ạ,+,×Fæ.ç         -- Main link, applies above link
ạ,+,×F            -- The list [difference, sum, product]
      æ.          -- Dot product (multiply corresponding elements) with
        ç         -- The above link.

PHP, 79 75 octets

deux versions:

[,$a,$b]=$argv;echo(10**strlen($s=$a+$b)*$a*$b+$s)*10**strlen($d=$a-$b)+$d;
[,$a,$b]=$argv;echo(10**strlen($a+$b)*$a*$b+$a+$b)*10**strlen($a-$b)+$a-$b;

prend l'entrée des arguments de la ligne de commande; courir avec -r.

Je suppose que se strlenqualifie de "fonction qui renvoie le nombre de chiffres",
bien qu'il utilise le nombre comme une chaîne. Faites-moi savoir sinon.

C (gcc) , 70 octets

#define _ for(c=1;a+b>=(c*=10););d=c*d+a-(b=-b);
c,d;f(a,b){d=a*b;_ _}

Essayez-le en ligne!

basé sur Steadybox réponse , mettant tout dans une macro pour un peu plus.

(Remarque: attribuer le résultat à dau lieu de atravaux, de manière inattendue. J'ai jeté un coup d'œil au code assembleur généré et il semble être correct.)

Haskell, 54 octets

a%0=a
a%b=10*a%div b 10+mod b 10
a#b=(a*b)%(a+b)%(a-b)

Le puzzle est implémenté via une fonction infixe #, par exemple 8#2 = 16106. L'autre fonction %,, définit la concaténation en base 10 (en supposant que le RHS est supérieur à 0).

Dyalog APL, 31 octets

{a⊥⍨10*1+⌊10⍟a←(⍺×⍵)(⍺+⍵)(⍺-⍵)}

basé sur l'exemple de code APL de l'énoncé du problème

PHP, 87 octets

[,$a,$b]=$argv;echo($s=$a-$b)+($t=$a+$b)*10**($l=strlen($s))+$a*$b*10**($l+strlen($t));

et une solution non valide pour 37 octets

[,$a,$b]=$argv;echo$a*$b,$a+$b,$a-$b;

Rubis, 61 octets

->a,b{[a*b,a+b,a-b].reduce{|x,y|z=y;x*=10while(z>z/=10);x+y}}

Ce qui ressemble étrangement à cette réponse Javascript, mais sans utiliser de logarithme.

Python, 92 91 caractères

def g(x,y):
    l=lambda x,i=0:l(x/10,i+1)if x else 10**i
    a=x-y
    a+=(x+y)*l(a)
    return x*y*l(a)+a

Merci à la suggestion de Wizards;)

R (3.3.1), 104 octets

function(x,y)Reduce(function(p,q)p*10^(floor(log10(q)+1))+q,lapply(c(`*`,`+`,`-`),function(z)z(x,y)),0)

renvoie une fonction anonyme.

Ceci est ma première tentative de golf, donc tout commentaire est apprécié.

REXX, 70 octets

f:arg a b
c=a-b
c=(a+b)*10**length(c)+c
c=a*b*10**length(c)+c
return c

Bien sûr, le chemin natif serait beaucoup plus court:

f:arg a b
return a*b||a+b||a-b

PowerShell, 88 octets

param($x,$y)$l=2;if(($a=$x+$y)-gt9){$l++};($x*$y)*[math]::Pow(10,$l)+$a*10+$x-$y

PowerShell ne possède pas d'opérateur électrique qui n'aide pas. Je ne peux pas non plus compter la longueur d'un entier sauf si vous le comptez comme une chaîne, ce que nous ne pouvons pas faire, donc je vérifie si c'est -gt9 pour connaître la longueur. Cela pourrait probablement être plus concis mais je dois retourner au travail.

Python 2.7, 109 96 octets

import math
a=lambda n:10**int(math.log10(10*n))
b,c=input()
d=b-c+(b+c)*a(b-c)
print d+b*c*a(d)

Corrigé après avoir suivi les règles du concours. Crédits à mbomb007 pour avoir fait passer le code de 109 octets à 96 octets

J , 25 octets

X=.10#.[:;10#.inv&.>*;+;-

1. *;+;- Encadrez les résultats de chaque opération.
2. 10#.inv&.>Convertissez chaque résultat en un tableau de chiffres de base 10. ( invest ^:_1)
3. [:; Déballez et rejoignez les tableaux.
4. 10#. Convertissez un tableau de chiffres de base 10 en un entier.
5. X=.définissez ce qui précède comme l'opérateur X.

Résultats:

   8 X 2
16106
   5 X 4
2091
   9 X 6
54153

Mathematica, 67 octets

c=Ceiling;l=Log10;#-#2+(#+#2)10^(c@l[#-#2]/. 0->1)+10^c@l[2#]10#2#&

Prend x-y, puis prend le log10 de x-y, l'arrondit, calcule 10 à la puissance de cela, puis le multiplie par x+y. Mais nous devons également considérer comme log10(x-y)étant 0, donc nous remplaçons 0 par 1. Ensuite, nous prenons le log10 de 2x, arrondi, plus 1, et trouvons 10 à la puissance de cela. Multipliez cela par xyet ajoutez-le.

05AB1E , 23 22 16 octets

-Dg°¹²+*Dg°¹²**O

Essayez-le en ligne!

Nous aurions pu économiser quelques octets si nous avions été autorisés à utiliser des chaînes dans le programme (mais pas dans les calculs) en bouclant sur une chaîne contenant les opérations "-+*", car le code effectué pour chaque opération est le même.
Bien sûr, si nous avions été autorisés à utiliser la concaténation, nous aurions économisé beaucoup plus.

R, 64 octets

x=scan();(b=(a=diff(-x))+10^nchar(a)*sum(x))+10^nchar(b)*prod(x)

Usage:

> x=scan();(b=(a=diff(-x))+10^nchar(a)*sum(x))+10^nchar(b)*prod(x)
1: 8 2
3: 
Read 2 items
[1] 16106