Đầu vào: Hai số nguyên thập phân. Chúng có thể được cung cấp cho mã trong đầu vào tiêu chuẩn, làm đối số cho chương trình hoặc chức năng hoặc dưới dạng danh sách.

Đầu ra: Sản phẩm của họ, dưới dạng số nguyên thập phân. Ví dụ, đầu vào 5 16sẽ dẫn đến đầu ra 80.

Hạn chế: Không có sơ hở tiêu chuẩn xin vui lòng. Đây là môn đánh gôn , trả lời với số lượng byte thắng thấp nhất.

Ghi chú: Bố cục bị đánh cắp từ thử thách trước đó của tôi, Thêm hai số .

Các trường hợp thử nghiệm:

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

Hoặc dưới dạng 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

Bảng xếp hạng

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, Stacked, Implicit, Jolf, Clojure, Braingolf, 8th, Common Lisp, Julia, Pyt, Appleseed, Stax, Reality, dc 1 byte

*

Bạn có thể chỉnh sửa câu trả lời này để thêm các ngôn ngữ khác *là câu trả lời hợp lệ.

C (GCC), 13 byte

Không hoạt động trên tất cả các triển khai, nhưng không sao.

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

Hãy thử nó trên TIO!

Beatnik , 888 byte

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

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

Tôi đang sử dụng trình thông dịch C vì trình thông dịch Python trên TIO khó chịu thực thi địa chỉ nếu điều kiện để nhảy lùi không được đáp ứng. Một cách giải quyết dễ dàng cho trình thông dịch Python là đệm một số bước để tạo địa chỉ. Tôi tin là không đúng:

                                   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

Đầu vào phải là hai số nguyên cách nhau bởi một khoảng trắng, không có dòng mới.

Câu trả lời này hoạt động trên lý thuyết cho tất cả các số nguyên, nếu mỗi ô có thể lưu trữ một giá trị lớn tùy ý, không giới hạn ở 0 - 255. Nhưng nó sẽ tràn ra nếu | A | + | B | > 22. Và nó chạy rất chậm nếu | A | + | B | > 6. Vì vậy, không có nhiều trường hợp bạn thực sự có thể kiểm tra và một giải pháp if-other cho những trường hợp đó có thể còn ngắn hơn.

Ý tưởng là tính các số tam giác T (N) = N (N + 1) / 2 bằng cách giảm giá trị về 0 và tổng hợp tất cả các giá trị trung gian. Khi đó ta có thể nhận được câu trả lời A * B = T (A + B) - T (A) - T (B).

Nhưng thật khó để tính cả 3 giá trị. Nó thực hiện điều này bằng cách tính toán trước tiên T (A + B) - A, để lại một bản sao của A trong ngăn xếp để thêm lại sau đó và sử dụng hết đầu vào B. Sau đó, đệ quy tìm số tam giác lớn nhất nhỏ hơn số đó là T ( A + B-1) trừ các trường hợp đặc biệt bằng không. Chúng ta có thể lấy lại B = T (A + B) - A - T (A + B-1) và tính T (B) từ đó.

Số N là số tam giác iff bằng với số tam giác lớn nhất nhỏ hơn N, cộng với số lượng tam giác không âm nhỏ hơn N. Điều này chạy trong O (2 ^ (T (A + B) -A)) và là phần chậm nhất trong chương trình.

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.

Toán học, 4 byte

1##&

Ví dụ sử dụng: 1##&[7,9]trả về 63. Thật vậy, cùng chức năng này đa dạng bất kỳ số lượng đối số của bất kỳ loại nào với nhau.

Như các nhà lập trình toán học Mathicala biết, điều này hoạt động vì ##đề cập đến toàn bộ chuỗi các đối số cho một hàm và phép nối trong Mathicala (thường) đại diện cho phép nhân; vì vậy 1##đề cập đến (1 lần) sản phẩm của tất cả các đối số của hàm. Đây &chỉ là viết tắt của Functionlệnh xác định hàm thuần (không tên).

