Herausforderung:

In den sozialen Netzwerken kursiert ein albernes Rätsel, das lautet:

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

Implementieren einer Funktion oder Bediener , daß bei gegebenen zwei positive ganze Zahlen sind xund yderart , dass x > y > 0, ergibt die richtige Antwort als eine ganze Zahl ist , wobei die Antwort der Ziffern sind die Ziffern x * yvon den Ziffern , gefolgt von x + yder durch die Ziffern gefolgt x - y. Sehr einfach.

Regeln:

• Standardlücken sind nicht zulässig.
• Das ist Code-Golf, also gewinnt der kürzeste Code in Bytes.
• Eine Validierung der Eingabedaten ist nicht erforderlich. Dieses Programm kann abstürzen oder bei ungültiger Eingabe Müll zurückgeben.
• Sie dürfen numerische Funktionen und Operatoren verwenden (einschließlich Ganzzahl und Gleitkomma, mathematische Bibliotheksfunktionen und andere Funktionen, die Zahlen akzeptieren und zurückgeben).
• Sie dürfen eine Funktion verwenden, die gegebenenfalls die Anzahl der Ziffern einer Zahl zurückgibt.
• Sie sind nicht in Ihrem Code zu verwenden , Strings oder irgendeine Art von Verkettung überall erlaubt.
• Das Ergebnis kann zurückgegeben oder in den Stapel verschoben werden, je nachdem, was in der Sprache gilt. Das Ergebnis muss eine Ganzzahl sein, keine Zeichenfolge.

Beispielcode:

Dyalog APL :

Der folgende Code erstellt einen dyadischen Operator mit dem Namen X.

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

Erläuterung:

• In APL werten Sie von rechts nach links aus.

• ⍺ and ⍵ sind der linke und der rechte Operand

• ⌊10⍟⍺-⍵lautet: floor of log10(⍺-⍵). Führt zuerst eine Subtraktion durch, dann einen Logarithmus und dann einen Floor. Von rechts nach links. log10 wird ausgeführt, um die Ziffern von zu zählen ⍺-⍵(danach muss 1 summiert werden).

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

• Somit ⍺×⍵×10*(2+⌊10⍟⍺+⍵)+⌊10⍟⍺-⍵ist das Produkt um die Summe aus der Anzahl der Stellen der Summe und der Differenz nach links verschoben. Das Multiplizieren mit einer Zehnerpotenz verschiebt eine ganze Zahl nach links.

• ((⍺+⍵)×10*1+⌊10⍟⍺-⍵) ist die um die Anzahl der Stellen der Differenz nach links verschobene Summe.

• (⍺-⍵)ist der Unterschied. Hier ist kein Schalten notwendig.

• X←{...} So definieren Sie einen Operator in APL.

Beispiele:

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

GNU dc:

Der folgende Code erstellt ein Makro mit dem Namen a:

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

Erläuterung:

• sxund syPop ein Element aus dem Stapel und speichern Sie es auf den Registern xund ysind.

• lxund lyein Element aus den Registern geladen xund yjeweils und schiebt es auf den Stapel.

• d dupliziert das letzte Element im Stapel.

• ^ berechnet die Potenz zweier Zahlen.

• ZGibt eine Zahl aus und gibt die Anzahl der Stellen zurück. Dies geschieht, weil dces keine Logarithmusfunktion gibt.

• [...]saSpeichert ein Makro im Register a. lalädt es. xFührt das Makro oben im Stapel aus.

Beispiele:

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

JavaScript (ES7), 63 61 59 Bytes

4 Bytes gespart dank 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 Bytes

Vielen Dank an @GB für das Speichern von 4 Bytes!

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

Probieren Sie es online!

Bash, 66

• 2 Bytes gespart dank @chepner.

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

Probieren Sie es online aus .

EXCEL, 61 Bytes

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

Excel, 18 Bytes nicht gültig

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

Gestapelt , 36 Bytes

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

Probieren Sie es online!

Vorher: ,@A$(-+*){!A...n!}"!:inits$#'"!$summap:[email protected]\^1\,\*sum

