आत्म-निहित शक्तियाँ

13

पूर्णांक को देखते हुए n, सबसे छोटे एक्सपोनेंट को e1 से अधिक आउटपुट करता है n^eजिसमें nएक विकल्प के रूप में शामिल है ।

उदाहरण के लिए, के लिए 25, उत्तर होना चाहिए 2, के रूप में 25 ^ 2 = 625, जिसमें 25एक विकल्प के रूप में शामिल है , लेकिन के लिए जवाब 13होना चाहिए 10, के रूप में 13 ^ 10 = 137858491849, इसलिए 10सबसे कम प्रतिपादक है जिसके लिए परिणाम 13एक विकल्प के रूप में शामिल है ।

नियम

  • मानक I / O नियम
  • मानक खामियां लागू होती हैं
  • बाइट्स में सबसे छोटा कोड जीतता है
  • n हमेशा से एक पूर्णांक होगा 0

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

1 => 2   (1 ^ 2 = 1)
2 => 5   (2 ^ 5 = 32)
3 => 5   (3 ^ 5 = 243)
4 => 3   (4 ^ 3 = 64)
5 => 2   (5 ^ 2 = 25)
6 => 2   (6 ^ 2 = 36)
7 => 5   (7 ^ 5 = 16807)
8 => 5   (8 ^ 5 = 32768)
9 => 3   (9 ^ 3 = 729)
10 => 2  (10 ^ 2 = 100)
11 => 11 (11 ^ 11 = 285311670611)
12 => 14 (12 ^ 14 = 1283918464548864)
13 => 10 (13 ^ 10 = 137858491849)
14 => 8  (14 ^ 8 = 1475789056)
15 => 26 (15 ^ 26 = 3787675244106352329254150390625)
16 => 6  (16 ^ 6 = 16777216)
17 => 17 (17 ^ 17 = 827240261886336764177)
18 => 5  (18 ^ 5 = 1889568)
19 => 11 (19 ^ 11 = 116490258898219)
20 => 5  (20 ^ 5 = 3200000)
25 => 2  (25 ^ 2 = 625)
30 => 5  (30 ^ 5 = 24300000)
35 => 10 (35 ^ 10 = 2758547353515625)
40 => 3  (40 ^ 3 = 64000)
45 => 5  (45 ^ 5 = 184528125)
50 => 2  (50 ^ 2 = 2500)
55 => 11 (55 ^ 11 = 13931233916552734375)
60 => 2  (60 ^ 2 = 3600)
65 => 17 (65 ^ 17 = 6599743590836592050933837890625)
70 => 5  (70 ^ 5 = 1680700000)
75 => 3  (75 ^ 3 = 421875)
80 => 5  (80 ^ 5 = 3276800000)
85 => 22 (85 ^ 22 = 2800376120856162211833149645328521728515625)
90 => 3  (90 ^ 3 = 729000)
95 => 13 (95 ^ 13 = 51334208327950511474609375)
100 => 2 (100 ^ 2 = 10000)

पहले 1000 उत्तरों को उत्पन्न करने के लिए पायथन लिपि

code-golf  number 
— Skidsdev
स्रोत
— स्किड्सदेव
— झबरा

जवाबों:

4

आर , 69 44 बाइट्स

function(n,i=2){while(!grepl(n,n^i))i=i+1;i}

अनाम फ़ंक्शन। बिगज में परिवर्तित iहोने पर बड़े पैमाने पर काम करता nहै (TIO देखें)। मुझे कुछ Giuseppe और digEmAll सिखाने के लिए धन्यवाद!

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

— बीएलटी
स्रोत
61 बाइट्स - आपके पास एक अतिरिक्त स्थान था n, ?n^iऔर डिफ़ॉल्ट रूप pasteसे कनवर्ट करता है character:-)
— Giuseppe
56 बाइट्स - वापसी iपर्याप्त होनी चाहिए।
— गिउसेप्पे
2
44 बाइट्स पेस्ट आवश्यक नहीं है, grepl डिफ़ॉल्ट रूप से चरित्र में कनवर्ट करता है :)
— digEmAll
समस्या यह है कि यह "दोषपूर्ण" है जब फ्लोटिंग पॉइंट सटीकता की वजह से एक्सपोर्टर बड़े हो जाते हैं और तथ्य यह है कि बड़ी संख्या को वैज्ञानिक संकेतन में स्ट्रिंग में बदल दिया जाता है। उदाहरण के लिए 15 रिटर्न 17 जबकि यह 26 होना चाहिए। तो, सैद्धांतिक रूप से यह काम करता है, लेकिन व्यवहार में हमें बिग
— इंटेगर
1
BigInt के लिए @digEmAll आप इनपुट को बलपूर्वक बड़ा कर सकते हैं जैसे कि GZ से BigZ की तरह और यह अभी भी काम करना चाहिए, संभवत: iएक बड़ेZ के रूप में अच्छी तरह से बदलने के लिए
— Giuseppe
3

