入力： 2つの10進整数。これらは、標準入力のコードに、プログラムまたは関数の引数として、またはリストとして与えることができます。

出力： 10進整数としての積。たとえば、入力5 16は出力につながります80。

制限：標準的な抜け穴はありません。これはcode-golfであり、最小バイト数で答えが勝ちます。

注：以前の課題である2つの数字を追加して盗まれたレイアウト。

テストケース：

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

*

この回答を編集して*、有効な回答である他の言語を追加できます。

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

オンラインでお試しください！

TIOのPythonインタープリターは、逆方向ジャンプの条件が満たされない場合、迷惑なことにアドレスを実行するため、Cインタープリターを使用しています。Pythonインタープリターの簡単な回避策は、いくつかのnopをパディングしてアドレスnopにすることです。私はどちらも正しくないと信じています：

                                   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

入力は、スペースで区切られた2つの整数である必要があります。末尾に改行はありません。

この答えは、各セルが0〜255に制限されない任意の大きな値を格納できる場合、すべての整数に対して理論的に機能します。ただし、| A | + | B | > 22.そして| A | + | B | > 6.したがって、実際にテストできるケースは多くなく、それらのケースのif-elseソリューションはさらに短くなる可能性があります。

アイデアは、値を0にデクリメントしてすべての中間値を合計することにより、三角数T（N）= N（N + 1）/ 2を計算することです。その後、A * B = T（A + B）-T（A）-T（B）という答えを得ることができます。

しかし、3つの値すべてを計算するのは難しいです。これを行うには、まずT（A + B）-Aを計算し、スタックにAのコピーを残して後で追加し、入力Bを使い果たします。次に、それよりも小さい最大の三角形の数T（ A + B-1）特別な場合を除きます。B = T（A + B）-A-T（A + B-1）を取得し、そこからT（B）を計算できます。

数値Nは、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。実際、この同じ関数は、任意の型の任意の数の引数をまとめて乗算します。

Mathematicaコードゴルファーが知っているように、これ##は機能する引数のシーケンス全体を指し、Mathematicaの連結（多くの場合）が乗算を表すために機能します。そのため1##、関数のすべての引数の積を（1回）参照します。これ&はFunction、純粋な（名前のない）関数を定義するコマンドの略です。

他のコード内では、共通シンボル*は乗算として機能します。スペースも同様に7 9解釈されます7*9（実際、現在のMathematicaのREPLバージョンでは、そのようなスペースは乗算記号として表示されます！）。さらに良いことに、Mathematicaが1つのトークンの開始点と別のトークンの終了点を判断できる場合、乗算演算子にバイトはまったく必要ありません：5yは5*y、および3.14Log[9]として自動的に解釈され3.14*Log[9]ます。

網膜、38 37 31バイト

完全に新しいアプローチ、古いアプローチは以下にあります。

M!`-
*\)`-¶-

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

オンラインでお試しください！

説明

まず、記号を扱います：

M!`-

-文字列内のすべてに一致し、改行で区切って返します

*\)`-¶-

（次の空行がある）
*\)は、この結果と前のステージを改行なしで印刷し、文字列を前の状態（入力文字列）に戻すことを意味します。残りの部分は-、改行で区切られた2つを削除します。

次に、最初の数値を単項に変換します。

.* 
$*_

（最初の行の最後にスペースがあります）。_この場合、標準の数字1が2番目の数字に存在する可能性があり、これは後で競合するため、単項数字として使用します。

次に、実際の乗算に進みます。

_
$'$*_

それぞれ_は、それに続くすべての単項表現に置き換えられます（_単項数字として使用）。単項への変換では数字以外の文字が無視されるため、これは2番目の数値の単項表現を「最初の数値」回繰り返します。2番目の数値は、文字列の末尾に10進数表現のままになります。

最後に、シングルで、文字列内の_数を返し_ます。これは、乗算の結果です。

前の答え：（警告：出力すべきときに空の文字列を出力します0）

網膜、 45  42 41バイト

ゲームをしましょう！算術演算子を持たず、自然数のみの限定的なサポートを備えた言語で相対数を掛けます...

