Giriş: İki ondalık sayı. Bunlar standart girdideki koda, programa veya işleve argüman olarak veya bir liste halinde verilebilir.

Çıktı: Ondalık bir tamsayı olarak ürünleri. Örneğin, giriş 5 16çıkışa yol açacaktır 80.

Kısıtlamalar: Lütfen standart boşluklar yok. Bu kod-golf , kazanılan bayt miktarındaki en düşük cevabı verir.

Notlar: Mizanpaj, önceki meydan okumamdan çalındı, İki sayı ekle .

Test durumları:

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

Veya CSV olarak:

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

Liderler Sıralaması

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, Düşük, MATL, İleri, PigeonScript, Yığılmış, Örtük, Jolf, Clojure, Braingolf, 8., Ortak Lisp, Julia, Pyt, Elmalar, Stax, Gerçeklik, dc 1 bayt

*

*Geçerli bir cevap olan başka dilleri eklemek için bu cevabı düzenleyebilirsiniz .

C (GCC), 13 bayt

Tüm uygulamalar üzerinde çalışmıyor , ama sorun değil.

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

TIO'da dene!

Beatnik , 888 bayt

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

Çevrimiçi deneyin!

C tercüman kullanıyorum çünkü TIO'daki Python tercüman, geriye doğru atlanma koşulu karşılanmadığında sinir bozucu bir şekilde adresi çalıştırıyor. Python yorumlayıcısı için kolay bir geçici çözüm, adresi nop yapmak için bazı nops doldurmaktır. İkisinin de doğru olmadığına inanıyorum:

                                   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

Girdi, satır sonlarını izlemeden boşlukla ayrılmış iki tamsayı olmalıdır.

Bu cevap, her hücre 0 - 255 ile sınırlı değil, keyfi bir şekilde büyük bir değer depolayabiliyorsa, tüm tamsayılar için teoride çalışır. Fakat eğer | A | + | B | > 22. Ve eğer | A | + | B | > 6. Yani gerçekten test edebileceğiniz pek fazla vaka yoktur ve bu durumlar için bir if-if çözümü daha da kısa olabilir.

Buradaki fikir, değeri 0'a düşürerek ve tüm ara değerleri toplayarak T (N) = N (N + 1) / 2 üçgen sayılarını hesaplamaktır. Sonra A * B = T (A + B) - T (A) - T (B) cevabını alabiliriz.

Ancak bu 3 değeri de hesaplamak zor. Bunu, önce T (A + B) - A'yı hesaplayarak, daha sonra geri eklemek üzere yığında A'nın bir kopyasını bırakarak ve B girişini kullanarak yapar. Ardından, tekrar tekrar en büyük üçgen sayısını T değerinden daha küçük bulur. A + B-1) sıfır özel durumlar hariç. B = T (A + B) - A - T (A + B-1) 'i geri alabilir ve T (B)' yi oradan hesaplayabiliriz.

N sayısı, N'den küçük en büyük üçgen sayıya eşitse, artı N'den küçük olan negatif olmayan üçgen sayıların sayısına eşitse, üçgen bir sayıdır. Bu O (2 ^ (T (A + B) -A)) içinde çalışır. ve programın en yavaş kısmı.

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 bayt

1##&

Örnek kullanım: 1##&[7,9]döndürür 63. Aslında, bu aynı fonksiyon, herhangi bir tipteki herhangi bir sayıda argümanı bir araya getirir.

Mathematica kod yazarlarının bildiği gibi, bu işe yarıyor çünkü ##bir fonksiyonun tüm argüman sırasına atıfta bulunuyor ve Mathematica'daki birleştirme (çoğu zaman) çarpımı temsil ediyor; bu 1##, fonksiyonun tüm argümanlarının ürününü (1 kez) belirtir. Bu &, Functionsaf (adsız) bir işlevi tanımlayan komut için kısadır .

Diğer kodun içinde, ortak sembol *çarpma işlevi görür. Öyleyse bir boşluk var, bu şekilde 7 9yorumlanır 7*9(aslında, Mathematica'nın şu anki REPL sürümü aslında çarpma işaretleri gibi alanları görüntüler!). Daha da iyisi, eğer Mathematica, bir jetonun nerede başladığını ve diğerinin bittiğini söyleyebiliyorsa, çarpma operatörü için hiçbir bayta ihtiyaç duyulmaz: 5yotomatik olarak 5*y, ve 3.14Log[9]olarak yorumlanır 3.14*Log[9].

Retina , 38 37 31 bayt

Tamamen yeni yaklaşım, eskisi aşağıda.

M!`-
*\)`-¶-

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

Çevrimiçi deneyin!

açıklama

İlk olarak, şu işareti ele alıyoruz:

M!`-

-dizedeki tüm eşleşir ve bunları yeni satırlarla ayırarak döndürür

*\)`-¶-

(aşağıdaki boş satırla)
*\)bunun sonucunu belirtir ve önceki aşamalar yeni satır olmadan yazdırılmalı ve daha sonra dize öncekine geri döndürülmelidir (giriş dizgisi). Kalan kısım -, yeni satır ile ayrılan ikisini kaldırır .

