将两个数字相乘

21

输入：两个十进制整数。这些可以在标准输入中作为程序或函数的参数或列表形式提供给代码。

输出：其乘积，以十进制整数表示。例如，输入5 16将导致输出80。

限制：请没有标准漏洞。这是代码高尔夫球，以最少的字节数获胜。

注意：布局因我先前的挑战而被盗，请加上两个数字。

测试用例： 

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

排行榜

显示代码段

code-golf  math  number 
— 德库德里阿夫采夫
source
4
@FlipTack假定加法和乘法在任何语言中都一样容易，我不知道它是否真的是真的。
— Fatalize
16
我认为允许“加两个数字”挑战但关闭这个挑战是不公平的。尽管在大多数编程语言中它是微不足道的，但这仍然是一个有效的挑战。如果范围太广，那么“加两个数字”的挑战也必须范围太广。
— Mego
32
如果每个人都不喜欢琐碎的挑战，他们可以自由地对其进行否决，但这是一个完全有效的话题挑战，而且距离“过于宽泛”还差得远（如果有的话，您可能会说琐碎的挑战太狭窄了）。我正在重新打开。就是说，如果有人觉得琐碎的挑战侮辱了他们的智慧，我鼓励他们寻找使任务变得不那么琐碎的语言。
— Martin Ender
16
接下来：减去两个数字！
— steenbergh
7
@wat不遗余力，是吗？
— Gareth

Answers:

39

Brachylog V1、05AB1E，J，K，欠载，MATL，Forth，PigeonScript，堆叠式，隐式，Jolf，Clojure，Braingolf，第8个，Common Lisp，Julia，Pyt，Appleseed，Stax，Reality，dc 1字节

*

您可以编辑此答案以添加其他*有效的语言。

— 致命
source
Polygot，05AB1E和其他5种语言。
— 魔术章鱼缸
13
我在其中编辑了Underload。这是可能的，这些最有趣的，因为欠它不具备做减法，除法，或添加1个字节的方法。
— 巴音牛
这在Pyth中无效。Pyth不接受像这样的隐式输入。
— isaacg
添加了朱莉娅，例如*(5,16)
— gggg
32

C（GCC），13个字节

并非适用于所有实现，但可以。

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

在TIO上尝试！

— 贝特塞格
source
6
等等，这应该以某种方式返回a吗？我不明白……
— Outgolfer的Erik
2
对此进行解释将很有帮助。（a是f()-为何返回其值的本地堆栈变量？）。+1，顺便说一句-非常聪明地滥用了ABI。
— Digital Trauma'1
6
@EriktheOutgolfer return关键字只是将其参数的redult放在EAX寄存器中。在这种情况下，生成的可执行文件将对a*b在该寄存器，因此return不执行任何操作。
— 丹尼斯，
7
嘿，那是我的把戏！codegolf.stackexchange.com/a/106067/18535 :-)
— GB
12
很高兴一次看到C排名第一！实际上，您可以通过仅用替换f(a,b){a*=b;}部分1##&然后将语言更改为Mathematica 来节省大约9个字节。
— 艾伯特·伦肖
21

Beatnik，888位元组

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

在线尝试！

我使用的是C解释器，因为如果不满足向后跳转的条件，那么TIO上的Python解释器会烦人地执行该地址。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

输入应为两个整数，中间用一个空格隔开，且不尾随换行符。

如果每个单元格都可以存储任意大的值（不限于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）。

但是要计算所有三个值是很棘手的。为此，它首先计算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.
— 吉米23013
source
哇。只是...哇 我已经放置赏金，您将在7天内得到赏金。
— NieDzejkob
19

Mathematica，4个字节

1##&

用法示例：1##&[7,9]返回63。确实，同一函数将任意数量的任何类型的参数组合在一起。

正如Mathematica的代码爱好者所知，之所以起作用，##是因为它引用了函数的整个参数序列，并且Mathematica中的级联（通常）表示乘法；因此1##指的是函数所有参数的乘积（1倍）。这&只是Function定义纯（未命名）函数的命令的缩写。

