素数的素数


16

出于此挑战的目的,素数的素数(PPP)定义为一个数字,可以定义为素数对素数的幂。例如,9是PPP,因为它可以表示为3 ^ 2。另一方面,81不是PPP,因为它只能表示为3 ^ 4,而4不是质数。头几个PPP是:4,8,9,25,27,32,49,121,125,128,169,243,289,343 ...这是OEIS序列A053810

你的任务:

编写一个程序或函数,使其对于输入整数n返回/输出第n个PPP(1索引或0索引),无论您喜欢哪个。

输入:

通过任何合理的方法获得的0到1,000之间的整数。

输出:

输入指示的索引处的PPP。

测试用例:

它们是1索引的,因此,如果您的程序采用0索引的输入,则对于指定的输入-1应该达到相同的输出。

3  -> 9
6  -> 32
9  -> 125

得分:

,最低得分(以字节为单位)获胜!


这个挑战被沙盒化
Gryphon

Answers:


8

05AB1E(旧版) 9  7字节

保存了2个字节,感谢@KevinCruijssen

µNÓ0Kp»

在线尝试!

µ           # while counter_variable != input:
 N          #   push iteration counter                       e.g. 125
  Ó         #   get prime exponents                          -> [0, 0, 3]
   0K       #   filter out zeros                             -> [3]
     p      #   is prime?                                    -> [1]
      »     #   join with newlines: we use » instead of J
            #   so that [0,1] is not interpreted as truthy   -> 1
            #   implicit: if 1, increment counter_variable

哦,我喜欢使用»代替代替,J所以0\n1不解释为真实!但是,您可以通过省略来在旧版本的05AB1E(您在TIO中也使用过)中保存一个字节½,因为这是隐式完成的µ这是我的05AB1E技巧的第二个要点)。也ʒĀ}可以0K7字节
Kevin Cruijssen

@KevinCruijssen酷。谢谢!
Arnauld

5

外壳,10字节

!fȯṗ§*ELpN

在线尝试!

说明

!fȯṗ§*ELpN  Implicit input.
 f       N  Filter the natural numbers by this function:
  ȯṗ§*ELp    Argument is a number, say 27.
        p    Prime factors: [3,3,3]
       L     Length: 3
      E      Are all elements equal: 1
    §*       Multiply last two: 3
  ȯṗ         Is it prime? Yes, so 27 is kept.
!           Index into remaining numbers with input.

4

其实 14个位元组

基于Xcoder先生的Pyth解决方案。欢迎打高尔夫球。在线尝试!

;ur♂P;∙⌠iⁿ⌡MSE

开球

                Implicit input n
;ur             Duplicate and push [0..n]
   ♂P           Push the 0th to nth primes
     ;∙         Push Cartesian square of the primes
       ⌠iⁿ⌡M    Reduce each list in the Cartesian square by exponentiation
            SE  Sort the list and get the nth index (0-indexed)

4

Mathematica,48个字节