O^`^|-
--

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

説明

最初の3行は記号を扱います：

O^`^|-

これにより、正規表現に一致Oする^すべての文字列がソートされ、逆になります^|-。実際には、これは最初の空の文字列と、2番目の数字の前の最終的なマイナス記号と一致し、マイナスの場所に空の文字列を配置してそれらを並べ替えます。この後、すべて-が文字列の先頭にあり、それらのペアは次の2行で簡単に削除できます。

その後、組み込み関数を使用して数値を単項表現に変換し、実際の乗算を行います。

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

any 1に一致し、それらのそれぞれを1後続のスペースの後のすべてで置き換えます。最初の数字の各桁は完全な2番目の数字に置き換えられ、2番目の数字の各数字は空の文字列に置き換えられます。

最後の部分は、再び単項から10進数に変換する組み込み関数です。

オンラインでお試しください！

スクラッチ、1バイト

使用法：*記号の両側に数字を配置します

注：Scratchは視覚言語であるため、@ mbomb007がスクラッチバイトをカウントする方法について通知するまで、Scratchが消費するバイト数を把握できませんでした

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バイト

Nitrodonがキャッチしたミスにより2バイト節約

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

オンラインでお試しください！

スタッククリーンバージョン、62 60バイト

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

オンラインでお試しください！

説明

この説明は、関連するアルゴリズムの説明であり、実際のコードは省略しています。Brain-Flakを熟読する方法を知っていることを前提としています。コードまたはアルゴリズムのいずれかを理解するのに助けが必要な場合は、コメントを残して編集または対応させていただきます。

これは少し奇妙なもので、ほとんどうまくいかない奇妙な数学を使用しています。私が最初にしたことは、常にO（n）ステップで終了するループを作成することでした。これを行う通常の方法は、nと-nを反対側のスタックに配置し、ゼロに達するまでそれぞれに1つずつ追加することですが、少し奇妙な方法でそれを行いました。私の方法では、私は入力の下にカウンターを置き、それぞれのステップは、私はカウンターがに追加インクリメント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ステップで終了します。実際、nが正の場合は2nステップで終了し、nが負の場合は2n-1ステップで終了します。ここでテストできます。

ループ内に約2nステップあり、どのようにnを乗算しますか？数学の魔法があります。ここでは、アキュムレータを作成します。プロセスの各ステップでは、2番目の入力（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 ^番目の用語は常にm * nであり、前の用語は常に-m * nであることに気付くでしょう。これにより、ループが目的の結果と完全に一致するようになります。少し幸せな偶然;）

Dyalog APL、1バイト

× 左側に1つ、右側に1つ

×...または左または右または両側の複数の数字

×/ リスト内のすべての数値を乗算します

×/¨ 指定されたリストのペアを乗算します

×/∊ 配列内のすべての数値を多重化します

これは、すべての算術関数、すべてのサイズとランクの配列、およびすべてのデータ型の数に適用されます。

R、3バイト

'*'

