一系列产品

39

您的任务很简单：给定两个整数a和b，输出∏[a,b]; 也就是介于a和之间的乘积b。您可能需要a和b任何合理的格式，不管是参数的函数，一个列表输入，标准输入，等等。您可以以任何合理的格式输出，例如返回值（用于函数）或STDOUT。a永远小于b。

请注意，结尾可能是的排他或包含b。我不挑剔 ^ _ ^

测试用例

[a,b) => result
[2,5) => 24
[5,10) => 15120
[-4,3) => 0
[0,3) => 0
[-4,0) => 24

[a,b] => result
[2,5] => 120
[5,10] => 151200
[-4,3] => 0
[0,3] => 0
[-4,-1] => 24

这是一个代码高尔夫球，因此以字节为单位的最短程序获胜。

排行榜

这篇文章底部的Stack Snippet会根据答案a）生成目录，a）作为每种语言最短解决方案的列表，b）作为整体排行榜。

为确保您的答案显示出来，请使用以下Markdown模板以标题开头。

## Language Name, N bytes

N您提交的文件大小在哪里。如果您提高了分数，则可以将旧分数保留在标题中，方法是将它们打掉。例如：

## Ruby, <s>104</s> <s>101</s> 96 bytes

如果要在标头中包含多个数字（例如，因为您的分数是两个文件的总和，或者您想单独列出解释器标志罚分），请确保实际分数是标头中的最后一个数字：

## Perl, 43 + 2 (-p flag) = 45 bytes

您还可以将语言名称设置为链接，然后该链接将显示在代码段中：

## [><>](http://esolangs.org/wiki/Fish), 121 bytes

显示代码段

code-golf  math 
— 科纳·奥布莱恩
source
1
我明天在TI-BASIC中回答这个问题。
— SuperJedi224
@ SuperJedi224祝你好运;）
— Conor O'Brien
输入可以当作b, a吗？
— FlipTack
@FlipTack是你可以
— 康纳尔奥布莱恩

Answers:

36

果冻，2个字节

rP

以两个数字作为命令行参数。在线尝试。

请注意，这是包含范围。对于一个字节（3个字节）的开销，我们可以使它排他：

’rP

在线尝试。请注意，必须b a按此版本的顺序指定参数。

说明

包括的

a rP b
  r   dyadic atom, creates inclusive range between a and b
   P  computes product of the list

独家

b ’rP a
  ’   decrement b (by default, monadic atoms in dyadic chains operate on the left argument)
   r  range
    P product
— 意大利面
source
10
我怀疑这是可以
— 击败的
14
@ kirbyfan64sos果冻吗？
— 亚伦
30

ArnoldC，522个 511字节

在codegolf上的第一篇文章！

我这样做很有趣。独家范围。

LISTEN TO ME VERY CAREFULLY f
I NEED YOUR CLOTHES YOUR BOOTS AND YOUR MOTORCYCLE a
I NEED YOUR CLOTHES YOUR BOOTS AND YOUR MOTORCYCLE b
GIVE THESE PEOPLE AIR
HEY CHRISTMAS TREE r
YOU SET US UP 1
HEY CHRISTMAS TREE l
YOU SET US UP 1
STICK AROUND l
GET TO THE CHOPPER r
HERE IS MY INVITATION r
YOU'RE FIRED a
ENOUGH TALK
GET TO THE CHOPPER a
HERE IS MY INVITATION a
GET UP 1
ENOUGH TALK
GET TO THE CHOPPER l
HERE IS MY INVITATION b
LET OFF SOME STEAM BENNET a
ENOUGH TALK
CHILL
I'LL BE BACK r
HASTA LA VISTA, BABY

说明（感谢Bijan）：

DeclareMethod f
        MethodArguments a
        MethodArguments b
        NonVoidMethod
        DeclareInt r
        SetInitialValue 1
        DeclareInt l
        SetInitialValue 1
        WHILE l
                AssignVariable r
                        SetValue r
                        MultiplicationOperator a
                EndAssignVariable
                AssignVariable a
                        SetValue a
                        + 1
                EndAssignVariable
                AssignVariable l
                        SetValue b
                        > a
                EndAssignVariable
        EndWhile
        Return r