Bên trong mã khác, ký hiệu chung *không đóng vai trò là phép nhân. Không gian cũng vậy, do đó 7 9được hiểu là 7*9(thực sự, phiên bản REPL hiện tại của Mathicala thực sự hiển thị các không gian như dấu hiệu nhân!). Thậm chí tốt hơn, tuy nhiên, nếu Mathematica có thể nói một trong những nơi bắt đầu và kết thúc thẻ khác, sau đó không có byte ở tất cả là cần thiết cho một nhà điều hành nhân: 5yđược tự động hiểu là 5*y, và 3.14Log[9]như 3.14*Log[9].

Võng mạc , 38 37 31 byte

Cách tiếp cận hoàn toàn mới, cái cũ là dưới đây.

M!`-
*\)`-¶-

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

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

Giải trình

Đầu tiên, chúng tôi xử lý các dấu hiệu:

M!`-

khớp tất cả -trong chuỗi và trả về chúng cách nhau bởi dòng mới

*\)`-¶-

(với một dòng trống sau)
*\)có nghĩa là kết quả của điều này và các giai đoạn trước sẽ được in mà không có dòng mới, và sau đó chuỗi trở lại như trước đó (chuỗi đầu vào). Phần còn lại loại bỏ hai -ngăn cách bởi một dòng mới.

Sau đó, chúng tôi chuyển đổi số đầu tiên thành unary:

.* 
$*_

(có một khoảng trống ở cuối dòng đầu tiên). Chúng tôi sử dụng _như là chữ số đơn của chúng tôi trong trường hợp này, bởi vì chữ số tiêu chuẩn 1có thể có mặt trong số thứ hai, và điều này sẽ xung đột sau đó.

Bây giờ chúng ta có được phép nhân thực tế:

_
$'$*_

Mỗi cái _được thay thế bằng đại diện đơn nhất của mọi thứ theo sau nó (vẫn sử dụng _làm chữ số đơn). Vì chuyển đổi sang unary bỏ qua các ký tự không có chữ số, điều này sẽ lặp lại biểu diễn đơn của số thứ hai cho lần "số thứ nhất". Số thứ hai sẽ vẫn ở dạng đại diện thập phân ở cuối chuỗi.

Cuối cùng, với một lần duy nhất, _chúng ta trả về số lượng _trong chuỗi, đó sẽ là kết quả của phép nhân.

Câu trả lời trước: (cảnh báo: xuất ra một chuỗi trống khi cần xuất 0)

Võng mạc ,  45  42 41 byte

Hãy chơi một trò chơi! Nhân số tương đối với một ngôn ngữ không có toán tử số học và chỉ hỗ trợ giới hạn cho số tự nhiên ... Nghe có vẻ buồn cười :)

O^`^|-
--

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

Giải trình

Ba dòng đầu tiên xử lý các dấu hiệu:

O^`^|-

Điều này sắp xếp Ovà sau đó đảo ngược ^tất cả các chuỗi phù hợp với regex ^|-. Trong thực tế, điều này khớp với chuỗi trống khi bắt đầu và dấu trừ cuối cùng trước số thứ hai và sắp xếp lại chúng đặt chuỗi trống vào vị trí của dấu trừ. Sau này, tất cả -nằm ở đầu chuỗi và một cặp trong số chúng có thể được gỡ bỏ dễ dàng bằng hai dòng tiếp theo.

Sau đó, chúng tôi sử dụng một nội trang để chuyển đổi số thành biểu diễn đơn nhất và sau đó đến phép nhân thực tế:

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

Chúng tôi phù hợp với bất kỳ 1, và thay thế từng người trong số họ bằng tất cả 1sau một không gian sau. Mỗi chữ số của số thứ nhất sẽ được thay thế bằng số thứ hai đầy đủ, trong khi mỗi chữ số của số thứ hai sẽ được thay thế bằng chuỗi trống.