Sonra ilk sayıyı unary'e çeviririz:

.* 
$*_

(ilk satırın sonunda bir boşluk var). _Bu durumda tek hanemiz olarak kullanırız , çünkü standart rakam 1ikinci sayıda bulunabilir ve bu daha sonra çakışacaktır.

Şimdi gerçek çarpmaya başlıyoruz:

_
$'$*_

Her biri _, onu takip eden her şeyin tekli temsili ile değiştirilir (hala _tek basamaklı olarak kullanılır ). Unary'e dönüştürme, rakam olmayan karakterleri yoksayar, bu ikinci sayının "ilk sayı" süreleri için aynı temsili olarak tekrarlanır. İkinci sayı dizgenin sonunda ondalık göstergede kalacaktır.

Sonunda, bir tek ile dizenin _içindeki sayıyı _döndürürüz, bu çarpmanın sonucu olacaktır.

Önceki cevap: (uyarı: çıktığında boş bir dize çıkarır 0)

Retina ,  45  42 41 bayt

Hadi oyun oynayalım! Göreceli sayıları, aritmetik işleci olmayan ve yalnızca doğal sayılar için sınırlı desteği olan bir dille çarpın ... Kulağa komik geliyor :)

O^`^|-
--

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

açıklama

İlk üç satır işareti ile ilgilidir:

O^`^|-

Bu , sıralı ifadeyle eşleşen tüm dizeleri sıralar Ove sonra tersine çevirir . Uygulamada bu, başlangıçtaki boş dize ile eşleşir ve ikinci sayıdan önce eksi işareti çıkar ve boş dizeyi eksi yerine yerleştirmelerini yeniden sıralar. Bundan sonra, hepsi dizenin başlangıcındadır ve bir çift sonraki iki satırla kolayca çıkarılabilir.^^|--

Ondan sonra sayıları tekli gösterime dönüştürmek için bir yerleşik kullanırız ve sonra gerçek çarpma gelir:

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

Herhangi birini eşleştiririz 1ve her birini 1sonraki boşluktan sonra ile değiştiririz . İlk sayının her basamağı, tam ikinci numara ile değiştirilirken, ikinci sayının her basamağı, boş dize ile değiştirilecektir.

Son kısım tekrar unary'den ondalık basamağa dönüştürmek için yerleşiktir.

Çevrimiçi deneyin!

Karalama , 1 bayt

Kullanım: Numaraları *işaretin her iki tarafına da yerleştirin.

Not: Scratch görsel bir dil olduğundan, @ mbomb007 beni çizik bayt sayımı için bir yöntem hakkında belirtene kadar ne kadar bayt tükettiğini bulamadım.

Brain-Flak , 56 bayt

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

Bu, yığın temiz olmadığından tam bir program olarak çalıştırılmalı ve girişler her iki yığındaki tek öğeler olmalıdır.

Çevrimiçi deneyin!

Açıklama: (x ve y girişlerini çağır)

Bölüm 1:

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

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

Bu noktada bir yığında [x, y], diğerinde [-x, -y] var.

Bölüm 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 bayt

ES6, daha genel bir *operatörden daha hızlı olan 32 bit tam sayılar için özel bir işleve sahiptir .

Math.imul

Bu arada, bu sadece bu kadar uzun

a=>b=>a*b

Brain-Flak , 56 54 52 bayt

Nitrodon tarafından yakalanan bir hata sayesinde 2 bayt kurtarıldı

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

Çevrimiçi deneyin!

Yığın temiz sürüm, 62 60 bayt

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

Çevrimiçi deneyin!

açıklama

Bu açıklama, söz konusu algoritmanın bir açıklamasıdır ve herhangi bir gerçek kodu dışarıda bırakır. Brain-Flak'ı yeterince okumayı bildiğinizi varsayar. Kod veya algoritmayı anlamak için yardıma ihtiyacınız olursa, yorum yazarsanız düzenlemekten veya cevap vermekten memnuniyet duyarım.

Bu biraz garip olanı ve sadece zor işe yarayan bazı garip matematik kullanıyor. Yaptığım ilk şey, O (n) adımlarında daima sonlanacak bir döngü oluşturmaktı . Bunu yapmanın normal yolu n ve -n'yi ters yığınlara koymak ve biri sıfıra gelinceye kadar her birini eklemektir, ancak bunu biraz garip bir şekilde yaptım. Benim yöntemimde girişin altına bir sayaç koydum ve her adımda sayacı artırıyorum, onu n'ye ekleyip n işaretini çeviriyorum .