EndMethodDeclaration
— 齐乔
source
哈哈哈......我笑还是老样子
— rpax
但有一个很好的解释
— rpax
这里它被转换和缩进使用此作为参考
— 赞
您正在使用哪个口译员？
— lirtosiast 2015年
官方一。您是正确的@NO PROBLEMO和1（不是0;）））
— Zycho
18

Python，30个字节

f=lambda a,b:a>b or a*f(a+1,b)

包含范围。重复乘以并递增左端点，直到它高于右端点为止，在这种情况下，它是1的空乘积（如True）。

— 异或
source
13

Minecraft 15w35a +，程序大小共456个（如下所示）

在此处输入图片说明

这计算PI [a,b)。输入是通过使用这两个命令给出：/scoreboard players set A A {num}和/scoreboard players set B A {num}。/scoreboard objectives add A dummy输入之前请记住使用。

得分使用：{program size} + ( 2 * {input command} ) + {scoreboard command} = 356 + ( 2 * 33 ) + 34 = 456。

此代码对应于以下伪代码：

R = 1
loop:
  R *= A
  A += 1
  if A == B:
    print R
    end program

在此处下载世界。

— GamrCorps
source
节目大小通过这种计分方法计算。
— GamrCorps，2015年
该死，你比我还早。：I
— Addison Crump 2015年
您需要指定快照版本，即15w46a或其他名称。
— 艾迪生·克伦普
我的世界：d大声笑，高尔夫在我的世界：d
— username.ak
12

TI-BASIC，9个字节