Phần cuối cùng lại là phần dựng sẵn để chuyển đổi từ unary sang thập phân.

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

Cào , 1 byte

Cách sử dụng: Đặt số ở cả hai phía của *dấu hiệu

Lưu ý: Vì Scratch là ngôn ngữ trực quan nên tôi không thể biết được nó tiêu thụ bao nhiêu byte cho đến khi @ mbomb007 lưu ý tôi về một phương pháp để đếm byte đầu

Brain-Flak , 56 byte

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

Điều này phải được chạy như một chương trình đầy đủ vì nó không phải là ngăn xếp sạch và các đầu vào phải là thành phần duy nhất trong một trong hai ngăn xếp.

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

Giải thích: (gọi đầu vào x và y)

Phần 1:

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

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

Tại thời điểm này, chúng ta có [x, y] trên một ngăn xếp và [-x, -y] trên ngăn xếp khác.

Phần 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 byte

ES6 có chức năng dành riêng cho số nguyên 32 bit, nhanh hơn *toán tử chung hơn .

Math.imul

Ngẫu nhiên, điều này chỉ miễn là:

a=>b=>a*b

Brain-Flak , 56 54 52 byte

2 byte được lưu nhờ một lỗi bắt gặp bởi Nitrodon

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

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

Ngăn xếp phiên bản sạch, 62 60 byte

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

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

Giải trình

Giải thích này là một lời giải thích về thuật toán liên quan và bỏ qua bất kỳ mã thực tế nào. Nó giả định rằng bạn biết cách đọc thành thạo Brain-Flak. Nếu bạn cần trợ giúp để hiểu mã hoặc thuật toán, tôi sẽ vui lòng chỉnh sửa hoặc trả lời nếu bạn để lại nhận xét.

Đây là một chút của một kỳ lạ và sử dụng một số toán học kỳ lạ mà hầu như không hoạt động. Điều đầu tiên tôi làm là tạo một vòng lặp luôn kết thúc trong các bước O (n) . Cách thông thường để làm điều này là đặt n và -n vào các ngăn đối diện và thêm từng cái cho đến khi một số không, tuy nhiên tôi đã làm theo cách hơi lạ. Trong phương pháp của tôi, tôi đặt một bộ đếm bên dưới đầu vào và mỗi bước tôi tăng bộ đếm thêm nó vào n và lật dấu của n .

Hãy đi qua một ví dụ. Nói 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

Tôi sẽ không chứng minh điều đó ở đây nhưng điều này sẽ luôn chấm dứt cho bất kỳ đầu vào nào và sẽ thực hiện trong khoảng 2n bước. Trong thực tế, nó sẽ chấm dứt trong 2n bước nếu n dương và 2n-1 bước nếu n âm. Bạn có thể kiểm tra điều đó ở đây .

Bây giờ chúng ta có khoảng 2n bước trong vòng lặp, làm thế nào để chúng ta nhân với n ? Vâng ở đây có một số phép thuật toán học. Đây là những gì chúng tôi làm: Chúng tôi tạo một bộ tích lũy, mỗi bước của quy trình chúng tôi thêm đầu vào thứ hai ( m ) vào bộ tích lũy và lật dấu của cả hai, sau đó chúng tôi đẩy tổng số trên tất cả các vòng lặp xảy ra, đây là sản phẩm.

Tại sao trên trái đất là trường hợp đó?

Vâng, hãy đi qua một ví dụ và hy vọng nó sẽ trở nên rõ ràng. Trong ví dụ này, chúng tôi đang nhân 5 với 3 , tôi sẽ chỉ hiển thị các giá trị quan trọng

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

Hy vọng cơ chế là rõ ràng ở đây. Chúng tôi đang bước qua tất cả các bội số của m theo thứ tự các giá trị tuyệt đối của chúng. Sau đó, bạn sẽ nhận thấy rằng thuật ngữ ^thứ 2n luôn là m * n và thuật ngữ trước luôn luôn là -m * n . Điều này làm cho nó để vòng lặp của chúng tôi hoàn toàn phù hợp với kết quả mà chúng tôi muốn. Một chút trùng hợp hạnh phúc;)