Bir örnek üzerinden geçelim. Ki 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

Burada ispat etmeyeceğim ancak bu her zaman herhangi bir giriş için sonlandırılacak ve yaklaşık 2n adımda bunu yapacak . Aslında sonlanacak olan 2n halinde adımda , n pozitif ve 2-n-1 adım ise n negatiftir. Bunu burada test edebilirsiniz .

Şimdi , döngümüzde yaklaşık 2n adım var , n ile çarpacağız ? İşte biraz matematik sihri var. İşte yaptığımız şey: Bir akümülatör yaparız, işlemin her aşamasını akümülatöre ikinci girişi ( m ) ekleriz ve her ikisinin de işaretini çeviririz, daha sonra toplamı gerçekleşen tüm döngülere iteriz, işte bu ürün.

Neden böyle oluyor?

Öyleyse bir örnek üzerinde yürüyelim ve umarım netleşir. Bu örnekte çarpıyoruz 5 ile 3'ü , sadece önemli değerleri göstereceğim

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

Umarım mekanizma burada belirgindir. M katlarının mutlak değerlerinin sırasına göre adım atıyoruz . Daha sonra ihbar olduğunu edecektir 2n ^inci terim daima * n m hep öncesi ve dönem -m * n . Bu, döngülerimizin istediğimiz sonuçlarla mükemmel bir şekilde hizalanmasını sağlar. Biraz mutlu bir tesadüf;)

Dyalog APL , 1 bayt

× soldan bir numara alır, sağdan bir numara alır

×... hatta solda veya sağda veya her iki tarafta da birden çok numara

×/ listedeki tüm sayıları çarpar

×/¨ verilen bir listedeki çiftleri çarpar

×/∊ Bir dizideki tüm sayıları mulitpliize eder

Bu, tüm aritmetik fonksiyonlar, her büyüklük ve değer dizileri ve tüm veri tiplerinin sayıları için geçerlidir.

R, 3 bayt

'*'

Bu tam olarak iki argüman alan bir fonksiyondur. Olarak çalıştır '*'(a,b).

prodAynı şeyi yapan, ancak isteğe bağlı sayıda argüman alabilene de bakın .

ArnoldC, 152 bytes

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

Try it online!

Hexagony, 9 bytes

