Sfida:

Sui social network circola un puzzle stupido che recita:

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

Implementare una funzione o un operatore che, quando vengono dati due numeri interi positivi xe ysimili x > y > 0, fornisce la risposta corretta come numero intero , in cui le cifre della risposta sono le cifre x * yseguite dalle cifre di x + yseguite dalle cifre di x - y. Molto semplice.

Regole:

• Le scappatoie standard non sono ammesse.
• Questo è code-golf, quindi vince il codice più breve in byte.
• Non è richiesta la convalida dei dati di input . Questo programma potrebbe arrestarsi in modo anomalo o restituire immondizia quando viene fornito un input non valido.
• Puoi utilizzare funzioni e operatori numerici (inclusi numeri interi e virgola mobile, funzioni della libreria matematica e altre funzioni che accettano e restituiscono numeri).
• Puoi utilizzare una funzione che restituisce il numero di cifre di un numero, se applicabile.
• Stai Non permesso usare le stringhe o qualsiasi tipo di concatenazione qualsiasi punto del codice.
• Il risultato può essere restituito o trasferito nello stack, a seconda della lingua. Il risultato deve essere un numero intero, non una stringa.

Codice di esempio:

Dyalog APL :

Il codice seguente crea un operatore diadico denominato X.

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

Spiegazione:

• In APL, si valuta da destra a sinistra.

• ⍺ and ⍵ sono rispettivamente l'operando sinistro e destro

• ⌊10⍟⍺-⍵si legge: floor of log10(⍺-⍵). Prima esegue la sottrazione, quindi il logaritmo, quindi il pavimento. Da destra a sinistra log10 viene eseguito per contare le cifre di ⍺-⍵(è necessario sommare 1 in seguito).

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

• Quindi, ⍺×⍵×10*(2+⌊10⍟⍺+⍵)+⌊10⍟⍺-⍵è il prodotto, spostato a sinistra dalla somma del numero di cifre della somma e della differenza. Moltiplicando per una potenza di 10 si sposta un numero intero a sinistra.

• ((⍺+⍵)×10*1+⌊10⍟⍺-⍵) è la somma, spostata a sinistra dal numero di cifre della differenza.

• (⍺-⍵)è la differenza Non è necessario spostare qui.

• X←{...} è come si definisce un operatore in APL.

Esempi:

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

GNU dc:

Il codice seguente crea una macro denominata a:

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

Spiegazione:

• sxe sypop un elemento dallo stack e salvarlo sui registri xe y, rispettivamente.

• lxe lycarica un elemento dai registri xe yrispettivamente e spingilo nello stack.

• d duplica l'ultimo elemento nello stack.

• ^ calcola la potenza di due numeri.

• Zapre un numero e restituisce il suo numero di cifre. Questo viene fatto perché dcnon ha una funzione logaritmica.

• [...]samemorizza una macro nel registro a. lalo carica. xesegue la macro nella parte superiore dello stack.

Esempi:

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

JavaScript (ES7), 63 61 59 byte

Risparmiato 4 byte grazie a 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 byte

Grazie a @GB per aver salvato 4 byte!

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

Provalo online!

Bash, 66

• 2 byte salvati grazie a @chepner.

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

Provalo online .

EXCEL, 61 byte

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

Excel, 18 byte non validi

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

Impilato , 36 byte

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

Provalo online!

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

Proverò a spremere un byte o due prima di scrivere una spiegazione. ( #'= size of, ed "è "do on each", nessuna stringa allegata qui.)

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

TI-Basic, 34 33 byte

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

GNU dc, 36

Definisce una macro m che accetta i primi due membri dello stack, applica la macro e lascia il risultato nello stack (come nell'esempio nella domanda):

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

Provalo online .

Perl 6 ,  81 61  58 byte

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

Provalo

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

Provalo

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

Provalo

Gelatina , 27 byte

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

Definisce un collegamento / funzione diadica, richiamabile con ç. Accetta due numeri interi come input e restituisce un numero intero. Ha il vantaggio di essere in grado di prendere x <y o x >y usando la differenza assoluta.

Provalo online!

Spiegazione:

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

Dettagli:

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

due versioni:

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

accetta input dagli argomenti della riga di comando; corri con -r.

Immagino si strlenqualifichi come "funzione che restituisce il numero di cifre",
sebbene utilizzi il numero come stringa. Fammi sapere se no.

C (gcc) , 70 byte

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

Provalo online!

basato su Steadybox risposta di , mettendo tutto in una macro per giocare a golf un po 'di più.

(Nota: assegnare il risultato al dposto di afunziona, inaspettatamente. Ho dato un'occhiata al codice assembly generato e sembra essere ok.)

Haskell, 54 byte

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

Il puzzle viene implementato tramite una funzione infix #, ad es 8#2 = 16106. L'altra funzione, %definisce la concatenazione di base 10 (supponendo che l'RHS sia maggiore di 0).

Dyalog APL, 31 byte

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

basato sul codice APL di esempio dall'istruzione del problema

PHP, 87 byte

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

e una soluzione non valida per 37 byte

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

Rubino, 61 byte

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

Che sospettosamente assomiglia molto a questa risposta Javascript, ma senza usare un logaritmo.

Python, 92 91 caratteri

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

Grazie al suggerimento di Wizards;)

R (3.3.1), 104 byte

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

restituisce una funzione anonima.

Questo è il mio primo tentativo di golf, quindi ogni feedback è apprezzato.

REXX, 70 byte

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

Certo, il modo nativo sarebbe molto più breve:

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

PowerShell, 88 byte

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

PowerShell non ha un operatore di potenza che non aiuta. Inoltre non posso contare la lunghezza di un numero intero a meno che tu non lo conti come una stringa, cosa che non possiamo fare, quindi controllo per vedere se è -gt9 per conoscere la lunghezza. Potrebbe essere più conciso, ma devo tornare al lavoro.

Python 2.7, 109 96 byte

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)

Corretto dopo le seguenti regole del concorso. Crediti a mbomb007 per aver portato il codice da 109 byte a 96 byte

J , 25 byte

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

1. *;+;- Riquadro i risultati di ciascuna operazione.
2. 10#.inv&.>Converti ogni risultato in una matrice di cifre in base 10. ( invè ^:_1)
3. [:; Deseleziona e unisciti agli array.
4. 10#. Converti un array di cifre in base 10 in un numero intero.
5. X=.definire quanto sopra come operatore X.

risultati:

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

Mathematica, 67 byte

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

Prende x-y, quindi prende il log10 di x-y, lo arrotonda, calcola 10 alla potenza di quello e quindi lo moltiplica per x+y. Ma dobbiamo anche considerare di log10(x-y)essere 0, quindi sostituiamo 0 con 1. Quindi prendiamo il log10 di 2x, arrotondato per eccesso, più 1, e troviamo 10 alla potenza di quello. Moltiplicalo per xye aggiungilo su.

05AB1E , 23 22 16 byte

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

Provalo online!

Avremmo potuto risparmiare qualche byte se ci fosse stato permesso di usare le stringhe nel programma (ma non nei calcoli) eseguendo il ciclo su una stringa contenente le operazioni "-+*", poiché il codice eseguito per ciascuna operazione è lo stesso.
Naturalmente, se ci fosse stato permesso di usare la concatenazione, avremmo risparmiato molto di più.

R, 64 byte

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

Uso:

> 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