पायथन 2 , 42 41 बाइट्स

-1 बाइट धन्यवाद अर्जन जोहान्सन ( सीधे वापस लौटते हुए y)

f=lambda x,y=2:y*(`x`in`x**y`)or f(x,y+1)

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

स्पष्टीकरण / Ungolfed

2,3... से पुनरावर्ती समारोह की कोशिश ... जब तक हम सफल नहीं होते:

# Start recursion with y=2
def f(x,y=2):
    # If we succeed, we arrived at the desired y
    if `x` in `x**y`:
        return y
    # Else we try with next y
    else:
        return f(x, y+1)

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

— ბიმო
स्रोत
1
— अर्जन जोहान्सन
@ IrjanJohansen: अजीब, मुझे लगा कि मैंने कोशिश की है, बिल्कुल यकीन नहीं है कि मैं क्या याद किया। आपका बहुत बहुत धन्यवाद!
— 22
मुझे एक स्थान से बचने के लिए गुणन को स्वैप करना पड़ा, शायद यह वही था?
— अर्जन जोहान्सन २ '’
@ WasrjanJohansen: शायद यही था, हाँ।
— ბიმო
3

जावास्क्रिप्ट (ES6 / Node.js),  41  40 बाइट्स

@ बग्घी को 1 बाइट धन्यवाद दिया

एक नंबर के रूप में इनपुट लेता है ( n<15 लिए काम करता है ) या एक BigInt शाब्दिक।

n=>(g=x=>`${x*=n}`.match(n)?2:-~g(x))(n)

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

— Arnauld
स्रोत
1
— झबरा
@ शैगी आपको बड़े पूर्णांक का उपयोग करने की आवश्यकता है, अन्यथा यह कुछ परीक्षण मामलों में सही उत्तर नहीं देगा। अंत में इसका समान बाइटकाउंट n=>(g=x=>$ {x * = n} है.match(n)?2n:-~g(x))(n)
— लुइस फेलिप डी
1
@LuisfelipeDejesusMunoz, आम तौर पर हमें सटीक मुद्दों के बारे में चिंता करने की ज़रूरत नहीं है, लेकिन यह BigInf के साथ भी काम करेगा।
— झबरा
छोटी सी बात लेकिन अगर यह BigInt का उपयोग करता है तो शीर्षक जावास्क्रिप्ट (Node.js) नहीं होना चाहिए? ES6 अभी तक BigInt नहीं है।
— शायरु असकोतो
@ शायरूआसाकोतो आप सही कह रहे हैं। मेरा प्रारंभिक इरादा यह समझाने का था कि यह एक नंबर या एक BigInt के साथ काम करता है। अब स्पष्ट किया है।
— अरनौलद
3

एपीएल (डायलॉग यूनिकोड) , 25 23 17 बाइट्स

-2 बाइट्स का शुक्रिया @Erik the Outgolfer

-6 बाइट्स @ngn की बदौलत

कोड बनाने के लिए @ H.PWiz को धन्यवाद, कस्टम ⎕pp(प्रिंट सटीक) की आवश्यकता नहीं है

⊢⍟×⍣(∨/(⍕÷)⍷0⍕⊣)⍨

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

⊢⍟×⍣(∨/(⍕÷)⍷0⍕⊣)⍨
  ×⍣(          )⍨ generates a geometric progression by repeatedly multiplying the argument
                   by its original value
     ∨/(⍕÷)⍷0⍕⊣   the progression stops when this function, applied between the new and the
                   last old member, returns true
         ÷        the original argument (ratio between two consecutive members)
        ⍕         formatted as a string
           ⍷      occurrences within...
            0⍕    ...the formatted (with 0 digits after the decimal point)...
              ⊣   ...new member
     ∨/           are there any?
