एक्सपोजर बिट की गणना बिट द्वारा करें

Question

आपका कार्य निम्न चरणों के साथ धीरे-धीरे घातांक की गणना करना है:

दो आदानों (इस उदाहरण में, 4 और 8) को देखते हुए, आपको समीकरण की गणना बिट द्वारा समीकरण बिट द्वारा करनी चाहिए। आप 4^8एक बड़ा आधार मूल्य (4) और एक छोटा घातांक (8) होगा। आप अधिक घातांक और विभाजन का उपयोग करके ऐसा कर सकते हैं। आप घातांक को मान X से विभाजित कर सकते हैं (बशर्ते कि X घातांक का एक मुख्य विभाजक है), और आधार मान ( B ) में बनाएँ B^X। उदाहरण के लिए, आप कर सकते हैं:

4^8 = (4 ^ 2)^(8 / 2) = 16^4

मैंने पिछले समीकरण में X को 2 से बदल दिया है।

आप 16^4फिर से इसे और सरल बना सकते हैं X = 2:

16^4 = (16 ^ 2)^(4 / 2) = 256^2

और फिर अंत में एक संख्या (फिर से, X = 2) की गणना करें :

256^2 = (256 ^ 2)^(2 / 2) = 65536^1 = 65536

इसलिए,

4^8 = 16^4 = 256^2 = 65536

यह वह आउटपुट है जो आपको देना चाहिए। आउटपुट सेपरेटर थोड़ा लचीला होता है, उदाहरण के लिए, आप समीकरणों को अलग-अलग न्यूलाइन या स्पेस के बजाय अलग कर सकते हैं =। या, आप उन्हें एक सूची में डाल सकते हैं (लेकिन आपको ^विभाजक के रूप में एक अंक या वर्ण का उपयोग नहीं करना चाहिए )।

जैसा कि मार्टिन एंडर ने बताया, ^यह भी लचीला है। उदाहरण के लिए, आप आउटपुट में [A, B]या A**Bइसके बजाय उपयोग कर सकते हैं A^B।

X केवल प्रधान हो सकता है, जिसका अर्थ है कि आप X = 8समाधान के लिए सीधे प्राप्त करने के लिए उपयोग नहीं कर सकते हैं, और X के मान केवल दूसरे इनपुट (घातांक) के प्रमुख कारक होंगे।

उदाहरण:

(input) -> (output)
4^8 -> 4^8=16^4=256^2=65536
5^11 -> 5^11=48828125
2^15 -> 2^15=32^3=32768 (2^15=8^5=32768 is also a valid output)

