गैर तुच्छ शक्तियाँ

Question

गैर-तुच्छ शक्तियों को मुद्रित करने के लिए सबसे छोटा प्रोग्राम लिखें 12 2 ^ 12 क्रम में

गैर-तुच्छ शक्ति का अर्थ है आधार और प्रतिपादक> 1

प्रमुख व्हाट्सएप वैकल्पिक है
जब कई समाधान होते हैं, तो आदेश महत्वपूर्ण नहीं होता है, इसलिए

16 = 4^2, 2^4 ठीक है

नमूना उत्पादन:

      4 = 2^2
      8 = 2^3
      9 = 3^2
     16 = 2^4, 4^2
     25 = 5^2
     27 = 3^3
     32 = 2^5
     36 = 6^2
     49 = 7^2
     64 = 2^6, 4^3, 8^2
     81 = 3^4, 9^2
    100 = 10^2
    121 = 11^2
    125 = 5^3
    128 = 2^7
    144 = 12^2
    169 = 13^2
    196 = 14^2
    216 = 6^3
    225 = 15^2
    243 = 3^5
    256 = 2^8, 4^4, 16^2
    289 = 17^2
    324 = 18^2
    343 = 7^3
    361 = 19^2
    400 = 20^2
    441 = 21^2
    484 = 22^2
    512 = 2^9, 8^3
    529 = 23^2
    576 = 24^2
    625 = 5^4, 25^2
    676 = 26^2
    729 = 3^6, 9^3, 27^2
    784 = 28^2
    841 = 29^2
    900 = 30^2
    961 = 31^2
   1000 = 10^3
   1024 = 2^10, 4^5, 32^2
   1089 = 33^2
   1156 = 34^2
   1225 = 35^2
   1296 = 6^4, 36^2
   1331 = 11^3
   1369 = 37^2
   1444 = 38^2
   1521 = 39^2
   1600 = 40^2
   1681 = 41^2
   1728 = 12^3
   1764 = 42^2
   1849 = 43^2
   1936 = 44^2
   2025 = 45^2
   2048 = 2^11
   2116 = 46^2
   2187 = 3^7
   2197 = 13^3
   2209 = 47^2
   2304 = 48^2
   2401 = 7^4, 49^2
   2500 = 50^2
   2601 = 51^2
   2704 = 52^2
   2744 = 14^3
   2809 = 53^2
   2916 = 54^2
   3025 = 55^2
   3125 = 5^5
   3136 = 56^2
   3249 = 57^2
   3364 = 58^2
   3375 = 15^3
   3481 = 59^2
   3600 = 60^2
   3721 = 61^2
   3844 = 62^2
   3969 = 63^2
   4096 = 2^12, 4^6, 8^4, 16^3, 64^2

Comments

यहां बहुत सारी शक्तियां गायब हैं; 21 ^ 3 आदि के बारे में क्या? "गैर-तुच्छ शक्तियों" की आपकी परिभाषा क्या है?

— हॉलवबो

क्या कई समाधान बाईं ओर एक ही संख्या के साथ मुद्रित करना संभव है, अगर कई समाधान हैं?

— फ्युजएक्सएक्सएल

@hallvabo, आज सुबह कॉफी नहीं थी। अब इसे ठीक कर लें

— gnibbler

@FUxxxxl, आपको एक ही लाइन पर कई सॉल्यूशन डालने होंगे, हालाँकि ब्याज के लिए कृपया वैकल्पिक संस्करण भी प्रस्तुत करें, यदि आवश्यकता आपकी भाषा में बहुत बड़ा

— बदलाव लाती है

+1 जब मुझे अधिक वोट मिलते हैं :-)

— हॉल्वैबो

Answer 1

रूबी 1.9, 112 111 99 वर्ण

4097.times{|x|s=[]
2.upto(64){|a|2.upto(12){|b|a**b==x&&s<<[a,b]*?^}}
puts [x,s*", "]*" = "if s[0]}

मेरे सिस्टम पर पूर्ण होने में लगभग 0.8 सेकंड लगते हैं। एक तेज़ समाधान 111 वर्ण लंबा है:

