^{最初是乘法数字根}

挑战

^{^{基本上按照标题说}}

方法

通过我们的一种标准输入法，给定正整数 1 <= N <= 100000000，将每个数字相乘，而忽略零。

例如：拿一个数字，说361218402：

3* 6=18
18* 1=18
18* 2=36
36* 1=36
36* 8=288
288* 4=1152
1152* 1 ^{（忽略零或将它们变成1）} =1152
1152* 2=2304

的输出361218402是2304

测试用例

1 => 1
其他数字> 0 =>本身
10 => 1
20 => 2
100 => 1
999 => 729
21333 => 54
17801 => 56
4969279 => 244944
100000000 => 1

不允许使用标准漏洞，这是代码高尔夫球，因此最短的字节数为准！

恭喜乔·金（Jo King）以70字节的健壮答案得到了赏金！

— 芬达
source

5

我宁可称这种非零数字产品。“ root”表示减少到个位数，在此并不总是如此。

— 暴民埃里克（Erik the Outgolfer）'18年

1

我们可以将输入作为字符串吗？或（按一下）数字数组？

— 粗野的

@EriktheOutgolfer是的，但是，如果重复此过程足够多的时间，它的确会总是显示一位数字。

— DJMcMayhem

您可以输入带引号的输入，但是，如果您要输入数字，则不能输入预先

— 准备好的

7

如果我们必须支持最多100000000000我建议测试用例99999999999 => 31381059609，因为它不适合默认的32位整数。最好将最大输出降低到32位最大值（2147483647）。

— 凯文·克鲁伊森

3

Pyt，3 个字节

ąžΠ

说明：

ą       Convert input to array of digits (implicit input as stack is empty)
 ž      Remove all zeroes from the array
  Π     Get the product of the elements of the array

在线尝试！

— mudkip201
source

感到惊讶的是，这种相对较新的高尔夫语言是唯一能够以3个字节解决这一挑战的语言！

— ETHproductions

我也为此感到惊讶！

— mudkip201

初次接受时我没有看到您的答案，但这是最短的答案！

— FantaC

11

Haskell，27个字节

foldr((*).max 1.read.pure)1

在线尝试！

与UniHaskell和`-XUnicodeSyntax`

import UniHaskell

f ∷ String → Int
f = product ∘ map (max 1 ∘ read ∘ pure)

说明

我将从最初拥有的内容开始：

product.map(max 1.read.pure)

这是一个无点表达式，其计算结果是以字符串（或字符列表）s（"301"）作为参数的函数。它映射max 1.read.pure到s上，本质上是将每个字符i注入到列表中（使其成为字符串）（["3", "0", "1"]），然后读取它，然后对字符串求值（[3, 0, 1]），最后取i和1中的较大者（[3, 1, 1]）。然后，它取product所得的整数列表（3）。

然后，我用以下方法打了一下高尔夫球：

foldr((*).max 1.read.pure)1

之所以有效，product是因为它等效于foldr (*) 1。我没有映射和折叠，而是通过折叠将两者结合起来(*).max 1.read.pure，将每个非零数字乘以累加器。

— 全人类
source

9

Python 2，34个字节

f=lambda n:n<1or(n%10or 1)*f(n/10)

在线尝试！

— 丹尼斯
source

7

果冻，4字节

Do1P

在线尝试！或查看测试套件

怎么运行的

Do1P - Main link. Argument: n (integer)  e.g. 1230456
D    - Digits                                 [1, 2, 3, 0, 4, 5, 6]
 o1  - Replace 0 with 1                       [1, 2, 3, 1, 4, 5, 6]
   P - Product                                720

— 开斋节
source

@tfbninja调用每个输入的主链接

— caird coinheringaahing

6

R，40个字节

cat(prod((x=scan()%/%10^(0:12)%%10)+!x))

在线尝试！

由于保证输入不超过12位数字，因此应该可以很好地工作。将数字计算为x（包括前导零），然后将零替换为1并计算乘积。

cat(					#output
    prod(				#take the product of
         (x=				#set X to
	    scan()			#stdin
		  %/%10^(0:12)%%10)	#integer divide by powers of 10, mod 10, yields digits of the input, with leading zeros. So x is the digits of the input
                                   +!x  #add logical negation, elementwise. !x maps 0->1 and nonzero->0. adding this to x yields 0->1, leaving others unchanged
                                      ))

— 朱塞佩
source

因此，这是如何使用R进行代码高尔夫。。。不错；）仍在尝试弄清楚这是如何工作的！

— Florian

1

@Florian我添加了更详细的解释。

— 朱塞佩

这是分割数字的一种新方法，我将不得不尝试！

— BLT

