用三三代替二

36

给定一个正整数n编写一些代码来利用其因式分解和替换所有的因素，它2与3。

例如

12 = 2 * 2 * 3 -> 3 * 3 * 3 = 27

这是代码高尔夫球，因此目标是最小化答案的字节数。

测试用例

1 -> 1
2 -> 3
3 -> 3
4 -> 9
5 -> 5
6 -> 9
7 -> 7
8 -> 27
9 -> 9
10 -> 15
11 -> 11
12 -> 27
13 -> 13
14 -> 21
15 -> 15
16 -> 81
17 -> 17
18 -> 27
19 -> 19
20 -> 45
21 -> 21
22 -> 33
23 -> 23
24 -> 81
25 -> 25
26 -> 39
27 -> 27
28 -> 63
29 -> 29

code-golf arithmetic number-theory

— 小麦巫师
source

Answers:

63

Fractran，3个字节

3/2

Fractran实际上只有一个内置函数，但是它恰好可以完成此任务要求的功能。（它本身也是图灵完备的。）

该语言实际上没有标准化的语法或解释器。该解释器（在博客文章的注释中-一种非常简单的语言）将接受此处显示的语法。（还有其他具有其他语法的Fractran解释器，例如，有些人会将该程序编写为3 2，甚至使用3和2作为命令行参数编写，这会导致得分为0 + 3字节。我怀疑在一个程序中比3更好吗？预先存在的口译员。）

说明

3/2
 /   Replace a factor of
  2  2
3    with 3
     {implicit: repeat until no more replacements are possible}

10

关于这项工作正确的工具通话..

— 凯文Cruijssen

23

“不要支持仅使用简单内置函数的简单解决方案。” 好吧，在这种情况下：知道有一种语言“ Fractran”具有一个内置的内置组件可以解决此特定任务，这本身就令人印象深刻。

— Stewie Griffin'5

3

相关的SO代码高尔夫（PPCG之前的版本）：编写Fractran解释器。

— 霍布斯（Hobbs）

1

@AnderBiguri：可能正在寻找一种非常简单/易于实现的图灵完整的语言。Fractran真的很优雅，就像图灵沥青一样。大多数都具有更多粗糙的边缘，特殊情况或细节，可以在不造成较大差异的情况下进行更改。

3

@AnderBiguri似乎是从他对Collatz猜想的研究中得出的；他证明了Collatz的推广等同于Fractran，并且Fractran是图灵完备的，因此推广的Collatz尚不确定。

— 霍布斯（Hobbs）

21

Python 2，28个字节

f=lambda n:n%2*n or 3*f(n/2)

在线尝试！

只要数字是偶数，就将数字递归除以2并将结果乘以3。奇数返回自己。

32字节alt：

lambda n:n*(n&-n)**0.58496250072

在线尝试。有一些浮动错误。常数是log_2(3)-1。

用于(n&-n)查找的2的最大幂n，通过将3**k其2**k提高到的幂进行转换log_2(3)-1。

— 异或
source

很好，这正是我的解决方案！

— 小麦巫师

@WheatWizard我也是，啊哈！

— 重力1998年

18

05AB1E，4个字节

Ò1~P

在线尝试！

怎么运行的

Ò     Compute the prime factorization of the input.
 1~   Perform bitwise OR with 1, making the only even prime (2) odd (3).
   P  Take the product of the result.

— 丹尼斯
source

仅仅因为素因式分解仅是一个字节，

— 所以它就将

5

@HyperNeutrino：我也注意到：“ Dennis为什么使用05AB1E？哦，相同的算法，较短的内置名称”。因此，我不得不去寻找一种语言，通过使用更合适的内置函数，我可以用更少的字节来做到这一点。

14

Haskell，24个 23字节

until odd$(*3).(`div`2)

除以2再乘以3，直到Haskell中出现奇数技巧为止。

在线尝试！

用lambda代替pointpoint函数并具有相同的字节数：

odd`until`\x->div(x*3)2

