Thử thách:

Có một câu đố ngớ ngẩn lưu hành trên các mạng xã hội có nội dung:

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

Thực hiện một hàm hoặc toán tử, khi được cho hai số nguyên dương xvà ynhư vậy x > y > 0, sẽ trả lời đúng là một số nguyên , trong đó các chữ số của câu trả lời là các chữ số x * ytheo sau các chữ số x + ytheo sau là các chữ số của x - y. Rất đơn giản.

Quy tắc:

• Sơ hở tiêu chuẩn là không được phép.
• Đây là mã golf để mã ngắn nhất tính theo byte thắng.
• Xác nhận dữ liệu đầu vào là không cần thiết. Chương trình này có thể sụp đổ hoặc trả lại rác khi được cung cấp đầu vào không hợp lệ.
• Bạn được phép sử dụng các hàm số và toán tử (bao gồm số nguyên và dấu phẩy động, hàm thư viện toán học và các hàm khác chấp nhận và trả về số).
• Bạn được phép sử dụng hàm trả về số chữ số của một số, nếu có.
• Bạn không được phép sử dụng chuỗi hoặc bất kỳ loại nối nào ở bất kỳ đâu trong mã của bạn.
• Kết quả có thể được trả về hoặc đẩy vào ngăn xếp, tùy theo áp dụng trong ngôn ngữ. Kết quả phải là một số nguyên, không phải là một chuỗi.

Mã mẫu:

Thuốc nhuộm APL :

Các mã sau đây tạo ra một toán tử dyadic có tên X.

X ← {(⍺ - ⍵) + ((⍺ +)) 10 ⍵}

Giải trình:

• Trong APL, bạn đánh giá từ phải sang trái.

• ⍺ and ⍵ lần lượt là toán hạng trái và phải

• ⌊10⍟⍺-⍵đọc : floor of log10(⍺-⍵). Đầu tiên thực hiện cơ chất sau đó logarit sau đó sàn. Từ phải qua trái. log10 được thực hiện để đếm các chữ số của ⍺-⍵(bạn phải tính tổng 1 sau đó).

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

• Do đó, ⍺×⍵×10*(2+⌊10⍟⍺+⍵)+⌊10⍟⍺-⍵là sản phẩm, được dịch sang trái bởi tổng số chữ số của tổng và hiệu. Nhân với lũy thừa 10 sẽ dịch chuyển một số nguyên sang trái.

• ((⍺+⍵)×10*1+⌊10⍟⍺-⍵) là tổng, dịch chuyển sang trái theo số chữ số của chênh lệch.

• (⍺-⍵)là sự khác biệt Không có sự thay đổi là cần thiết ở đây.

• X←{...} là cách bạn xác định một toán tử trong APL.

Ví dụ:

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

GNU dc:

Đoạn mã sau tạo một macro có tên a:

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

Giải trình:

• sxvà sybật một phần tử từ ngăn xếp và lưu nó vào các thanh ghi xvà y, tương ứng.

• lxvà lytải một phần tử từ các thanh ghi xvà ytương ứng và đẩy nó vào ngăn xếp.

• d nhân đôi phần tử cuối cùng trong ngăn xếp.

• ^ tính sức mạnh của hai số.

• Zbật một số và trả về số chữ số của nó. Điều này được thực hiện vì dckhông có chức năng logarit.

• [...]salưu trữ một macro trong đăng ký a. latải nó xthực thi macro ở đầu ngăn xếp.

Ví dụ:

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

JavaScript (ES7), 63 61 59 byte

Đã lưu 4 byte nhờ 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

Cảm ơn @GB vì đã tiết kiệm 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;}

Hãy thử trực tuyến!

Bash, 66

• Lưu 2 byte nhờ @chepner.

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

Hãy thử trực tuyến .

EXCEL, 61 byte

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

Excel, 18 byte không hợp lệ

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

Xếp chồng lên nhau , 36 byte

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

Hãy thử trực tuyến!

Trước đây: ,@A$(-+*){!A...n!}"!:inits$#'"!$summap:pop@.10\^1\,\*sum

