같은 숫자 64는 여러 가지 방법으로 정수의 힘으로 표현할 수 있습니다.

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

가능한 모든 [1,2,3,6]바이트 (여기서는 ) 의 정렬 된 배열을 가능한 한 적은 바이트로 출력하십시오.

입력

1보다 크고 10000보다 작은 양의 정수입니다.

산출

입력 을 정수로 표현할 수있는 정수 전력의 배열 p(포함 1)입니다 . 출력은 순서대로 10 진수를 가질 수 있습니다.a^pa

부동 소수점 문제는 프로그램에서 처리해야합니다.

예

Input: 3
Output: [1]

Input: 9
Output: [1, 2]

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

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

스코어 보드

점수가 보드에 표시 되려면 다음 형식이어야합니다.

# Language, Bytes

취소 선이 문제를 일으키지 않아야합니다.

function getURL(e){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function getAnswers(){$.ajax({url:getURL(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),useData(answers)}})}function getOwnerName(e){return e.owner.display_name}function useData(e){var s=[];e.forEach(function(e){var a=e.body.replace(/<s>.*<\/s>/,"").replace(/<strike>.*<\/strike>/,"");console.log(a),VALID_HEAD.test(a)&&s.push({user:getOwnerName(e),language:a.match(VALID_HEAD)[1],score:+a.match(VALID_HEAD)[2],link:e.share_link})}),s.sort(function(e,s){var a=e.score,r=s.score;return a-r}),s.forEach(function(e,s){var a=$("#score-template").html();a=a.replace("{{RANK}}",s+1+"").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SCORE}}",e.score),a=$(a),$("#scores").append(a)})}var QUESTION_ID=58047,ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",answers=[],answer_ids,answers_hash,answer_page=1;getAnswers();var VALID_HEAD=/<h\d>([^\n,]*)[, ]*(\d+).*<\/h\d>/;

body{text-align:left!important}table thead{font-weight:700}table td{padding:10px 0 0 30px}#scores-cont{padding:10px;width:600px}#scores tr td:first-of-type{padding-left:0}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script><link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"><div id="scores-cont"><h2>Scores</h2><table class="score-table"><thead> <tr><td></td><td>User</td><td>Language</td><td>Score</td></tr></thead> <tbody id="scores"></tbody></table></div><table style="display: none"> <tbody id="score-template"><tr><td>{{RANK}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SCORE}}</td></tr></tbody></table>

Pyth, 10 바이트

f}Q^RTSQSQ

데모

각 거듭 제곱에 대해 해당 거듭 제곱에 취한 입력까지 모든 숫자 목록을 생성 한 다음 입력이 목록에 있는지 확인합니다.

하스켈, 38

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

꽤 직설적 인. 목록 이해는 b에서 입력이 n나타나는 값을 찾습니다 [1^b, 2^b, ..., n^b]. b범위 를 확인하면 충분합니다 [1..n].

파이썬 2, 53

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

Brute는 [0, n-1]의 지수와 [1, n]의 지수의 모든 염기 조합을 강제합니다.

파이썬 3, 56 바이트

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

정말 서투른입니다. 각 잠재적 인 i-th 루트는 정수를 반올림하고 거듭 제곱을 취하여 i원래와 같은지 확인 하여 정수를 제공 하는지 테스트합니다 .

부동 소수점은 다음과 같은 것을 제공하기 때문에 루트가 정수인지 직접 확인하는 것은 까다 롭습니다 64**(1/3) == 3.9999999999999996. 정수로 반올림하면 전력을 가져가 원래 값으로 돌아가는지 확인할 수 있습니다. 이것을 제안 해 주신 1 ypercube에게 감사합니다.

feersum은 더 짧고 영리한 솔루션을 제공 합니다. 당신은 모두 정말로 그것을 찬성해야합니다.

Pyth, 11 10 12 바이트

fsmqQ^dTSQSQ

가능한 모든 전력 조합을 확인합니다. 아주 느린.

CJam, 23 바이트

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

이것은의 주요 인수 분해를 통해 작동합니다 n의 모든 지수의 제수의 교집합을 계산하여 작동합니다.

그것은 다른 솔루션 보다 조금 길지만 2 와 2 사이의 모든 정수에 대해 작동하고 즉시 완료 될 것으로 기대합니다 ⁽⁶³⁾ 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.

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)

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) 내의 표현식 .

편집 : 2 바이트를 면도하는 &&대신 게으른 논리를 사용 if하고 질문에 설명이 추가되었으므로 입력 프롬프트가 추가되었습니다. 이전에 입력이 저장된 것으로 가정n .

편집 2 : 그룹화를 피하여 2 바이트를 저장 ~~(.5+...)하도록 변경 되었습니다 .5+...|0.

편집 3 :var 4 바이트를 저장하기 위해 제거 되었습니다. 엄격하지 않은 모드에서는 허용됩니다.

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ᵐḋˢ⊇ᵛ×f10 바이트입니다.

젤리 , 6 바이트

ÆEg/ÆD

온라인으로 사용해보십시오!

    ÆD    The list of divisors of
ÆE        the exponents in the prime factorization of the input
   /      reduced by
  g       greatest common divisor.

05AB1E , 3 바이트

Ó¿Ñ

온라인으로 사용해보십시오!

관련없는 문자열의 젤리 응답 포트 .

Ó       # exponents in the prime factorization
 ¿      # gcd
  Ñ     # divisors

자바 스크립트 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는 부동 소수점 정확도가 끔찍합니다.

CJam, 20 바이트

ri_,1df+\1$fmL9fmO&p

입력 n의 경우 log _b n을 계산합니다. 모두 B 작거나 같은 N 및 정수 결과를 유지한다.

이것은 2 와 2 사이의 모든 정수에서 작동합니다. 9,999 . 실행 시간은 대략 O (n) 입니다.

CJam 통역사 에서 온라인으로 사용해보십시오 .

작동 원리

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.

루비, 50

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

화면에 인쇄합니다.

루비, 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 번째 근까지 계산됩니다. 이는 총 오버 킬이지만 무한 루프를 작성하는 가장 짧은 방법 인 것 같습니다.

Stax , 6 바이트

£ÅeÉåC

실행 및 디버깅

소인수 분해에서 지수의 gcd의 모든 제수입니다. 젤리 알고리즘과 동일합니다.

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)

루비 , 46 바이트

무차별 대입 솔루션. 자기 설명; 입력 용$n$모든 숫자 찾기 $e$ 일부를위한 곳 $b$, $b^e=n$.

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

온라인으로 사용해보십시오!

C # (Visual C # 대화 형 컴파일러) , 93 바이트

g=n=>Enumerable.Range(1,n);
f=n=>g(n).SelectMany(x=>g(n).Where(y=>(Math.Pow(x,y)==n))).Reverse()

온라인으로 사용해보십시오!

Japt , 10 바이트

õ
f@mpX øN

시도 해봐

õ            :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