编辑：@ ais523在原始版本中保存了一个字节，在替代版本中@@ rrjan Johansen保存了一个字节，因此两个版本的长度仍然相同。谢谢！

— 妮米
source

3

lambda版本可以缩短为odd`until`\x->div(x*3)2。

— 与Orjan约翰森

2

也可以通过使用$替换一对括号将原始版本缩短一个字节：在线尝试！

@ØrjanJohansen：啊，太好了！谢谢。

— nimi

@ ais523：我怎么会错过那个，谢谢！

— nimi

2

我想你忘了删除一对()从拉姆达版本

— CAD97

8

JavaScript（ES6），19个字节

f=x=>x%2?x:f(x*1.5)

当输入可被2整除时，将其乘以1.5，相当于将其除以2再乘以3。

— ETH生产
source

2

x*3/2具有相同的字节数

— Leaky Nun

1

f=js通常不需要。

— 克里斯多夫（Christoph）

3

@Christoph谢谢，但是要称呼它本身f(x*1.5)必须有name f，因此要f=包括在内。

— ETHproductions's

@ETHproductions嗯……当然！我错过了。调用代码到底是什么样子的？

— 克里斯多夫（Christoph）

2

@Christoph 这是相关的元文章。

— ETHproductions's

8

Brain-Flak，76字节

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

在线尝试！

说明

该程序的工作原理是将数字除以2，然后增加三倍，直到从该除法中得到余数。然后，它停止循环并翻倍，并将其加到最终数字上。

最终会有更详细的解释...

— 0'
source

>即将推出...

— 小麦巫师

7

Mathematica，22个 19字节

感谢lanlock4节省了3个字节！

#//.x_?EvenQ:>3x/2&

重复进行替换的纯函数，一次2的倍数。适用于所有小于2 ^65537的正整数。

— 格雷格·马丁
source

会x_?EvenQ代替x_/;EvenQ@x吗？

— 不是一棵树

1

您完全正确，谢谢！

— 格雷格·马丁

6

MATL，7，6个字节

Yf1Z|p

在线尝试！

由于丹尼斯的天才观察，节省了1个字节

解释此问题的最佳方法是在各个点显示堆栈。

Yf  % Prime factors

[2 2 2 3]

1Z| % Bitwise OR with 1

[3 3 3 3]

p   % Product

81

替代解决方案：

Yfto~+p

— DJMcMayhem
source

真好！我只有Yf3H$X>p8个字节

— 路易斯·门多

6

05AB1E，6 5字节

多亏了Adnan，节省了一个字节。

ÒDÈ+P

在线尝试！

说明

Ò       # push list of prime factors of input
 D      # duplicate
  È     # check each factor for evenness (1 if true, else 0)
   +    # add list of factors and list of comparison results
    P   # product

— 艾米尼亚
source

2

ÒDÈ+P应该保存一个字节

— 阿德南（Adnan）

@Adnan：谢谢！

— 艾米娜（Emigna）'17

6

爱丽丝，9字节

2/S 3
o@i

在线尝试！

爱丽丝（Alice）有一个内置函数，可以用另一个数字除数。我认为我真的不会这么快就使用它...

使用用于I / O的字符代码点，将变为6个字节：I23SO@。

说明

2   Push 2 (irrelevant).
/   Reflect to SE. Switch to Ordinal.
i   Read all input as a string.
    The IP bounces up and down, hits the bottom right corner and turns around,
    bounces down again.
i   Try to read more input, but we're at EOF so this pushes an empty string.
/   Reflect to W. Switch to Cardinal.
2   Push 2.
    The IP wraps around to the last column.
3   Push 3.
S   Implicitly discard the empty string and convert the input string to the integer
    value it contains. Then replace the divisor 2 with the divisor 3 in the input.
    This works by multiplying the value by 3/2 as long as it's divisible by 2.
/   Reflect to NW. Switch to Ordinal.
    Immediately bounce off the top boundary. Move SW.   
o   Implicitly convert the result to a string and print it.
    Bounce off the bottom left corner. Move NE.
