อินพุต:สองจำนวนเต็มทศนิยม สิ่งเหล่านี้สามารถให้กับรหัสในอินพุตมาตรฐานเป็นอาร์กิวเมนต์ของโปรแกรมหรือฟังก์ชันหรือเป็นรายการ

ผลลัพธ์:ผลิตภัณฑ์เป็นจำนวนเต็มทศนิยม ยกตัวอย่างเช่นการป้อนข้อมูลที่จะนำไปสู่การส่งออก5 1680

ข้อ จำกัด :ไม่มีช่องว่างมาตรฐานกรุณา นี่คือรหัสกอล์ฟคำตอบในจำนวนไบต์ต่ำสุดที่ชนะ

หมายเหตุ:เค้าโครงขโมยมาจากก่อนหน้านี้ความท้าทายของฉันเพิ่มตัวเลขสอง

กรณีทดสอบ:

1 2   -> 2
4 5   -> 20
7 9   -> 63
-2 8  -> -16
8 -9  -> -72
-8 -9 -> 72
0 8   -> 0
0 -8  -> 0
8 0   -> 0
-8 0  -> 0
0 0   -> 0

หรือเป็น CSV:

a,b,c
1,2,2
4,5,20
7,9,63
-2,8,-16
8,-9,-72
-8,-9,72
0,8,0
0,-8,0
8,0,0
-8,0,0
0,0,0

ลีดเดอร์บอร์ด

var QUESTION_ID=106182,OVERRIDE_USER=8478;function answersUrl(e){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"https://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/<a/.test(o)&&(o=jQuery(o).text()),s[o]=s[o]||{lang:e.language,user:e.user,size:e.size,link:e.link}});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){return e.lang>s.lang?1:e.lang<s.lang?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;

body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr></thead> <tbody id="answers"> </tbody> </table> </div><div id="language-list"> <h2>Winners by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr></thead> <tbody id="languages"> </tbody> </table> </div><table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table>

Brachylog V1, 05AB1E, J, K, Underload, MATL, Forth, PigeonScript, ซ้อนกัน, โดยนัย, Jolf, Clojure, Braingolf, 8th, Lisp สามัญ, Julia, Pyt, Appleseed, Stax, Reality, dc 1 ไบต์

*

คุณสามารถแก้ไขคำตอบนี้เพื่อเพิ่มภาษาอื่นซึ่ง*เป็นคำตอบที่ถูกต้อง

C (GCC) 13 ไบต์

ใช้งานไม่ได้กับทุกการใช้งาน แต่ไม่เป็นไร

f(a,b){a*=b;}

ลองใช้กับ TIO!

Beatnik , 888 ไบต์

k I
j k ZZZZX z
xw k C vp yQ KD xw z j k ZZZZX z
j k ZZZD z xw bZ ZX
k XX z qs xw vp xw xw vp xw vp vp vp k I Xj ZZD hd
xw yQ K k ZZZZX xo exx
qs yQ XA xw xw xw xw z xw bZ K
xw xw k I
j k ZZZZX z
xw k C vp yQ XA hd k I z j k ZZZZX z
j xw k A vp bZ ZX
k ZZZZX z qs xw vp xw xw vp xw vp vp vp k I Xj ZZD hd
xw yQ K k ZZZZX xo exx
qs yQ F k ZZZZK xo
vp
xw xw z qs xw bZ X xw k I z xw Xj K
qs xw bZ KA vp qs xw Xj C hd
qs z xw xw xw xw z qs
xw xw xw xw z qs k I qs k I z xw Xj ZC
qs bZ ZZZX qs xw yQ C hd xw
k I vp qs k I qs
xw Xj ZZC hd hd z Kz ZZD
k I z xw xw xw xw z qs k I qs k I Xj ZZZZF
z
xw xw z qs xw bZ X xw k I z xw Xj K
qs xw bZ KA vp qs xw Xj C hd
z qs xw
xw xw z qs xw bZ X xw k I z xw Xj K
qs xw bZ KA vp qs xw Xj C hd
z vp
xw xw z qs
xw xw z qs
k I qs
xw bZ ZZX k I z qs k I vp
xw k ZA z yQ ZA hd qs k I vp qs k I Xj ZZKD
qs xw Xj ZZK
hd qs xw Xj ZZZZ hd
k ZZZZKD vp xo xw Xj K

ลองออนไลน์!

ฉันใช้ล่าม C เพราะล่าม Python บน TIO จะดำเนินการกับที่อยู่อย่างน่ารำคาญหากเงื่อนไขสำหรับการกระโดดถอยหลังไม่พบ วิธีแก้ปัญหาง่ายๆสำหรับล่าม Python คือการบีบ nops เพื่อทำให้ที่อยู่ไม่อยู่ ฉันเชื่อว่าไม่ถูกต้อง:

                                   C       Python  My interpretation
IP after skiping N words           IP+N+1  IP+N+2  IP+N+2
IP after skiping back N words      IP-N    IP-N+1  IP-N+2
IP after not skiping N words       IP+2    IP+2    IP+2
IP after not skiping back N words  IP+2    IP+1    IP+2

อินพุตควรเป็นจำนวนเต็มสองจำนวนคั่นด้วยช่องว่างโดยไม่ต้องขึ้นบรรทัดใหม่

คำตอบนี้ใช้ได้กับทฤษฎีสำหรับจำนวนเต็มทั้งหมดหากแต่ละเซลล์สามารถเก็บค่าที่มีขนาดใหญ่ตามอำเภอใจไม่ จำกัด อยู่ที่ 0 - 255 แต่จะล้นหาก | A | + | B | > 22. และมันจะทำงานช้ามากหาก | A | + | B | > 6. มีหลายกรณีที่คุณสามารถทดสอบได้จริงและโซลูชัน if-else สำหรับกรณีเหล่านั้นอาจสั้นกว่านี้

แนวคิดคือการคำนวณตัวเลขสามเหลี่ยม T (N) = N (N + 1) / 2 โดยการลดค่าเป็น 0 และสรุปค่ากลางทั้งหมด จากนั้นเราจะได้คำตอบ A * B = T (A + B) - T (A) - T (B)

แต่มันเป็นเรื่องยากที่จะคำนวณทั้ง 3 ค่า มันทำได้โดยเริ่มจากการคำนวณ T (A + B) - A โดยปล่อยสำเนา A ไว้ในสแต็กเพื่อเพิ่มกลับมาในภายหลังและใช้อินพุต B มากขึ้นเรื่อย ๆ จากนั้นหาสามเหลี่ยมที่ยิ่งใหญ่ที่สุดที่มีขนาดเล็กกว่านั้น A + B-1) ยกเว้นกรณีพิเศษเป็นศูนย์ เราสามารถรับ B = T (A + B) - A - T (A + B-1) และคำนวณ T (B) จากที่นั่น