Sort[Join@@Array[(p=Prime)@#^p@#2&,{#,#}]][[#]]&   

在线尝试!

但马丁·恩德(Martin Ender)有一个更好的主意,并节省了6个字节

Mathematica,42个字节

Sort[Power@@@Prime@Range@#~Tuples~2][[#]]&   

在线尝试!


您可以使用Union代替Join来避免Sort
Martin Ender

但我认为Outer可以节省更多的时间Array(Union@@Outer[Power,p=Prime@Range@#,p])[[#]]&
马丁·恩德

Tuples更短:Sort[Power@@@Prime@Range@#~Tuples~2][[#]]&
马丁安德


4

R +数字,57个字节

function(n,x=numbers::Primes(2*n))sort(outer(x,x,"^"))[n]

在线尝试!

outer 就是这样方便的功能。

可以肯定的是,它将始终有效。有空的时候会正式辩论。


4

Haskell95 85 80字节

@Lynn -10个字节,@ WillNess
-5个字节

从0开始

(!!)[x|x<-[2..],p<-[[i|i<-[2..x],all((>)2.gcd i)[2..i-1]]],or[y^e==x|e<-p,y<-p]]

在线尝试!

说明

(!!)                    -- point-free expression, partially evaluate index-access operator
[x|x<-[2..]             -- consider all integers x>=2
,p<-                    -- let p be the list of all primes <=x
[[                      -- list of a list so p ends up as a list
i|i<-[2..x],            -- consider all i<=x to be potentially prime
all((>)2.gcd i)[2..i-1] -- if the gcd of i with all smaller integers is
                        -- smaller than 2 then this i is actually prime
 ]],or                  -- if any of the following list entries is true
[y^e==x|                -- the condition y^e==x holds for x with ...
e<-p,y<-p]              -- y and e being prime, i.e. x is a PPP,
]                       -- then add this x to the output sequence / list

f=(!!)[x|x<-[2..],or[y^e==x|y<-p x,e<-p x]]节省10个字节。
林恩

通过内联可以得到82个字节f=(!!)[x|x<-[2..],p<-[[i|i<-[2..x],all((>)2.gcd i)[2..i-1]]],or[y^e==x|e<-p,y<-p]]。也许还可以,不算数f=吗?(永远不能确定规则)。
尼斯将于

曾经有人告诉我,确实f=不应该算在内。因此,它将为80个字节(!!)[x|x<-[2..],p<-[[i|i<-[2..x],all((>)2.gcd i)[2..i-1]]],or[y^e==x|e<-p,y<-p]]
Will Ness

4

Python 2中163个 157 137 136字节

p=input();r=i=0;e=lambda p:all(p%d for d in range(2,p))
while~-i<p:
 r+=1
 for x in range(r*r):y=x%r;x/=r;i+=x**y==r>e(x)>0<e(y)
print r

在线尝试!


使用列表来保存字节:i=[]....i+=[r]*....
Felipe Nardi Batista

通过删除第二个153个字节for
Felipe Nardi Batista

@FelipeNardiBatista我没有使用列表,因为在第一次迭代中,程序正在定义一个函数。感谢您的关注和进一步的高尔夫。
乔纳森·弗雷希

您能否返回,r而不是返回i[p]
ASCII码


2

Pyth,15个字节

e.f/^FR^fP_TSZ2

在这里尝试!验证更多测试用例。

说明

ef / ^ FR ^ fP_TSZ2-完整程序。Q表示输入。

 .f-第一个Q输入的结果真实。使用变量Z。
        fP_TSZ-过滤素数的范围[1,Z]。
       ^ 2-笛卡尔正方形。基本上,笛卡尔积与它本身有关。
    ^ FR-通过取幂减少每个列表。
  /-计算^中Z的出现。
e-最后一个元素。

2

Javascript 137133字节

P=n=>{for(p=[i=2];j=++i<n*9;j^i&&p.push(i))
for(;j*j<=i;)j=i%++j?j:i
x=[]
for(i of p)
for(j of p)
x[i**j]=1
return Object.keys(x)[n]}

console.log(P(1000))
console.log(P(800))
console.log(P(9))
console.log(P(5))

**正常算法(100ms结果)P = n => {

  for(p=[i=2];f=++i<=n*10;!f||p.push(i))
    for(j=0;f&&(x=p[j++])*x<=i;)
      f=i%x
  x=[]
  T=0
  for(i of p)
  for(j of p)
  {
    l= i**j
    if(++T>n &&x.length<l )
    break
    x[l] = 1
  }
  return Object.keys(x)[n]
}

5
嗯,这是代码高尔夫球,不是最快的代码。因此,与其他人相比,您提交的速度并不重要,因为这是通过字节数进行评分的。请在答案中包括提交的字节数和语言。
狮ry

但是它应该至少有一个时间限制,我可以打高尔夫,但是100ms解决方案将变成5秒解决方案,可以吗?
DanielIndie

2
该解决方案可能需要任何有限的时间才能运行。唯一的目标是使代码更短。
狮ry

2

APL(Dyalog扩展),15字节

{⍵⌷∧∊∘.*⍨¯2⍭⍳⍵}

在线尝试!

说明

{⍵⌷∧∊∘.*⍨¯2⍭⍳⍵}

                 Right argument. Our input.
{              }  Wraps the function in dfn syntax which allows us to use ⍵.
                  Range [1..⍵].
          ¯2     Get the n-th prime for each n in the range.
      ∘.*⍨        Get the prime powers of each prime.
                 Flatten the list.
                 In Extended, this is monadic sort ascending.
 ⍵⌷               Get the input-th index of the list of prime powers of primes.

2

Perl 6,50个字节

{(sort [X**] (^7028,^24)>>.grep(&is-prime))[$_-1]}

在线尝试!

  (^7028,^24)            # create 2 ranges from 0
     >>.grep(&is-prime)  # grep for primes in both
 [X**] ...               # calc each exponential pair (2^2, 2^3, 2^5...)
(sort ... )[$_-1]        # sort and get value at index n-1

24和7028的原因是,最大值(n = 1000)为49378729,即7027 ^ 2,而适合该值的2的最大素数为23。因此覆盖2..7027 ^ 2.。 23包括前1000个中的所有项目(以及许多备用零件)。



1

PARI / GP,48个字节

f(n)=[x|x<-[1..4^n],isprime(isprimepower(x))][n]

如果不计算f(n)=部分,则为43个字节。


没有设置符号的另一种方法不会检查很多不必要的情况:

f(n)=c=0;i=1;while(c<n,i++;isprime(isprimepower(i))&&c++);i

0

Java 8,211字节

import java.util.*;n->{List l=new Stack();for(int a=2,b;a<132;a++)for(b=2;b<132;b++)if(p(a)*p(b)>0)l.add(Math.pow(a,b));Collections.sort(l);return l.get(n);}int p(int n){for(int i=2;i<n;n=n%i++<1?0:n);return n;}

效率很低的方法。它基本上计算从2 2999 999 132 132的所有PPP,并将其存储在列表中,然后对该列表进行排序,然后n从该列表中获取第“ th”项。

编辑:我现在使用132 132而不是使用999 999来获得28,225个项目的列表,而不是使用999 999来得到28,225个项目的列表。这样可以大大提高性能,并且完全可以接受,因为质询指出我们应该支持索引0到1,000的输入。(但是,更改为不会影响字节数。)1e3132

说明:

在这里尝试。

import java.util.*;           // Required import for List, Stack and Collections

n->{                          // Method with integer as parameter and Object as return-type
  List l=new Stack();         //  List to store the PPPs in
  for(int a=2,b;a<132;a++)    //  Loop (1) from 2 to 1,000 (exclusive)
    for(b=2;b<132;b++)        //   Inner loop (2) from 2 to 1,000 (exclusive)
      if(p(a)*p(b)>0)         //    If both `a` and `b` are primes:
        l.add(Math.pow(a,b)); //     Add the power of those two to the List
                              //   End of loop (2) (implicit / single-line body)
                              //  End of loop (1) (implicit / single-line body)
  Collections.sort(l);        //  Sort the filled List
  return l.get(n);            //  Return the `n`'th item of the sorted List of PPPs
}                             // End of method

int p(int n){                 // Separated method with integer as parameter and return-type
  for(int i=2;                //  Index integer (starting at 2)
      i<n;                    //  Loop from 2 to `n` (exclusive)
    n=n%i++<1?                //   If `n` is divisible by `i`:
       0                      //    Change `n` to 0
      :                       //   Else:
       n                      //    Leave `n` the same
  );                          //  End of loop
  return n;                   //  Return `n` (which is now 0 if it wasn't a prime)
}                             // End of separated method

0

J,21个字节

{[:/:~@,[:^/~p:@i.@>:

零索引匿名函数。

在线尝试!

试图回到事物的波动中,但是我似乎已经忘记了制作好单子链的所有技巧。

简短说明

构造一个从第0个素数到输入索引加1的素数(占0)的素数幂表。展平此列表并对其进行排序,然后对其进行索引。我现在意识到,由于表可能不够大,因此对于某些值可能会给出不正确的结果-在这种情况下,我将编辑像1e4这样的硬编码值就足够了。我无法以另一种方式证明它(它通过给定的测试用例),所以请让我知道这是否是一个问题。

也是21个字节

3 :'y{/:~,^/~p:i.>:y'
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.