Input A
prod(randIntNoRep(A,Ans

Ans 从提示中获取一个号码，从提示中获取另一个号码。

也为9个字节，将输入作为来自的列表Ans：

prod(randIntNoRep(min(Ans),max(Ans
— 小鱼
source
1
我花了一些时间自己弄清楚，所以我要在这里发布：TI-BASIC中的每个函数都是一个字节。
— Nic Hartley 2015年
3
@QPaysTaxes很多，但不是全部。%是两个字节。
— mbomb007
12

Python 2，44 38字节

lambda l:reduce(int.__mul__,range(*l))

显而易见的匿名函数答案。

编辑：感谢xnor使用我不知道的某些功能保存6个字节。

— 昆托
source
1
您可以使用内置的int.__mul__代替lambda。这两个数字x,y也可以解压缩为*l。
— xnor
36
划掉44仍像44
— 一个spaghetto
10

Pyth，5个字节

*FrQE

Pyth没有产品，因此我们在范围内减少*。

使用独家范围。

— 小鱼
source
4
*FrFQ是等效的，但具有不同的输入，只是为了好玩:)
— FryAmTheEggman 2015年
8

Mathematica，15个字节

1##&@@Range@##&

仅适用于非负整数的较短解决方案：

#2!/(#-1)!&
— Alephalpha
source
3
对于非负整数甚至更短：#2!#/#!&
— Anders Kaseorg
8

JavaScript（ES6），34个字节

(a,b)=>eval("for(c=a;a<b;)c*=++a")

有时候，最简单的答案就是最好的答案！for里面只是一个循环eval。包含范围。

— 用户名
source
哇。这很让人佩服！
— Conor O'Brien 2015年
哎呀，我刚才想打高尔夫的时候就想到了这个确切的解决方案... +1
— ETHproductions 2015年
1
这个甚至更短，有25个字符： f=(a,b)=>a<b?a*f(a+1,b):1
— Matthias Burtscher
7

认真地，4个字节

,ixπ

,         Read list [a,b] from stdin
 i        Flatten it to a b
  x       Pop a,b, push range(a,b)
   π      Pop the list and push its product.

十六进制转储：

2c6978e3

在线尝试

— 昆托
source
7

Japt，7个字节

像这样的简单挑战总是很有趣。:)

UoV r*1

在线尝试！

说明

UoV r*1  // Implicit: U = first input, V = second input
UoV      // Generate range [U,V).
    r*1  // Reduce by multiplication, starting at 1.

哇，与到目前为止的其他答案相比，这似乎很可悲。我需要在Japt上做更多的工作...

— ETH生产
source
说明？：3
— Conor O'Brien
@CᴏɴᴏʀO'Bʀɪᴇɴ完成:)
— ETHproductions 2015年
2
哇，5K代表！：D
— ETHproductions 2015年
6

Haskell，19个 17字节

a#b=product[a..b]

用法示例：2#5-> 120。

— 妮米
source
您可以选择包含b。
— xnor
@xnor：烦恼，一定忽略了这一点。谢谢！
— nimi
我不确定，但是我认为PPCG允许以表达式形式给出答案。
— 自豪的haskeller 2015年
@proudhaskeller：默认值为允许完整的程序和功能。摘要，表达式等必须在任务描述中明确允许。
— nimi 2015年
5

Prolog，45个字节

码：

p(A,B,C):-A=B,C=A;D is A+1,p(D,B,E),C is A*E.

解释：

p(A,B,C):-A=B,      % A is unifiable with B
          C=A       % Unify C with A
          ;         % OR
          D is A+1, % D is the next number in the range
          p(D,B,E), % Recurse on the range after the first element
          C is A*E. % The result C is the product of the first element and the result 
                      of the recursion

例：

p(5,10,X).
X = 151200

p(-4,-1,X).
X = 24
— 艾米尼亚
source
5

八度，15字节

@(a,b)prod(a:b)

直截了当。使用包含范围。

— 小鱼
source
5

CJam，6 19 18 10字节

感谢Dennis和RetoKoradi在高尔夫方面的帮助！

q~1$-,f+:*

在线尝试

将输入作为a b。计算PI [a,b)。

注意：此程序长6个字节，并且仅当a和b为正数时才有效。

q~,>:*

在线尝试

将输入作为a b。计算PI [a,b)。

— GamrCorps
source
q~{_)_W$<}g;]:*保存三个字节。
— 丹尼斯
4
q~1$-,f+:*10个字节
— Reto Koradi
5

Bash + GNU实用程序，13

seq -s* $@|bc

假设当前目录中没有名称以开头的文件-s。开始和结束（包括结束）作为命令行参数传递。

这简单地产生了从开始到结束的序列，由分隔*，然后通过管道传输到以bc进行算术评估。

— 数字创伤
source
2
但是我从开始所有文件-s！：P
— Conor O'Brien 2015年
5

MATL（非竞争），4个字节

包含范围

2$:p

在线尝试！

说明

2$: % Implicitly grab two input arguments and create the array input1:input2
p   % Take the product of all array elements

感谢@Don Muesli帮助我掌握了整个MATL的知识。

— Suever
source
好答案！由于语言是挑战的发布日期，因此您可以发布答案，但也许您应该表明它不符合获奖资格
— Luis Mendo
是不是&:p一个字节的短？
— DJMcMayhem
@DrGreenEg​​gsandIronMan是的，所以我想它还是没有竞争，所以我可以缩短它，但是在我发布我的答案时，我们没有了&
— Suever
4

Ruby，22个字节

->i,n{(i..n).reduce:*}

取消高尔夫：

-> i,n {
  (i..n).reduce:* # Product of a range
}

用法：

->i,n{(i..n).reduce:*}[5,10]
=> 151200
— 瓦苏阿达里
source
1
昨晚我在考虑相同的解决方案，但没有时间编写它。
— 亚历克西斯·安德森
4

C，32个字节

对于[a,b)：

f(a,b){return a-b?a*f(a+1,b):1;}

对于[a,b]（根据Katenkyo的建议，再次为32个字节）：

f(a,b){return a<b?a*f(a+1,b):b;}
— 萨希尔·阿罗拉（Sahil Arora）
source
1
我在C中找到了另一个解决方案，如果您感兴趣的话，它也是32个字节f(a,b){return a<b?a*f(a+1,b):b;}。:)
— Katenkyo 2015年
-5字节在GCC与a=...代替return...
4

05AB1E，2个字节（非竞争）

码：

ŸP

说明：

Ÿ   # Inclusive range [input, ..., input]
 P  # Total product of the list
    # Implicit printing top of the stack
— 阿德南
source
4

J，8个字节