Ich werde versuchen, ein oder zwei Bytes herauszuholen, bevor ich eine Erklärung schreibe. ( #'= Größe von und "ist "do on each", hier ohne Bedingungen.)

Noncompeting bei 26 Bytes $(*+-)#!!:{%y#'10\^x*y+}#\.

TI-Basic, 34 33 Bytes

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

GNU DC, 36

Definiert ein Makro m, das die beiden obersten Elemente des Stapels einnimmt, das Makro anwendet und das Ergebnis auf dem Stapel belässt (wie im Beispiel in der Frage gezeigt):

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

Probieren Sie es online aus .

Perl 6 ,  81 61  58 Bytes

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

Versuch es

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

Versuch es

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

Versuch es

Gelee , 27 Bytes

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

Definiert eine dyadische Verknüpfung / Funktion, die mit aufgerufen werden kann ç. Nimmt zwei Ganzzahlen als Eingabe und gibt eine Ganzzahl zurück. Es hat den zusätzlichen Vorteil, dass man x <y oder x >y nehmen kann, indem man die absolute Differenz verwendet.

Probieren Sie es online!

Erläuterung:

+,ạ,.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

Einzelheiten:

+,ạ,.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 Bytes

zwei Versionen:

[,$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;

Nimmt Eingaben von Befehlszeilenargumenten entgegen. renn mit -r.

Ich vermute, strlenqualifiziert als "Funktion, die die Anzahl der Stellen zurückgibt",
obwohl es die Nummer als Zeichenfolge verwendet. Lass es mich wissen, wenn nicht.

C (gcc) , 70 Bytes

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

Probieren Sie es online!

basierend auf der Antwort von Steadybox , alles in ein Makro einfügen , um ein bisschen mehr Golf zu spielen.

(Hinweis: Das Ergebnis dzuzuweisen, afunktioniert unerwartet. Ich habe mir den generierten Assembly-Code angesehen und es scheint in Ordnung zu sein.)

Haskell, 54 Bytes

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

Das Puzzle wird über eine Infix-Funktion implementiert #, z 8#2 = 16106. Die andere Funktion %definiert die Verkettung der Basis 10 (vorausgesetzt, die RHS ist größer als 0).

Dyalog APL, 31 Bytes

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

basierend auf dem Beispiel-APL-Code aus der Problembeschreibung

PHP, 87 Bytes

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

und eine ungültige Lösung für 37 Bytes

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

Ruby, 61 Bytes

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

Was verdächtig nach dieser Javascript-Antwort aussieht , aber ohne einen Logarithmus zu verwenden.

Python, 92 91 Zeichen

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

Danke an Wizards Vorschlag;)

R (3.3.1), 104 Bytes

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

Gibt eine anonyme Funktion zurück.

Dies ist mein erster Golfversuch, daher ist jedes Feedback willkommen.

REXX, 70 Bytes

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

Natürlich wäre der native Weg viel kürzer:

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

PowerShell, 88 Bytes

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

PowerShell hat keinen an den Netzbetreiber, der nicht hilft. Kann auch die Länge einer Ganzzahl nicht zählen, es sei denn, Sie zählen sie als Zeichenfolge, was wir nicht können. Daher überprüfe ich, ob es -gt9 ist, um die Länge zu ermitteln. Könnte vielleicht knapper sein, aber ich muss mich wieder an die Arbeit machen.

Python 2.7, 109 96 Bytes

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)

Korrigiert nach folgenden Wettbewerbsregeln. Dank an mbomb007 für die Reduzierung des Codes von 109 auf 96 Byte

J , 25 Bytes

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

1. *;+;- Box die Ergebnisse jeder Operation.
2. 10#.inv&.>Konvertieren Sie jedes Ergebnis in ein Array von 10-stelligen Zahlen. ( invist ^:_1)
3. [:; Entpacken und verbinden Sie die Arrays.
4. 10#. Konvertiert ein Array von 10er-Stellen in eine Ganzzahl.
5. X=.Definieren Sie das Obige als Operator X.

Ergebnisse:

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

Mathematica, 67 Bytes

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

Nimmt x-y, nimmt dann das log10 von x-y, rundet es auf, berechnet 10 zur Potenz davon und multipliziert es dann mit x+y. Aber wir müssen auch berücksichtigen log10(x-y), dass wir 0 sind, also ersetzen wir 0 durch 1. Dann nehmen wir das log10 von 2x, aufgerundet plus 1, und finden 10 zur Potenz davon. Multiplizieren Sie das mit xyund fügen Sie das hinzu.

05AB1E , 23 22 16 Bytes

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

Probieren Sie es online!

Wir hätten ein paar Bytes sparen können, wenn wir Strings im Programm hätten verwenden dürfen (aber nicht in Berechnungen), indem wir einen String durchlaufen, der die Operationen enthält "-+*", da der für jede Operation ausgeführte Code derselbe ist.
Wenn wir Verkettung hätten verwenden dürfen, hätten wir natürlich viel mehr gespart.

R, 64 Bytes

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

Verwendung:

> 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