计算主要因素

27

不久前，我们遇到了一个主要的因式分解挑战，但是这个挑战已经存在了将近六年，并且几乎不能满足我们当前的要求，因此我认为现在是时候提出一个新的挑战了。

挑战

编写一个程序或函数，将大于1的整数作为输入，并输出或返回其主要因子的列表。

规则

  • 输入和输出可以通过任何标准方法和任何标准格式给出。
  • 输出中必须包含重复因素。
  • 输出可以是任何顺序。
  • 输入将不小于2或大于2 31-1。
  • 允许内置，但鼓励包括非内置解决方案。

测试用例

2 -> 2
3 -> 3
4 -> 2, 2
6 -> 2, 3
8 -> 2, 2, 2
12 -> 2, 2, 3
255 -> 3, 5, 17
256 -> 2, 2, 2, 2, 2, 2, 2, 2
1001 -> 7, 11, 13
223092870 -> 2, 3, 5, 7, 11, 13, 17, 19, 23
2147483646 -> 2, 3, 3, 7, 11, 31, 151, 331
2147483647 -> 2147483647

计分

这是code-golf，因此以字节为单位的最短代码获胜。

code-golf  primes  factoring 
— ETH生产
source
2
如果您不允许内置，那就更好了。
— 缓冲区超速读取
2
不允许内置的@TheBitByte挑战通常被视作没有Y挑战的Do X，尤其是因为有时很难分辨一个解决方案在技术上是否是内置的。
— ETHproductions 2013年
1
那么，请尽情享受<5字节解决方案！在我撰写本文时，Pyth已经在1个字节中完成了它。
— 缓冲读取
2
@TheBitByte主要将其视为一种语言挑战。尝试击败Python的解决方案或其他没有内置语言的语言。
— isaacg
1
@isaacg好吧，我同意用语言进行查看是一种更好的方法。
— 缓冲读取

Answers:

15

Pyth，1个字节

P

我喜欢Pyth在这次挑战中的机会。

— 伊萨格
source
16
直到出现“ P”语言并以0字节为单位
— 为止
10

Python 2，53字节

f=lambda n,i=2:n/i*[f]and[f(n,i+1),[i]+f(n/i)][n%i<1]

i依次尝试每个潜在的除数。如果i为除数，则将其前置并用重启n/i。否则，尝试第二高的除数。由于除数是按升序检查的，因此仅找到质数。

作为一个程序，需要55个字节：

n=input();i=2
while~-n:
 if n%i:i+=1
 else:n/=i;print i
— 异或
source
8

Mathematica，38个 30字节

感谢@MartinEnder 8个字节！

Join@@Table@@@FactorInteger@#&
— 郑焕民
source
怎么FactorInteger[#][[All, 1]]&样 26个字节
— David G. Stork
@ DavidG.Stork这是行不通的，因为它不会重复的首要因素，如果功率大于1
— JungHwan民
4

JavaScript（ES6），44个字节

f=(n,x=2)=>n-1?n%x?f(n,x+1):[x,...f(n/x)]:[]

由于实际上是从2迭代到每个素数，包括最后一个素数，因此效率极低。您可以以5个字节为代价大大降低时间复杂度：

f=(n,x=2)=>x*x>n?[n]:n%x?f(n,x+1):[x,...f(n/x,x)]
— ETH生产
source
3

实际上，6个字节

w`in`M

在线尝试！

说明：

w`in`M
w       factor into primes and exponents
 `in`M  repeat each prime # of times equal to exponent
— 梅果
source
您o现在可以使用，对吧？
— 奥利弗
@Oliver是的，但是我通常不使用内置函数更新旧答案。
— Mego
2

聋哑，3个字节

该语言还很年轻，还没有真正适合任何主要的语言，但是它可以进行素因数分解：

A/D

这将等待用户输入，然后输出主要因素列表。

— 卡德
source
2

MATLAB，6个字节

我认为这不需要任何解释。

factor
— 瑕疵
source
1

Bash + coreutils，19个字节

factor|sed s/.*:.//

在线尝试！

— 丹尼斯
source
如果使用输出中的空格不重要，则可以删除一个字节factor|sed s/.*://。同样factor|cut -d: -f2（或factor|cut -d\ -f2为了匹配您当前的输出），字节长度相同，但是运行速度更快，并且使用的内存开销更少。
— 卡雷布（Caleb）
我会问OP关于空白的问题。可悲的是，我需要factor|cut -d\ -f2-消除前导空间，该空间要长一个字节。
— 丹尼斯
1

批次，96个字节

@set/an=%1,f=2,r=0
:l
@set/af+=!!r,r=n%%f
@if %r%==0 echo %f%&set/an/=f
@if %n% gtr 1 goto l
— 尼尔
source
1

六边形，58字节

还没有打高尔夫球，但是@MartinEnder应该仍然可以销毁它

打印出以空格分隔并尾随空格的因子

打高尔夫球：

2}\..}$?i6;>(<...=.\'/})."@...>%<..'':\}$"!>~\{=\)=\}&<.\\

布置：

     2 } \ . .
    } $ ? i 6 ;
   > ( < . . . =
  . \ ' / } ) . "
 @ . . . > % < . .
  ' ' : \ } $ " !
   > ~ \ { = \ )
    = \ } & < .
     \ \ . . .

