Multiply two numbers

Input: Two decimal integers. These can be given to the code in standard input, as arguments to the program or function, or as a list.

Output: Their product, as a decimal integer. For example, the input 5 16 would lead to the output 80.

Restrictions: No standard loopholes please. This is , answer in lowest amount of bytes wins.

Notes: Layout stolen from my earlier challenge, Add two numbers.

Test cases:

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


Or as 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>

• @FlipTack That's assuming addition and multiplication are as easy in any language, which I don't know if it's actually true. Jan 9, 2017 at 8:13
• I don't think it's fair to allow the "add two numbers" challenge but close this one. Even though it's very trivial in most programming languages, it's still a valid challenge. If this is too broad, then the "add two numbers" challenge must also be too broad.
– user45941
Jan 9, 2017 at 8:42
• Anyone is free to downvote trivial challenges if they don't like them, but this is a perfectly valid and on-topic challenge and it's nowhere near "too broad" (if anything, you might call a trivial challenge too narrow). I'm reopening this. That said, if anyone feels that trivial challenges insult their intelligence, I encourage them to seek out languages that make the task less trivial. Jan 9, 2017 at 9:19
• Uo next: Subtract two numbers! Jan 9, 2017 at 12:57
• @wat Leaving no barrel-bottom unscraped, eh? Jan 10, 2017 at 12:39

Brachylog V1, 05AB1E, J, K, Underload, MATL, Forth, PigeonScript, Stacked, Implicit, Jolf, Clojure, Braingolf, 8th, Common Lisp, Julia, Pyt, Appleseed, Stax, Reality, dc, Vyxal, Keg, Swift, Fig*, Chocolate, ><>, Thunno*: 1 byte

*


You may edit this answer to add other languages for which * is a valid answer.

*Actually $$\\log_{256}(96)\approx\$$ 0.823 bytes in Fig and Thunno

• Polygot, 05AB1E and like 5 other languages. Jan 9, 2017 at 17:41
• I edited Underload into this. It's possibly the most interesting of these, because Underload does not have a 1 byte method of doing subtraction, division, or addition.
– user62131
Jan 12, 2017 at 15:13
• Here's another one: codegolf.stackexchange.com/a/106187/62257 Feb 22, 2017 at 0:23
• This isn't valid in Pyth. Pyth doesn't take implicit input like this. Dec 9, 2017 at 2:27
• Added Julia, eg *(5,16)
– gggg
Jan 16, 2018 at 23:36

C (GCC), 13 bytes

Doesn't work on all implementations, but that's OK.

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


Try it on TIO!

• Wait, is this supposed to somehow return a? I don't get it... Jan 9, 2017 at 15:23
• An explanation to how this works would be helpful. (a is a local stack variable to f() - why is its value returned?). +1, btw - very clever abuse of the ABI. Jan 9, 2017 at 17:29
• @EriktheOutgolfer The return keyword simply places the redult of the its argument in the EAX register. In this case, the generated executable does the computation of a*b in that register, so return doesn't do anything. Jan 9, 2017 at 18:03
• Hey, that was my trick! codegolf.stackexchange.com/a/106067/18535 :-)
– G B
Jan 10, 2017 at 13:03
• So happy to see C at the top for once! You can actually shave off about 9 bytes by simply replacing the f(a,b){a*=b;} part with 1##& and then just changing your language to Mathematica. Feb 8, 2017 at 23:40

Beatnik, 888 bytes

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


Try it online!

I'm using the C interpreter because the Python interpreter on TIO annoyingly executes the address if the condition for jumping backward isn't met. An easy workaround for the Python interpreter is to pad some nops to make the address nop. I believe neither is correct:

                                   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


Input should be two integers separated by a space, without trailing newlines.

This answer works in theory for all integers, if each cell can store an arbitrarily large value, not limited to 0 - 255. But it overflows if |A|+|B| > 22. And it runs very slowly if |A|+|B| > 6. So there is not many cases you can actually test and an if-else solution for those cases might be even shorter.

The idea is to compute the triangular numbers T(N) = N(N+1)/2 by decrementing the value to 0 and summing up all the intermediate values. Then we can get the answer A*B = T(A+B) - T(A) - T(B).