APL Dyalog , 1 byte

× lấy một số ở bên trái và một số ở bên phải

×... hoặc thậm chí nhiều số ở bên trái hoặc bên phải hoặc cả hai bên

×/ nhân tất cả các số trong một danh sách

×/¨ nhân các cặp trong một danh sách nhất định

×/∊ mulitplies tất cả các số trong một mảng

Điều này áp dụng cho tất cả các hàm số học, mảng của tất cả các kích cỡ và cấp bậc và số của tất cả các kiểu dữ liệu.

R, 3 byte

'*'

Đây là một hàm có chính xác hai đối số. Chạy như '*'(a,b).

Cũng xem prodcái nào làm điều tương tự nhưng có thể lấy một số lượng đối số tùy ý.

ArnoldC , 152 byte

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

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

Lục giác , 9 byte

?{?/*!@'/

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

Điều này thực sự khá đơn giản. Đây là phiên bản mở ra:

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

Chỉ /cần chuyển hướng luồng điều khiển đến dòng thứ hai để lưu byte trên dòng thứ ba. Điều đó làm giảm mã cho chương trình tuyến tính này:

?{?'*!@

Bản thân mã tuyến tính này thực sự sẽ là một giải pháp hợp lệ nếu đầu vào bị giới hạn ở các số dương hoàn toàn, nhưng do khả năng kết quả không tích cực, điều này không được đảm bảo chấm dứt.

Chương trình sử dụng ba cạnh bộ nhớ theo hình chữ Y:

A   B
 \ /
  |
  C

Con trỏ bộ nhớ bắt đầu trên cạnh Achỉ về phía trung tâm.

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

Tôi đã thực hiện một tìm kiếm mạnh mẽ cho các giải pháp 7 byte (tức là những giải pháp phù hợp với độ dài 2 bên) và nếu tôi không mắc lỗi (hoặc có một giải pháp bận rộn cần nhiều thời gian để hoàn thành, mà tôi nghi ngờ) thì một giải pháp 7 byte không tồn tại. Có thể có một giải pháp 8 byte (ví dụ: bằng cách sử dụng lại ?hoặc chỉ sử dụng một lệnh chuyển hướng thay vì hai /), nhưng điều đó vượt quá những gì mà việc tìm kiếm vũ lực của tôi có thể làm được và tôi chưa tìm thấy bằng tay.

Piet , 16 byte

5bpiaibpikibptai

Thông dịch viên trực tuyến có sẵn ở đây.

Giải trình

Để chạy, dán mã ở trên vào hộp văn bản ở bên phải của trang được liên kết. Dưới đây là một biểu diễn đồ họa của mã này với kích thước codel 31. Lưới là để dễ đọc và có thể can thiệp vào các trình thông dịch truyền thống của Piet.
Mã chạy tuyến tính từ trái sang phải, đi dọc theo đỉnh của hình ảnh cho đến khối màu xanh lá cây đầu tiên, nơi dòng chương trình di chuyển đến hàng giữa của các codel. Codel trắng đơn độc là cần thiết cho dòng chương trình. Nó có thể được thay thế bằng một codel của bất kỳ màu nào khác ngoài màu xanh lá cây hoặc xanh đậm, nhưng tôi đã chọn màu trắng để dễ đọc.

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]

Nếu bạn nghĩ rằng văn bản không phải là cách tốt nhất để thể hiện chương trình Piet hoặc có vấn đề với kích thước byte của các chương trình Piet nói chung, vui lòng cho biết ý kiến ​​của bạn trong cuộc thảo luận về meta .

BitCycle -U , 68 byte

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

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

Nhân hai số không phải là một vấn đề nhỏ trong BitCycle, đặc biệt là khi cần xử lý các dấu hiệu! Đây là nỗ lực thứ hai của tôi; cái đầu tiên (về cơ bản là cùng một thuật toán, bố cục khác nhau) là 81 byte, do đó, rất có thể cái này cũng có thể được rút ngắn.

Chương trình lấy hai số làm đối số dòng lệnh và đầu ra thành thiết bị xuất chuẩn. Các -Ulá cờ là để chuyển đổi các số thập phân để unary ký , vì BitCycle biết duy nhất của 0 và 1.

Giải trình

Giải thích này giả định rằng bạn hiểu những điều cơ bản của BitCycle (xem Esolang hoặc GitHub readme). Tôi sẽ căn cứ vào lời giải thích của tôi về phiên bản không có căn cứ này, được thấy ở đây -2thời gian tính toán 3:

Tổng quan

Các số đơn nguyên đã ký bao gồm ký hiệu ( 0đối với số không cố định, trống cho số dương) theo sau là độ lớn (một số 1s bằng giá trị tuyệt đối của số). Để nhân hai trong số chúng, chúng ta cần XOR các dấu hiệu (đầu ra a 0nếu chính xác một trong số chúng là 0, hoặc không có gì nếu cả hai hoặc không) và sau đó nhân độ lớn (và đầu ra nhiều 1s). Chúng ta sẽ đạt được phép nhân bằng phép cộng lặp lại.

Ký bit

Bắt đầu từ hai nguồn ?, chúng tôi tách ra các dấu hiệu từ cường độ sử dụng +. 0s (bit dấu) rẽ trái và được dẫn dọc theo hàng trên cùng, trong khi 1s (cường độ) rẽ phải và kết thúc ở hai Bbộ sưu tập.

Phần xử lý các dấu hiệu trông như thế này:

  v

  \  v
> \  /

! <

Nếu cả hai số là không có chủ đích, hai 0bit đến từ đầu v. Cái đầu tiên phản ánh từ trên xuống \, được gửi về phía nam, và phản ánh ra /. Trong khi đó, bit thứ hai đi qua đỉnh bị vô hiệu hóa \và phản xạ ra khỏi đáy \. Hai bit truyền cho nhau, đi thẳng qua các bộ chia đã ngừng hoạt động ở hàng dưới cùng và đi ra khỏi sân chơi.

Nếu chỉ một trong các số là không có chủ đích, một số 0đến từ đầu. Nó nảy xung quanh cả ba bộ chia và cuối cùng lại đi về phía bắc, cho đến khi nó chạm vào vvà một lần nữa được gửi về phía nam. Lần này, nó đi qua các bộ tách bị vô hiệu hóa và đến được <, nó sẽ gửi nó vào bồn rửa! .

Vòng lặp để lưu trữ cường độ

Độ lớn của số đầu tiên đi vào Bbộ sưu tập trong phần này:

B v
  \
  C v
^   <

0 A ^

Trước khi trình Bthu thập mở ra, trình Athu thập sẽ phát hành đĩa đơn 0được đặt trong đó, sau đó đi đến cuối hàng đợi B. Chúng ta sẽ sử dụng nó làm giá trị cờ để chấm dứt vòng lặp khi tất cả các 1bit trongB đó không còn nữa.

Mỗi khi Bbộ sưu tập mở, \bộ chia tách ra bit đầu tiên từ hàng đợi và gửi nó đến logic xử lý ở giữa. Phần còn lại của các bit đi vào Cvà khi các Cbộ thu mở ra, chúng được gửi trở lại B.

Độ lớn của số thứ hai đi vào Bbộ sưu tập trong phần này:

v   ~
C B ~
    <

Khi các Bbộ sưu tập mở, các bit đi vào bản sao dưới cùng ~. Các 1bit gốc rẽ phải và được gửi về phía tây vào logic xử lý ở giữa. (Các) bản sao phủ định 0rẽ trái và ngay lập tức đánh một bản sao khác. Ở đây 0, rẽ phải và đi ra khỏi sân chơi, trong khi 1s bị phủ nhận (bây giờ nghi ngờ) rẽ trái và được gửi vào C. Khi Cmở ra, họ quay trở lại B.

Bổ sung lặp đi lặp lại

Logic xử lý trung tâm là phần này:

   v
   v


@  =  !

Các bit từ cả hai vòng (một từ phía tây và mọi thứ từ phía đông) được gửi về phía nam vào công tắc =. Thời gian phải được thiết lập sao cho bit từ vòng lặp phía tây đến đó trước. Nếu là a 1, công tắc sẽ chuyển sang }, gửi các bit sau về phía đông vào bồn !để được xuất. Khi tất cả các 1s đã biến mất, chúng tôi nhận được 0, thay đổi công tắc thành {. Điều này sẽ gửi các bit sau vào @, kết thúc chương trình. Nói tóm lại, chúng ta xuất độ lớn (đơn nguyên) của số thứ hai nhiều lần bằng số 1s trong số (đơn vị) của số thứ nhất.

Python 3 , 11 byte

int.__mul__

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

Cũng hoạt động cho các số nguyên dưới 2**32trong Python 2.

Java 8, 10 9 byte

a->b->a*b

Hãy thử nó ở đây.

Java 7, 31 byte

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

Hãy thử nó ở đây.

Là chương trình đầy đủ ( 99 90 byte) :

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

Hãy thử nó ở đây.

Bình thường, 2 byte

*E

Hãy thử nó ở đây!

Đánh giá tự động của Pyth được theo cách ở đây. Để giải quyết vấn đề này, tôi đang sử dụng đánh giá rõ ràng cho một trong các đối số

TI-Basic, 2 byte

Rất đơn giản.

prod(Ans

PHP, 21 byte

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

lấy đầu vào từ các đối số dòng lệnh. Cũng hoạt động với phao.

Võng mạc , 39 35 byte

Cảm ơn Leo đã cho tôi sử dụng một ý tưởng của anh ấy mà cuối cùng đã tiết kiệm được 4 byte.

[^-]

*\)`--

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

Đầu vào được phân tách theo dòng.

Hãy thử trực tuyến! (Bộ kiểm tra phân tách không gian để thuận tiện.)

Giải trình

Hai giai đoạn đầu in một dấu trừ nếu chính xác một trong hai đầu vào là âm. Họ làm điều này mà không thực sự thay đổi đầu vào. Điều này được thực hiện bằng cách nhóm chúng trong giai đoạn thứ hai với )và biến chúng thành một hoạt động khô với *. Các \tùy chọn trên ngăn chặn giai đoạn thứ hai in một linefeed trailing.

[^-]

Đầu tiên, chúng tôi loại bỏ tất cả mọi thứ trừ các dấu trừ.

*\)`--

Sau đó, chúng tôi hủy các dấu trừ nếu có hai trong số chúng còn lại.

.+
$*

Bây giờ chúng tôi chuyển đổi từng dòng thành đại diện đơn nhất của giá trị tuyệt đối của nó. Điều này sẽ thoát khỏi dấu trừ vì $*chỉ tìm số không âm đầu tiên trong trận đấu (tức là nó không biết về dấu trừ và bỏ qua chúng).

\G1
_

Dòng đầu tiên được chuyển đổi thành _, bằng cách khớp các 1s riêng lẻ miễn là chúng liền kề với trận đấu trước đó (do đó, chúng tôi không thể khớp với 1s trên dòng thứ hai, vì nguồn cấp dòng phá vỡ chuỗi này).

_|1+
$'

Điều này thực hiện phép nhân thực tế. Chúng tôi thay thế từng _(trên dòng đầu tiên) cũng như toàn bộ dòng thứ hai mọi thứ sau trận đấu đó. Các _vì thế trận đấu sẽ bao gồm toàn bộ dòng thứ hai (nhân nó bằng các số 0s trong dòng đầu tiên), và dòng thứ hai sẽ được gỡ bỏ vì không có gì sau trận đấu đó là. Tất nhiên, kết quả cũng sẽ bao gồm một số rác ở dạng _s và đường truyền, nhưng điều đó không thành vấn đề.

1

Chúng tôi kết thúc bằng cách đơn giản là đếm số 1s trong kết quả.

MATLAB, 5 4 byte

@dot

dotlấy tích của hai vectơ có độ dài bằng nhau. Nếu chúng ta nuôi nó bằng hai vô hướng, nó sẽ đơn giản nhân hai số.

prodlấy sản phẩm của các giá trị trong tất cả các hàng của mỗi cột của ma trận. Nếu ma trận là một chiều (tức là một vectơ), thì nó hoạt động dọc theo chiều không đơn, lấy sản phẩm của tất cả các phần tử trong vectơ.

dotngắn hơn một byte so với prodmột byte ngắn hơn so với nội dung rõ ràng hơn times.

Gọi nó như vậy:

@dot
ans(3,4)
ans = 
   12

PigeonScript , 1 byte

*

Giải thích:
*nhìn vào ngăn xếp để xem có gì ở đó không. Nếu không, nó sẽ nhắc đầu vào và nhân các đầu vào với nhau

Perl 6 , 4 byte

&[*]

Đây chỉ là toán tử nhân thông thường *, được biểu diễn như một hàm thông thường. Như một phần thưởng, nếu được cho một số, nó sẽ trả về số đó và nếu không có số nào thì nó sẽ trả về 1số nhân.

> <>, 5 byte

i|;n*

Lấy đầu vào là một ký tự ascii, xuất ra một số.

Giải trình:

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

Bạn cũng có thể làm

ii*n;

Nhưng tôi cảm thấy giải pháp của tôi là waaay mát.

Một khả năng khác là bỏ dấu chấm phẩy, điều này sẽ dẫn đến việc con trỏ bật ra khỏi gương, nhấn lệnh in và ném lỗi vì ngăn xếp trống.

Mã máy Intel 8080 , MITS Altair 8800 , 28 byte

Điều này thực hiện phép nhân nhị phân trên CPU Intel 8080 (khoảng năm 1974) không có hướng dẫn nhân hoặc chia. Đầu vào là các giá trị 8 bit và sản phẩm là giá trị 16 bit được trả về trong BCcặp thanh ghi.

Dưới đây là mã máy cùng với hướng dẫn từng bước để tải chương trình vào Altair 8800 bằng cách sử dụng các công tắc bảng mặt trước.

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

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

Nếu bạn đã nhập chính xác, trên ngăn kéo trạng thái máy trong trình giả lập, nội dung RAM của bạn sẽ như sau:

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

Đầu vào

Số nhân trong Cđăng ký, và nhân vào D. Các cổ phiếu Altair không có STDINđầu vào chỉ bằng các công tắc bảng mặt trước.

Đầu ra

Kết quả được hiển thị trên D7- D0đèn (hàng trên cùng bên phải) ở dạng nhị phân.

5 x 16 = 80 (0101 0000)

4 x 5 = 20 (0001 0100)

7 x 9 = 63 (0011 1111)

8 x -9 = -72 (1011 1000)

Lưu ý tương thích: điều này cũng sẽ chạy trên IMSAI 8080 , mặc dù hiện chưa được kiểm tra.

C #, 10 byte

a=>b=>a*b;

Nó chỉ là một phép nhân đơn giản.

Thạch , 1 byte

×

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

Bắt buộc nộp Jelly.

Clojure, 1 byte

*

: P Là một phần thưởng, điều này hoạt động trên bất kỳ số lượng đối số:

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

Điều thú vị là bạn có thể dễ dàng lấy mã nguồn của nó:

(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 byte

λx.λy.x*y

Điều này có thể được gán cho một chức năng như thế này:

multiply:λx.λy.x*y

và được gọi như thế này:

result<multiply(a,b)