⊢⍟                use logarithm to determine what power of ⍵ we reached
— Quintec
स्रोत
यह 17 के लिए विफल रहता है क्योंकि यह 1717 ^ 14 = 1.6837782655940093E17 में मिलता है, लेकिन क्या सटीक उत्तर का समर्थन करना चाहिए idk
— user41805
@ Cowsquack मुझे सिर्फ मनमाने ढंग से समायोजित करना है⎕PP
— Quintec
ओह रुको, जो काम भी नहीं करेगा
— क्विंटेक
— निकोलगर्फ़
— ngn
2

एसएएस, 71 66 बाइट्स

संपादित करें: ;run;इनपुट के अंत तक निहित होने के कारण इसे अंत में हटा दिया गया ।

data a;input n;e=1;do until(find(cat(n**e),cat(n)));e+1;end;cards;

इनपुट डेटा को cards;बयान के बाद दर्ज किया जाता है , जैसे:

data a;input n;e=1;do until(find(cat(n**e),cat(n)));e+1;end;cards;
1
2
3
4
5
6
7
8
9
10
11
12
13
14

एक डेटासेट उत्पन्न करता है aजिसमें इनपुट nऔर आउटपुट होते हैं e।

यहाँ छवि विवरण दर्ज करें

— जोश एलर
स्रोत
यह एक फ़ंक्शन परिभाषा या समतुल्य प्रतीत होता है (मैं वास्तव में एक "मैक्रो" मानता हूं) इसका मतलब यह है कि इसे तर्कों के साथ बुलाया जाना चाहिए (यानी %p(n)) पूरी तरह से ठीक है, हालांकि आउटपुट इस बात पर निर्भर करता है कि macroएसएएस मूल्यों को वापस कर सकता है या नहीं । यदि वे वापस आ सकते हैं, तो "आउटपुट" परिणाम को वापस करके होना चाहिए, अन्यथा इसे मानक आउटपुट विधि द्वारा समर्थित होने पर इसका उत्पादन करना चाहिए
— स्काईड्सदेव
@Skidsdev प्रतिक्रिया के लिए धन्यवाद! एसएएस थोड़ा अजीब है; मैक्रोज़ वास्तव में कार्य नहीं कर रहे हैं, वे सिर्फ एक पाठ प्रतिस्थापन भाषा हैं जो संकलित होने पर 'वास्तविक' एसएएस कोड उत्पन्न करते हैं। मेरी नज़र इस बात पर थी कि कोडगुल्फ़ में अन्य लोगों ने एसएएस के लिए I / O कैसे किया है, और मैक्रो स्टेटमेंट से छुटकारा पाने के आधार पर मेरे उत्तर को संपादित किया है।
— जोश एलर
1

क्लीन , 99 बाइट्स

import StdEnv,Text,Data.Integer
$n=hd[p\\p<-[fromInt 2..]|indexOf(""<+n)(""<+prod(repeatn p n))>=0]

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

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

साफ , 64 बाइट्स

import StdEnv,Text
$n=hd[p\\p<-[2..]|indexOf(""<+n)(""<+n^p)>=0]

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

— Οurous
स्रोत
1

जावा (ओपनजेडके 8) , 84 बाइट्स

एक स्ट्रिंग के रूप में इनपुट लेता है जो संख्या का प्रतिनिधित्व करता है और एक इंट आउटपुट करता है।

अधिकांश बाइट्स BigDecimalबड़ी संख्या को संसाधित करने के लिए आवश्यक होने की क्रिया से आते हैं ।

n->{int i=1;while(!(new java.math.BigDecimal(n).pow(++i)+"").contains(n));return i;}

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

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

यह काफी सरल है, लेकिन मैं इसके बाद की व्याख्या के लिए स्पष्टीकरण शामिल करूंगा;

n->{                                    // Lamdba taking a String and returning an int
    int i=1;                            // Initialises the count
    while(!                             // Loops and increments until
        (new java.math.BigDecimal(n)    // Creates a new BigDecimal from the input n
            .pow(++i)+"")               // Raises it to the power of the current count
            .contains(n)                // If that contains the input, end the loop
    );
    return i;                           // Return the count
}
— ल्यूक स्टीवंस
स्रोत
0

चारकोल , 19 बाइट्स

Ｗ∨‹Ｌυ²¬№ＩΠυθ⊞υＩθＩＬυ

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। स्पष्टीकरण:

Ｗ∨‹Ｌυ²¬№ＩΠυθ⊞

