整数幂


19

某些数字64可以用多种方式表示为整数幂:

64 ^ 1
 8 ^ 2
 4 ^ 3
 2 ^ 6

[1,2,3,6]以尽可能少的字节输出所有可能的幂(在此为)的排序数组。


输入项

大于1且小于10000的正整数。


输出量

可以将输入表示为的整数幂p(包括1)的数组a^p用整数a。只要顺序正确,输出就可以有小数。

任何浮点问题都必须由程序处理。


例子

Input: 3
Output: [1]

Input: 9
Output: [1, 2]

Input: 81
Output: [1, 2, 4]

Input: 729
Output: [1, 2, 3, 6]

计分板

为了使您的分数出现在黑板上,应该采用以下格式:

# Language, Bytes

删除线不会引起问题。


1
我的答案会打印[1 2 3 6]出最后一个测试用例。莫非同时打印[6 3 2 1][1.0 2.0 3.0 6.0]还是[6.0 3.0 2.0 1.0]
丹尼斯2015年

2
关于输入大小和浮点运算,我们可以假设什么?这会影响您尝试将数字取根并查看结果是否为整数的解决方案。
xnor

4
我认为对根的引用使每个人都感到困惑,因此我将其重写为权力。随意改变。
xnor

1
我感谢编辑!只要可以提高我的问题的质量(我相信你的意思),就总是欢迎提出建议和修改。我只是最近才开始在这个特定的网络上提问,并发现社区普遍欢迎。批评和纠正非常感谢!@xnor
Zach Gates

1
只需找到最大的有效功率,然后列出其因素!
SuperJedi224

Answers:


10

Pyth,10个字节

f}Q^RTSQSQ

示范

对于每种电源,它会生成所有数字的列表,直到采用该电源的输入为止,然后检查输入是否在列表中。


10

哈斯克尔(38)

f n=[b|b<-[1..n],n`elem`map(^b)[1..n]]

非常简单。列表推导查找b其中输入n出现的值[1^b, 2^b, ..., n^b]。检查b范围就足够了[1..n]


9

Python 2,53

lambda n:[i/n for i in range(n*n)if(i%n+1)**(i/n)==n]

暴力破解[0,n-1]中指数的底数和[1,n]中底数的所有组合。


8

Python 3,56个字节

lambda n:[i for i in range(1,n)if round(n**(1/i))**i==n]

这真是笨拙。通过对每个可能的i第n个根进行四舍五入,使用的幂i并检查其是否等于原始来测试是否给出整数。

直接检查根是否为整数是很棘手的,因为浮点会给出64**(1/3) == 3.9999999999999996。将其舍入为整数可以让我们检查取幂是否返回到原始值。感谢ypercube提出这个建议,节省了1个字节。

feersum 解决方案更短,更聪明。你们所有人都应该对此表示赞成。


如果检查不正确round(n**(1/i),0)**i==n吗?
ypercubeᵀᴹ

@ypercube好调用,加上0默认的舍入精度,可以节省一个字节。
xnor 2015年

7

Pyth,11 10 12字节

fsmqQ^dTSQSQ

检查所有可能的功率组合。非常慢。


5

CJam,23个字节

rimF{1=:E){E\d%!},}%:&p

通过采用n的质因子分解并计算所有指数的除数的交集来工作。

这是一个有点长于我的其他解决办法,但我期待它的工作(并完成瞬间)对之间的所有整数22 63 - 1

CJam解释器中在线尝试。

怎么运行的

ri                       Read an integer from STDIN.
  mF                     Push its prime factorization.
    {             }%     For each [prime exponent]:
     1=:E                  Retrieve the exponent and save it in E.
         ){     },         Filter; for each I in [0 ... E]:
           E\d%              Compute E % Double(I).
                             (Casting to Double is required to divide by 0.)
               !             Push the logical NOT of the modulus.
                           Keep I if the result is truhty, i.e., if I divides E.
                    :&   Intersect all resulting arrays of integers.
                      p  Print the resulting array.

5

APL,17个字节

(X=⌊X←N*÷⍳N)/⍳N←⎕

我的第一个APL程序;打高尔夫球的建议表示赞赏。

              N←⎕  ⍝ Store input into N
             ⍳     ⍝ The list [1 2 ... N]
            /      ⍝ Select the elements A for which
      N*÷⍳N)       ⍝ N^(1/A)