ตัวเลข N คือตัวเลขสามเหลี่ยม iff เท่ากับจำนวนสามเหลี่ยมที่ยิ่งใหญ่ที่สุดที่เล็กกว่า N บวกกับจำนวนของรูปสามเหลี่ยมที่ไม่เป็นลบที่เล็กกว่า N. ซึ่งจะทำงานใน O (2 ^ (T (A + B) -A)) และเป็นส่วนที่ช้าที่สุดในโปรแกรม

k I                                         Push 1
j k ZZZZKAAA z                              Input and decrement by 48.
xw k AAA vp yQ (input_a_loop)               If the character was '-':
xw z j k ZZZZKAAA z                           Replace with 0 and input another.
input_a_loop:
j k ZZZAA z xw bZ (input_a_end)             Input and break if it is a space.
k ZKA z qs xw vp xw xw vp xw vp vp vp       Otherwise multiply the previous
                                              value by 10 and add.
k I Xj (input_a_loop)                       Continue the loop.
input_a_end: hd                             Discard the space.
xw yQ (check_sign) k ZZZZKAAA xo exx        If A=0, print 0 and exit.
                                            Stack: ?, A_is_positive, A
check_sign:
qs yQ (check_sign_else)                     If A is positive... or not,
xw xw xw xw z xw bZ (check_sign_end)          in either cases, push 2 copies
check_sign_else: xw xw k I                    of A and the negated flag back
check_sign_end:                               as a constant.
                                            Stack: A, A, A, A_is_negative
j k ZZZZKAAA z                              Similar for B.
xw k AAA vp yQ (input_b_loop)               If the character was '-':
hd k I z j k ZZZZKAAA z                       Decrement the flag and input another.
input_b_loop:
j xw k A vp bZ (input_b_end)                EOF is checked instead of a space.
k ZZZZKAAA z qs xw vp xw xw vp xw vp vp vp
k I Xj (input_b_loop)
input_b_end: hd
xw yQ (output_sign) k ZZZZKAAA xo exx       If B=0, print 0 and exit.
                                            Stack: A, A, A, A*B_is_negative, B
output_sign:
qs yQ (output_sign_end) k ZZZZK xo          If negative, output '-'.
output_sign_end:

vp                                          Add.        Stack: A, A, A+B
xw xw z qs                                  Insert a 0. Stack: A, A, 0, A+B.
xw bZ { xw k I z xw Xj }                    Copy and decrement while nonzero.
                                            Stack: A, A, 0, A+B, A+B-1, ..., 0
qs xw bZ { vp qs xw Xj } hd                 Add while the second value in the
                                              stack is nonzero.
                                            Stack: A, A, T(A+B)
qs z xw xw xw xw z qs                       Stack: A, C0=T(A+B)-A, C0, F0=0, C0

expand_loop:
xw xw xw xw z qs k I qs                     Stack: A, C0, C0, F0=0,
                                              ..., [P=C, P, S=0, F=1], C
dec_expand: k I z xw Xj (expand_loop)       Decrement and continue if nonzero.
                                            Stack: [P=1, P, S, F], C=0
                                            The last number 0 is assumed to
                                              be a triangular number.
test: qs bZ (extract_end)                   If F=0, break.
qs xw yQ (test_not_first) hd xw             If S=0, it's the first triangular
                                              number below previous C. Set S=C.
test_not_first: k I vp qs k I qs            S+=1 and restore F=1.
xw Xj (dec_expand)                          If C!=0, recursively expand from C-1.
hd hd z Kz (test)                           If S=P, P is a triangular number,
                                              return to the previous level.
k I z xw xw xw xw z qs k I qs               Otherwise, decrement P and try again.
k I Xj (dec_expand)
extract_end:                                Stack: A, C0, C0, T(A+B-1)

z                                           Subtract and get B.
xw xw z qs xw bZ { xw k I z xw Xj }         Computes T(B).
qs xw bZ { vp qs xw Xj } hd
                                            Stack: A, C0, T(B)
z qs xw                                     Stack: C0-T(B), A, A

xw xw z qs xw bZ { xw k I z xw Xj }         Computes T(A).
qs xw bZ { vp qs xw Xj } hd
z vp                                        Get A*B=(C0-T(B))+(A-T(A))
xw xw z qs                                  Stack: 0, X=A*B

divide: xw xw z qs                          Stack: 0, ..., Y=0, X
subtract: k I qs                            Stack: 0, ..., Y, Z=1, X
xw bZ {                                     While X!=0:
k I z qs k I vp                               X-=1, Z+=1.
xw k ZA z yQ (not_ten)                        But if Z=11:
hd qs k I vp qs k I Xj (subtract)               Y+=1, reset Z and restart the loop.
not_ten: qs xw Xj }
hd qs xw Xj (divide)                        Put Z under Y and make Y the new X,
                                              continue the loop if X!=0.
hd                                          Discard X.

print_loop:
k ZZZZKAA vp xo xw Xj (print_loop)          Add each cell by 47 and print.

Mathematica, 4 ไบต์

1##&