But it is tricky to compute all the 3 values. It does this by firstly computing T(A+B) - A, leaving a copy of A in the stack to add back later, and using up the input B. Then recursively find the greatest triangular number smaller than that, which is T(A+B-1) except for the zero special cases. We can get back B = T(A+B) - A - T(A+B-1) and compute T(B) from there.

A number N is a triangular number iff it equals to the greatest triangular number smaller than N, plus the number of non-negative triangular numbers smaller than N. This runs in O(2^(T(A+B)-A)) and is the slowest part in the program.

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
k I Xj (input_a_loop)                       Continue the loop.
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,
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.

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

• Woah. Just... woah. I've place the bounty, you'll get it in 7 days.
– Maya
Apr 14, 2018 at 8:39

Scratch, 1 byte

Usage: Place numbers in both sides of * sign

Note: Since Scratch is a visual language I could not figure out how many bytes it consumes until @mbomb007 noted me about a method for counting scratch bytes

Mathematica, 4 bytes

1##&


Example usage: 1##&[7,9] returns 63. Indeed, this same function multplies any number of arguments of any type together.

As Mathematica codegolfers know, this works because ## refers to the entire sequence of arguments to a function, and concatenation in Mathematica (often) represents multiplication; so 1## refers to (1 times) the product of all the arguments of the function. The & is just short for the Function command that defines a pure (unnamed) function.

Inside other code, the common symbol * does act as multiplication. So does a space, so that 7 9 is interpreted as 7*9 (indeed, the current REPL version of Mathematica actually displays such spaces as multiplication signs!). Even better, though, if Mathematica can tell where one token starts and another ends, then no bytes at all are needed for a multiplication operator: 5y is automatically interpreted as 5*y, and 3.14Log[9] as 3.14*Log[9].

• What makes ##& invalid?
– Lynn
Aug 12, 2018 at 12:44
• ##& returns its list of arguments as a 'Sequence' object—suitable for plugging into other functions that take multiple arguments. In this context, ##& doesn't do anything to its list of arguments; we want that list to be multiplied together. Aug 12, 2018 at 17:31

Retina, 3837 31 bytes

Completely new approach, the old one is below.

M!-
*\)-¶-

.*
$*_ _$'$*_ _  Try it online! Explanation First, we deal with the sign: M!-  matches all - in the string and returns them separated by newlines *\)-¶-  (with a following empty line) *\) means the result of this and the previous stages should be printed without a newline, and then the string reverted to what it was before (the input string). The remaining part removes two - separated by a newline. Then we convert the first number to unary: .*$*_