?{?/*!@'/

Try it online!

This is actually fairly straightforward. Here is the unfolded version:

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

The / just redirect the control flow to the second line to save bytes on the third. That reduces the code to this linear program:

?{?'*!@

This linear code on its own would actually be a valid solution if the input was limited to strictly positive numbers, but due to the possibility of non-positive results, this isn't guaranteed to terminate.

The program makes use of three memory edges in a Y-shape:

A   B
 \ /
  |
  C

The memory pointer starts on edge A pointing towards the centre.

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

I ran a brute force search for 7-byte solutions (i.e. those that fit into side-length 2), and if I didn't make a mistake (or there's a busy-beaver-y solution that takes a long time to complete, which I doubt) then a 7-byte solution doesn't exist. There might be an 8-byte solution (e.g. by reusing the ? or using only one redirection command instead of two /), but that's beyond what my brute force search can do, and I haven't found one by hand yet.

Piet, 16 bytes

5bpiaibpikibptai

Online interpreter available here.

Explanation

To run, paste the code above in the text box on the right side of the linked page. Below is a graphical representation of this code with codel size 31. The grid is for readability and may interfere with traditional Piet interpreters.
The code runs linearly from left to right, going along the top of the image until the first green block, where program flow moves to the middle row of codels. The white lone white codel is necessary for program flow. It could be replaced with a codel of any color other than green or dark blue, but I have chosen white for readability.

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]

If you think that text is not the best way to represent a Piet program or have an issue with the byte size of Piet programs in general, please let your opinion be known in the discussion on meta.

BitCycle -U, 68 bytes

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

Try it online!

Multiplying two numbers is not a trivial problem in BitCycle, especially when signs need to be handled! This is my second attempt; the first one (essentially same algorithm, different layout) was 81 bytes, so it's quite possible this one could be shortened too.

The program takes the two numbers as command-line arguments and outputs to stdout. The -U flag is to convert the decimal numbers to signed unary, since BitCycle knows only of 0's and 1's.

Explanation

This explanation assumes you understand the basics of BitCycle (see Esolangs or the GitHub readme). I'll base my explanation on this ungolfed version, seen here computing -2 times 3:

Overview

Signed unary numbers consist of the sign (0 for nonpositive, empty for positive) followed by the magnitude (a number of 1s equal to the number's absolute value). To multiply two of them, we need to XOR the signs (output a 0 if exactly one of them is 0, or nothing if both or neither are) and then multiply the magnitudes (and output that many 1s). We'll achieve the multiplication by repeated addition.

Sign bits

Starting from the two sources ?, we split off the signs from the magnitudes using +. 0s (sign bits) turn left and are directed along the top row, while 1s (magnitudes) turn right and end up in the two B collectors.

The section that handles the signs looks like this:

  v

  \  v
> \  /

! <

If both numbers are nonpositive, two 0 bits come in from the top v. The first one reflects off the top \, is sent southward, and reflects off the /. Meanwhile, the second bit passes through the deactivated top \ and reflects off the bottom \. The two bits pass each other, go straight through the now-deactivated splitters on the bottom row, and go off the playfield.

If only one of the numbers is nonpositive, one 0 comes in from the top. It bounces around all three splitters and ends up going northward again, until it hits the v and is once more sent south. This time, it passes through the deactivated splitters and reaches the <, which sends it into the sink !.

Loops to store the magnitudes

The magnitude of the first number goes into the B collector in this section:

B v
  \
  C v
^   <

0 A ^

Before the B collector opens, the A collector releases the single 0 that was placed in it, which then goes onto the end of the queue in B. We'll use it as a flag value to terminate the loop when all the 1 bits in B are gone.

Each time the B collectors open, the \ splitter peels off the first bit from the queue and sends it to the processing logic in the middle. The rest of the bits go into C, and when the C collectors open, they are sent back into B.

The magnitude of the second number goes into the B collector in this section:

v   ~
C B ~
    <

When the B collectors open, the bits go into the bottom dupneg ~. The original 1 bits turn right and are sent west into the processing logic in the middle. The negated copies (0s) turn left and immediately hit another dupneg. Here the 0s turn right and go off the playfield, while the (now doubly) negated 1s turn left and are sent into C. When C opens, they go back into B.

Repeated addition

The central processing logic is this part:

   v
   v


@  =  !

Bits from both loops (one from the western side, and everything from the eastern side) are sent south into the switch =. The timing has to be set up so that the bit from the western loop gets there first. If it is a 1, the switch changes to }, sending the following bits eastward into the sink ! to be output. Once all the 1s are gone, we get the 0, which changes the switch to {. This sends the following bits into the @, which terminates the program. In short, we output the (unary) magnitude of the second number as many times as there are 1s in the (unary) magnitude of the first number.

Python 3, 11 bytes

int.__mul__

Try it online!

Also works for integers under 2**32 in Python 2.

Java 8, 10 9 bytes

a->b->a*b

Try it here.

Java 7, 31 bytes

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

Try it here.

As full program (99 90 bytes):

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

Try it here.

Pyth, 2 bytes

*E

Try it here!

Pyth's automatic evaluation gets in the way here. To get around it, I'm using explicit evaluation for one of the arguments

TI-Basic, 2 bytes

Very straightforward.

prod(Ans

PHP, 21 bytes

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

takes input from command line arguments. Also works with floats.

Retina, 39 35 bytes

Thanks to Leo for letting me use an idea of his that ended up saving 4 bytes.

[^-]

*\)`--

.+
$*
\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.

MATLAB, 5 4 bytes

@dot

dot takes the dot product of two vectors of equal length. If we feed it with two scalars, it will simply multiply the two numbers.

prod takes the product of the values in all rows of each column of a matrix. If the matrix is one-dimensional (i.e. a vector), then it acts along the non-singleton dimension, taking the product of all elements in the vector.

dot is one byte shorter than prod which is one byte shorter than the even more obvious builtin times.

Call it as such:

@dot
ans(3,4)
ans = 
   12

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

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.

><>, 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 machine code, MITS Altair 8800, 28 bytes

This implements binary multiplication on the Intel 8080 CPU (c. 1974) which did not have multiplication or division instructions. Inputs are 8-bit values and the product is a 16-bit value returned in the BC register pair.

Here is the machine code along with step-by-step instructions to load the program into an Altair 8800 using the front panel switches.

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

Try it online!

If you've entered it all correctly, on the machine state drawer in the simulator your RAM contents will look like:

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

Input

Multiplier in C register, and multiplicand into D. The stock Altair has no STDIN so input is by front panel switches only.

Output

The result is displayed on the D7-D0 lights (top right row) in binary.

5 x 16 = 80 (0101 0000)

4 x 5 = 20 (0001 0100)

7 x 9 = 63 (0011 1111)

8 x -9 = -72 (1011 1000)

Compatibility note: this should also run on the IMSAI 8080, though currently untested.

C#, 10 bytes

a=>b=>a*b;

It's just a simply multiplication.

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)