在其他代码中，公共符号*确实充当乘法。空格7 9也是如此，因此可以解释为7*9（实际上，Mathematica的当前REPL版本实际上将这些空格显示为乘法符号！）。更妙的是，不过，如果数学能告诉其中一个令牌的开始和结束的另一个，则没有字节都需要一个乘法运算符：5y自动解释为5*y，和3.14Log[9]作为3.14*Log[9]。

— 格雷格·马丁
source
是什么使##&无效？
— 林恩
##&返回其参数列表作为“序列”对象-适用于插入带有多个参数的其他函数。在这种情况下，##&对其参数列表不做任何事情；我们希望将该列表相乘。
— 格雷格·马丁
19

视网膜，38 37 31字节

全新的方法，下面是旧方法。

M!`-
*\)`-¶-

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

在线尝试！

说明

首先，我们处理标志：

M!`-

匹配-字符串中的所有字符并返回它们，并用换行符分隔

*\)`-¶-

（带有空行）
*\)意味着打印此阶段和前一阶段的结果时应不带换行符，然后将字符串还原为之前的字符串（输入字符串）。其余部分删除两个-由换行符分隔的。

然后，我们将第一个数字转换为一元：

.* 
$*_

（第一行末尾有一个空格）。_在这种情况下，我们将其用作一进制数字，因为标准数字1可以出现在第二个数字中，以后会发生冲突。

现在我们来看看实际的乘法：

_
$'$*_

每个_变量都由其后所有内容的一元表示形式代替（仍然_用作一进制数字）。由于转换为一进制会忽略非数字字符，因此这会将第二个数字的一​​进制表示重复“第一个数字”次数。第二个数字将保留在字符串末尾的十进制表示形式中。

最后，使用单_数返回_字符串中的数字，这将是乘法的结果。

上一个答案：（警告：应该输出时输出一个空字符串0）

视网膜， 45  42 41字节

来玩个游戏！将相对数与没有算术运算符且仅对自然数的有限支持的语言相乘...听起来很有趣:)

O^`^|-
--

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

说明

前三行处理该符号：

O^`^|-

这将排序O，然后反转^所有与regex匹配的字符串^|-。实际上，这与开头的空字符串匹配，并与第二个数字之前的最终减号匹配，并对它们进行重新排序，将空字符串放在减号的位置。此后，所有操作-都在字符串的开头，并且可以在接下来的两行中轻松删除它们中的一对。

之后，我们使用内置函数将数字转换为一元表示形式，然后进行实际的乘法运算：

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

我们匹配任何一个1，并1在随后的空格之后用所有以下所有字符替换它们。第一个数字的每个数字将被完整的第二个数字替换，而第二个数字的每个数字将被空字符串替换。

最后一部分还是内置的，可以从一元转换回十进制。

在线尝试！

— 狮子座
source
2
我希望我每次打高尔夫球都能投票赞成，做得好！
— Kritixi Lithos
哇，这种新方法太神奇了。我想你赢了。：）（它甚至说服了我，默认字符$*应该是_。）
— Martin Ender
顺便说一句，这里是在相同的字节数的ASCII唯一的解决方案的情况下，你更喜欢：tio.run/nexus/retina#U9VwT/...
— 马丁安德
1
有趣的事实：很明显，我自己发现在某个时候混合使用一元和十进制运算符的技巧。
— Martin Ender
1
我尝试将其更新为Retina 1.0，由于有了新的限制和新的重复运算符，它现在只需要23个字节：tio.run / ## K0otycxLNPyvpxqj4Z7wX8vOR9dQxyBBl0tPW4dLiyueS0UdSP7 / ... ...您甚至可以在单个正数上进行乘法现在（.+,(.+)到$.($1**），但实际上这里有更多字节。
— Martin Ender
15

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
— 赖利
source
1
哇！绝对是迄今为止最令人印象深刻的答案
— DJMcMayhem
@DJMcMayhem并且（稍作修改）它比Wiki上的字节数高18个字节
— Riley
您是否拥有对Flask Wiki的写权限？我想上传一个简短的版本。
— DJMcMayhem
@DJMcMayhem我没有访问权限。如果您想看一看，我在Brain-Flak聊天室中张贴了较短的一个，然后上传。
— 莱利
我知道已经有一段时间了，但是您有一些竞争 ;）
— 小麦巫师
11