/   Reflect to S. Switch to Cardinal.
@   Terminate the program.

— 马丁·恩德
source

1

您的痴迷已得到官方确认。

— Leaky Nun

4

果冻，8 5字节

Æf3»P

Æf3»P  Main Link, argument is z
Æf     Prime factors
  3»   Takes maximum of 3 and the value for each value in the array
    P  Takes the product of the whole thing

在线尝试！

-3个字节，感谢@Dennis的提示！

— 超中微子
source

2

提示：2是唯一的偶数和最小的素数。

— 丹尼斯，

@丹尼斯，我明白了。是的，现在知道了。谢谢！:)

— HyperNeutrino

恭喜您学习果冻。

— Leaky Nun

@LeakyNun谢谢！并感谢您教给我。:)

— HyperNeutrino'5

祝贺这个答案！

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

4

Pyth- 14 10 9个字节

*^1.5/PQ2

计算素数分解（/ PQ2）中的2s数。将输入乘以1.5 ^（2s的个数）

— 玛利亚
source

有趣的方法-太糟糕了，它不如现有的Pyth解决方案那么短。

— 硕果累累

@ Challenger5我在这里没有看到任何其他的Pyth解决方案。

— 玛丽亚

1

好吧好吧。这是一种比典型挑战更有趣的方法。

— 硕果累累

4

Java，38个字节

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

在线尝试！

以前的43字节解决方案：

int f(int n){for(;n%2<1;)n=n/2*3;return n;}

在线尝试！

— 漏尼姑
source

4

六角，112 91字节