ตัวอย่างการใช้งาน: ผลตอบแทน1##&[7,9] 63อันที่จริงฟังก์ชั่นเดียวกันนี้เพิ่มจำนวนอาร์กิวเมนต์ใด ๆ ด้วยกันทุกชนิด

ดังที่ codegolfers ของ Mathematica รู้ว่างานนี้เพราะ##อ้างถึงลำดับทั้งหมดของการขัดแย้งกับฟังก์ชันและการต่อข้อมูลใน Mathematica (บ่อยครั้ง) หมายถึงการคูณ ดังนั้น1##หมายถึง (1 ครั้ง) ผลคูณของอาร์กิวเมนต์ทั้งหมดของฟังก์ชัน &เป็นเพียงระยะสั้นสำหรับFunctionคำสั่งที่กำหนดบริสุทธิ์ (ไม่มีชื่อ) ฟังก์ชั่น

ภายในรหัสอื่น ๆ สัญลักษณ์ทั่วไป*จะทำหน้าที่เป็นตัวคูณ ดังนั้นช่องว่างจึง7 9ถูกตีความว่าเป็น7*9(จริง ๆ แล้วรุ่น REPL ปัจจุบันของ Mathematica จริง ๆ แล้วจะแสดงช่องว่างเช่นเครื่องหมายการคูณ!) ยิ่งไปกว่านั้น แต่ถ้า Mathematica สามารถบอกที่หนึ่งเริ่มต้นโทเค็นและปลายอีกแล้วไม่มีไบต์ที่ทุกคนมีความจำเป็นสำหรับผู้ประกอบการคูณ: 5yถูกตีความโดยอัตโนมัติขณะที่5*yและ3.14Log[9]เป็น3.14*Log[9]เป็น

เรติน่า , 38 37 31 ไบต์

แนวทางใหม่อย่างสมบูรณ์แบบเก่าอยู่ด้านล่าง

M!`-
*\)`-¶-

.* 
$*_
_
$'$*_
_

ลองออนไลน์!

คำอธิบาย

ก่อนอื่นเราต้องจัดการกับสัญญาณ:

M!`-

จับคู่ทั้งหมด-ในสตริงและส่งคืนคั่นด้วยบรรทัดใหม่

*\)`-¶-

(ด้วยบรรทัดว่างต่อไปนี้)
*\)หมายถึงผลลัพธ์ของขั้นตอนนี้และขั้นตอนก่อนหน้านี้ที่ควรพิมพ์โดยไม่ต้องขึ้นบรรทัดใหม่จากนั้นสตริงจะเปลี่ยนกลับเป็นแบบเดิม (สตริงอินพุต) ส่วนที่เหลือจะลบสองรายการ-โดยคั่นด้วยการขึ้นบรรทัดใหม่

จากนั้นเราแปลงหมายเลขแรกเป็นเอก:

.* 
$*_

(มีช่องว่างที่ท้ายบรรทัดแรก) เราใช้_เป็นตัวเลขเอกของเราในกรณีนี้เนื่องจากตัวเลขมาตรฐาน1สามารถปรากฏในหมายเลขที่สองและอาจขัดแย้งกันในภายหลัง

ตอนนี้เราถึงการคูณจริง:

_
$'$*_

แต่ละคน_จะถูกแทนที่ด้วยการเป็นตัวแทน unary ของทุกสิ่งที่ตามมา (ยังคงใช้_เป็นตัวเลขหลัก) เนื่องจากการแปลงเป็น unary จะละเว้นอักขระที่ไม่ใช่ตัวเลขการทำเช่นนี้จะทำซ้ำการแสดงตัวเลขที่สองโดยไม่นับเป็น "ครั้งแรก" ตัวเลขที่สองจะยังคงอยู่ในรูปของทศนิยมในตอนท้ายของสตริง

ในตอนท้ายด้วยเดี่ยว_เรากลับจำนวนของ_ในสตริงซึ่งจะเป็นผลมาจากการคูณ

คำตอบก่อนหน้า: (คำเตือน: เอาต์พุตสตริงว่างเมื่อควรเอาต์พุต0)

เรติน่า ,  45  42 41 ไบต์

เล่นเกมกันเถอะ! ทวีคูณตัวเลขที่สัมพันธ์กันด้วยภาษาที่ไม่มีตัวดำเนินการทางคณิตศาสตร์และการสนับสนุนที่ จำกัด สำหรับตัวเลขที่เป็นธรรมชาติเท่านั้น ... ฟังดูตลก :)

O^`^|-
--

\d+
$*
1(?=1* (1*))?
$1
1+
$.&

คำอธิบาย

สามบรรทัดแรกจัดการกับเครื่องหมาย:

O^`^|-

ประเภทนี้Oแล้วกลับ^ทุกสายที่ตรงกับ ^|-regex ในทางปฏิบัติสิ่งนี้จะจับคู่สตริงว่างในตอนเริ่มต้นและเครื่องหมายลบท้ายสุดก่อนหมายเลขที่สองและเรียงลำดับใหม่ให้วางสตริงว่างในตำแหน่งลบ หลังจากนี้ทั้งหมด-อยู่ที่จุดเริ่มต้นของสตริงและคู่ของพวกเขาสามารถลบออกได้อย่างง่ายดายด้วยสองบรรทัดถัดไป

หลังจากนั้นเราใช้ builtin เพื่อแปลงตัวเลขเป็นการแสดงเอกและจากนั้นการคูณจริงมา:

1(?=1* (1*))?
$1

เราจับคู่ใด ๆ1และแทนที่แต่ละรายการด้วย1ช่องว่างต่อไปนี้ ตัวเลขแต่ละตัวของหมายเลขแรกจะถูกแทนที่ด้วยตัวเลขที่สองเต็มในขณะที่ตัวเลขแต่ละตัวของตัวเลขที่สองจะถูกแทนที่ด้วยสตริงที่ว่างเปล่า

ส่วนสุดท้ายเป็น builtin อีกครั้งเพื่อแปลงกลับจาก unary เป็นทศนิยม