ध्यान रखें कि इनपुट प्रारूप भी लचीला है (जैसे आप ले सकते हैं A \n Bया A Bइसके बजाय A^B। जाहिर है, यह एक समस्या नहीं होगी यदि आप दो तर्कों को लेते हुए एक फ़ंक्शन लिखते हैं।

दूसरे उदाहरण में, हम गणना करने के लिए सीधे जाते हैं, चूंकि 11प्रधान है और हम कोई और कदम नहीं उठा सकते हैं।

आप इसे हल करने के लिए एक प्रोग्राम या फ़ंक्शन लिख सकते हैं, और आप क्रमशः मूल्य को प्रिंट या वापस कर सकते हैं।

जैसा कि यह कोड-गोल्फ है , वह सबसे छोटा कोड जीतता है!

Comments

@JonathanAllan मैं वह भी देख रहा था। 32^3और 8^15512 भी नहीं हैं।

— यति

@JonathanAllan को

— स्पॉट

@ ओएक्सएक्स आखिरी के रूप में मुद्रित किया जा सकता है x^1?

— रॉड

@ नहीं, यह नहीं हो सकता। वह मूर्खतापूर्ण होगा।

— ओकेक्स

Answer 1

जेली , 16 बाइट्स

*Uż:Ṫ
ÆfṪ1;×\ç@€

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

इनपुट एक एकल सूची है [base, exponent]। निम्न मानदंड लिंक का वापसी मूल्य सूचियों की एक सूची है, एक पूर्ण कार्यक्रम के रूप में उस सूची का प्रतिनिधित्व मुद्रित होता है, उदाहरण के लिए 2^15=8^5=32768^1इस प्रकार मुद्रित किया जाता है:

[[2, 15], [8, 5], [32768, 1]]

कैसे?

ÆfṪ1;×\ç@€ - Main link: [base, exponent]            e.g.     [4,12]
Æf         - prime factorization array (vectorises)      [[2,2],[2,2,3]]
  Ṫ        - tail (tailing first costs bytes)                   [2,2,3]
   1;      - 1 concatenated with the result                   [1,2,2,3]
     ×\    - reduce with multiplication  (make factors)       [1,2,4,12]
       ç@€ - call last link (1) as a dyad for €ach with reversed @rguments
           - implicit print if running as a full program

*Uż:Ṫ - Link 1, an entry in the equality: [base, exponent], factor  e.g. [4, 12], 4
*     - exponentiate (vectorises) : [base ^ factor, exponent ^ factor]   [256, 20736]
 U    - upend                                                            [20736, 256]
   :  - integer division: [base // factor, exponent // factor]           [1, 3]
  ż   - zip                                                        [[20736, 1], [256, 3]]
    Ṫ - tail                                                                    [256, 3]
                                               ...i.e at a factor of 4: 4 ^ 12 = 256 ^ 3

---

यह एक अनुगामी द्वारा 2 बाइट्स के लिए ग्रिड के रूप में स्वरूपित किया जा सकता है µG, जैसे:

    2    15
    8     5
32768     1

... या पूरी तरह से स्वरूपित, सहित ट्रिमिंग ^1, 9 के लिए, एक अनुगामी के साथ j€”^j”=ṖṖ, जैसे:

2^15=8^5=32768

Answer 2

जावास्क्रिप्ट (ईएस 7), 55 बाइट्स

f=(a,b,c=2)=>b>1?b%c?f(a,b,c+1):a+['^'+b,f(a**c,b/c)]:a

( ) के ,स्थान पर उपयोग करता है ।=2^15,8^5,32768

परीक्षण के मामलों

f=(a,b,c=2)=>b>1?b%c?f(a,b,c+1):a+['^'+b,f(Math.pow(a,c),b/c)]:a
g=(a,b)=>console.log(`f(${a}, ${b}):`,f(a,b))

g(4,8)
g(5,11)
g(2,15)

नोट: क्रॉस-ब्राउज़र संगतता के Math.powबजाय स्निपेट का उपयोग करता **है।

Comments

फ़ायरफ़ॉक्स 54 रात का निर्माण ES7 100% का समर्थन करता है! : O kangax.github.io/compat-table/es2016plus/#firefox54

— mbomb007

Answer 3

05AB1E , 23 22 17 बाइट्स

लचीले आउटपुट प्रारूप को नोट करके 5 बाइट्स सहेजे गए।

Ò©gƒ²®N¹‚£P`Šm‚Rˆ

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

व्याख्या

के लिए उदाहरण 2^15

Ò©                 # calculate primefactors of exponent and store in register
                   # STACK: [3,5]
  g                # length
                   # STACK: 2
   ƒ               # for N in range[0 ... len(primefactors)] do
    ²              # push base
                   # STACK: 2
     ®             # push primefactors
                   # STACK: 2, [3,5]
      N¹‚£         # split into 2 parts where the first is N items long
                   # 1st, 2nd, 3rd iteration: [[], [3, 5]] / [[3], [5]] / [[3, 5], []]
          P        # reduce each by product
                   # STACK 1st iteration: 2, [1,15]
           `       # split list to items on stack
                   # STACK 1st iteration: 2, 1, 15
            Š      # move down the current exponent
                   # STACK 1st iteration: 15, 2, 1
             m     # raise base to the rest of the full exponent
                   # STACK 1st iteration: 15, 2
              ‚    # pair them up
                   # STACK 1st iteration: [15,2]
               R   # reverse the pair
                   # STACK 1st iteration: [2,15]
                ˆ  # store it in global list
                   # print global list at the end of execution

Answer 4

सी, 125 123 + 4 ( -lm) = 129 127 बाइट्स

i;f(n,m)double n;{if(m-1){printf("%.0f^%d=",n,m);for(i=2;i<=m;i++)if(!(m%i))return f(pow(n,i),m/i);}else printf("%.0f",n);}

एक डबल और एक पूर्णांक लेता है।

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

Answer 5

हास्केल, 64 बाइट्स

a#b|v:_<-[x|x<-[2..b],mod b x<1]=[a,b]:(a^v)#div b v|1<2=[[a^b]]

प्रयोग उदाहरण: 2 # 32-> [[2,32],[4,16],[16,8],[256,4],[65536,2],[4294967296]]। इसे ऑनलाइन आज़माएं! ।

यह काम किस प्रकार करता है:

a#b                       -- take input numbers a and b
   |                      -- if
      [x|x<-[2..b]   ]    --  the list of all x drawn from [2..b]
              ,mod b x<1  --  where x divides b
    v:_<-                 --  has at least one element (bind the first to v)
       = [a,b]:           --  the the result is the [a,b] followed by
          (a^v)#div b v   --  a recursive call with parameters (a^v) and (div b v)
   |1<2                   -- else (i.e. no divisors of b)
       = [[a^b]]          --  the result is the singleton list of a singleton list
                          --    of a^b

Answer 6

बैश + जीएनयू उपयोगिताओं, 82

echo $1^$2
f=`factor $2|egrep -o "\S+$"`
((m=$2/f,r=$1**f,m-1))&&$0 $r $m||echo $r

पुनरावर्ती खोल स्क्रिप्ट। यह TIO में काम नहीं करता है, लेकिन एक स्क्रिप्ट के रूप में सहेजे जाने और निष्पादित होने पर ठीक चलता है:

$ ./expbit2.sh 4 8
4^8
16^4
256^2
65536
$ ./expbit2.sh 5 11
5^11
48828125
$ ./expbit2.sh 2 15
2^15
32^3
32768
$