[:%/!@<:

用法

>> f =: [:%/!@<:
>> f 10 5
<< 15120

>>STDIN和<<STDOUT 在哪里。

说明

计算∏[a,b]为(b-1)!/(a-1)!。

minus_one =: <:
factorial =: !
of        =: @
monadic   =: [:
division  =: %/
f =: monadic division factorial of minus_one

以前的13字节版本

当我不知道什么时候写的J：p

*/(}.[:>:i.)/

用法：

   */(}.[:>:i.)/ 5 10
30240

说明：

*/            NB. multiply over
  (
   }.         NB. remove [the first x items] from
     [:>:     NB. increment all of
         i.   NB. the numbers from 0 to [y-1]
           )
            / NB. insert the above code into the following numbers

详细说明：

i.10 would produce 0 1 2 3 4 5 6 7 8 9

>:i.10 would make it 1 2 3 4 5 6 6 7 8 9 10

the [: is used to make the ">:" take only one argument (a monad)
because if it takes two arguments, it is a different function.
so [:>:i.10 becomes 1 2 3 4 5 6 7 8 9 10

}. means take away the first [x] items from the following list,
so 5}.1 2 3 4 5 6 7 8 9 10 becomes 6 7 8 9 10

the two slashes "/" in the code are actually the same
for example, */6 7 8 9 10 becomes 6*7*8*9*10
— 漏尼姑
source
1
很好的解释！
— wizzwizz4 2016年
2
您可以使用[:*/]+i.@-为10个字节，如果你把范围[a, b)为b ([:*/]+i.@-) a这样10 ([:*/]+i.@-) 5的输出15120。
— 英里
@miles当我根本不知道J时写了这个答案：p
— Leaky Nun
如果两个参数都不为正，则您的8字节解决方案将不起作用。
— 丹尼斯
4

JavaScript（ES6），22个字节

我不敢相信我们当中的JS高尔夫球手都没有想到使用递归...

a=>F=b=>a-b?b*F(b-1):a

使用例如分配给变量var q = a=>F=b=>a-b?b*F(b-1):a，然后调用like q(2)(5)。

— ETH生产
source
4

Brachylog，3个字节

⟦₃×

在线尝试！

输入以形式传递[A,B]。的范围内是唯一的B，但可以通过更换进行包容₃用₂。

— 不相关的字符串
source
3
欢迎来到PPCG！如今，何时制作语言都变得无关紧要，因此此答案极具竞争力。希望您过得愉快！
— 科纳·奥布莱恩
啊，很高兴知道！我想我一直在看太多过时的挑战，并按票数排序。
— 不相关的字符串
@UnrelatedString顺便说一句，如果您看到那些不竞争的消息，则将它们删除就可以了。
— 硕果累累
3

Python，52个字节

很简单的代码；有点太久了。

def p(a,b):
 t=1
 for i in range(a,b):t*=i
 return t
— 神探洛克9
source
3

JavaScript（ES6），45 41字节

@CᴏɴᴏʀO'Bʀɪᴇɴ节省了4个字节

(a,b)=>[...Array(b-a)].reduce(x=>x*a++,1)

似乎太长了...

(a,b)=>           // Define an anonymous function that takes parameters a and b, and returns:
[...Array(b-a)]   // An array of b-a items,
.reduce(          // Reduced by
x=>x*a++          //  multiplying each item with the previous,
,1)               //  starting at 1.
— ETH生产
source
这样可行？赞！我认为您不需要y在reduce映射中使用，因此请在x=>x*a++
— Conor O'Brien
@CᴏɴᴏʀO'Bʀɪᴇɴ谢谢，这个技巧非常有效！
— ETHproductions 2015年
2
您应该在末尾添加分号。得分。
— Seadrus
3

朱莉娅，16个字节

f(a,b)=prod(a:b)

注意：如果允许将范围对象a:b（实际上存储为起始值和终止值，并且内部包含“每步增加1”值）作为输入，则仅需要4个字节：prod。

— 格伦·奥
source
3

Perl 6、14个字节

{[*] $^a..$^b}

用法：

my &code = {[*] $^a..$^b}
say code |$_ for (2,5),(5,10),(-4,3),(0,3),(-4,-1);
# 120
# 151200
# 0
# 0
# 24

say chars code 1,10000;
# 35660

如果要排除最后一个元素，请使用..^代替..

— 布拉德·吉尔伯特b2gills
source
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.