@BLT是我在R中打高尔夫球的秘诀之一！

— 朱塞佩

5

C（gcc），39个字节

k;f(n){for(k=1;n;n/=10)k*=n%10?:1;k=k;}

需要在不进行优化的情况下进行编译（无论如何，这是gcc的默认设置）。

在线尝试！

— 稳定箱
source

这k=k;将k在返回寄存器意外，只是普通的邪恶。您可能应该补充说，这仅适用于x86 / x64上的优化。+1。

— tomsmeding

1

@tomsmeding令人惊讶的是，它确实可以在x86以外的体系结构上运行。O0gcc的默认设置是不使用优化（），因此无需显式使用该标志。我想我还是会在帖子中提及它。

— Steadybox

您可能需要指定与其一起使用的GCC的确切版本，以供将来校对。

— moonheart08年

@ moonheart08我怀疑它在某些版本后会停止工作。无论如何，它可以与最新版本一起使用，因此可以使用发布时间来查找至少可以使用的版本。

— Steadybox'3

5

Brain-Flak，74 72 70字节

-2感谢Nitrodon建议获得该数字的取反，这样您以后只需要增加而不是减少即可

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

在线尝试！

可能有几种方法可以进一步解决这个问题，例如~~重做乘法以避免必须将总数初始化为1。~~（-2字节）

怎么运行的：

{ Loop over every number
  ([{}]((((()()()){}){}){}){}) Add 48 to the negative of the ASCII to get the negation of the digit
  { If the number is not 0
     ({<({}())><>([[]](){})<>}<><{}>)<> Multiply the total by the number
                                          If the total is on an empty stack, add 1
  } 
  {} Pop the excess 0
}<> Switch to the stack with the total

— 乔·金
source

1

您可以通过计算实际数字的取反来

— 再打

4

05AB1E，4个字节

0KSP

在线尝试！

说明

0K     # remove zeroes
  S    # split to list of digits
   P   # product

— 艾米尼亚
source

我接受了这个答案，因为这是果冻，果壳和05AB1E之间的四路联系，您首先回答。

— FantaC

4

J，₁₇ ₁₄ 13字节

-4字节@GalenIvanov提供