h={};(2..64).map{|a|(2..12).map{|b|a**b<4097&&(h[a**b]||=[])<<[a,b]*?^}}
puts h.sort.map{|a,b|[a,b*", "]*" = "}

Answer 2

अजगर, 113

आर = रेंज
आर में k (4097) के लिए:
 v = ',' .join (`i` + '^' + 'j`for i in R (2,65) in j के लिए R (2,13) ​​यदि i ** j == k)
 यदि v: प्रिंट k, '=', v

इसे पूरा करने में कुछ सेकंड लगते हैं।
सबसे तेज़ लूप से बचने के लिए एक शब्दकोश का उपयोग करते हुए एक तेज़ (148 चार्ट) संस्करण, ~ 0.01 सेकंड में चलता है:

आर = रेंज (2,65)
पी = {}
मैं में आर के लिए:
 जे में आर के लिए:
    यदि i ** j <4097: p [i ** j] = p.get (i ** j, []) + [`i` + '^' + 'j`]
k के लिए, v को सॉर्ट किया गया (p.items ()): प्रिंट k, '=', ',' .join (v)।

Comments

मुझे पूरा यकीन है कि आउटपुट के लिए बराबरी के संकेत की आवश्यकता है, हालाँकि इससे कोड साइज़ में बदलाव नहीं होना चाहिए।

— केविन ब्राउन

जब मैंने (वैकल्पिक) प्रमुख व्हाट्सएप से छुटकारा पाया, तो मैंने गलती से इसे हटा दिया। ठीक कर दिया!

— हॉल्वैबो

Answer 3

विंडोज पॉवरशेल, 102

शुरुआती कोड के लिए वेंटरो की मदद से।

$OFS=', '
4..4KB|%{$x=$_
if($s=2..64|%{$a=$_
2..12|?{[math]::pow($a,$_)-eq$x}|%{"$a^$_"}}){"$x = $s"}}

Answer 4

इंटरएक्टिव जे, 118 101 98

3 :0"0 i.4097
if.#l=.":2j2+63(<.@%~j.|)I.y=,^/~2+i.63
do.echo(":y),' = ',l rplc j`^,' ';', 'end.
)

(अंतिम नई पंक्ति अनावश्यक)

प्रस्तुति के लिए अभी भी बहुत सारे कोड ...

नोट: सिद्धांत रूप में बदल रहा है 63और 63करने के लिए yऔर y2 अधिक बाइट्स बचाता है, बल्कि उस संस्करण स्मृति के चरम राशि का उपयोग करता है।

यादृच्छिक द्वारा संपादित।

Comments

[जगह] j [backtick] ^, ''; ',' के बजाय 'j';'^';' ';', '3 बाइट्स सेव करता है। (इसे प्रारूपण करते हुए ...)

— यादृच्छिक

@randomra आपको संपादित अधिकार मिल गए हैं; कृपया आगे जाएं! (मुझे अपने वर्तमान सेटअप के साथ सत्यापित करने के लिए J वाला बॉक्स नहीं मिल रहा है, और मैं जल्दबाज़ी में हूँ)। यह जे को शो का सबसे अच्छा हिस्सा बना देगा, इसे न दिखाना एक अफ़सोस की बात होगी! :-)

— जेबी

Answer 5

बैश, 138 चार्ट

i=2;j=1
f(){((v>4096))&&((j=1,++i))
a[$v]+="$i^$j, "
((v=i**++j,i<65))&&f
}
f
f(){
echo $j = ${a[$j]}
((j++<v))&&f
}
f|sed '/=$/d;s/.$//'

संपादित करता

• (169: 155) 2 forए के लिए while।
• (155: 148) के साथ जोड़ें+=
• (148: 147)while जे के पुन: उपयोग के साथ आउटपुट
• (147: 142) खाली लाइनों को हटाने के लिए sed का उपयोग करें
• (142: 137) डाल vमें (())4096 (अंतिम मान) के लिए, का उपयोग करें v
• (137: 134) सेड कोट्स को हटा दें, (())एक्सप्रेशन से जुड़ें
• (134: 132) लूप को पुनरावर्ती कार्यों के साथ बदलें
• (132: 142) अल्पविराम भूल गए ,:(
• (142: 138) अपडेट से थक गए: पी

Answer 6

PHP, 138 अक्षर - आउटपुट

<?for($b=1;++$b<65;)for($e=1;++$e<13;)if(4097>$f=pow($b,$e))$p[$f][]="$b^$e";ksort($p);foreach($p as$n=>$c)echo"$n = ".join($c,", ")."\n";

Ungolfed

<?php

// Array of combinations

$powers = array();

// Loop through every base from 2 to 64, as 64 is the highest you can go

for($base = 2; $base < 65; $base++){

    // Loop through all powers from 2 to 12, as 12 is the maximum

    for($power = 2; $power < 13; $power++){

        // Calculate the power

        $end = pow($base, $power);

        // Kill the loop if the result is too high

        if($end > 4096){
            break;
        }

        // Add the combination if the result is within limits

        $powers[$end][] = $base."^".$power;
    }
}

// Sort the powers by the total amount

ksort($powers);

// Output the powers in the correct format

foreach($powers as $number => $combinations){
    echo $number." = ".implode($combinations, ", ")."\n";
}

Answer 7

पायथन, 127 वर्ण

F={}
for i in range(693):a,b=i/11+2,i%11+2;F[a**b]=F.get(a**b,'')+', %d^%d'%(a,b)
for k in sorted(F)[:81]:print k,'=',F[k][2:]

Answer 8

मैथेमेटिका, 152 बाइट

Print/@Cases[Range@4096,n_/;(2<=##&&##==##&)@@(f=#2&@@@FactorInteger@#&)@n:>{n,Row[{n^(1/#),#}~Row~"^"&/@Reverse@Rest@Divisors@#,", "]&@@f@n}~Row~" = "]

यह शर्मनाक रूप से लंबा हो गया। आउटपुट स्वरूपण पर 25 अक्षर जैसे कुछ खर्च किए जाते हैं। वास्तविक कोड काफी सरल है: उन संख्याओं को फ़िल्टर करें जहां प्राइम फैक्टरशिप में सभी एक्सपोर्टर समान हैं। फिर, उनमें से प्रत्येक के लिए प्रतिपादक के प्रत्येक विभाजक के लिए एक परिणाम उत्पन्न होता है (1 को छोड़कर, स्वयं सहित)।

Answer 9

सी (589 बाइट्स)

int pow(int a,int b){
   int res = 1;
   while(b>0){
    while(b%2 == 0){
        a *= a; b/=2;
    }
    b--;
    res = res*a;
}
return res;
}
char s[99],t[9];

int main(){
   int N,T,a,i,f,e,n;
  for(n = 2; n <= 1<<12; n++){
      strcpy(s,"");
      T = N = n;
      f = 0;
      int sqt = sqrt(N)+1;
      for(i = 2; i <= sqt; i++){
         for(e=0;0==N%i;e++,N/=i);
           for(a = i; e > 1;e = e%2?(e+1)/2:e/2)
              for(a=i;a<T;pow(a,e)==T?f++?0:printf("%d =",T),sprintf(t,", %d^%d",a,e),strcat(s,t):0,a*=i);
    }
    f?puts(s+1):0;
   }
   return 0;
 }

मैंने यह भी गवारा नहीं किया कि यह दृष्टिकोण सबसे अच्छा नहीं है, लेकिन अभी तक काफी तेजी से विचारधारा में सटीक 0s का उत्पादन करता है ।

Answer 10

OCaml + बैटरियों, 220 206 158 156 वर्ण

सबसे अच्छे समाधानों से संकेत लेना:

Printf.(iter(fun x->match
String.join", "[?List:sprintf"%d^%d"b e|b<-2--64;e<-2--12;float
x=float b**float e?]with""->()|s->printf"%5d = %s\n"x s)(4--4096))

(लाइनों को छोटा रखने के लिए महत्वपूर्ण व्हाट्सएप पर लाइन समाप्त होती है।) एक तेज़ लेकिन लंबा संस्करण जो उन्हें परीक्षण करने के बजाय शक्तियां उत्पन्न करता है:

Printf.(List.(iter(fun l->printf"%5d = %s\n"(fst(hd l))(String.join", "(map
snd l)))(group(fun(x,_)(y,_)->x-y)[?List:truncate p,sprintf"%d^%d"b
e|b<-2--64;e<-2--12;p<-List:[float b**float e];p<=4096.?])))

Answer 11

हास्केल, 146 वर्ण

c[a]=a
c(a:z)=a++", "++c z
n#[]=""
n#s=shows n$" = "++c s++"\n"
main=putStr$(\n->n#[shows x$'^':show y|x<-[2..64],y<-[2..12],x^y==n])=<<[4..4096]

Answer 12

जावास्क्रिप्ट, 160

o={}
i=2
s=''
n=4097
for(k=4;k<n;k=++i*i)for(j=2;k<n;k*=i)
{a=i+'^'+j
if(o[k])o[k]+=', '+a
else o[k]=a
j++}for(i=0;i<n;i++)if(o[i])s+='\n'+i+' = '+o[i]
alert(s)

194

o={},i=2,s='',n=4096
for(k=4;k<=n;k=i*i){for(j=2;k<=n;k*=i){o[k]=o[k]||[]
o[k].push(i+'^'+j)
j++}i++}
for(i=0;i<n;i++){if(o[i]){s+='\n'+i+' = '
for(j in o[i])s+=(j==0?'':', ')+o[i][j]}}
alert(s)

Comments

पीछे लेना; कृपया टिप्पणियों के रूप में गोल्फ सुझाव पोस्ट करें, संपादन नहीं।

— lirtosiast

Answer 13

पायथ, 39 बाइट्स

jm++^Fhd" = "j", "jL\^d<.g^Fk^tS64 2 81

इसे यहाँ ऑनलाइन आज़माएँ ।

jm++^Fhd" = "j", "jL\^d<.g^Fk^tS64 2 81
                               S64       [1-64]
                              t          Discard first element
                             ^     2     Cartesian product of the above with itself
                        .g               Group the pairs, as k, using:
                          ^Fk              [a,b] -> a^b
                       <             81  Take the first 81 results of the above (those where exponential <= 4096)
 m                                       Map the remaining groups, as d, using:
                  jL\^d                    Join each pair in d on "^"
             j", "                         Join on ", "
  +     " = "                              Prepend " = "
   +^Fhd                                   Prepend the result of the exponent of one of the pairs
j                                        Join the result of the above on newlines, implicit print

यदि आउटपुट स्वरूप लचीला है, तो रिक्त स्थान की आवश्यकता को दूर करने के लिए -5 बाइट्स के " = "साथ \=और उसके ", "साथ प्रतिस्थापित करने के लिए\,

Answer 14

हास्केल, 131

p[]=return()
p((x,y,z):s)=do print$show x++" = "++show y++"^"++show z;p s
main=p [(x,y,z)|x<-[2..2^12],y<-[2..x],z<-[2..x],x==y^z]

Comments

समान मान रखने वाली शक्तियां एक ही पंक्ति पर होने वाली हैं

— माउंटनवार्क

Answer 15

जावास्क्रिप्ट, 148 चार्ट

s=''
for(i=2;i<4097;i++){q=''
for(a=2;a<65;a++)for(b=2;b<13;b++)if(Math.pow(a,b)==i)q+=a+'^'+b+', '
if(q)s+=i+' = '+q.slice(0,-2)+"\n"}alert(s)

Answer 16

C 184

किसी भी सी संकलक के साथ (चेतावनी के साथ) संकलन करना चाहिए

char*l[5000],*t=l+4100,*u;
main(b,e,r) 
{
  for(;++b<65;)
    for(e=2,r=b;(r*=b)<4100;l[r]=u)
      t+=1+sprintf(u=t,"%s, %d^%d",l[r]?l[r]:"",b,e++);
  for(r=1;++r<4097;)
    l[r]&&printf("%d =%s\n",r,l[r]+1);
}

Answer 17

पायथ, 55 वर्ण

=Tr2 64V^2 12JYFZTFbTIqN^ZbaJj\^[Zb))))IJjk[Nd\=dj", "J

पायथ का उपयोग करते हुए मेरा पहली बार, इसलिए यह शायद बेहतर हो सकता है। यह एक क्रूर बल है जो 64 ^ 64 तक की जांच करता है, इस प्रकार यह काफी धीमा है। आप केवल 64 ^ 12 तक की जाँच करके समय बचा सकते हैं, लेकिन इसके लिए एक बाइट खर्च होगी।

Answer 18

जावास्क्रिप्ट (ईएस 6) 134 127

संपादित संशोधित, बगफिक्स और छोटा संपादित करें संपादित करें 2 कुछ शोध के बाद, मुझे एहसास हुआ कि कालानुक्रमिक कारणों से यह उत्तर अमान्य था। सवाल भविष्यवाणी करता हैarrow functions वर्षों से से है।

उस सभी ने कहा, अन्य जेएस उत्तर रास्ते बहुत जटिल हैं

/* for TEST:redefine console.log */ console.log=x=>O.innerHTML+=x+'\n';

for(l=[],b=1;++b<65;)for(e=2,r=b;(r*=b)<4197;)(l[r]=l[r]||[]).push(b+'^'+e++);l.some(function(v,i){console.log(i+' = '+v.join(', '))})

<pre id=O></pre>

Comments

यदि आप '=' स्वरूपण के बारे में बहुत अधिक परवाह नहीं करते हैं, तो आप 121 बाइट्स को कम कर सकते हैं: (l = [], b = 1; ++ b <65;) के लिए (e = 2, r = b; ; (आर * = ख) <4197;) (एल [आर] = एल [आर] || []) धक्का (ख + '^' + ई ++);। l.map ((V, i) => कंसोल। लॉग (i + '=' + v.join`, `))

— मामा फन रोल

@molarmanful प्रारूपण के बारे में सख्त आवश्यकताएं हैं

— edc65

ओह ठीक है ... कम से कम v.join भाग को बदलें। यह कम से कम बाइट की गिनती को 123 तक ले जा सकता है।

— मामा फन रोल

@molarmanful उस समय इस चुनौती (और यह उत्तर!) पोस्ट किए गए थे, किसी भी ब्राउज़र में टेम्पलेट स्ट्रिंग्स लागू नहीं किए गए थे: फ़ायरफ़ॉक्स पहले था - rel 34, dec 2014 पहले - फिर क्रोम, मार्च 2015। आप एक सुविधा का उपयोग नहीं कर सकते जो उपलब्ध थी। प्रश्न के 3 साल बाद

— edc65

ओह अच्छा ... मुझे नहीं पता था कि। मैं अभी एक हफ्ते पहले ES6 में आया था!

— मामा फन रोल

Answer 19

05AB1E , 36 बाइट्स

2žxŸãΣ`m}99£.γ`m}εн`m'=yε'^ý}„, ý)}»

मुझे लग रहा है कि थोड़ा अलग दृष्टिकोण का उपयोग करके इसे थोड़ा बेहतर किया जा सकता है।

इसे ऑनलाइन आज़माएं।

स्पष्टीकरण:

2žxŸ           # Create a list in the range [2,64]
    ã          # Create each possible pair by taking the cartesian product with itself
Σ`m}           # Sort these `a,b`-pairs by their result of `a ** b`
    99£        # Only leave the first 99 pairs
       .γ`m}   # And then group the `a,b`-pairs by their result of `a ** b`
ε              # Now map each list of pairs `y` to:
 н             #  Take the first pair of list `y`
  `m           #  Take the `a ** b` value
 '=           '#  Push character "=" to the stack
 yε            #  Inner map over the pairs of list `y`:
   '^ý        '#   Join each pair with a "^" delimiter
      }„, ý    #  After the inner map: join these strings with a ", " delimiter
 )             #  Wrap all values on the stack into a list
}»             # After the outer map: join every inner list by spaces,
               # and the outer list by newlines (and output the result implicitly)