ลองออนไลน์!

ขีดข่วน 1 ไบต์

การใช้งาน: ใส่ตัวเลขลงในทั้งสองด้านของ*เครื่องหมาย

หมายเหตุ: ตั้งแต่ Scratch เป็นภาษาภาพฉันไม่สามารถทราบได้ว่าต้องใช้กี่ไบต์จนกว่า @ mbomb007 จะจดบันทึกฉันเกี่ยวกับวิธีการนับจำนวนรอยขีดข่วน

Brain-Flakขนาด 56 ไบต์

([({}<([({})<>])<>>)<>]){({}[()]<(({})<({}{})>)>)<>}{}{}

สิ่งนี้จะต้องถูกเรียกใช้เป็นโปรแกรมแบบเต็มเนื่องจากไม่สะอาดหมดจดและอินพุตต้องเป็นองค์ประกอบเดียวในสแต็กทั้งสอง

ลองออนไลน์!

คำอธิบาย: (เรียกอินพุต x และ y)

ส่วนที่ 1:

([({}<([({})<>])<>>)<>])

([                    ]) # Push negative x on top of:
      ([      ])         # negative y. After...
  ({}<            >)     # pushing x and...
        ({})             # y...
            <>  <>  <>   # on the other stack (and come back)

ณ จุดนี้เรามี [x, y] ในหนึ่งกองและ [-x, -y] ที่อื่น

ส่วนที่ 2:

{({}[()]<(({})<({}{})>)>)<>}{}{}
{                          }     # Loop until x (or -x) is 0
 ({}[()]<              >)        # Decrement x
         (({})<      >)          # Hold onto y
               ({}{})            # Add y and the number under it (initially 0)
                         <>      # Switch stacks
                            {}{} # Pop x and y leaving the sum

JavaScript (ES6), 9 ไบต์

ES6 มีฟังก์ชันเฉพาะสำหรับเลขจำนวนเต็ม 32 บิตซึ่งเร็วกว่าตัว*ดำเนินการทั่วไปมากขึ้น

Math.imul

อนึ่งนี่เป็นเพียงตราบใดที่:

a=>b=>a*b

Brain-Flak , 56 54 52 ไบต์

บันทึก 2 ไบต์ด้วยความผิดพลาดที่ Nitrodon จับได้

({}(<()>)<>)({<([{}({}())])><>([{}]([{}]))<>}<{}{}>)

ลองออนไลน์!

สแต็กเวอร์ชั่นคลีน62 60 ไบต์

({}(<()>)(<>))({<([{}({}())])><>([{}]([{}]))<>}<{}{}<>{}{}>)

ลองออนไลน์!

คำอธิบาย

คำอธิบายนี้เป็นคำอธิบายเพิ่มเติมเกี่ยวกับอัลกอริทึมที่เกี่ยวข้องและไม่ใช้รหัสจริงใด ๆ ถือว่าคุณรู้วิธีอ่าน Brain-Flak อย่างเชี่ยวชาญ หากคุณต้องการความช่วยเหลือในการทำความเข้าใจทั้งรหัสหรืออัลกอริทึมฉันยินดีที่จะแก้ไขหรือตอบสนองหากคุณแสดงความคิดเห็น

นี่เป็นสิ่งแปลก ๆ เล็กน้อยและใช้คณิตศาสตร์แปลก ๆ ที่เพิ่งจะได้ผล สิ่งแรกที่ฉันทำคือการทำลูปที่จะยุติในO (n) เสมอขั้นตอนเสมอ วิธีปกติในการทำเช่นนี้คือการใส่nและ-nลงบนสแต็กตรงข้ามและเพิ่มเข้าไปทีละอันจนกระทั่งศูนย์หนึ่งกระทบ แต่ฉันทำแบบคนแปลกหน้าเล็กน้อย ในวิธีการของฉันฉันวางเคาน์เตอร์ใต้อินพุตและแต่ละขั้นตอนฉันเพิ่มตัวนับเพิ่มเข้าไปในnและพลิกสัญลักษณ์ของ n

ลองมาดูตัวอย่างกัน พูดn = 7

7  -8   6  -9   5 -10   4 -11   3 -12   2 -13   1 -14   0
0   1   2   3   4   5   6   7   8   9  10  11  12  13  14

ฉันจะไม่พิสูจน์ที่นี่ แต่สิ่งนี้จะสิ้นสุดสำหรับอินพุตใด ๆ และจะทำในขั้นตอนประมาณ2n ในความเป็นจริงมันจะยุติใน2nขั้นตอนถ้าnเป็นบวกและ2n-1ขั้นตอนถ้าnเป็นลบ คุณสามารถทดสอบมันได้ที่นี่

ตอนนี้เรามีประมาณ ขั้นตอน 2nในลูปของเราเราจะคูณด้วยn ได้อย่างไร? ทีนี้นี่ก็มีเวทย์มนตร์ทางคณิตศาสตร์ นี่คือสิ่งที่เราทำ: เราทำการสะสมแต่ละขั้นตอนของกระบวนการที่เราเพิ่มอินพุตที่สอง ( m ) ไปที่แอคคูมูเลเตอร์และพลิกสัญลักษณ์ของทั้งคู่ สินค้า

ทำไมบนโลกนี้เป็นอย่างนั้น?

ลองดูตัวอย่างและหวังว่ามันจะชัดเจน ในตัวอย่างนี้เราคูณ5ด้วย3ฉันจะแสดงเฉพาะค่าที่สำคัญ

total       -> 0  -5   5 -10  10 -15  15
accumulator -> 0  -5  10 -15  20 -25  30
m           -> 5  -5   5  -5   5  -5   5