(X=⌊X←             ⍝ equals its floor (that is, is an integer)

请添加伪代码/解释。但是+1(现在不能投)使用APL( - 是简洁的前它是很酷):-)
mınxomaτ

也+1,对APL的热爱。终极高尔夫球车。

基于伪代码,这不太可能起作用(除非APL执行近似浮点相等性测试)。例如,pow(pow(7,3),1./3))我得到6.99999999999999C或Python的。这是因为在计算1 / A时会损失精度。
feersum

@feersum我对脱机口译员一无所知,但是tryapl.org上所有3的幂都可以正常工作。
lirtosiast

@ThomasKwa似乎确实使用了近似相等性检验。dyalog.com/uploads/documents/Papers/tolerant_comparison/...
feersum

3

JavaScript(ES5),73个字节 81个字节 79个字节 75个字节

for(n=+prompt(),p=Math.pow,i=0;i++<n;)p(.5+p(n,1/i)|0,i)==n&&console.log(i)

检查是否可能的根的最接近整数幂等于n~~(.5+...)等价Math.round(...)于整数范围(0到2 ^ 31-1)中的表达式。

编辑:使用惰性&&逻辑而不是if剃除2个字节,并且由于问题添加了说明,因此增加了输入提示。以前假设输入存储在n

编辑2:更改~~(.5+...).5+...|0通过避免分组来节省两个字节。

编辑3:删除var以保存4个字节。在非严格模式下,这是可以接受的。


您可以通过打乱表达式来剃除几个字节:for(var p = Math.pow,i = 1; i ++ <n; p(~~(.5 + p(n,1 / i)),i)== n && console .log(i));

@Alhadis感谢您的输入,我将做一点编辑
Patrick Roberts

@PatrickRoberts你可以捏p=Math.pow到提示节省1个字节
Downgoat

@vihan,这将是无效的声明,因为这var是必需的
Patrick Roberts

除非您的意思for不是prompt..
Patrick Roberts 2015年

3

Brachylog,8个字节

≥^↙.?≥ℕ≜

在线尝试!

通过其输入变量获取输入并通过其输出变量按要求升序生成每个功率,这与旧的解决方案≥ℕ≜^↙.?∧恰好具有完全相同的长度不同。

≥           Some number which is less than or equal to
            the input,
 ^          when raised to the power of
  ↙.        the output,
    ?       is the input.
       ≜    Label
            the output
      ℕ     as a whole number
     ≥      which is less than or equal to
    ?       the input.

我没有严格的理由来断言每个指数都不大于输入,但是为了使程序真正终止,必须对其进行限制。

ḋḅlᵛf对于所有给定的测试用例,它是一个简短得多的(非生成器)解决方案,但是,如果输入不是由不同素数乘积产生的,则该解决方案将失败。(请考虑一下,因为所有测试用例都是素数的幂,ḋlf也可以使用...)为了解决这个问题,我想出的最好ḋḅlᵐḋˢ⊇ᵛ×f结果是10字节。




2

JavaScript ES7,66个字节

利用实验性数组理解。仅适用于Firefox。

n=>[for(i of Array(n).keys(m=Math.pow))if(m(0|.5+m(n,1/i),i)==n)i]

可能打高尔夫球。我可能会尝试将表达式压缩得更短一些,并希望找到长Array(n).keys()语法的替代方法。

可以更短一些,但是JavaScript具有非常好的浮点精度。


Ah, learned something new... cool.
Patrick Roberts

2

CJam, 20 bytes

ri_,1df+\1$fmL9fmO&p

For input n, this computes logb n for all b less or equal to n and keeps the results that are integers.

This should work for all integers between 2 and 9,999. Run time is roughly O(n).

Try it online in the CJam interpreter.

How it works

ri                   e# Read an integer N from STDIN.
  _,                 e# Copy N and transform it into [0 ... N-1].
    1df+             e# Add 1.0 to each, resulting in [1.0 ... Nd].
        \1$          e# Swap the array with N and copy the array.
           fmL       e# Mapped log base N: N [1.0 ... Nd] -> [log1(N) ... logN(N)]
              9fmO   e# Round each logarithm to 9 decimals.
                  &  e# Intersect this array with [1.0 ... Nd].
                   p e# Print the result.

15,625是唯一失败的输入还是您测试过的唯一失败的输入?
Beta Decay 2015年

绝对有其他人。实际上,我刚刚发现它也失败了4913,这使我以前的修订版无效。
丹尼斯