Tôi sẽ cố gắng vắt kiệt một hoặc hai byte trước khi viết lời giải thích. ( #'= kích thước của và "là "làm trên mỗi", không có chuỗi nào được đính kèm ở đây.)

Không biên dịch ở 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

Xác định một macro mlấy hai thành viên trên cùng của ngăn xếp, áp dụng macro và để lại kết quả trên ngăn xếp (theo ví dụ trong câu hỏi):

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

Hãy thử trực tuyến .

Perl 6 ,  81 61  58 byte

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

Thử nó

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

Thử nó

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

Thử nó

Thạch , 27 byte

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

Xác định một liên kết / chức năng dyadic, có thể gọi với ç. Lấy hai số nguyên làm đầu vào và trả về một số nguyên. Nó có thêm phần thưởng là có thể lấy x <y hoặc x >y bằng cách sử dụng sự khác biệt tuyệt đối.

Hãy thử trực tuyến!

Giải trình:

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

Chi tiết:

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

hai phiên bản:

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

lấy đầu vào từ các đối số dòng lệnh; chạy với -r.

Tôi đoán strlenđủ điều kiện là "hàm trả về số chữ số",
mặc dù nó sử dụng số này dưới dạng chuỗi. Hãy cho tôi biết nếu không.

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

Hãy thử trực tuyến!

dựa trên câu trả lời của Steadybox , đưa mọi thứ vào một vĩ mô để chơi nó nhiều hơn một chút.

(Lưu ý: việc gán kết quả cho dthay vì acông việc, thật bất ngờ. Tôi đã xem mã lắp ráp được tạo và nó có vẻ ổn.)

Haskell, 54 byte

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

Câu đố được thực hiện thông qua hàm infix #, vd 8#2 = 16106. Hàm khác %, xác định phép nối cơ sở 10 (giả sử RHS lớn hơn 0).

APL Dyalog, 31 byte

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

dựa trên mã APL mẫu từ báo cáo sự cố

PHP, 87 byte

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

và một giải pháp không hợp lệ cho 37 byte

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

Ruby, 61 byte

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

Điều đáng ngờ trông rất giống câu trả lời Javascript này , nhưng không sử dụng logarit.

Python, 92 91 Chars

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

Nhờ gợi ý của Phù thủy;)

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)

trả về một hàm ẩn danh.

Đây là nỗ lực chơi gôn đầu tiên của tôi, vì vậy mọi phản hồi đều được đánh giá cao.

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

Tất nhiên, cách bản địa sẽ ngắn hơn nhiều:

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 không có toán tử điều khiển mà không giúp. Cũng không thể đếm chiều dài của một số nguyên trừ khi bạn tính nó là một chuỗi, điều mà chúng ta không thể làm được, vì vậy tôi kiểm tra xem nó có phải là -gt9 để biết độ dài không. Có khả năng có thể ngắn gọn hơn nhưng tôi phải trở lại làm việc.

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)

Sửa chữa sau khi tuân theo các quy tắc của cuộc thi. Tín dụng cho mbomb007 để giảm mã từ 109 byte xuống 96 byte

J , 25 byte

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

1. *;+;- Hộp kết quả của mỗi hoạt động.
2. 10#.inv&.>Chuyển đổi mỗi kết quả thành một mảng gồm 10 chữ số cơ bản. ( invlà ^:_1)
3. [:; Bỏ hộp và tham gia các mảng.
4. 10#. Chuyển đổi mảng gồm 10 chữ số cơ bản thành một số nguyên.
5. X=.xác định ở trên là toán tử X.

Các kết quả:

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

Toán học, 67 byte

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

Mất x-y, sau đó lấy log10 của x-y, làm tròn nó, tính 10 với sức mạnh của nó và sau đó nhân nó lên x+y. Nhưng chúng ta cũng cần xem xét log10(x-y)là 0, vì vậy chúng ta thay 0 bằng 1. Sau đó, chúng ta lấy log10 của 2x, làm tròn lên, cộng với 1 và tìm 10 với sức mạnh của điều đó. Nhân số đó với xy, và thêm nó vào.

05AB1E , 23 22 16 byte

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

Hãy thử trực tuyến!

Chúng tôi có thể đã lưu một vài byte nếu chúng tôi được phép sử dụng các chuỗi trong chương trình (nhưng không phải trong tính toán) bằng cách lặp qua một chuỗi chứa các hoạt động "-+*", vì mã được thực hiện cho mỗi hoạt động là như nhau.
Tất nhiên, nếu chúng tôi được phép sử dụng phép nối, chúng tôi sẽ tiết kiệm được nhiều hơn.

R, 64 byte

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

Sử dụng:

> 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