解释稍后。

— 蓝色
source
1

C，92个字节

int p(int n){for(int i=2;i<n;i++)if(n%i==0)return printf("%d, ",i)+p(n/i);printf("%d\n",n);}

非高尔夫版本：

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>

int prime(int number) {
    for (int i = 2; i < number; i++) {
        if (number % i == 0) {
            printf("%d, ", i);
            return prime(number / i); //you can golf away a few bytes by returning the sum of your recursive function and the return of printf, which is an int
        }                             //this allow you to golf a few more bytes thanks to inline calls
    }
    printf("%d\n", number);
}

int main(int argc, char **argv) {
    prime(atoi(argv[1]));
}
— 瓦伦丁·玛丽埃（Valentin Mariette）
source
0

Perl 6的，77 64个字节   

{my$a=$_;.is-prime??$_!!map ->\f{|({$a%f||($a/=f)&&f}...^*!= f)},(2... *>$a)}

试试吧

{my$a=$_;map ->\f{|({$a%f||($a div=f)&&f}...^ f>*)},(2... *>$a)}

试试看（注意：它没有足够的时间分配完成）

性能更高的版本稍长一些，为100字节。

{my$a=$_;map ->\f{|({$a.is-prime??($/=$a)&&($a=0)||$/!!($a%f||($a div=f)&&f)}...^ f>*)},(2... *>$a)}

试试吧

扩展：（64字节版本）

{
  my $a = $_;  # the input ｢$_｣ is read-only by default
  map
    -> \f {
      |(              # slip ( flattens into outer list )

        # generate sequence of 0 or more ｢f｣s
        {
          $a % f      # is it not evenly divisible

          ||          # if it is evenly divisible
          ($a div=f)  # divide it
          &&          # and
          f           # return ｢f｣
        }
        ...^   # keep doing that until
        f > *  # ｢f｣ is bigger
      )

    },

    # do that over the following list

    (2 ... * > $a) # generate a sequence from 2
                   # up to whatever the value of $a
                   # is at the time of the check
}
— 布拉德·吉尔伯特b2gills
source
0

VB.NET，86个字节

在一些欧拉计划中就已经有了这个功能。为了简短起见，删除了优化，这就是结果。自然，VB非常冗长，因此相当长。我不算领先的空格。它可以省略，但更易于阅读。

它以整数作为参数，并在其后打印逗号的素数。末尾有逗号。

Sub A(a)
    For i=2To a ' VB re-evaluates a each time, so the /= at the end of the loop shortens this
        While a Mod i=0 ' this is a factor. We've grabbed primes before this, so this must be a prime factor
            Console.Write(i &",") ' output
            a/=i ' "mark" the prime as "used"
        End While
    Next
End Sub
— 布莱恩·J
source
0

Perl 6，51个字节

递归解决方案：

sub f(\n,\d=2){n-1??n%d??f n,d+1!!(d,|f n/d,d)!!()}
— 肖恩
source
0

Java（OpenJDK），259个字节

import java.util.*;interface g{static void main(String[]z){int a=new Scanner(System.in).nextInt();int b=0;int[]l={};for(int i=2;i<=a;i++){for(;a%i<1;l[b-1]=i){l=Arrays.copyOf(l,b=l.length+1);a/=i;}}for(int i=0;i<b;i++)System.out.print(l[i]+(i<b-1?", ":""));}}

在线尝试！

— 帕维尔
source
请参阅此要点，以了解如何进一步处理此提交内容：gist.github.com/kritixilithos/fde37dc5a8ae54852aa134a6e70ea495。如果您需要澄清一些信息，请在第19个字节处ping我：)
— Kritixi Lithos
0

Ruby，61个字节

require'prime';->x{x.prime_division.flat_map{|x|[x[0]]*x[1]}}

我能想到的最短的内置版本。

— 塞姆斯
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.