JavaScript（ES6），9个字节

ES6具有专用于32位整数的功能，比更通用的*运算符要快。

Math.imul

顺便说一句，这只要：

a=>b=>a*b
— Arnauld
source
太棒了，现在我知道Math.imul，谢谢！
— chau giang
9

Brain Flaak，56 54 52字节

由于Nitrodon发现错误，节省了2个字节

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

在线尝试！

堆栈干净版本，62 60字节

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

在线尝试！

说明

该说明更多地是对所涉及算法的说明，并省略了任何实际代码。它假定您知道如何熟练地阅读Brain-Flak。如果您需要帮助来理解代码或算法，如果您发表评论，我很乐意编辑或回复。

这有点奇怪，并且使用了一些几乎无法解决的怪异数学。我做的第一件事是制作一个总是以O（n）步骤终止的循环。这样做的通常方法是将n和-n放在相反的堆栈上，并在每个堆栈上加一个，直到一个达到零为止，但是我这样做的方式有些奇怪。在我的方法，我把一个计数器的输入下面的每一步我增加计数器将它添加到ñ和翻转的符号ñ。

让我们来看一个例子。说n = 7

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

我不会在这里证明这一点，但这将始终终止于任何输入，并且将在大约2n步内完成。事实上，它会终止2n个步骤，如果ñ是正和2N-1 ，如果步骤ñ为负。您可以在这里进行测试。

现在我们的循环中大约有2n步，如何乘以n？好吧，这里有一些数学魔术。我们要做的是：创建一个累加器，在过程的每一步中，将第二个输入（m）添加到累加器，并翻转两个符号的正负号，然后将总数推入所有发生的循环，这就是产品。

到底为什么呢？

好吧，让我们看一个例子，希望它会变得清楚。在这个例子中，我们乘以5的3，我将只显示重要的价值观

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

希望该机制在这里显而易见。我们按照m的绝对值顺序遍历所有m的倍数。然后，您会注意到第2n 个项始终为m * n，而始终为-m * n之前的项。这样一来，我们的循环就可以完美地与所需结果保持一致。有点巧合；）

— 小麦巫师
source
8

R，3个字节

'*'

这个函数需要两个参数。运行为'*'(a,b)。

另请参阅prod哪个功能相同，但可以接受任意数量的参数。

— 土拨鼠
source
这本身就是有效的表达方式吗？如果不是，则需要以提交'*'。
@ ais523嗯，是的，它本身不是有效的表达式。我已编辑帖子以澄清。谢谢！
— rturnbull
4
致下降投票者：已修复。
— Rɪᴋᴇʀ
8

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

在线尝试！

— 汤姆291
source
1
+1充分交谈（换行符）用手交谈
— MilkyWay90
8

六边形，9字节