(there's a space at the end of the first line). We use _ as our unary digit in this case, because the standard digit 1 can be present in the second number, and this would conflict later.

Now we get to the actual multiplication:

_
$'$*_


Each _ is replaced by the unary representation of everything following it (still using _ as the unary digit). Since conversion to unary ignores non-digit characters, this will repeat the unary representation of the second number for "first number" times. The second number will remain in decimal representation at the end of the string.

In the end, with a single _ we return the number of _ in the string, which will be the result of the multiplication.

Previous answer: (warning: outputs an empty string when it should output 0)

Retina,  45 42 41 bytes

Let's play a game! Multiply relative numbers with a language which has no arithmetic operators and limited support only for natural numbers... Sounds funny :)

O^^|-
--

\d+
$* 1(?=1* (1*))?$1
1+
$.&  Explanation The first three lines deal with the sign: O^^|-  This sorts O and then reverses ^ all strings matching the regex ^|-. In practice this matches the empty string at the start, and the eventual minus sign before the second number, and reorders them placing the empty string in the place of the minus. After this, all - are at the beginning of the string, and a pair of them can be removed easily with the next two lines. After that, we use a builtin to convert numbers to unary representation, and then comes the actual multiplication: 1(?=1* (1*))?$1


We match any 1, and substitute each of them with all the 1 after a following space. Each digit of the first number will be replaced by the full second number, while each digit of the second number will be replaced by the empty string.

The last part is again a builtin to convert back from unary to decimal.

Try it online!

• I wish I could upvote submission each time you golf it, nice job! Feb 18, 2017 at 10:03
\G1
_
_|1+
$' 1  Input is linefeed-separated. Try it online! (Space-separated test suite for convenience.) Explanation The first two stages print a minus sign if exactly one of the two inputs is negative. They do this without actually changing the input. This is done by grouping them in the second stage with ) and turning them into a dry-run with *. The \ option on the second stage prevents printing a trailing linefeed. [^-]  First, we remove everything except the minus signs. *\)--  Then we cancel the minus signs if there are two of them left. .+$*


Now we convert each line to the unary representation of its absolute value. This will get rid of the minus sign because $* only looks for the first non-negative number in the match (i.e. it doesn't know about minus signs and ignores them). \G1 _  The first line is converted to _, by matching individual 1s as long as their adjacent to the previous match (hence, we can't match the 1s on the second line, because the linefeed breaks this chain). _|1+$'


This performs the actual multiplication. We replace each _ (on the first line) as well as the entire second line everything after that match. The _ matches will therefore include the entire second line (multiplying it by the number of 0s in the first line), and the second line will be removed because there is nothing after that match. Of course the result will also include some junk in the form of _s and linefeeds, but that won't matter.

1


We finish by simply counting the number of 1s in the result.

PigeonScript, 1 byte

*


Explanation:
* looks to the stack to see if there is anything there. If not, it prompts for input and multiplies the inputs together

• This should be added here instead Feb 17, 2017 at 19:15

Perl 6, 4 bytes

&[*]


This is just the ordinary infix multiplication operator *, expressed as an ordinary function. As a bonus, if given one number it returns that number, and if given no numbers it returns 1, the multiplicative identity.

• Alternative 4 UTF-8 byte solution: *×* Apr 14, 2018 at 14:15

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)

• Does this not work? Please explain the doe vote. Jan 11, 2017 at 12:19
• I wasn't the downvoter, but I think I can guess what happened: this is a very trivial question (and thus very heavily downvoted, but with many upvotes cancelling that out), and likely to attract people who downvote trivial questions. This answer's also fairly trivial, and it's likely that some of the people who downvote trivial questions also like to downvote trivial answers. (Personally, I prefer to leave trivial answers at 0, so I'm not voting either way on this one.)
– user62131
Jan 12, 2017 at 15:22

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

BitCycle, 33 bytes

 >>\/v
?+ \/
? +~!/
A + =
~BC^


Try it online!

This takes input via command line args, with the -U flag to convert it into signed unary.

This only uses one pair of collectors in the main loop by representing the first number with unary 0s and the other number with 1s, allowing us to store both in the same collector.

Explanation:

No fancy gifs sorry. This also assumes you have at least a passing familiarity with BitCycle.

?+       Get both numbers as signed unary from the ? sources
? +      Sends 0s upwards (0s signify that the number is negative), and 1s downwards

  >>\/v  Given either 0, 1 or 2 zeroes
+ \/
+ !/  Push a 0 (signifying negative) if there is exactly one 0

 +      Push the first number as unary 1s to collector A
+     Push the second number as unary 0s to collector B
A +    Then push the first number into collector B
~BC   Then push both into collector C

     /    If the first bit out of collector C is 0
+ =    Turn the = into { and discard the first bit
BC^    All the 0s go back to collector B, and the 1s go up

  +~!     Duplicate and print all the 1s
+      Push the duplicates back into B
~B


This loops until it runs out of 0s in the collector, then the = turns into a } and discards the rest of the 1 bits.

C#, 10 bytes

a=>b=>a*b;


It's just a simply multiplication.

• You beat me to it! Jan 9, 2017 at 14:27
• How does the => => work? I'd expect (a,b)=>a*b; Jan 11, 2017 at 10:54
• @Carra It works, that this lambda expression returns a delegate, which returns the result, so you call it this way, if you call this lambda f:f(a)(b). Jan 11, 2017 at 11:27
• This would be a form of function currying Apr 1, 2019 at 20:33

Jelly, 1 byte

×


Try it online!

Obligatory Jelly submission.