2

红宝石,50岁

->n{(1..n).map{|i|(n**(1.0/i)+1e-9)%1>1e-8||p(i)}}

打印到屏幕。

Ruby,57岁

->n{a=[]
(1..n).map{|i|(n**(1.0/i)+1e-9)%1>1e-8||a<<i}
a}

返回一个数组。

在测试程序中:

f=->n{(1..n).map{|i|(n**(1.0/i)+1e-9)%1>1e-8||puts(i)}}

g=->n{a=[]
(1..n).map{|i|(n**(1.0/i)+1e-9)%1>1e-8||a<<i}
a}

f.call(4096)
puts g.call(4096)

计算每个根并以1为模对它们进行测试,以查看余数是否小于1e-8。由于精度有限,某些有效的整数根的计算形式为0.9999 ..,因此需要向其添加1e-9。

最多可以计算出n的第n个根,这完全是过度杀伤力,但这似乎是编写非无限循环的最短方法。



2

DC,104字节

输入来自端子,输出已打印,也输出在堆栈上。

因此使用?运算符,您需要使用dc -e "<solution>"dc <file with solution in it>

没有人看到我的答案,更不用说对它们进行投票了,但是我真的很喜欢解决DC中的问题。到目前为止,这是该线程中效率最低的解决方案,但我想还是应该发布它。

1sb?sn[lesi]ss[lble1+dse^dln=sln>c]sc[liSflq1+sq]sm[Lfplq1-dsq0<p]dsp[lb1+sb0si0selcxli0!=mlbln!=h]dshxx

入门材料

1sb           Store 1 in register b
?sn           Store user input in register n
[lesi]ss      A macro to copy the e to the i register, stored in the s register

宏以提高所有能力的底数,直到结果大于目标或等于目标

[lble1+dse^dln=sln>c]sc
[lb                 ]   load our base num (register b)
[  le               ]   load our exponent (register e)
[    1+dse          ]   add 1 to the exponent, copy and store in the e register
[         ^d        ]   raise the base to the exponent and copy it
[           ln=s    ]   load the user input, if that is equal to the power result run the macro in register s
[               ln>c]   load the user input, if it's greater than the power result run the macro in register c (this one)
[                   ]sc save this macro in register c

将上述指数宏中找到的有效指数值保存到另一个堆栈的宏

[liSflq1+sq]sm
[liSf      ]     copy the i register to the top of the stack in register f
[    lq1+sq]     add 1 to the q register
[          ]sm   save this macro in the m register

宏,以从2到目标数字的所有基数运行宏2倍于宏(宏c)

[lb1+sb0si0selcxli0!=mlbln!=h]dsh
[lb1+sb                      ]     add 1 to the base number
[      0si0se                ]     reset the i and e registers (previously found value and exponent
[            lcx             ]     load and run the c macro
[               li0!=m       ]     load the result of the c macro and if it's not 0, run m to save it to the f stack
[                     lbln!=h]     if our base number is not equal to our target number, run macro h (this macro)
[                            ]dsh  duplicate this macro and save one copy, so that one is left on the stack to run later

宏以打印f堆栈中的值

[Lfplq1-dsq0<p]dsp
[Lfp          ]      load the top value from the f register and print it
[   lq1-dsq   ]      load the q register and subtract one from it and save it
[          0<p]      if the q register is greater than 0, run macro p (this macro) again
[             ]dsp   duplicate this macro and save one copy, so that one is left on the stack to run later

xx finally run the two macros on the stack (h and then p)


1
我猜想知道DC的人并不多。回答新问题(尤其是最早的问题之一)将有助于引起更多关注。您也可以尝试使用TIO链接作为答案,因为这非常流行。这是TIO上DC
mbomb007

Thanks! I'll definitely use that for answers going forwards!
FlexEast

1

Ruby, 46 bytes

Brute force solution. Self-explanatory; for input n, find all numbers e where for some b, be=n.

->n{(0..n).select{|e|(1..n).find{|b|b**e==n}}}

Try it online!



0

Japt, 10 bytes

õ
f@mpX øN

Try it

õ            :Implicit input of integer U
õ            :Range [1,U]
f@mpX øN     :Reassign to U
f            :Filter
 @           :By passing each X through the following function
  m          :  Map U
   pX        :    Raise to the power of X
      ø      :  Contains
       N     :    Any element of the (singelton) array of inputs
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.