41

चुनौती:

एक प्रोग्राम बनाएं जो एक सकारात्मक पूर्णांक को स्वीकार करता है और जांचता है कि क्या इसे (3 ^ x) -1 के रूप में लिखा जा सकता है, जहां एक्स एक और सकारात्मक पूर्णांक है ।

यदि यह हो सकता है, तो आउटपुट एक्स

यदि यह नहीं हो सकता है, आउटपुट -1 या झूठा बयान।

उदाहरण इनपुट / आउटपुट

इनपुट:

इसे (3 ^ 1) - 1 के रूप में लिखा जा सकता है, इसलिए हम x को आउटपुट करते हैं जो 1 है

आउटपुट:

इनपुट:

26 को (3 ^ 3) - 1 के रूप में लिखा जा सकता है, इसलिए हम आउटपुट x (3)

आउटपुट:

इनपुट:

1024 को (3 ^ x) - 1 के रूप में नहीं लिखा जा सकता है, इसलिए हम -1 आउटपुट करते हैं

आउटपुट:

-1

यह कोड-गोल्फ है इसलिए कम से कम बाइट्स जीतता है

गणितज्ञ, 21 16 बाइट्स

-1&@@Log[3,#+1]&

गणितज्ञ के प्रतीकात्मक अभिकलन का उपयोग करता है। यदि #+1तीन की शक्ति है तो Log[3,#+1]एक पूर्णांक परिणाम की गणना करेगा जो एक परमाणु मान है। अन्यथा हम जैसा है Log[#+1]/Log[3]वैसा ही प्राप्त करेंगे। चूंकि यह एक परमाणु मूल्य नहीं है, यह एक अभिव्यक्ति है जो हमेशा फॉर्म का होता है head[val1,val2,...]। इस मामले में यह वास्तव में कुछ ऐसा है Times[Power[Log[3], -1], Log[#+1]]।

हम परिणाम के लिए एक और फ़ंक्शन लागू करके दो मामलों के बीच अंतर करते हैं। वास्तव में क्या लागू होता है कि यह headएक अभिव्यक्ति के हिस्से को बदल देता है । चूंकि पूर्णांक परिणाम परमाणु होते हैं, उन पर किसी भी फ़ंक्शन को लागू करने से कुछ भी नहीं होता है। विशेष रूप से f @@ atom == atom।

हालांकि, दूसरे मामले में, सिर को प्रतिस्थापित किया जाता है। जिस फ़ंक्शन का हम उपयोग कर रहे हैं -1&वह एक साधारण फ़ंक्शन है जो इसके तर्कों और रिटर्न को अनदेखा करता है -1। इसलिए हमें -1&[Power[Log[3], -1], Log[#+1]]गैर-पूर्णांक मामलों में कुछ मिलता है , जो सीधे मूल्यांकन करता है -1। जादू के माध्यम से विशेष आवरण।

— मार्टिन एंडर
स्रोत

13

पायथन, 46 44 बाइट्स

lambda x:max(n*(3**n-1==x)for n in range(x))

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

इस मामले में, 0falsy मूल्य होगा। मेरे गलत आउटपुट को इंगित करने के लिए @ mbomb007 के साथ-साथ 2 बाइट्स कोई []बचत नहीं है ।

— nmjcman101
स्रोत

आप [n for n in range(x)if 3**n-1==x]-4 बाइट्स के लिए फिर से लिख सकते हैं , झूठी सूची के रूप में झूठी

— रॉड

फिक्स्ड, धन्यवाद! @ फिर यह वापस आ जाएगा [n] के बजाय n मुझे लगता है

— nmjcman101

@ nmjcman101 को समस्या नहीं होनी चाहिए

— रॉड

@Rod मैं अभी के लिए कल्पना करने के लिए सख्ती से पालन करना पसंद करूंगा

— nmjcman101

@Rod यदि किसी पूर्णांक की आउटपुटिंग आवश्यक है, तो आप इसे किसी सूची में तब तक आउटपुट नहीं कर सकते, जब तक कि विशेष रूप से OP इसे अनुमति नहीं देता।

— mbomb007

13

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

f x=last(-1:[i|i<-[1..x],3^i-1==x])

प्रयोग उदाहरण: f 26-> 3।

— nimi
स्रोत

पुनश्च: यह ऑनलाइन कोशिश करो! हास्केल का समर्थन करता है! (अच्छा जवाब btw!)

— निर्दोष

11

05AB1E , 7 बाइट्स

3IÝm<¹k

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

व्याख्या

3        # push 3 
 I       # push input
  Ý      # range [0 ... input]
   m     # 3^[0 ... input]
    <    # -1
     ¹k  # find index of input, return -1 if not found

— Emigna
स्रोत

05AB1E स्पष्ट रूप से आधार रूपांतरण में अच्छा है क्या यह वास्तव में सबसे अच्छा तरीका है?

— जैसन' ’

1

@ जासेन: आधार रूपांतरण के साथ मेरे प्रयास अब लंबे हो गए हैं। अगर इससे बेहतर कोई तरीका है तो मैं इसे नहीं देख रहा हूं। हालांकि मुझे गलत साबित करने के लिए स्वतंत्र महसूस करें :)

— Emigna

उचित रूप से, मैंने केवल भाषा का वर्णन पढ़ा है, और, इसलिए 5 बाइट समाधान देखने की उम्मीद है ....

— जैसन

1

@ जेसेन <3zm©.ïi®निकटतम है, मुझे उसकी तरह श्रेणियों का उपयोग नहीं मिला है।

— मैजिक ऑक्टोपस Urn

1

3DÝms<k... कोई बात नहीं ... मैं एक और बाइट दाढ़ी नहीं कर सकता, कसम खाता हूं।

— मैजिक ऑक्टोपस Urn

9

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

R3*’i

आउटपुट x या 0 (मिथ्या)।

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

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

R3*’i  Main link. Argument: n

R      Range; yield [1, ..., n].
 3*    Map each k to 3**k.
   ’   Decrement the results.
    i  First index of n (0 if not found).

— डेनिस
स्रोत

6

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

f=lambda n,i=0:i*0**n or n%3/2*f(n/3,i+1)

एक पुनरावर्ती फ़ंक्शन जो 0गैर-मिलान इनपुट के लिए वापस आता है। बार-बार फर्श को इनपुट 3 से विभाजित करता है, इसमें चरणों की संख्या की गणना करता है i, जो अंत में आउटपुट है। लेकिन, यदि कोई भी चरण n2 modulo 0 का मान नहीं पैदा करता है , तो संख्या इसके लिए नहीं थी 3^i-1, इसलिए आउटपुट 0 से गुणा किया जाता है।

— XNOR
स्रोत

6

पर्ल, 31 बाइट्स

say grep{3**$_-1==$i}0..($i=<>)

-Eचलाने के लिए ध्वज की आवश्यकता है :

perl -E 'say grep{3**$_-1==$i}0..($i=<>)' <<< 26

स्पष्टीकरण:
grep{3**$_-1==$i}0..($i=<>)श्रेणी के तत्वों की सूची लौटाता है 0..$_(यानी 0 से इनपुट तक) जो परीक्षण को संतुष्ट करता है 3**$_-1==$i। केवल एक तत्व इस परीक्षण को संतुष्ट कर सकता है, इसलिए यह निर्देश 0 या 1 तत्व की एक सरणी लौटाएगा। हम तब इस सूची को प्रिंट करते हैं: या तो Xकुछ भी नहीं (जो गलत है)।

— बापू
स्रोत

5

अजगर, 11 बाइट्स

?-JjQ3 2ZlJ

आधार 3 में कनवर्ट करता है और समानता की जाँच करता है [2, 2, ..., 2]।

— orlp
स्रोत

आप इसे एक बाइट के साथ कम कर सकते हैं ?-2JjQ3ZlJ, जब से <col> <num>और पर्थ में <num> <col>विनिमेय हैं -।

— 5

5

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

f=(n,k=33)=>3**k-n-1&&--k?f(n,k):k

या सिर्फ 30 29 बाइट्स अगर विफलता पर एक त्रुटि के साथ बाहर निकलना ठीक है:

f=(n,k)=>~(n-3**k)?f(n,-~k):k

परीक्षा

कोड स्निपेट दिखाएं

f=(n,k=33)=>3**k-n-1&&--k?f(n,k):k

console.log(f(177146))
console.log(f(847288609442))
console.log(f(5559060566555522))
console.log(f(123456))

स्निपेट का विस्तार करें

— Arnauld
स्रोत

5

जावा 8, 37 58 67 बाइट्स

i->{String s=i.toString(i,3);return s.matches("2*")?s.length():-1;}

यह लैम्ब्डा एक Function<Integer, Integer>संदर्भ में फिट बैठता है और सरल आधार 3 चाल का उपयोग करता है।

इस बार इसे सही तरीके से काम करना चाहिए।

3

क्या यह केवल सही या गलत प्रिंट नहीं होगा जब इसे प्रारूप में लिखा जा सकता है? लेकिन मैंने नतीजे के लिए कहा जब परिणाम सच है

— पी। केटिनो

2

यही प्रतिभा है! +1 बहुत ही चतुर दृष्टिकोण के लिए

— डीजेएमकेम

यह चतुर है ... मेरा मानना है कि आप परनों को हटा सकते हैं और बस बना सकते हैं i->। इसके अलावा, यदि आप iएक के रूप में लेते हैं, तो आप Longउपयोग कर सकते हैं a.toString(...)(आईडी गलत तरीके से स्थैतिक कार्यों का उपयोग करने के बारे में कुछ चेतावनी देंगे, लेकिन संकलन करना चाहिए)। हालांकि, जैसा कि ओपी ने कहा, आपको केवल सही या गलत नहीं, बल्कि मूल्य वापस करने की आवश्यकता है।

— FlipTack

यदि लैम्ब्डा को एक अलग फ़ंक्शन प्रकार में संग्रहीत किया जाता है तो स्थिर चाल काम करती है। मैंने रिटर्न वैल्यू भी तय की। मुझे वह हिस्सा याद आ गया होगा।

5

प्रसंस्करण, 60 56 बाइट्स

void q(float n){n=log(n+1)/log(3);print(n>(int)n?-1:n);}

-1झूठा होने पर आउटपुट ।

व्याख्या

void q(float n){              // n is input
  n=log(n+1)/log(3);          // finds X in 3^X+1=n as a float (here we'll storing that in n)
  print(n>(int)n?-1:n);       // checks if the float is greater than
                              // the number rounded down (by int casting)
                              // if it is greater, output -1
                              // otherwise output X
}

void1 बाइट का उपयोग करने की तुलना में कम है float, इसलिए यह फ़ंक्शन मान वापस करने के बजाय सीधे आउटपुट करता है।

दूसरा तरीका

void z(float n){int c=0;for(++n;n>1;c++)n/=3;print(n==1?c:-1);}

63 बाइट्स के लिए, लेकिन मुझे लगता है कि मूल समाधान की तुलना में इस ऊंचाई को छोटा किया जा सकता है। मैं इस पर काम कर रहा हूँ।

— क्रिकटी लिथोस
स्रोत

@FlipTack हाँ, मुझे पता था कि यह जावा में नहीं होगा। मैंने सिर्फ इसलिए पूछा क्योंकि मुझे यकीन नहीं था कि प्रसंस्करण ने उन लाइनों के साथ कुछ जोड़ा नहीं था। "विशिष्ट मूल्य" का उपयोग किया जाना था -1, हालांकि, 0. यह तब से नहीं बदला गया है, हालांकि, इसलिए मैं शायद इसके बारे में अपनी टिप्पणी साफ कर दूंगा।

— ज्योबिट्स

रुको, तो क्या मैं 0अब लौट सकता हूं ?

— क्रिक्टी लिथोस

मैं अभी भी नहीं कहूँगा। प्रश्न गलत होने पर उपयोग करने के लिए एक वैकल्पिक पूर्णांक मान देता है, लेकिन 0जावा / प्रोसेसिंग में कभी भी मिथ्या नहीं है जिसका मुझे पता है।

— ज्योबिट्स

मैं Yougt प्रसंस्करण जावा से कम छद्म माना जाता था

— Pavel

@Pavel लेकिन मैं लैम्बदास का उपयोग नहीं करता: /

— क्रिति लिथोस

4

ब्रेकीलॉग , 8 बाइट्स

,3:.^-?,

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

यदि सही है और false.यदि यह असंभव है तो मूल्य को बढ़ाता है।

व्याख्या

यह दिए गए संबंध का प्रत्यक्ष प्रतिलेखन है:

,     ,      (Disable implicit unification)
 3:.^        3^Output…
     -?              … - 1 = Input

— Fatalize
स्रोत

आप इसे लगभग 7 बाइट्स के रूप में नीचे गोल्फ कर सकते हैं +~^r~:3, लेकिन दुर्भाग्य से ~:वह नहीं करता है जो आप उम्मीद कर सकते हैं (संभावना है कि :एक बिल्टिन के बजाय सिंटैक्स है), और ऐसा लगता है कि पहचान की गई है :।

@ ais523 यह सही है, :एक नियंत्रण प्रतीक है, और ~केवल विधेय पर काम करता है।

— घातक

3

पर्ल 6 , 25 24 बाइट्स

{first $_==3** *-1,0..$_}

कोशिश करो

{first $_==3***-1,0..$_}

**काम करने के बाद अंतरिक्ष को हटाना क्योंकि यह दूसरे इन्फिक्स ऑपरेटर की तुलना में अधिक लंबा है जो मेल खा सकता है *।
इसलिए इसके बजाय …***…पारस किया जाता … ** * …है … * ** …।

कोशिश करो

विस्तारित:

{  # bare block lambda with implicit parameter ｢$_｣

  first
    $_ == 3 ** * - 1,   # WhateverCode lambda
    #          ^- current value

    0 .. $_             # a Range up-to (and including) the input

}

— ब्रैड गिल्बर्ट b2gills
स्रोत

3

आर, 24 बाइट्स

प्लाननापस के उत्तर से एक अलग दृष्टिकोण , और एक बाइट कम!

match(scan(),3^(1:99)-1)

से सभी पूर्णांकों उत्पन्न 3^1-1करने के लिए 3^99-1, और चेक stdin मैचों यदि। यदि हां, तो यह उस इंडेक्स को लौटाता है जिस पर यह मेल खाता है, जो है x। यदि नहीं, तो NAगलत मान के रूप में लौटाता है ।

संयोग से, यह इनपुट के रूप में कई मानों को स्वीकार करेगा, और उन सभी का परीक्षण करेगा, जो एक साफ-सुथरी विशेषता है।

— rturnbull
स्रोत

3

प्रोलॉग, 20 बाइट्स

d(A,X):-A#=(3**X)-1.

यह भाषा नरक के रूप में मस्त है।

| ?- d(1024,X).

no
| ?- d(26,X).

X = 3

yes
| ?- d(2,X).

X = 1

yes

— नाम मैकचेंज
स्रोत

2

05AB1E , 9 बाइट्स

DÝ3sm<Q1k

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

झूठी के लिए प्रिंट -1।

D         # Duplicate the input
 Ý3sm     # Push [0 .. input]^3 (e.g. [0^3, 1^3, 2^3, 4^3 ...])
     <    # subtract 1
      Q   # push a 1 everywhere that equals the input, and 0 everywhere else
       1k # push the index of the 1, or -1 if not found
          # implicit output

— रिले
स्रोत

2

MATL , 8 बाइट्स

3i:^qG=f

यह xमौजूद होने पर संख्या को आउटपुट करता है, या अन्यथा कुछ भी आउटपुट नहीं करता है, जो कि मिथ्या है।

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

व्याख्या

3    % Push 3
i    % Input n
:    % Range: gives `[1 2 ... n]
^    % Power, element-wise. Gives [3^1 3^2 ... 3^n]
q    % Subtract 1, element-wise. Gives [3^1-1 3^2-1 ... 3^n-1]
=    % Test for equality. Contains 'true' at the position x, if any,
     % where 3^x-1 equals n
f    % Find. Gives index of the 'true' position, which ix x; or gives
     % an empty array if no such position exists. Implicitly display

— लुइस मेंडो
स्रोत

2

जाप , 11 बाइट्स

o æ@U+1¥3pX

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

मदद करने के लिए ETHproductions के लिए बड़ा धन्यवाद!

— ओलिवर
स्रोत

2

पायथन 3, 74 66 64 बाइट्स

_{-10 बाइट्स @ mbomb007, @FlipTack और @ nmjcman101 को धन्यवाद}

from math import*
def f(n):x=ceil(log(n,3));print((3**x-1==n)*x)

— dfernan
स्रोत

आप अपने सभी कोड एक लाइन पर रख सकते हैं और उपयोग कर सकते हैं from math import*। इसके अलावा return n==3**x-1and x।

— mbomb007

65 बाइट समाधान

— mbomb007

@ mbomb007 फ़ंक्शन को परिणाम को प्रिंट करने की अनुमति है STDOUT, इसलिए आप उस प्रिंट में वापस बदल सकते हैं।

— FlipTack

यदि आप इसे पायथन वन के बजाय सैजमैथ समाधान के रूप में प्रस्तुत करते हैं, तो आप पहली पंक्ति को पूरी तरह से छोड़ सकते हैं।

— फेडेरिको पोलोनी

65 बाइट्स में अन्य कमी के साथ, आप एक बाइट के लिए import mathऔर उपयोग कर सकते हैं math.ceil। इसके अलावा, आप बदल सकते हैं 3**x-1==n and xकरने के लिएx*(3**x-1==n)

— nmjcman101

2

रूबी, 30 बाइट्स

nilयदि कोई संख्या नहीं मिली तो रिटर्न (एक मिथ्या मूल्य)। [इसे ऑनलाइन आज़माएं]

->n{(0..n).find{|i|3**i-1==n}}

— मूल्य स्याही
स्रोत

2

सी, 56 बाइट्स

 n;f(a){n=0;for(a++;!(a%3)&&(a/=3);++n);return --a?-1:n;}

एक इनपुट में जोड़ें और फिर बार-बार तीन से विभाजित करें जब तक कि शेष न मिल जाए, अगर एक तक पहुंचा जाता है तो विभाजन की गिनती वापस आ जाएगी -1

— Jasen
स्रोत

के a%3<1बजाय के साथ एक बाइट बचाओ !(a%3)। एक और 0मिथ्या के लिए।

— तीतस

मान लें कि आप GCC का उपयोग कर संकलन कर रहे हैं, तो आप कुल 10 (11) बाइट्स बचा सकते हैं: आपको n को शून्य से प्रारंभ करने की आवश्यकता नहीं है यदि आप जानते हैं कि आप इस फ़ंक्शन को केवल एक बार कॉल करेंगे, तो n डिफ़ॉल्ट रूप से शून्य हो जाएगा ( क्योंकि यह वैश्विक है) - यह 4 बाइट्स कम है; भी आपको रिटर्न स्टेटमेंट की आवश्यकता नहीं है, लिखकर a=--a?-1:n;आप 5 बाइट बचाएंगे। यदि गैर-शून्य फ़ंक्शन में कोई वापसी नहीं है, तो यह केवल अंतिम असाइनमेंट का उपयोग करेगा। साथ ही @ टिट्स ने क्या कहा।

— एट्टोइन श्रदालु

1

सुझाएँ a%3?0:(a/=3)बजाय!(a%3)&&(a/=3)

— ceilingcat

2

बैश / यूनिक्स उपयोगिताओं, 37 35 बाइट्स

bc<<<`dc<<<3o$1p|grep ^2*$|wc -c`-1

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

बेस 3 में बदलने के लिए dc का उपयोग करता है, जाँचता है कि परिणामी स्ट्रिंग सभी 2s है, वर्णों की संख्या (एक नई रेखा सहित) को गिनाती है, और फिर 1 को घटाने के लिए bc का उपयोग करती है।

यदि आधार 3 में संख्या सभी 2s नहीं है , तो grep कुछ भी नहीं (यहां तक कि एक नई रेखा भी नहीं) आउटपुट करता है, इसलिए वर्ण गणना 0 है, और 1 पैदावार -1 घटाता है।

— मिशेल स्पेक्टर
स्रोत

2

C क्लेंग 3.8.1, 53 , 52 , 54 , 51 बाइट्स के साथ संकलित

n;f(y){y++;for(n=0;y%3==0;y/=3)n++;return y^1?0:n;}

@SteadyBox ने पहले से ही C में एक समाधान पोस्ट किया है, लेकिन मैं एक अलग दृष्टिकोण का उपयोग कर रहा हूं।

@ बाइट्स बचाने में मदद करने के लिए जैसन का धन्यवाद।

— वेड टायलर
स्रोत

1

हाँ, लेकिन यह काम करता है? समानता के लिए फ़्लोट्स की तुलना करना अक्सर अप्रत्याशित विफलता के लिए एक नुस्खा है (बड़े इनपुट का प्रयास करें)

— जैसन

@ जासेन हम्म ने कोशिश नहीं की, लेकिन सी logरिटर्न में doubleतो शायद यह काम कर जाए।

— वेड टायलर

डबल एक प्रकार का फ्लोटिंग पॉइंट वैल्यू है इसलिए वह समस्या बनी रहती है।

— १29 पर जैसन '’

3 ^ 19 के लिए ठीक काम करने लगता है जो शायद काफी बड़ा है।

— जैसन

@ जैसन यह 3 ^ 10 के लिए काम नहीं करता है

— वेड टायलर

2

सी, 42 बाइट्स, वेड टायलर से अनुकूलित

n;f(y){for(n=0;y%3>1;y/=3)n++;return!y*n;}

प्रयत्न

सी, 37 बाइट्स, बिना `return`

n;f(y){for(n=0;y%3>1;y/=3)n++;n*=!y;}

प्रयत्न

nवैश्विक है, लेकिन (I)MULकेवल एक रजिस्टर में ही इसका डेस्ट ऑपरेंड हो सकता है, इसलिए इसे EAX(सामान्य पसंद) और वहां चल देना होगा

जावास्क्रिप्ट 6, 32 बाइट्स

f=(y,n)=>y%3>1?f(y/3|0,-~n):!y*n
;[1,2,3,8,12,43046720].forEach(x=>console.log(f(x)))

स्निपेट का विस्तार करें

यदि "मिथ्या" समान होने की आवश्यकता है, तो 33 बाइट्स:

f=(y,n)=>y%3>1?f(y/3|0,-~n):!y&&n

— l4m2
स्रोत

2

Pyt , 10 9 बाइट्स

←⁺3ĽĐĐƖ=*

स्पष्टीकरण:

←                Get input
 ⁺               Add one
  3Ľ             Log base 3
    ĐĐ           Triplicate top of stack
      Ɩ          Convert top of stack to integer
       =         Check for equality between top two on stack
        *        Multiply by log_3(input+1)

स्पष्ट रूप से 1 जोड़ने के बजाय वेतन वृद्धि समारोह का उपयोग करके एक बाइट को बचाया

— mudkip201
स्रोत

9 बाइट्स किस कोड पेज में हैं? (UTF-8 में यह 17 बाइट्स है)

— जैसन

1

पायथन, 64 बाइट्स

Falseयदि आउटपुट उस प्रारूप में नहीं लिखा जा सकता है।

def f(n):L=[3**x-1for x in range(n)];print n in L and L.index(n)

यह 64 बाइट्स में भी काम करता है, और नकली स्ट्रिंग को नकली उत्पादन के रूप में प्रिंट करता है:

def f(n):
 try:print[3**x-1for x in range(n)].index(n)
 except:0

65 बाइट्स के लिए एक रचनात्मक समाधान, 0मिथ्याकरण के लिए आउटपुट :

lambda n:-~",".join(`3**x-1`for x in range(n+1)).find(',%s,'%n)/2

— mbomb007
स्रोत

उत्पादन नहीं करता है xऔर न ही -1।

— dfernan

मैच के मामले में कार्यक्रम के xबजाय आउटपुट होना चाहिए n।

— dfernan

नहीं, यह सकारात्मक पूर्णांक को आउटपुट करना चाहिए कि जब एक्स के साथ प्रतिस्थापित किया जाता है, तो आपको इनपुट मिलता है। प्रश्न X को एक चर के रूप में संदर्भित करता है, न कि एक स्ट्रिंग के रूप में

— P. Ktinos

@ P.Ktinos ने इसे ठीक किया।

— mbomb007

1

अजगर, 10 बाइट्स

*J@hQ3!%J1

यहाँ कोशिश करो!

— नीला
स्रोत

1

जूलिया, 30 बाइट्स

n->findfirst(n.==3.^(0:n)-1)-1

यह एक सरल कार्य है - यह एक वेक्टर बनाता है जिसमें trueकेवल उसी स्थिति में होता है 3^a-1, जहां a0 और के बीच पूर्णांक वाला वेक्टर होता है n। यह "पहली" स्थिति को ढूंढता है जो true1 है और घटाता है (यदि यह सब है false, तो खोज शून्य का मूल्यांकन करता है, और यह -1 लौटता है)।

के रूप में 0:nहै 0पहली जगह में, अनुक्रमण के लिए घटाना 1 सुधारता है और भी सक्षम बनाता है -1झूठी प्रतिक्रिया।

— ग्लेन हे
स्रोत

1

पाइके, ९ ६ बाइट्स

3m^Qh@

यहाँ कोशिश करो!

3m^    -  map(3**i, range(input))
     @ - V in ^
   Qh  -  input + 1

पुराने 9 बाइट संस्करण:

b3'l}\2q*

यहाँ कोशिश करो!

— नीला
स्रोत

1

अजगर 8 बाइट्स

xm^3dUQh

     UQ  # generate all values 1..Q (Q is the input)
 m^3d    # map 3^d over this ^ list
x      h # find the input+1 (hQ) in the result of the last command

यहाँ कोशिश करो

— छड़ी
स्रोत

क्या यह संख्या (3 ^ x) - 1 प्रारूप में लिखी जा सकती है?

गणितज्ञ, 21 16 बाइट्स

पायथन, 46 44 बाइट्स

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

05AB1E , 7 बाइट्स

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

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

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

पर्ल, 31 बाइट्स

अजगर, 11 बाइट्स

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

परीक्षा

जावा 8, 37 58 67 बाइट्स

प्रसंस्करण, 60 56 बाइट्स

व्याख्या

दूसरा तरीका

ब्रेकीलॉग , 8 बाइट्स

व्याख्या

पर्ल 6 , 25 24 बाइट्स

विस्तारित:

आर, 24 बाइट्स

प्रोलॉग, 20 बाइट्स

05AB1E , 9 बाइट्स

MATL , 8 बाइट्स

व्याख्या

जाप , 11 बाइट्स

पायथन 3, 74 66 64 बाइट्स

रूबी, 30 बाइट्स

सी, 56 बाइट्स

बैश / यूनिक्स उपयोगिताओं, 37 35 बाइट्स

C क्लेंग 3.8.1, 53 , 52 , 54 , 51 बाइट्स के साथ संकलित

सी, 42 बाइट्स, वेड टायलर से अनुकूलित

सी, 37 बाइट्स, बिना return

जावास्क्रिप्ट 6, 32 बाइट्स

Pyt , 10 9 बाइट्स

पायथन, 64 बाइट्स

अजगर, 10 बाइट्स

जूलिया, 30 बाइट्स

पाइके, ९ ६ बाइट्स

अजगर 8 बाइट्स

सी, 37 बाइट्स, बिना `return`