หวังว่ากลไกจะปรากฏที่นี่ เรากำลังก้าวผ่านทวีคูณทั้งหมดของmตามค่าสัมบูรณ์ของพวกเขา จากนั้นคุณจะแจ้งให้ทราบว่า2n ^THระยะอยู่เสมอm * nและระยะเวลาก่อนที่จะเสมอ-m * n สิ่งนี้ทำให้การวนลูปของเราสอดคล้องกับผลลัพธ์ที่เราต้องการอย่างสมบูรณ์แบบ เป็นเรื่องบังเอิญที่มีความสุข;)

Dyalog APL , 1 ไบต์

× ใช้หมายเลขหนึ่งทางด้านซ้ายและหมายเลขหนึ่งทางด้านขวา

×... หรือแม้กระทั่งตัวเลขหลายตัวทางซ้ายหรือขวาหรือทั้งสองข้าง

×/ คูณตัวเลขทั้งหมดในรายการ

×/¨ ทวีคูณคู่ในรายการที่กำหนด

×/∊ mulitplies ตัวเลขทั้งหมดในอาร์เรย์

สิ่งนี้ใช้กับฟังก์ชั่นทางคณิตศาสตร์ทั้งหมดอาร์เรย์ทุกขนาดและแถวและตัวเลขของประเภทข้อมูลทั้งหมด

R, 3 ไบต์

'*'

นี่คือฟังก์ชั่นที่รับอาร์กิวเมนต์สองตัว '*'(a,b)ทำงานเป็น

ดูprodว่าสิ่งใดทำสิ่งเดียวกัน แต่สามารถรับจำนวนอาร์กิวเมนต์ได้โดยพลการ

ArnoldC , 152 ไบต์

HEY CHRISTMAS TREE c
YOU SET US UP 0
GET TO THE CHOPPER c
HERE IS MY INVITATION a
YOU'RE FIRED b
ENOUGH TALK
TALK TO THE HAND c
YOU HAVE BEEN TERMINATED

ลองออนไลน์!

Hexagony , 9 ไบต์