これは、正確に2つの引数を取る関数です。として実行'*'(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

オンラインでお試しください！

六角形、9バイト

?{?/*!@'/

オンラインでお試しください！

これは実際にはかなり簡単です。展開されたバージョンは次のとおりです。

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

/ちょうど第三にバイトを保存するために、第2のラインに制御フローをリダイレクトします。これにより、この線形プログラムのコードが削減されます。

?{?'*!@

入力が厳密に正の数に制限されている場合、この線形コード自体は実際には有効なソリューションになりますが、非正の結果が生じる可能性があるため、これが終了することは保証されません。

プログラムは、Y字型の3つのメモリエッジを使用します。

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バイトのソリューションがあるかもしれません（たとえば?、2つではなく1つのリダイレクトコマンドを再利用するか、使用することで/）

Piet、16バイト

5bpiaibpikibptai

オンライン通訳はこちらから入手できます。

説明

実行するには、リンクされたページの右側のテキストボックスに上記のコードを貼り付けます。以下は、コードサイズ31のこのコードのグラフィカルな表現です。グリッドは読みやすくするためのもので、従来のPietインタープリターに干渉する場合があります。
コードは左から右に直線的に実行され、画像の上部を最初の緑のブロックまで進み、そこでプログラムフローはコーデルの中央の行に移動します。ホワイトローンホワイトコーデルは、プログラムフローに必要です。緑または濃い青以外の色のコーデルで置き換えることもできますが、読みやすいように白を選択しました。

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プログラムのバイトサイズに問題がある場合は、metaに関する議論で意見を述べてください。

BitCycle -U、68バイト

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

オンラインでお試しください！

2つの数値を乗算することは、特に記号を処理する必要がある場合、BitCycleでは些細な問題ではありません！これは私の2回目の試みです。最初のアルゴリズム（基本的に同じアルゴリズム、異なるレイアウト）は81バイトであったため、このアルゴリズムも短縮できる可能性があります。

プログラムは、コマンドライン引数として2つの数値を取り、stdoutに出力します。-Uフラグは、10進数に変換することで署名単項 BitCycleのみ0と1人の知っているので、。

説明

この説明は、BitCycleの基本を理解していることを前提としています（ EsolangsまたはGitHubのreadmeを）。私は、このungolfedバージョン、ここで見計算上の私の説明ベースます-2回3：

概要

符号付き単項数は、記号（0非正の場合は空、正の場合は空）とそれに続く大きさ（1数の絶対値に等しいsの数）で構成されます。それらの2つを乗算するには、符号をXORし（0それらの正確に1つがである場合はaを出力し、0両方またはどちらでもない場合は何も出力しない）、大きさを乗算します（そしてその数を出力します1）。繰り返し加算することで乗算を実現します。

符号ビット

2つのソースから開始して?、次のように大きさからサインを分離します。+。0s（符号ビット）は左に曲がり、上の行に沿って向けられますが、1s（大きさ）は右に曲がって2つのBコレクターに入ります。

標識を処理するセクションは次のようになります。

  v

  \  v
> \  /

! <

両方の数値が正でない場合0、上部から2 ビットが入りvます。最初のものは上から反射し、\南向きに送信され、/。一方、2番目のビットは非アクティブ化されたtop \を通過し、bottomで反射し\ます。2つのビットは互いに通過し、最下行の非アクティブ化されたスプリッターを直進し、プレイフィールドを離れます。

数字の1つだけが正ではない場合、1つ0が上から入ります。3つすべてのスプリッターで跳ね返り、再び北向きになって、v南に送られます。今回は、非アクティブ化されたスプリッターを通過してに到達<し、シンクに送信され!ます。

大きさを保存するループ

最初の数値の大きさは、Bこのセクションのコレクターに送られます。

B v
  \
  C v
^   <

0 A ^

Bコレクターが開く前に、コレクターはその中に置かれAたシングル0をリリースし、その後、のキューの終わりに移動しますB。フラグ値として使用して、すべての1ビットがBがなくなった。

Bコレクターが開くたびに、\スプリッターはキューから最初のビットを剥ぎ取り、中央の処理ロジックに送信します。残りのビットはに入りC、Cコレクターが開くとに戻されBます。

2番目の数値の大きさは、Bこのセクションのコレクターに入ります。

v   ~
C B ~
    <

ときにBコレクターが開いて、ビットは、下dupnegに入ります~。元の1ビットは右に曲がり、中央の処理ロジックに西向きに送信されます。無効化されたコピー（0s）は左に曲がり、すぐに別のデュプネグに当たります。ここで0sは右に曲がってプレイフィールドを離れ、（現在は二重になっている）否定された1sは左に曲がってに送られCます。ときにC開き、彼らが戻って入りますB。

繰り返し追加

中央処理ロジックはこの部分です：

   v
   v


@  =  !

両方のループからのビット（西側からのビット、および東側からのすべて）は、スイッチに南へ送信され=ます。タイミングは、ウエスタンループからのビットが最初に到達するように設定する必要があります。aの場合1、スイッチはに変わり}、次のビットを!出力するシンクに東向きに送信します。すべての1sがなくなったら、を取得し0、スイッチをに変更し{ます。これにより、次のビットがに送信され@、プログラムが終了します。つまり、1最初の数の（単項）の大きさにs があるのと同じ回数、2番目の数の（単項）の大きさを出力します。

Python 3、11バイト

int.__mul__

オンラインでお試しください！

2**32Python 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の自動評価が邪魔になります。それを回避するために、引数の1つに対して明示的な評価を使用しています

TI-Basic、2バイト

とても簡単です。

prod(Ans

PHP、21バイト

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

コマンドライン引数から入力を受け取ります。フロートでも動作します。

網膜、39 35バイト

4バイトを節約することになった彼のアイデアを教えてくれたLeoに感謝します。

[^-]

*\)`--

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

入力は改行で区切られます。

オンラインでお試しください！（便宜上、スペースで区切られたテストスイート。）

説明

最初の2つのステージは、2つの入力のうち1つが負の場合にマイナス記号を出力します。実際に入力を変更せずにこれを行います。これは、を2番目のステージでグループ化し、)でドライランに変換することで行われます*。\2番目のステージのオプションは、後続の改行を印刷しません。

[^-]

まず、マイナス記号を除くすべてを削除します。

*\)`--

次に、マイナス記号が2つ残っている場合は、マイナス記号をキャンセルします。

.+
$*

次に、各行をその絶対値の単項表現に変換します。これは$*、一致する最初の非負数のみを検索するため、マイナス記号を取り除きます（つまり、マイナス記号を認識せず、それらを無視します）。

\G1
_

最初の行は、前の一致に隣接する限り_個々1のsに一致することにより、に変換されます（したがって、1改行がこのチェーンを中断するため、2行目のsに一致することはできません）。

_|1+
$'

これにより、実際の乗算が実行されます。それぞれ_（最初の行）と2番目の行全体を、その一致の後にすべて置き換えます。_マッチは、したがって、（数を乗算全体セカンドライン含まれる0最初の行における複数）を、その一致した後は何も存在しないので、2行目は削除されます。もちろん、結果には_sと改行の形のジャンクも含まれますが、それは問題ではありません。

1

1結果のs の数を単純に数えることで終了します。

MATLAB、 5 4バイト

@dot

dot長さが等しい2つのベクトルの内積を取ります。2つのスカラーを入力すると、2つの数値が単純に乗算されます。

prod行列の各列のすべての行の値の積を取ります。行列が1次元（つまりベクトル）の場合、それは非1次元に沿って機能し、ベクトル内のすべての要素の積を取ります。

dot より1バイト短い prod明らかなビルトインよりさらに1バイト短い1バイトtimesです。

次のように呼び出します：

@dot
ans(3,4)
ans = 
   12

PigeonScript、1バイト

*

説明：
*スタックを調べて、何かあるかどうかを確認します。そうでない場合は、入力を要求し、入力を乗算します

Perl 6、4バイト

&[*]

これは*、通常の関数として表される、通常の中置乗算演算子です。ボーナスとして、1つの数値を指定するとその数値が返され1、数値を指定しないと乗算のID が返されます。

> <>、5バイト

i|;n*

ASCII文字として入力を受け取り、数値を出力します。

説明：

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

あなたもできる

ii*n;

しかし、私は私の解決策は素晴らしいと感じていますクーラー。

もう1つの可能性は、セミコロンをドロップすることです。これにより、ポインターがミラーから跳ね返り、印刷コマンドにヒットし、スタックが空なのでエラーがスローされます。

Intel 8080マシンコード、MITS Altair 8800バイト

これにより、乗算または除算命令を持たないIntel 8080 CPU（c。1974）でバイナリ乗算が実装されます。入力は8ビット値で、積は16ビット値で返されますBCレジスタペアでです。

フロントパネルスイッチを使用してプログラムを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レジスタの乗数、およびの被乗数D。ストックAltairにはない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;

単なる乗算です。

ゼリー、1バイト

×

オンラインでお試しください！

必須のゼリー提出。

Clojure、1バイト

*

：Pボーナスとして、これは任意の数の引数で機能します。

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

興味深いことに、そのソースコードを簡単に取得できます。

(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バイト

λx.λy.x*y

これは、次のような機能に割り当てることができます。

multiply:λx.λy.x*y

このように呼び出されます：

result<multiply(a,b)