网格大小6（91字节）

      ? { 2 . . <
     / = { * = \ "
    . & . . . { _ '
   . . { . . } ' * 2
  _ } { / . } & . ! "
 . > % . . < | . . @ |
  \ . . \ . | ~ . . 3
   . . " . } . " . "
    . & . \ = & / 1
     \ = { : = } .
      [ = { { { <

精简版

?{2..</={*=\".&...{_'..{..}'*2_}{/.}&.!".>%..<|..@|\..\.|~..3..".}.".".&.\=&/1\={:=}.[={{{<

网格大小7（112字节）

       ? { 2 " ' 2 <
      / { * \ / : \ "
     . = . = . = | . 3
    / & / { . . } { . "
   . > $ } { { } / = . 1
  _ . . } . . _ . . & . {
 . > % < . . ~ & . . " . |
  | . . } - " . ' . @ | {
   . . . = & . . * ! . {
    . . . _ . . . _ . =
     > 1 . . . . . < [
      . . . . . . . .
       . . . . . . .

在线尝试！

精简版：

?{2"'2</{*\/:\".=.=.=|.3/&/{..}{.".>$}{{}/=.1_..}.._..&.{.>%<..~&..".||..}-".'.@|{...=&..*!.{..._..._.=>1.....<[

非高尔夫版本以提高可读性：

近似内存布局

灰色路径（内存初始化）

?     Read input as integer (Input)
{     Move to memory edge "Divisor left"
2     Set current memory edge to 2 
" '   Move to memory edge "Divisor right" 
2     Set current memory edge to 2
"     Move to memory edge "Multiplier" 
3     Set current memory edge to 3
"     Move to memory edge "Temp 2" 
1     Set current memory edge to 1 
{ { { Move to memory edge "Modulo"
=     Turn memory pointer around 
[     Continue with next instruction pointer

循环进入

%     Set "Modulo" to Input mod Divisor
<     Branch depending on result

绿色路径（值仍可被2整除）

} } {     Move to memory edge "Result"
=         Turn memory pointer around 
*         Set "Result" to "Temp 2" times "Multiplier" (3) 
{ = &     Copy "Result" into "Temp2" 
{ { } } = Move to "Temp"
:         Set "Temp" to Input / Divisor (2)
{ = &     Copy "Temp" back to "Input"
"         Move back to "Modulo"

红色路径（值不再可以被2整除）

} = & " ~ & ' Drag what's left of "Input" along to "Multiplier"
*             Multiply "Multiplier" with "Temp 2"
! @           Output result, exit program

— 曼弗雷德·拉德维默
source

1

欢迎来到PPCG！:)

— 马丁·恩德

@MartinEnder谢谢，很棒的语言。:)

— Manfred Radlwimmer

1

感谢您使用它！:)如果您进行计算%2并且:2都进入“模数”边缘，您是否不能简化内存布局（以及因此所需的移动量）？（因此，您可以除去顶部的两个边缘。）然后，可以将“乘数”分支附加到“模数”边缘而不是“除数”边缘上，以便在每个分支之后需要较少的移动吗？（您甚至可以旋转该部分，以便“结果”或“温度2”触及“模”，这意味着您只需要复制一次最终结果即可计算出乘积。）

— 马丁·恩德

@MartinEnder嗯。我仍在绕过该语言的“痛苦”部分，因此，现在我可能会坚持不降低逻辑而缩小网格^^

— Manfred Radlwimmer

3

视网膜，23字节

.+
$*
+`^(1+)\1$
$&$1
1

在线尝试！

— 尼尔
source

3

Brachylog，7个字节

~×₂×₃↰|

在线尝试！

怎么运行的

~×₂×₃↰|      original program
?~×₂×₃↰.|?.  with implicit input (?) and output (.) added

?~×₂         input "un-multiplied" by 2
    ×₃       multiplied by 3
      ↰      recursion
       .     is the output
        |    or (in case the above fails, meaning that the input
                 cannot be "un-multiplied" by 2)
         ?.  the input is the output

— 漏尼姑
source

相关的。

2

J，11个字节

[:*/q:+2=q:

在线尝试！

[: cap（占位符，用于单调调用下一个动词）

*/ 的产品

q: 主要因素

+ 加号（即在其中添加一个）

2 二

= 等于（每个）

q: 主要因素

— 亚当
source

我以为你觉得[:恶心。

— Leaky Nun

@LeakyNun我知道，但是我不如Conor O'Brien聪明。

— 亚当

2

J，15 12 10字节

(+2&=)&.q:

在线尝试！工作原理类似于下面，只是有关于更换不同的逻辑2与3。

15字节

(2&={,&3)"+&.q:

在线尝试！

说明

(2&={,&3)"+&.q:
           &.    "under"; applies the verb on the right, then the left,
                 then the inverse of the right
             q:  prime factors
(       )"+      apply inside on each factor
     ,&3         pair with three: [factor, 3]
 2&=             equality with two: factor == 2
    {            list selection: [factor, 3][factor == 2]
                 gives us 3 for 2 and factor for anything else
           &.q:  under prime factor

— 科纳·奥布莱恩
source

writing，我写我的书时，您切换了算法。现在我们使用相同的。

— 阿达姆（Adám）'17年

@Adám哦，哈哈。好答案！我无法抗拒在roll这里使用的机会。:)

— 科纳·奥布莱恩

实际上，我也许可以再保存一些字节... 编辑保存了一些：D

— Conor O'Brien

有趣的是您称它为Roll，我称其为Under。希望尽快将其纳入APL。

— 2015年

@AdámHaha实际上被称为“下”。我对这些术语感到困惑

— Conor O'Brien

2

Pyth，9个字节

整数输出\ o /

*F+1.|R1P

测试套件。

怎么运行的

*F+1.|R1P
        P   prime factorization
    .|R1    bitwise OR each element with 1
*F+1        product

— 漏尼姑
source

2

Japt，19 16 10 9 7字节

k ®w3Ã×

在线尝试！

说明

 k ®   w3Ã ×
Uk mZ{Zw3} r*1
U              # (input)
 k m           # for every prime factor
    Z{Zw3}     # replace it by the maximum of itself and 3
           r*1 # output the product

— 路加
source

ah，JS与Japt并驾齐驱。可以肯定的是，解决方案要短得多；-)

— ETHproductions'5

提示：×是r@X*Y}1（或只是r*1）的快捷方式，可能会派上用场。也XwY有Math.max(X,Y)。

— ETHproductions '17

谢谢，尽管递归解决方案确实是最短的。

— 路加福音

好东西！我认为您可以k m_w3Ã×保存一个字节。另外，m_可以缩短为®。

— 奥利弗（Oliver）

2

PHP，36字节

for($a=$argn;$a%2<1;)$a*=3/2;echo$a;

在线尝试！

— 约格·赫尔瑟曼
source

1

for($a=$argn;!1&$a;)$a*=3/2;echo$a;重命名$argn将保存一个字节。

— 克里斯多夫（Christoph）

2

CJam，10 9个字节

rimf1f|:*

真的很简单。

说明：

ri  e# Read integer:         | 28
mf  e# Prime factors:        | [2 2 7]
1   e# Push 1:               | [2 2 7] 1
f|  e# Bitwise OR with each: | [3 3 7]
:*  e# Product:              | 63

— 硕果累累
source

2

六角形，28 27 26字节

?'2{{(\}}>='!:@=$\%<..>)"*

在线尝试！

布置：

    ? ' 2 {
   { ( \ } }
  > = ' ! : @
 = $ \ % < . .
  > ) " * . .
   . . . . .
    . . . .

这基本上运行：

num = input()
while num%2 == 0:
    num = (num/2)*3
print num

在这一点上，这是一个关于如何获得循环路径以最大程度减少字节数的练习。

— 乔·金
source

该死，我没想到

— Manfred Radlwimmer

1

@ManfredRadlwimmer别担心，用Hexagony编写任何代码本身就是一项成就

— Jo King

1

Japt，7个字节

k mw3 ×

在线尝试！

说明

k mw3 ×

k        // Factorize the input.
  mw3    // Map each item X by taking max(X, 3).
      ×  // Take the product of the resulting array.
         // Implicit: output result of last expression

— ETH生产
source

1

APL（Dyalog Unicode），26字节

{⍵(⊣×(3*⊢)×(÷2*⊢))2⍟⍵∨2*⍵}

在线尝试！

这太冗长了，我一定做错了...

— 克里特希·里索斯（Kritixi Lithos）
source

1

R，42个字节

答案中唯一正确的字节数。

x=gmp::factorize(scan());x[x==2]=3;prod(x)

非常简单，使用gmp包进行分解x，将2s替换为3s，然后返回乘积。

— 贾德
source

1

Befunge-93，20个字节

&>:2%!#v_.@
 ^*3/2 <

在线尝试！

& - take in input and add it to the stack
> - move right
: - duplicate the top of the stack
2 - add two to the stack
% - pop 2 and the input off the stack and put input%2 on the stack
! - logical not the top of the stack
# - jump over the next command
_ - horizontal if, if the top of the stack is 0 (i.e. input%2 was non zero) go 
    right, else go left

If Zero:
. - output the top of the stack
@ - end code

If Not Zero:
v - move down
< - move left
2 - add 2 the top of the stack
/ - pop top two, add var/2 to the stack
3 - add 3 to stack
* - pop top two, add var*3 to the stack
^ - move up
> - move right (and start to loop)

— Bwillsh
source

17字节

— Jo King

1

Perl 6、14个字节

{1.5**.lsb*$_}

lsb返回从右数起的最低有效位的位置。也就是说，在二进制表示形式中有多少个尾随零，这与因子2的数量相同。因此，将3/2提升至该乘方，我们就完成了。

say {$_*1.5**.lsb}(24);
> 81

— 菲尔·H
source

0

派克（Pyke），5个字节

P1.|B

在线尝试！

— 蓝色
source

0

实际上，9个字节

w⌠i1|ⁿ⌡Mπ

在线尝试！

说明：

w⌠i1|ⁿ⌡Mπ
w          factor into [prime, exponent] pairs
 ⌠i1|ⁿ⌡M   for each pair:
  i          flatten
   1|        prime | 1 (bitwise OR)
     ⁿ       raise to exponent
        π  product

— Mego
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.