?{?/*!@'/

在线尝试！

这实际上非常简单。这是展开的版本：

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

的/只是重定向控制流至所述第二线，以节省第三字节。这就减少了该线性程序的代码：

?{?'*!@

如果将输入限制为严格的正数，则单独使用此线性代码实际上将是有效的解决方案，但是由于可能会出现非正数结果，因此不能保证将其终止。

该程序使用Y形的三个内存边缘：

A   B
 \ /
  |
  C

内存指针从A指向中心的边开始。

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

我用蛮力搜索了7字节的解决方案（即适合侧面长度2的解决方案），如果我没有记错的话（或者有一个忙碌的海狸式解决方案需要很长时间才能完成，我对此表示怀疑），那么7字节的解决方案就不存在了。可能有一个8字节的解决方案（例如，通过重用the ?或仅使用一个重定向命令而不是两个/），但这超出了我的蛮力搜索所能做的，而且我还没有亲手找到一个。

— 马丁·恩德
source
7

Piet，16字节

5bpiaibpikibptai

可在此处在线翻译。

说明

要运行，请将上面的代码粘贴到链接页面右侧的文本框中。下图是该代码的代码大小为31的图形表示。该网格用于提高可读性，并且可能会干扰传统的Piet解释器。
代码从左到右线性运行，沿着图像的顶部一直到第一个绿色块，程序流移至中间的代码行。程序流程需要白色孤独的白色编码。可以用除绿色或深蓝色以外的任何颜色的代码代替它，但是出于可读性考虑，我选择了白色。

Code Visualization

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程序的字节大小有问题，请在元数据的讨论中表达您的意见。

— 迈克·布法尔迪奇
source
7

位周期 -U，68个字节

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

在线尝试！

在BitCycle中，将两个数字相乘不是小问题，尤其是在需要处理符号的情况下！这是我的第二次尝试；第一个（本质上是相同的算法，不同的布局）为81个字节，因此很有可能也可以将其缩短。

该程序将两个数字作为命令行参数，并输出到stdout。由于BitCycle仅知道0和1，因此该-U标志是将十进制数转换为带符号的一元。

说明

该说明假定您了解BitCycle的基础知识（请参阅 Esolangs或GitHub自述文件）。我将基于此版本的解释，这里是计算-2时间3：

Signed multiplication in BitCycle

总览

带符号的一元数字由符号（0对于非正数，为空，对于正数）后跟幅度（1s的个数等于数字的绝对值）组成。要将它们中的两个相乘，我们需要对符号进行异或运算（0如果它们中的一个正好是0，则输出a ，如果两个或都不是则不输出），然后将幅度相乘（并输出那么多1s）。我们将通过重复加法来实现乘法。

符号位

从这两个来源开始?，我们使用+。0s（符号位）向左转并沿顶部行定向，而1s（量级）向右转并结束于两个B收集器中。

处理标志的部分如下所示：

  v

  \  v
> \  /

! <

如果两个数字均为非正数0，则从顶部开始输入两位v。第一个从顶部反射\，向南发送，并从顶部反射/。同时，第二个位穿过停用的顶部\并从底部反射\。两位彼此通过，直接穿过底部行中现已停用的拆分器，然后离开运动场。

如果只有一个数字为非正数0，则从顶部开始输入一个。它在所有三个分离器周围反弹，最终再次向北移动，直到撞到v并再次向南发送。这次，它通过停用的分离器并到达<，将其发送到接收器。!。

循环存储幅度

第一个数字的大小B在本节中进入收集器：

B v
  \
  C v
^   <

0 A ^

在B收集器打开之前，收集A器释放0放置在其中的单个文件，然后将其放入队列中的末尾B。当所有1位都在其中时，我们将其用作标记值来终止循环B都消失。

每次B收集器打开时，\分配器都会从队列中剥离掉第一位，并将其发送到中间的处理逻辑。其余的位进入C，当C收集器打开时，它们被送回B。

第二个数字的大小进入B本节的收集器中：

v   ~
C B ~
    <

当B收集器打开时，钻头进入底部杜邦~。原始1位右转并向西发送到中间的处理逻辑中。否定的副本0向左转，立即撞到另一个dupneg。在这里，0s向右转并离开运动场，而（现在是双重的）否定的1s向左转并发送到C。当C打开后，他们重新回到B。

重复添加

中央处理逻辑是这一部分：

   v
   v


@  =  !

来自两个回路的位（一个来自西侧，所有东西都来自东侧）被发送到交换机南部=。必须设置时间，以使来自西部环路的钻头首先到达那里。如果是1，则开关将变为}，将以下位向东发送到接收器!以进行输出。一旦所有1s都消失了，我们得到0，将切换为{。这会将以下位发送到中@，从而终止程序。简而言之，我们输出的第二个数字的（一元）大小等于1第一个数字的（一元）大小中的s 倍。

— DLosc
source
5

PHP，21字节

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

从命令行参数获取输入。也可用于浮点数。

— 提图斯
source
5

视网膜，39 35字节

感谢Leo让我使用他的想法，最终节省了4个字节。

[^-]

*\)`--

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

输入以换行分隔。

在线尝试！（为方便起见，以空格分隔的测试套件。）

说明

如果两个输入之一恰好为负，则前两个阶段将打印一个负号。他们无需实际更改输入即可执行此操作。这是通过在第二阶段)将它们分组并将变成空运行来完成的*。\第二阶段的选项可防止打印尾随换行符。

[^-]

首先，我们删除除减号外的所有内容。

*\)`--

然后，如果还有两个负号，则我们将其取消。

.+
$*

现在，我们将每一行转换为其绝对值的一元表示形式。这将消除负号，因为$*它只查找比赛中的第一个非负数（即，它不知道负号而忽略它们）。

\G1
_

只要_匹配各个1s，只要它们与上一个匹配项相邻，第一行就会转换为，（因此，我们无法匹配1第二行上的s，因为换行会破坏此链）。

_|1+
$'

这执行实际的乘法。我们将每一行_（第一行）以及整个第二行替换为该匹配项之后的所有内容。_因此，匹配项将包括整个第二行（将其乘以0第一行中的s 的数目），并且将删除第二行，因为该匹配项之后没有任何内容。当然，结果还将包括_s和换行符形式的一些垃圾，但这无关紧要。

1

我们只需简单地计算1结果中的s 数即可。

— 马丁·恩德
source
5

MATLAB，5 4字节

@dot

dot取两个等长向量的点积。如果我们给它添加两个标量，它将简单地将两个数字相乘。

prod取矩阵每一列所有行中值的乘积。如果矩阵是一维的（即向量），则它沿非单维起作用，取向量中所有元素的乘积。

dot比prod内置的短字节短一个字节times。

这样称呼它：

@dot
ans(3,4)
ans = 
   12
— 斯蒂夫·格里芬
source
4

Perl 6、4个字节

&[*]

这只是普通的infix乘法运算符*，表示为普通的函数。作为奖励，如果给定一个数字，则返回该数字；如果不给定数字，则返回1乘性标识。

— 肖恩
source
备用4 UTF-8字节解决方案：*×*
— nwellnhof，
4

> <>，​​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;

但是我觉得我的解决方案比较酷。

另一种可能性是删除分号，这将导致指针从镜像反射回来，击中打印命令，并且由于堆栈为空而引发错误。

— Bolce Bussiere
source
4

英特尔8080机器代码，MITS Altair 8800, 28 bytes

这将在没有乘法或除法指令的Intel 8080 CPU（1974年）上实现二进制乘法。输入是8位值，乘积是在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)

enter image description here

4 x 5 = 20 (0001 0100)

enter image description here

7 x 9 = 63 (0011 1111)

enter image description here

8 x -9 = -72 (1011 1000)

enter image description here

兼容性说明：尽管目前尚未测试，它也应在IMSAI 8080上运行。

— 640KB
source
3

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)))
— 尼古妮
source
3

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)
— Conor O'Brien
source
Does this not work? Please explain the doe vote.
— Conor O'Brien
I wasn't the downvoter, but I think I can guess what happened: this is a very trivial question (and thus very heavily downvoted, but with many upvotes cancelling that out), and likely to attract people who downvote trivial questions. This answer's also fairly trivial, and it's likely that some of the people who downvote trivial questions also like to downvote trivial answers. (Personally, I prefer to leave trivial answers at 0, so I'm not voting either way on this one.)
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.