सूची की लंबाई कम से कम 2 होने तक दोहराएं और इसके उत्पाद में इनपुट हो ...

⊞υＩθ

... पूर्णांक में इनपुट डाला और सूची में धकेल दिया।

ＩＬυ

सूची की लंबाई स्ट्रिंग और स्पष्ट रूप से मुद्रित करने के लिए रखें।

— नील
स्रोत
0

पायथन 3 , 63 58 बाइट्स

def f(n,e=2):
	while str(n)not in str(n**e):e+=1
	return e

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

Python2 शायद कम होगा, लेकिन मुझे 3 का उपयोग करना पसंद है। लैम्बडा के साथ आना मुश्किल है, लेकिन मैं कुछ चीजों की कोशिश कर रहा हूं।

— Gigaflop
स्रोत
मैं अजगर को नहीं जानता लेकिन, क्या यह लैम्ब्डा का उपयोग करने से कम नहीं है?
— लुइस फेलिप डी जीसस मुनोज
@LuisfelipeDejesusMunoz मैंने ऐसा करने की कोशिश शुरू कर दी, लेकिन IDLE ने लंबू whileमें नंगे होने की शिकायत की । शायद मैं कुछ और तरीके आजमा सकता हूँ ..
— गिगाफ्लॉप 20
शायद कुछ पुनरावर्ती कार्य?
— लुइस फेलिप डी जेउस मुनोज
2
eतर्क-सूची (यानी। def f(n,e=2)) में परिभाषित करना और n**eकुछ बाइट्स को बचाना चाहिए, पायथन 2 वास्तव में काफी कुछ बाइट्स को बचाएगा।
— ।
@LuisfelipeDejesusMunoz लम्बदास फ़ंक्शंस की तरह नहीं हैं। एक लैम्ब्डा के दाहिने हाथ की ओर एक एकल अभिव्यक्ति होना चाहिए, और फ्लो-कंट्रोल कमांड जैसे काम नहीं करता है forया whileनहीं।
— जेम्स
0

मठगोल्फ , 10 बाइट्स

ôkï⌠#k╧▼ï⌠

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

व्याख्या

यह बेहद बेकार लगता है, इनपुट को दो बार स्पष्ट रूप से पढ़ना, दो बार लूप काउंटर को बढ़ाना।

ô            start block of length 6
 k           read integer from input
  ï          index of current loop, or length of last loop
   ⌠         increment twice
    #        pop a, b : push(a**b)
     k       read integer from input
      ╧      pop a, b, a.contains(b)
       ▼     do while false with pop
        ï    index of current loop, or length of last loop
         ⌠   increment twice
— maxb
स्रोत
0

सी # (.NET कोर) , 104 89 बाइट्स

a=>{int i=2;while(!(System.Numerics.BigInteger.Pow(a,i)+"").Contains(a+""))i++;return i;}

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

-1 बाइट: लूप के लिए बदल गया जबकि ( स्काइड्सडे के लिए धन्यवाद )
-14 बाइट्स: कॉल के लिए गाली देने वाले सी # का अजीब स्ट्रोकToString()

मानक संख्या C # प्रकार (int, double, long, ulong, आदि) के रूप में C # ' BigInteger लाइब्रेरी का उपयोग करने की आवश्यकता है , कुछ बड़ी संख्याओं (12, 15 और 17 सहित) के लिए विफल।

Ungolfed:

a => {
    int i = 2;                                          // initialize i

    while( !(System.Numerics.BigInteger.Pow(a,i) + "")  // n = a^i, convert to string
                                .Contains(a + ""))      // if n doesn't contain a
        i++;                                                // increment i

    return i;
}
— Meerkat
स्रोत
— स्किड्सदेव
0

पावरशेल (V3 +), 67 बाइट्स

function f{param($n)$i=1;do{}until([math]::pow($n,++$i)-match$n)$i}
— jyao
स्रोत
0

Oracle SQL, 68 बाइट्स

select max(level)+1 from dual,t connect by instr(power(x,level),x)=0

एक धारणा है कि स्रोत संख्या एक तालिका में संग्रहीत है t(x), उदा

with t as (select 95 x from dual)

एसक्यूएल * प्लस में टेस्ट करें

SQL> with t as (select 95 x from dual)
  2  select max(level)+1 from dual,t connect by instr(power(x,level),x)=0
  3  /

MAX(LEVEL)+1
------------
          13
— डॉ। वाई विट
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.