[:*/1>.,.&.":

在线尝试！

大概可以改善一些。编辑：就是这样。

说明

[: */ 1 >. ,.&.":
                 ": Convert to string
             ,.     Convert row to column vector
               &.   Convert to numbers
      1 >.        Maximum of each element with 1 (convert 0 to 1)
   */              Product
[:                 Cap fork

&.-under是一个漂亮的副词，它在右侧应用动词，然后在左侧应用动词，然后在右侧应用动词的逆词。从技术上讲，也可以使用eval（".-do）转换回数字。

— 油菜
source

1

您可以更改+0=]为*#] 在线尝试

— Galen Ivanov

1

[:*/0-.~,.&.":14个字节在线尝试

— Galen Ivanov，

@GalenIvanov我知道信号会很有用！我本来的想法是(+-.@*)，我想补充一下。我曾尝试使用'0'-.~一个字符串输入作为输入，但不确定为什么为什么我没想到要对数字进行分割。谢谢！

— 科尔

1

1>.0-.~少做一个字节的工作。[:*/1>.,.&.": 试试吧！

— Galen Ivanov

3

Python 2，43个字节

lambda n:eval('*'.join(`n`.replace(*'01')))

在线尝试！

— 竿
source

3

JavaScript（ES6），28个字节

专为32位整数而设计。

f=n=>!n||(n%10||1)*f(n/10|0)

测试用例

显示代码段

f=n=>!n||(n%10||1)*f(n/10|0)

console.log(f(1))        // => 1
console.log(f(10))       // => 1
console.log(f(20))       // => 2
console.log(f(100))      // => 1
console.log(f(999))      // => 729
console.log(f(21333))    // => 54
console.log(f(17801))    // => 56
console.log(f(4969279))  // => 244944

展开摘要

— Arnauld
source

3

Bash + coreutils + sed + bc，27 24 23字节

tr 0 1|sed s/\\B/*/g|bc

在线尝试！

— 丹尼斯
source

3

Brachylog，5个字节

⊇ẹ×ℕ₁

在线尝试！

说明

⊇        Take a subset of the input
 ẹ       Split the subset into a list of digits
  ×      Product
   ℕ₁    This product must be in [1, +∞)

之所以⊇可行，是因为从大子集到小子集是统一的，因此第一个将导致非零乘积的是排除所有零且没有别的东西。

— 致命
source

3

Perl 5，23 +1（`-p`）= 24字节

$\=1;s/./$\*=$&||1/ge}{

在线尝试！

— Xcali
source

3

Java 8，55 54 53 51字节

int f(int n){return n>0?(n%10>0?n%10:1)*f(n/10):1;}

@Dennis的Python 2答案端口。
-1个字节感谢@RiaD。

在这里尝试。

55 54字节版本：

n->{int r=1;for(;n>0;n/=10)r*=n%10>0?n%10:1;return r;}

在线尝试。

— 凯文·克鲁伊森
source

1

您可以像这样保存long f(long n){return n>0?(n%10>0?n%10:1)*f(n/10):1;}

— 原谅

1

抱歉，我要求使用此密码（45个字节），因为算法完全不同；-)

— OlivierGrégoire18年

3

朱莉娅0.6，26字节

!x=prod(max.(digits(x),1))

使用示例：

julia> !54
20

在线尝试！

— 林登·怀特
source

您能否添加一个如何调用它的示例以及字节数？您可以使用TIO！

— 朱塞佩

@Giuseppe糟糕，我分心了。我计算了长度，但没有添加。呵呵，TIO现在支持julia。整齐。

— Lyndon White

实际上，TIO支持Julia 0.4-0.6！非常好，+ 1。

— 朱塞佩

3

JavaScript（Node.js），30字节

f=([a,...b])=>a?(+a||1)*f(b):1

在线尝试！

将字符串作为输入，将其视为数组，并通过数组解构分离出第一个元素[a,...b]。+a||1返回与a字符对应的数字。我想剩下的就是自我解释。

— w
source

3

八度，21字节

感谢@Luis Mendo保存一个字节，并感谢@alephalpha保存另一个字节！

@(n)prod((k=n-48)+~k)

将输入作为一串数字。

在线尝试！

30个字节：

@(n)prod((k=num2str(n)-48)+~k)

将输入作为数字。

在线尝试！

— 稳定箱
source

@(n)prod((k=n-48)+~k)

— alephalpha

2

脑筋急转弯，88字节

可读版本：

#Push a 1 onto the alternate stack. Return to the main stack
(<>())<>

#While True:
{

    #Push the current digit minus 48 (the ASCII value of '0') onto the alternate stack
    ({}[((((()()()){}){}){}){}]<>)

    #If it's not 0...
    {
        (<

            #Multiply the top two values (the current digit and the current product that started at 1)
            ({}<>)({<({}[()])><>({})<>}{}<><{}>)

        #Also push a 0
        >)

    #Endwhile
    }

    #Pop the 0
    {}

    #Return to the main stack
    <>

#Endwhile
}

#Toggle to the alternate stack, and implicitly display
<>

在线尝试！

— DJMcMayhem
source

1

74字节

— Jo King

我从字面上忘记了我发表的评论，并从头重写了它。我要单独发布

— Jo King

2

Clojure，56个字节

(fn[n](apply *(replace{0 1}(map #(-(int %)48)(str n)))))

很基本。将数字转换为字符串，然后从每个字符中减去48，以将其转换回数字。然后，将每个0替换为1，然后将其应用于*所得的数字列表（*在列表中减少）。可以接受数字或字符串化的数字。

在线尝试！

(defn non-zero-prod [n]
  (let [; Abusing strings to get each digit individually
        str-n (str n)

        ; Then turn them back into numbers
        digits (map #(- (int %) 48) str-n)

        ; Substitute each 0 for a 1
        replaced (replace {0 1} digits)]

    ; Then get the product
    (apply * replaced)))

— 致癌物质
source

2

MATL，5个字节

!UXzp

输入作为字符串

在MATL在线上尝试一下！或在“在线试用”中验证测试用例！

说明

!     % Implicit input: string (row vector of chars). Transpose into
      % a column vector of chars
U     % Convert from string to number. Treats each row independently,
      % producing a column vector of numbers
Xz    % Keep only nonzeros
p     % Product. Implicit display

— 路易斯·门多
source

2

Befunge，23 22字节

1<*_$#`.#0@#:+!:-"0"~$

在线尝试！

说明

1<                        Push 1, turn back left, and push a second 1.       
                     $    Drop one of them, leaving a single 1, the initial product.

                -"0"~     Read a char and subtract ASCII '0', converting to a number.
             +!:          If it's 0, make it 1 (this is n + !n).
      `  0  :             Then test if it's greater than 0, to check for EOF.
   _                      If it is greater than 0, it wasn't EOF, so we continue left.
  *                       Multiply with the current product, becoming the new product.
1<                        Now we repeat the loop, but this time push only a single 1...
                     $    ...which is immediately dropped, leaving the current product.

   _                      On EOF, the input value will be negative, so we branch right.
    $                     We don't need the input, so drop it.
       .  @               Leaving us with the product, which we output, then exit.

— 詹姆斯·霍尔德尼斯
source

2

JavaScript（Node.js），36 33字节

简单Javascript（ES6）方法，将输入作为数字字符串，将其扩展到数组中，然后通过乘法进行归约，如果结果为0，则返回值。

多亏了Shaggy，节省了3个字节

s=>[...s].reduce((a,b)=>b*a||a,1)

在线尝试！

— 威尔逊·约翰逊Reta232
source

通过将输入作为字符串来节省3个字节。

— 粗野的

我不知道为什么我认为必须进行转换，谢谢：D

— Wilson Johnson Reta232 '18

2

Ruby，42 40 35 32 27字节

p eval (gets.chars-[?0])*?*

假设输入中没有换行符主要影响

-2个字节，感谢@GolfWolf

-5个字节，感谢@Conor O'Brien

— 哈瓦德·尼格德（HåvardNygård）
source

甚至小于tr：32个字节

— Cristian Lupascu，

@GolfWolf聪明:)

— 哈佛尼加德

您可能会使用*加入吗？p eval (gets.chars-[?0])*?*？

— 科纳·奥布莱恩

2

Java（OpenJDK 8），45字节

s->s.chars().reduce(1,(a,b)->b<49?a:a*(b-48))

在线尝试！

— 奥利维尔·格雷戈尔（OlivierGrégoire）
source

2

C＃，97字节（第一个高尔夫代码）

static int X(int y){var z=y.ToString();int r=1;foreach(var q in z){if(q!=48){r*=q-48;}}return r;}

不知道我是否必须将其包装在一个方法中，所以只包括它是安全的。

接受一个Int，将其转换为字符串，并返回每个忽略0的字符的倍数。由于程序使用ascii值将其读取为char，因此减至48。

— 詹姆斯·米
source

2

欢迎来到PPCG！我什么都没有的C＃，但是这会帮助你理解为它打高尔夫球的规则。

— H.PWiz '18

谢谢@ H.PWiz我真的开始喜欢这些小挑战，这绝对使我可以更改常规编程以使其更简洁，更高效。

— 詹姆斯m

欢迎和漂亮的第一次尝试：d你的答案一些提示：您可以删除var z=y.ToString();，直接放置在foreach，像这样：foreach(var q in y.ToString()); 并得到结果，你可以通过更换节省更多的字节{if(q!=48){r*=q-48;}}用r*=(q>48?q:1);，剃断支架和if。

— auhmaan

2

C＃（Visual C＃交互式编译器），46字节

i.Select(c=>c>48?c-48:1).Aggregate((p,c)=>p*c)

在线尝试！

— 奥马
source

1

Haskell，36个字节

f n=product[read[d]|d<-show n,d>'0']

相同字节数：

f n=product[max 1$read[d]|d<-show n]

在线尝试！

— 克里斯蒂安·卢帕斯库（Cristian Lupascu）
source

同样是36

— H.PWiz

1

果冻，6，5个字节

ṢU×\Ṁ

在线尝试！

— DJMcMayhem
source

5分钟，还不错！

— FantaC

DTịDP会节省一个字节，但是有更好的方法来去除零或将其替换为其他内容。

— 丹尼斯

5

ṢUṀ的

— Uriel

1

> <>，19个字节

1i:&0(?n&c4*-:0=+*!

在线尝试！

— 艾米尼亚
source

非零数字产品挑战

挑战

方法

测试用例

Pyt，3 个字节

Haskell，27个字节

与UniHaskell和-XUnicodeSyntax

说明

Python 2，34个字节

果冻，4字节

怎么运行的

R，40个字节

C（gcc），39个字节

Brain-Flak，74 72 70字节

怎么运行的：

05AB1E，4个字节

J，17 14 13字节

-4字节@GalenIvanov提供

说明

Python 2，43个字节

JavaScript（ES6），28个字节

测试用例

Bash + coreutils + sed + bc，27 24 23字节

Brachylog，5个字节

说明

Perl 5，23 +1（-p）= 24字节

Java 8，55 54 53 51字节

朱莉娅0.6，26字节

JavaScript（Node.js），30字节

八度，21字节

脑筋急转弯，88字节

Clojure，56个字节

MATL，5个字节

说明

Befunge，23 22字节

JavaScript（Node.js），36 33字节

Ruby，42 40 35 32 27字节

Java（OpenJDK 8），45字节

C＃，97字节（第一个高尔夫代码）

C＃（Visual C＃交互式编译器），46字节

Haskell，36个字节

果冻，6，5个字节

> <>，19个字节

与UniHaskell和`-XUnicodeSyntax`

J，₁₇ ₁₄ 13字节

Perl 5，23 +1（`-p`）= 24字节