Деякі числа, як-от, 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

Перекреслення не повинно спричинити проблем.

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]

Брут примушує всі комбінації основ у експонентах у [0, n-1], а підстав у [1, n].

Python 3, 56 байт

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

Це справді незграбно. Тестує, чи кожен потенційний i-корінь дає ціле число, округлюючи його, беручи на себе потужність iі перевіряючи, чи відповідає рівню оригіналу.

Безпосередня перевірка того, що корінь є цілою кількістю, є складним, оскільки плаваючі точки дають такі речі 64**(1/3) == 3.9999999999999996. Округлюючи його до цілого числа, давайте перевіримо, чи повертається потужність до початкового значення. Завдяки ypercube за те, що він запропонував це, заощаджуючи 1 байт.

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).

Редагувати: Використовували ледачу &&логіку замість того, ifщоб поголити 2 байти та додали запит на введення, оскільки питання додало уточнення. Раніше передбачалося, що вхід зберігається вn .

Редагувати 2: Змінено, ~~(.5+...)щоб .5+...|0зберегти два байти, уникаючи групування.

Правка 3: Видалено, varщоб зберегти 4 байти. У не строгому режимі це прийнятно.

Брахілог , 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 байт.

Желе , 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

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 має жахливу точність з плаваючою точкою.

CJam, 20 байт

ri_,1df+\1$fmL9fmO&p

Для введення n цей обчислює журнал _b n для всіх b, менший або рівний n, і зберігає цілі числа результатів.

Це має працювати для всіх цілих чисел від 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 обчислюється, що є загальним перевишкодом, але здавався найкоротшим способом написання нескінченного циклу.

Стакс , 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

Макрос для запуску 2x вище макросу (макрос c) через усі бази від 2 до нашого цільового числа

[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 # Interactive Compiler) , 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