?{?/*!@'/

ลองออนไลน์!

นี่เป็นเรื่องที่ค่อนข้างตรงไปตรงมา นี่คือรุ่นที่กางออก:

  ? { ?
 / * ! @
' / . . .
 . . . .
  . . .

/เพียงแค่เปลี่ยนเส้นทางการควบคุมการไหลไปยังบรรทัดที่สองเพื่อประหยัดไบต์ที่สาม ที่ช่วยลดรหัสให้กับโปรแกรมเชิงเส้นนี้:

?{?'*!@

รหัสเชิงเส้นนี้ของตัวเองจะเป็นทางออกที่ถูกต้องหากอินพุตถูก จำกัด ให้เป็นตัวเลขบวกอย่างเคร่งครัด แต่เนื่องจากความเป็นไปได้ของผลลัพธ์ที่ไม่เป็นบวกจึงไม่รับประกันว่าจะยุติ

โปรแกรมใช้ประโยชน์จากสามขอบหน่วยความจำในรูปตัว Y:

A   B
 \ /
  |
  C

ตัวชี้หน่วยความจำเริ่มต้นที่ขอบAชี้ไปทางกลาง

?   Read first input into edge A.
{   Move forward to edge B.
?   Read second input into edge B.
'   Move backward to edge C.
*   Multiply edges A and B and store the result in C.
!   Print the result.
@   Terminate the program.

ฉันวิ่งค้นหาสัตว์ป่าขนาด 7 ไบต์ (เช่นที่เข้ากับความยาวด้าน 2) และหากฉันไม่ได้ทำผิดพลาด (หรือมีวิธีแก้ปัญหาที่ช่องคลอดไม่ว่างที่ใช้เวลานานกว่าจะสำเร็จ) ซึ่งฉันสงสัย) จากนั้นโซลูชัน 7 ไบต์ไม่มีอยู่ อาจมีวิธีแก้ปัญหาแบบ 8 ไบต์ (เช่นการนำ?คำสั่งการเปลี่ยนทิศทางเดียวมาใช้ซ้ำหรือใช้คำสั่งเดียวแทนคำสั่งสองคำ/) แต่นั่นเป็นสิ่งที่เกินกว่าที่การค้นหากำลังดุร้ายของฉันสามารถทำได้และฉันยังไม่พบใคร

Piet , 16 ไบต์

5bpiaibpikibptai

ล่ามออนไลน์มีให้ที่นี่

คำอธิบาย

ในการเรียกใช้ให้วางโค้ดด้านบนในกล่องข้อความทางด้านขวาของหน้าที่เชื่อมโยง ด้านล่างคือการแสดงกราฟิกของรหัสนี้ด้วยขนาด codel 31 ตารางสำหรับการอ่านและอาจรบกวนการตีความ Piet แบบดั้งเดิม
โค้ดจะทำงานแบบเส้นตรงจากซ้ายไปขวาไปตามด้านบนของภาพจนถึงบล็อกสีเขียวอันแรกซึ่งการไหลของโปรแกรมย้ายไปที่แถวกลางของโคเดอร์ White cone white lone เป็นสิ่งจำเป็นสำหรับการไหลของโปรแกรม มันอาจถูกแทนที่ด้วย codel สีอื่นนอกเหนือจากสีเขียวหรือสีน้ำเงินเข้ม แต่ฉันเลือกสีขาวเพื่อให้สามารถอ่านได้

Instruction    Δ Hue    Δ Lightness    Stack
-----------    -----    -----------    -----
In (Number)    4        2              m
In (Number)    4        2              n, m
Multiply       1        2              m*n
Out (Number)   5        1              [Empty]
[Exit]         [N/A]    [N/A]          [Empty]

หากคุณคิดว่าข้อความที่ไม่ได้เป็นวิธีที่ดีที่สุดที่จะเป็นตัวแทนโปรแกรม Piet หรือมีปัญหากับขนาดไบต์ของโปรแกรม Piet ทั่วไปโปรดแจ้งให้ความคิดเห็นของคุณจะเป็นที่รู้จักในการอภิปรายเกี่ยวกับเมตา

BitCycle -U , 68 ไบต์

  >    > v
 ?+ >  +
Bv ?^ v ~
 \  v<CB~\v
 Cv  ^  <\/
^ <@=!   <
0A^

ลองออนไลน์!

การคูณสองตัวเลขนั้นไม่ใช่ปัญหาเล็กน้อยใน BitCycle โดยเฉพาะเมื่อต้องมีการจัดการสัญญาณ! นี่คือความพยายามครั้งที่สองของฉัน อันแรก (อัลกอริธึมที่เหมือนกันโดยพื้นฐาน, เลย์เอาต์ที่แตกต่างกัน) คือ 81 ไบต์, ดังนั้นจึงเป็นไปได้ค่อนข้างที่อันนี้จะสั้นลงได้เช่นกัน

โปรแกรมใช้ตัวเลขสองตัวเป็นอาร์กิวเมนต์บรรทัดคำสั่งและส่งออกไปยัง stdout การ-Uตั้งค่าสถานะคือการแปลงตัวเลขทศนิยมให้เป็นเอกภาพเนื่องจาก BitCycle รู้เพียง 0 และ 1

คำอธิบาย

คำอธิบายนี้จะถือว่าคุณเข้าใจพื้นฐานของ BitCycle (ดูEsolangsหรือ GitHub readme) ฉันจะยึดคำอธิบายของฉันกับรุ่น ungolfed นี้เห็นที่นี่การคำนวณ-2ครั้ง3:

ภาพรวม

หมายเลข unary ที่ลงนามประกอบด้วยเครื่องหมาย ( 0สำหรับ nonpositive, ว่างสำหรับค่าบวก) ตามด้วยขนาด (จำนวน1s เท่ากับค่าสัมบูรณ์ของตัวเลข) ในการคูณสองพวกเราต้อง XOR สัญญาณ (เอาท์ a 0ถ้าหนึ่งในนั้นคือ0หรือไม่มีอะไรถ้าทั้งสองอย่างหรือไม่ใช่) แล้วคูณขนาด (และเอาท์พุทที่หลาย1s) เราจะได้การคูณด้วยการเติมซ้ำ

เครื่องหมายบิต

เริ่มจากสองแหล่ง?เราแยกสัญญาณจากขนาดที่ใช้+เราแยกออกจากสัญญาณจากขนาดโดยใช้0s (บิตเครื่องหมาย) เลี้ยวซ้ายและมุ่งไปตามแถวบนสุดขณะที่1s (ขนาด) เลี้ยวขวาและจบลงในสองBนักสะสม

ส่วนที่จัดการสัญญาณมีลักษณะดังนี้:

  v

  \  v
> \  /

! <

ถ้าตัวเลขทั้งสอง nonpositive สองบิตมาจากด้านบน0 vคนแรกสะท้อนออกจากด้านบน\ถูกส่งไปทางใต้และสะท้อนออกมา/มา ในขณะที่สองบิตผ่านด้านบนปิดการใช้งานและสะท้อนออกจากด้านล่าง\ \บิตสองบิตผ่านกันและกันไปตรงผ่านตัวแยกที่ไม่ได้ใช้งานในแถวด้านล่างและออกจากสนามแข่งขัน

หากตัวเลขใดตัวเลขหนึ่งไม่เป็นเชิงลบก็จะมีตัวเลข0มาจากด้านบน มันกระดอนไปรอบตัวแยกสามตัวและจบลงที่ทิศเหนืออีกครั้งvและถูกส่งไปทางใต้อีกครั้ง คราวนี้มันผ่านแยกที่ปิดใช้งานและถึงซึ่งจะส่งมันลงไปในอ่างล้างจาน<!

ลูปเพื่อเก็บขนาด

ขนาดของตัวเลขแรกจะเข้าสู่ตัวBรวบรวมในส่วนนี้:

B v
  \
  C v
^   <

0 A ^

ก่อนที่จะBเก็บเปิดที่Aสะสมออกเดียวที่ถูกวางไว้ในนั้นซึ่งจากนั้นก็เดินไปยังจุดสิ้นสุดของคิวใน0 Bเราจะใช้มันเป็นค่าสถานะเพื่อยกเลิกการวนซ้ำเมื่อ1บิตทั้งหมดในBนั้นหายไป

ทุกครั้งที่มีการBสะสม\ตัวแยกสัญญาณแยกออกจากบิตแรกจากคิวและส่งไปยังตรรกะการประมวลผลที่อยู่ตรงกลาง ส่วนที่เหลือของบิตจะเข้าสู่Cและเมื่อCนักสะสมเปิดพวกเขาจะถูกส่งกลับเข้ามาBมา

ขนาดของตัวเลขที่สองเข้าสู่ตัวBรวบรวมในส่วนนี้:

v   ~
C B ~
    <

เมื่อBนักสะสมเปิดบิตไปเป็น ~dupneg 1บิตดั้งเดิมจะเลี้ยวขวาและส่งไปทางตะวันตกเข้าสู่ตรรกะการประมวลผลที่อยู่ตรงกลาง สำเนาเมื่อตะกี้0เลี้ยวซ้ายแล้วชนอีกชุดหนึ่ง ที่นี่0s เลี้ยวขวาและไปปิดสนามแข่งขันในขณะที่ (ตอนนี้เป็นทวีคูณ) เมื่อตะกี้1s Cเลี้ยวซ้ายและถูกส่งเข้าไปใน เมื่อเปิดขึ้นมาให้พวกเขากลับไปเป็นCB

นอกจากนี้ซ้ำแล้วซ้ำอีก

ตรรกะการประมวลผลกลางคือส่วนนี้:

   v
   v


@  =  !

บิตจากทั้งลูป (จากทางด้านตะวันตกและทุกอย่างจากฝั่งตะวันออก) =จะถูกส่งไปทางใต้สวิทช์ ต้องตั้งค่าเวลาเพื่อให้บิตจากลูปตะวันตกมาถึงก่อน หากเป็น a 1สวิตช์จะเปลี่ยน}โดยส่งบิตต่อไปนี้ไปทางทิศตะวันออกลงใน sink !เพื่อส่งออก ทุกครั้ง1ที่จะหายไปเราได้รับซึ่งการเปลี่ยนแปลงสลับไป0 {นี่จะส่งบิตต่อไปนี้ลงใน@ซึ่งจะยกเลิกโปรแกรม ในระยะสั้นเราส่งออกขนาด (unary) ของจำนวนที่สองหลาย ๆ ครั้งตามที่มีอยู่1ในขนาด (unary) ของจำนวนแรก

Python 3 , 11 ไบต์

int.__mul__

ลองออนไลน์!

ใช้ได้กับจำนวนเต็มที่อยู่2**32ใน Python 2 ด้วย

Java 8, 10 9 ไบต์

a->b->a*b

ลองที่นี่

Java 7, 31 ไบต์

int c(int a,int b){return a*b;}

ลองที่นี่

ในฐานะโปรแกรมเต็มรูปแบบ( 99 90 ไบต์) :

interface M{static void main(String[]a){System.out.print(new Long(a[0])*new Long(a[1]));}}

ลองที่นี่

Pyth, 2 ไบต์

*E

ลองที่นี่!

การประเมินอัตโนมัติของ Pyth มาถึงตรงนี้แล้ว เพื่อให้ได้รอบฉันใช้การประเมินผลที่ชัดเจนสำหรับหนึ่งในข้อโต้แย้ง

TI-Basic, 2 ไบต์

ตรงไปตรงมามาก

prod(Ans

PHP, 21 ไบต์

<?=$argv[1]*$argv[2];

รับอินพุตจากอาร์กิวเมนต์บรรทัดรับคำสั่ง ยังทำงานร่วมกับลอย

เรติน่า39 39ไบต์

ขอบคุณลีโอที่ให้ฉันใช้ความคิดของเขาที่จบลงด้วยการประหยัด 4 ไบต์

[^-]

*\)`--

.+
$*
\G1
_
_|1+
$'
1

อินพุตถูกคั่นด้วยตัวป้อนบรรทัด

ลองออนไลน์! (ชุดทดสอบแยกด้วยช่องว่างเพื่อความสะดวก)

คำอธิบาย

สองขั้นตอนแรกพิมพ์เครื่องหมายลบหากหนึ่งในสองอินพุตนั้นเป็นลบ พวกเขาทำสิ่งนี้โดยไม่เปลี่ยนอินพุตจริง นี้จะกระทำโดยการจัดกลุ่มไว้ในขั้นตอนที่สองด้วยและทำให้พวกเขากลายแห้งวิ่งด้วย) ตัวเลือกที่สองป้องกันขั้นตอนการพิมพ์เลื่อนบรรทัดต่อท้าย*\

[^-]

ก่อนอื่นเราจะลบทุกอย่างยกเว้นเครื่องหมายลบ

*\)`--

จากนั้นเราจะยกเลิกเครื่องหมายลบหากมีเหลืออยู่สองรายการ

.+
$*

ตอนนี้เราแปลงแต่ละบรรทัดเป็นการแทนค่าแบบ unary ของค่าสัมบูรณ์ สิ่งนี้จะกำจัดเครื่องหมายลบเพราะค้นหา$*เฉพาะหมายเลขที่ไม่เป็นลบครั้งแรกในการแข่งขัน (เช่นไม่ทราบเกี่ยวกับเครื่องหมายลบและไม่สนใจ)

\G1
_

บรรทัดแรกจะถูกแปลงเป็น_โดยการจับคู่แต่ละรายการ1ตราบใดที่อยู่ติดกับการแข่งขันก่อนหน้า (ดังนั้นเราจึงไม่สามารถจับคู่1s ในบรรทัดที่สองได้เนื่องจากการป้อนบรรทัดแบ่งสายโซ่นี้)

_|1+
$'

นี่เป็นการคูณที่แท้จริง เราแทนที่แต่ละ_บรรทัด (ในบรรทัดแรก) รวมถึงทุกบรรทัดที่สองหลังจากการแข่งขันนั้น การ_แข่งขันจะรวมบรรทัดที่สองทั้งหมด (คูณด้วยจำนวน0s ในบรรทัดแรก) และบรรทัดที่สองจะถูกลบเนื่องจากไม่มีอะไรหลังจากการแข่งขันนั้น แน่นอนว่าผลลัพธ์จะมีขยะในรูปแบบของ_s และ linefeeds ด้วย แต่นั่นไม่สำคัญ

1

เราเสร็จโดยเพียงนับจำนวน1s ในผลลัพธ์

MATLAB, 5 4 ไบต์

@dot

dotรับผลคูณดอทของเวกเตอร์สองตัวที่มีความยาวเท่ากัน ถ้าเราป้อนมันด้วยสองสเกลาร์มันก็จะคูณตัวเลขสองตัว

prodรับผลคูณของค่าในทุกแถวของแต่ละคอลัมน์ของเมทริกซ์ ถ้าเมทริกซ์เป็นหนึ่งมิติ (เช่นเวกเตอร์) มันจะทำตามมิติที่ไม่ใช่ซิงเกิลเอาผลคูณขององค์ประกอบทั้งหมดในเวกเตอร์

dotเป็นหนึ่งไบต์สั้นกว่าซึ่งเป็นหนึ่งไบต์สั้นกว่าในตัวชัดเจนมากขึ้นprodtimes

เรียกมันว่า:

@dot
ans(3,4)
ans = 
   12

PigeonScriptขนาด 1 ไบต์

*

คำอธิบาย:
*มองไปที่สแต็กเพื่อดูว่ามีอะไรในนั้นหรือไม่ หากไม่มีระบบจะแจ้งให้ป้อนข้อมูลและคูณอินพุตด้วยกัน

Perl 6 , 4 ไบต์

&[*]

นี่เป็นเพียงโอเปอเรเตอร์การคูณมัดแบบธรรมดา*ซึ่งแสดงเป็นฟังก์ชันทั่วไป เป็นโบนัสหากได้รับหนึ่งหมายเลขจะส่งคืนหมายเลขนั้นและหากไม่ได้รับหมายเลขจะส่งคืน1ตัวตนของการคูณ

><>, 5 Bytes

i|;n*

Takes input as an ascii character, outputs a number.

Explanation:

i                        | Get input.
 |                       | Mirror: Change the pointer's direction.
i                        | Get input again.
    *                    | Loop around to the right side. Multiply
   n                     | Print the value on the stack, as a number
  ;                      | End the program

You could also do

ii*n;

But I feel my solution is waaay cooler.

Another possibility is dropping the semicolon, which would result in the pointer bouncing off the mirror, hitting the print command, and throwing an error since the stack is empty.

รหัสเครื่อง Intel 8080 , MITS Altair 8800, 28 bytes

สิ่งนี้ใช้การคูณแบบไบนารีบนIntel 8080 CPU (c. 1974) ซึ่งไม่มีคำแนะนำการคูณหรือการหาร อินพุตเป็นค่า 8 บิตและผลิตภัณฑ์เป็นค่า 16 บิตที่ส่งคืนในBC register pair.

นี่คือรหัสเครื่องพร้อมกับคำแนะนำทีละขั้นตอนเพื่อโหลดโปรแกรมลงในAltair 8800โดยใช้สวิตช์แผงด้านหน้า

Step    Switches 0-7    Control Switch  Instruction Comment
1                       RESET
2       00 001 110      DEPOSIT         MVI  C, 5   Load multiplier into C
3       00 000 101      DEPOSIT NEXT                value is 5
4       00 010 110      DEPOSIT NEXT    MVI  D, 16  Load multiplicand into D
5       00 010 000      DEPOSIT NEXT                value is 16
6       00 000 110      DEPOSIT NEXT    MVI  B, 0   clear B register (high byte of result)
7       00 000 000      DEPOSIT NEXT
8       00 011 110      DEPOSIT NEXT    MVI  E, 9   set loop counter E multiplier size
9       00 001 001      DEPOSIT NEXT                (8 bits + 1 since loop ends in middle)
10      01 111 001      DEPOSIT NEXT    MOV  A, C   move multiplier into A for shift
11      00 011 111      DEPOSIT NEXT    RAR         shift right-most bit to CF
12      01 001 111      DEPOSIT NEXT    MOV  C, A   move back into C
13      00 011 101      DEPOSIT NEXT    DCR  E      decrement loop counter
14      11 001 010      DEPOSIT NEXT    JZ   19 00  loop until E=0, then go to step 27
15      00 011 001      DEPOSIT NEXT
16      00 000 000      DEPOSIT NEXT
17      01 111 000      DEPOSIT NEXT    MOV  A, B   move sum high byte into A
18      11 010 010      DEPOSIT NEXT    JNC  14 00  add if right-most bit of 
19      00 010 100      DEPOSIT NEXT                multiplier is 1, else go to 22
20      00 000 000      DEPOSIT NEXT
21      10 000 010      DEPOSIT NEXT    ADD  D      add shifted sums
22      00 011 111      DEPOSIT NEXT    RAR         shift right new multiplier/sum
23      01 000 111      DEPOSIT NEXT    MOV  B, A   move back into B
24      11 000 011      DEPOSIT NEXT    JMP  08 00  go to step 10
25      00 001 000      DEPOSIT NEXT
26      00 000 000      DEPOSIT NEXT
27      11 010 011      DEPOSIT NEXT    OUT  255    display contents of A on data panel
28      11 111 111      DEPOSIT NEXT
30      01 110 110      DEPOSIT NEXT    HLT         Halt CPU
31                      RESET                       Reset program counter to beginning
32                      RUN
33                      STOP

ลองออนไลน์!

หากคุณป้อนทุกอย่างถูกต้องบนลิ้นชักสถานะเครื่องในเครื่องมือจำลองเนื้อหา RAM ของคุณจะมีลักษณะดังนี้:

0000    0e 05 16 10 06 00 1e 09 79 1f 4f 1d ca 19 00 78 
0010    d2 14 00 82 1f 47 c3 08 00 d3 ff 76

อินพุต

ตัวคูณในการลงทะเบียนและเข้าสู่คูณC DAltair ของสต็อคไม่มีการSTDINป้อนข้อมูลโดยสวิตช์ด้านหน้าเท่านั้น

เอาท์พุต

ผลลัพธ์จะแสดงบนD7- D0ไฟ (แถวบนขวา) ในรูปแบบไบนารี่

5 x 16 = 80 (0101 0000)

4 x 5 = 20 (0001 0100)

7 x 9 = 63 (0011 1111)

8 x -9 = -72 (1011 1000)

หมายเหตุความเข้ากันได้: สิ่งนี้ควรทำงานบนIMSAI 8080แม้ว่าจะยังไม่ได้ทดสอบในขณะนี้

C #, 10 ไบต์

a=>b=>a*b;

มันก็แค่การคูณ

Jelly, 1 byte

×

Try it online!

Obligatory Jelly submission.

Clojure, 1 byte

*

:P As a bonus this works on any number of arguments:

[(*)
 (* 2)
 (* 2 3)
 (* 2 3 4)
 (* 2 3 4 5)] => [1 2 6 24 120]

Interestingly you can easily get its source code:

(source *)
(defn *
  "Returns the product of nums. (*) returns 1. Does not auto-promote
  longs, will throw on overflow. See also: *'"
  {:inline (nary-inline 'multiply 'unchecked_multiply)
   :inline-arities >1?
   :added "1.2"}
  ([] 1)
  ([x] (cast Number x))
  ([x y] (. clojure.lang.Numbers (multiply x y)))
  ([x y & more]
     (reduce1 * (* x y) more)))

Owk, 11 bytes

λx.λy.x*y

This can be assigned to a function like this:

multiply:λx.λy.x*y

and called like this:

result<multiply(a,b)