विजेता (स्पष्ट रूप से) डेनिस) है, जिसने 10 बाइट के साथ जेली का उपयोग किया था!

यह चुनौती अभी भी यहाँ है, लेकिन परिणाम अब नहीं लिया जाएगा।

एक संख्या का पावरट्रेन जॉन कॉनवे द्वारा एक अवधारणा है (जो कॉनवे के गेम ऑफ लाइफ बनाने के लिए भी उल्लेखनीय है, लेकिन यह बात नहीं है)। इसे इस प्रकार परिभाषित किया गया है:

किसी भी संख्या के लिए ..., संख्या का पावरट्रेन होता है ... (यानी हर 2 वां अंक, बाएं से दाएं, इससे पहले के अंक की एक शक्ति है)। यह प्रक्रिया तब तक दोहराई जाती है जब तक कि परिणाम एकल अंक न हो जाए।

उदाहरण:

2592 => (2^5)(9^2) = 2592 <= Cannot be further decomposed 135 => (1^3)5 = 5 1234 => (1^2)(3^4) = 81 => (8^1) = 8 1100 => (1^1)(0^0) = 1 # (0^0) = 1 -42 => -42 # Negative numbers output the input

आपकी चुनौती nइनपुट में किसी भी संख्या के लिए, आउटपुट के रूप में रिटर्न powertrain(n)(यानी nपावरट्रेन अपघटन समाप्त होने के बाद) है।

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

अस्वीकरण-बातें:

आपके पास इनपुट में विषम संख्या हो सकती है, अंतिम अंक में सिर्फ एक शक्ति नहीं होगी।
0 ^ 0 1 है, क्योंकि अगर यह 0 था, तो बहुत सारी संख्या तुरंत 0 या 1 तक गिर जाएगी।
यदि संख्या अभिकलन प्रक्रिया के किसी भी हिस्से में अविनाशी है (जैसे कि यदि यह समाप्त हो जाता है 2592), तो आप बस संख्या को आउटपुट कर सकते हैं।
यदि इनपुट है < 10(यानी सभी एकल अंक संख्या और नकारात्मक), इनपुट आउटपुट।

मैं शायद कुछ ~~घंटों के~~ दिनों के बाद विजेता की घोषणा करूंगा ।

वर्तमान लीडरबोर्ड:

जेली ( डेनिस ♦ ): 10

पायथ ( डेन्करएफ़े ): 16

MATL ( डॉन मूसली ): 21

पर्ल ( टन हास्पेल ): 42

हास्केल ( डेमियन ): 64

जावास्क्रिप्ट ईएस 6 ( edc65 ): 71

गणितज्ञ ( मर्फी ): 74

मैथमेटिका ( लीजनमैमल 978 ) और हास्केल ( रेंजी ): 77

पायथन 2 ( गणितमण्डल ): 111

पायथन 3 ( एरवान ): 161

जावा 8 ( ब्लू ): 229

Oracle SQL 11.2 ( Jeto ): 456

Befunge '93 ( Lex ): 490

code-golf math

— clismique
स्रोत

कुछ और परीक्षण मामलों की सराहना की जाएगी।

— मेरागो

तो इनपुट में 4 अंक अधिकतम होंगे?

— डेनकर

7

क्या होगा यदि एक चक्र तक पहुंच गया है, लेकिन चक्र की अवधि 1 नहीं है, या इनपुट संख्या चक्र का हिस्सा नहीं है?

— feersum

1

"मुझे यकीन है कि व्यवहार्यता के दायरे में कोई भी नहीं है"। क्या हम मान सकते हैं कि ऐसा कभी नहीं होगा? यदद लूप को हमेशा के लिए जाने की अनुमति दी जाती है यदि अवधि> 1 का चक्र पूरा हो जाता है?

— स्टीवी ग्रिफिन

6

प्रस्तावित परीक्षण मामले: 1100और -42अगर यह परीक्षण के मामलों में दिखाई नहीं देता है, तो किनारे के मामलों के नियमों को याद रखना आसान है।

— डेनिस

4

जेली, 15 14 12 10 बाइट्स

Ds2*/€Pµ³¡

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

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

Ds2*/€Pµ³¡  Main link. Argument: n

D           Convert n into the array of its decimal digits.
 s2         Split into pairs of digits.
   */€      Reduce each pair by exponentiation.
      P     Take the product of the resulting powers.
       µ    Push the preceding chain as a link, and start a new one.
        ³¡  Execute the link n times and return the last result.

— डेनिस
स्रोत

इसे केवल nबार-बार पुनरावृत्ति करके छोटा किया जा सकता है , लेकिन मेरे पास इस बात का प्रमाण नहीं है कि यह सभी संभावित सूचनाओं के लिए काम करता है।

— डेनिस

1

आप किसी भी उचित संख्या के लिए ठीक होना चाहिए। वास्तव में आप 16 पुनरावृत्तियों का उपयोग कर किसी भी संख्या के लिए लगभग निश्चित रूप से ठीक हैं : oeis.org/A133503

— टन हास्पेल

@ डेनिस हम्म, जो मैं अपने जवाब में करता हूं

— लुइस मेंडो

1

@DonMuesli और अब जब मैंने इसके बारे में सोचा है, यह शायद काम करता है। 0 और एक विषम सूचकांक प्राप्त करने की संभावनाएं बहुत अधिक हैं ...

— डेनिस

आधुनिक जेली में, यह 7 बाइट्स में किया जा सकता है:D*2/Pµ¡

— डेनिस

5

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

(>> = (==)) >> = जब तक $ p.show एक अनाम फ़ंक्शन है, जो पूर्णांक को इनपुट के रूप में लेती है और अपनी पावरब्रेन को वापस करती है।

जार्जब को धन्यवाद, 3 बाइट्स बचाए

p(x:y:r)=p[x]^p[y]*p r;p[]=1;p x=read x
(>>=(==))>>=until$p.show

— डेमियन
स्रोत

1

((==)=<<g)दो बाइट्स बचाता है (\n->g n==n)।

— जरगब

वाह, मैं मोनाद के (- (>) r) उदाहरण से परिचित नहीं हूं। ट्रिक के लिए धन्यवाद।

— डेमियन

विराम चिह्नों का यह बैराज (>>=(==))>>=वास्तव में एक ट्रेन जैसा दिखता है!

— आंद्रे

4

पर्ल, 42 48 बाइट्स

के लिए +2 शामिल करें -lp(आप भी ड्रॉप कर सकते -lहैं, लेकिन मुझे newlines पसंद हैं)

एसटीडीआईएन पर इनपुट के साथ चलाएं, जैसे

perl -lp powertrain.pl <<< 1234

powertrain.pl:

s/\B/1&pos?"**":"*"/eg until++$.>($_=eval)

(पुराने पर्ल्स पर आप रेगेक्स के बीच और जब तक स्पेस छोड़ सकते हैं)

यह निश्चित बिंदु को संभालने में सक्षम नहीं होगा, 24547284284866560000000000लेकिन यह बड़ा मान वैसे भी काम नहीं करेगा, क्योंकि उस समय तक प्रतिफल घातीय संकेतन में बदल जाता है।

उपरोक्त संस्करण 2592सभी संख्याओं के लिए वास्तव में तेजी से (सबसे अधिक छोरों पर) काम करेगा, जो कि घातीय संकेतन का उपयोग किए बिना प्रतिनिधित्व कर सकता है क्योंकि यह साबित होता है कि 2592और 24547284284866560000000000( https://oeis.org/A135385 ) के बीच कोई निश्चित बिंदु नहीं हैं

हालांकि यह अभी तक अप्रमाणित के रूप में कुछ ग्रहण करता है। सिद्धांत रूप में एक कमी हो सकती है जो X=10^7चरणों से अधिक लेती है (यह अनुमान लगाया जाता है कि कोई भी गैर-निश्चित बिंदु 16 से अधिक कदम नहीं उठाता है, https://oeis.org/A133503 ) जिसका मूल्य नीचे X(लेकिन ऊपर 10^7) नीचे गिरता है और फिर ऊपर जाता है फिर। अगर ऐसा है तो मुझे वापस नीचे आना होगा:

s/\B/1&pos?"**":"*"/eg until$s{$_=eval}++||/-/

व्याख्या

कोड अंकों के बीच रखकर **और *(बारी-बारी से) काम करता है

s/\B/1&pos?"**":"*"/eg

इसलिए 2592हो जाता है 2**5*9**2और 12345हो जाता है 1**2*3**4*5। ये मान्य पर्ल अभिव्यक्तियाँ हैं जिनका मूल्यांकन किया जा सकता है

$_ = eval

( 0**0है 1पर्ल में)। तो बस एक काउंटर है कि यह समाप्त हो जाता है के साथ चारों ओर एक पाश डाल दिया। चूँकि निश्चित बिंदुओं को छोड़कर मान बहुत तेज़ी से नीचे जाते हैं, इसलिए पावरट्रेन श्रृंखला पहले से ही परिवर्तित हो जाती है क्योंकि काउंटर को वास्तव में जाने का मौका मिलता है

— टन हास्पेल
स्रोत

3

पायथ, 25 18 11 16 बाइट्स

?<Q0Qu*F^McjGT2Q

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

7 14 बाइट्स @Jakube की मदद से बचाई गईं

व्याख्या

? <Q0Qu * F ^ McjGT2Q # Q = eval (इनपुट)

? <Q0Q # यदि इनपुट नकारात्मक रिटर्न Q है
     जब तक हम एक चक्र तक नहीं पहुंचते, तब तक यू फ़ंक्शन # पर लागू होता है               
                   # प्रारंभिक मान Q है और G में वर्तमान मान है
           jGT # अंकों की सूची में इनपुट विभाजित करें
          c 2 # 2 के जोड़े में विभाजित
        ^ M # प्रत्येक जोड़ी के लिए शक्ति की गणना करें
      * F # सभी शक्तियों के उत्पाद की गणना करता है

— Denker
स्रोत

1

मामूली परिवर्तनों के अलावा, अजगर मूल रूप से सिर्फ पायथन का एक गोल्फ संस्करण है?

— clismique

1

@Jakube संकेत के लिए धन्यवाद! :) मेरे लिए अभी भी सुबह जल्दी ...

— डेंकर

@DerpfacePython Yea, थोड़े। यदि आप इसके बारे में सीखना चाहते हैं तो डॉक्स पर एक नज़र डालें ।

— डेनकर

कोई बात नहीं। ;-)

— जकुबे

4

@DerpfacePython Pyth ने केवल "छोटा अजगर" के रूप में शुरुआत की, लेकिन यह पुकारने के लिए कि अब विघटनकारी होगा। पायथन ने पायथन से महत्वपूर्ण रूप से विचलन किया है।

— मेरागो

3

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

def p(n,b=0,o=''):
 if n<1:return n
 for c in str(n):o+=c+'**'[b:];b=~b
 j=eval(o+'1');return p(j)if j-n else j

विचार एक स्ट्रिंग जहां के अंकों बनाना है nआपरेशनों के बीच वैकल्पिक है जिसके द्वारा अलग किया जाता है *और **, और उसके बाद evalकि स्ट्रिंग। (अन्य समाधान इसी विचार का उपयोग करते हैं; उदाहरण के लिए टन हास्पेल के पर्ल उत्तर देखें ।)

तो, ऑपरेशन आगे और पीछे स्विच करता है '**'[0:], जो कि है **, और '**'[-1:], जो कि बस है *।

हालाँकि, for-loop के अंत तक , स्ट्रिंग एक ऑपरेशन (एक या दूसरे) के साथ समाप्त होती है, इसलिए हमें या तो अंतिम ऑपरेशन को छोड़ना होगा, या फिर एक और अंक जोड़ना होगा, ताकि स्ट्रिंग को समझ में आए।

सौभाग्य से, 1अंत में आवेदन करने से कोई फर्क नहीं पड़ता कि कौन सा ऑपरेशन अंतिम है। (यदि आप चाहें, तो 1गुणन और घातांक दोनों के लिए, दाईं ओर से एकतरफा पहचान है। यह कहने का एक और तरीका यह है कि powertrain(n) == powertrain(10*n + 1)सभी के लिए n>0।)

अंत में, यदि evalइनपुट (लंबाई- 1चक्र में) के समान ही परिणाम होता है , तो फ़ंक्शन समाप्त हो जाता है। अन्यथा, फ़ंक्शन परिणाम पर खुद को कॉल करता है। (यह लम्बाई के किसी भी चक्र पर हमेशा के लिए लटका रहेगा > 1, लेकिन ओपी की टिप्पणियों के अनुसार मुझे यह मानने की अनुमति है कि ऐसी कोई साइकिल नहीं है।)

(नोट: उपरोक्त स्पष्टीकरण एकल-अंक सकारात्मक पूर्णांक के लिए काम करता है, क्योंकि एकल-अंक इनपुट nपूरा हो n**1जाएगा, जिसके परिणामस्वरूप एक 1चक्र होगा। हालांकि, हमें गैर-सकारात्मक इनपुट स्वीकार करने की भी आवश्यकता है, इसलिए वहां एक शर्त है। उस शॉर्ट-सर्किट की शुरुआत अगर इनपुट से कम है 1। हम उस लाइन को समाप्त कर सकते हैं, और 17 बाइट्स बचा सकते हैं, अगर इनपुट गैर-नकारात्मक होने की गारंटी दी गई हो।)

— mathmandan
स्रोत

यह पक्षपाती लगता है, लेकिन ... अजगर होने के लिए अपवित्र 2. और इसकी एक व्याख्या है।

— १

@DerpfacePython धन्यवाद! (मुझे लगता है कि यह पायथन 3 में भी काम करेगा ...)

— मैथमैडैन

3

जावा 8, 265 244 229 बाइट्स

यह मेरा पहला उत्तर है, लेकिन मैं इस साइट को कुछ समय से पढ़ रहा हूं और सोचता हूं कि मुझे पता है कि मैं क्या कर रहा हूं। कम से कम यह befunge और SQL धड़कता है ...

दुर्भाग्य से, अन्य उत्तरों की तरह, यह एक java'a के कारण 245472842848665600000000000000 के लिए काम नहीं करता है, क्योंकि बड़े पूर्णांक कैसे मिल सकते हैं।

@JackAmmo की बदौलत 36 बाइट्स बचाए

public int p(int n){if(n<10)return n;int i=1,t=1,s=(int)Math.log10(n)+1,r[]=new int[s];for(;i<=s;){int a=(int)Math.pow(10,i);r[s-i++]=n%a/(a/10);}for(i=0;i<s-1;i++)t*=Math.pow(r[i],r[++i]);if(s%2==1)t*=r[s-1];return n==t?n:p(t);}

अघोषित स्पष्टीकरण

public int powertrain(int input){
    //handles negative and 1-digit cases
    if(input<10)return input;
    //initialize output variable       
    int total=1;
    // get "length" of number. Shorter than getting length of string representation
    int size=(int)Math.log10(input)+1;
    //initialize array to store digits
    int[] array=new int[size];
    //Now, because Java doesn't have support
    // for the "**" operation, and the way of turning
    // an integer into a string takes too many bytes,
    // I decided just to put every digit into an array with
    // math and iterate from there
    for(int i=1;i<=size;){
        int place=(int)Math.pow(10,i);
        //crazy math. Saved 1 byte by incrementing i when accessed
        array[size-i++]=input%place/(place/10);
    }
    for(int i=0;i<size-1;i++)
        //This is where the train happens.
        //Saved 1 byte by incrementing while accessing 
        //again, instead of i+=2 and i+1
        total*=Math.pow(array[i],array[++i]);
    //Make sure last number isn't left out if size is odd
    if(size%2==1)
        total*=array[size-1];
    //if we end up with same number, stop.
    //otherwise, keep recurring
    return input==total?input:powertrain(total);
}

— नीला
स्रोत

आपके पहले में अगर ... और if(n<10)return n;else{...}तो और अकारण ही तार्किक है क्योंकि तार्किक रूप से उस ब्लॉक में सब कुछ वैसे भी चलेगा जब n <10 झूठा हो। बाकी और 2 मिलान वाले ब्रेसिज़ को हटाने से आपको 6 बाइट्स मिलेंगे। आपके अंतिम के साथ भी ऐसी ही स्थिति है, अगर ... if(n==t)return n;else return p(t);एक और 5 बाइट्स को बचाने के लिए अन्य और उसके बाद के स्थान को हटा दें। वास्तव में आप इसे और भी छोटा कर सकते हैं यदि आप इसके बजाय ट्रायडिक ऑपरेटर का उपयोग करते हैं ... और तो औरreturn n==t?n:p(t);

— जैक अम्मो

आप कुछ और बाइट्स (17 मुझे लगता है) को टी, एस, आर और लूप के लिए एक साथ घोषित करके बचा सकते हैंint t=i=1,s=(int)Math.log10(n)+1,r[]=new int[s];for(;i<=s;){...}for(i=0;...)...

— जैक अम्मो

@JackAmmo मुझे पता नहीं था कि वैरिएबल को इस तरह घोषित किया जा सकता है, मुझे इसकी कोशिश करनी होगी। आपकी सहायताके लिए धन्यवाद!

— ब्लू

हाँ, आपको बस उन्हें घोषित करने के क्रम से सावधान रहना होगा यदि आप एक को दूसरे को इनिशियलाइज़ करने के लिए उपयोग कर रहे हैं (जैसे कि r यह कैसे परिभाषित करता है कि यह लंबाई को परिभाषित करता है)

— जैक अम्मो

बड़ी संख्या में मनमानी करने के लिए, आपको java के BigInteger class docs.oracle.com/javase/8/docs/api/java/math/BigInteger.html

— Jack Ammo

2

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

एक पुनरावृत्ति समारोह, जब एक पुनरावृत्ति पाया जाता है रोक। यह अधिक समय तक काम नहीं कर सकता (2 या अधिक मान दोहराता है) लेकिन ऐसा लगता है कि ऐसा नहीं हो सकता है, कम से कम जावास्क्रिप्ट संख्या की सीमित सीमा में (17 अंक)

f=n=>[...n+'1'].map((c,i)=>i&1?r*=Math.pow(d,c):d=c,r=1)&&n-r?f(r):n

परीक्षा

f=n=>[...n+'1'].map((c,i)=>i&1?r*=Math.pow(d,c):d=c,r=1)&&n-r?f(r):n

function go()
{
  v=+I.value
  R.textContent=f(v)
}  

go()

<input id=I value="1234"><button onclick="go()">Go</button>
<span id=R></span>

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

— edc65
स्रोत

+'1'एक पत्थर से दो पक्षियों को मारने में अच्छा लगा !

— नील

मुझे नहीं पता कि आपने इसकी पहले से ही जांच की थी लेकिन सबसे अच्छा मैं replace1 बाइट लंबे समय तक कर सकता था:f=n=>`${n}1`.replace(/../g,([x,y])=>r*=Math.pow(x,y),r=1)&&n-r?f(r):n

— नील

@ नील मैंने भी बहुत कोशिश की, लेकिन वह टेम्पलेट स्ट्रिंग एक नया विचार है ...

— edc65

1

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

Times@@(If[#2<1,1,#^#2]&)@@@Partition[IntegerDigits@#,2,2,1,1]&~FixedPoint~#&

अनाम फ़ंक्शन। बहुत जटिल नहीं है।

— LegionMammal978
स्रोत

फिर भी, क्या मुझे अभी भी स्पष्टीकरण मिल सकता है?

— clismique

1

Befunge 720 490 बाइट्स

कभी नहीं मुझे एक अजीब बात बताओ के बाद एक और करने के लिए विरोध नहीं कर सका । इसलिए, मैंने पिछले एक के "ASCII-fier" को अनुकूलित किया है। इस मामले में मुझे निर्देश सूचक को उन्हें पढ़ने के लिए अंकों पर चलाने की कोई आवश्यकता नहीं है, इसलिए मैंने उन्हें मानव पठनीय बनाने का प्रयास नहीं किया है। तो यह अब एक डिजीफायर के अधिक है।

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

v                                                    //top row is used for "variables"
>&:0`#v_.@                                           //initialize the counter                          
v     <                           g01_v#-p01:  <     //on our way back to the digitifier, check if we're done
>::>210p>55+%:10g0p-55+/:v            >10g.@         //digitifier, creates a series of ASCII characters at the top line, one for each digit in the source
        ^p01+1g01    _v#:<
v1$$                  <                              //forget some remainders of the digitifier, put 1 on the stack as a base of calculation
                      v p0-1g01-1g0-1g01*g0g01<      //taking powers of each pair of digit
>10g2-!#v_10g1-!#v_  1>                10g1-0g|
^                                  p01-2g01  *<
        >10g0g*  >                             ^     //extra multiplication with last digit if the number of digits was odd

यह संस्करण नकारात्मक इनपुट का भी समर्थन करता है। यह पिछले संस्करण पर एक महान सुधार है, अगर मैं ऐसा खुद कहूं। कम से कम 1 बग तय किया गया था और आकार बहुत कम कर दिया गया था।

— rael_kid
स्रोत

नकारात्मक संख्याओं को इनपुट करने के लिए कितने बाइट्स अधिक लगेंगे?

— क्लिस्मिक

मैं ईमानदार नहीं हूं। मुझे नकारात्मक संख्याओं और ग्रिड में कहीं लिखने में कुछ समस्याएं थीं। मैं इसे फिर से कोशिश करूँगा।

— rael_kid

मुझे अभी एक और बग मिला है। मैंने नकारात्मक संख्याओं के लिए समर्थन जोड़ने का प्रबंधन किया। मैं जल्द ही एक अद्यतन पोस्ट करूँगा! यह शायद बाइट्स की एक ही राशि होगी, क्योंकि मैं पूरे ग्रिड की गिनती करता हूं।

— rael_kid

1

हास्केल, 100 79 77 बाइट्स

g x|x==h x=x|1<2=g$h x;h=i.map(read.(:[])).show;i[]=1;i[a]=a;i(a:b:c)=a^b*i c

गोल्फ नहीं:

g x|x==h x=x|1<2=g$h x
h=i.map(read.(:[])).show
i[]=1
i[a]=a
i(a:b:c)=a^b*i c

यह फ़ंक्शन इनपुट को अंकों में विभाजित करता है और चाल के माध्यम से करता है i।

संपादित करें: कुछ सुझावों के लिए nimi के लिए धन्यवाद।

— Renzeee
स्रोत

कुछ सुझाव: क) i(a:[])=a है i[a]=a, बी) के लिए कोई ज़रूरत नहीं है max 1, क्योंकि 0^0 = 1हास्केल में, ग) के (:[])साथ प्रतिस्थापित करते हैं pure, घ) एक अलग समारोह में letभीतर ले जाते हैं gऔर if ... then ... elseगार्ड के साथ प्रतिस्थापित करते हैं :h=i.map(read.pure).show ; g x|x==h x=x|1<2=h x

— नीमी

purePrelude में नहीं है, लेकिन बाकी टिप्स काम करते हैं, धन्यवाद। मैं इसे गार्ड के साथ करने की कोशिश कर रहा था, लेकिन गार्ड के ;सामने इस्तेमाल करना खत्म कर दिया और यह काम नहीं किया, लेकिन अब मुझे पता है कि इसे कैसे काम करना चाहिए।

— रेनजी

pureआधार-4.8.2.0 के साथ आने वाले प्रस्तावना में है। पता नहीं कब पेश किया गया था। आप की जरूरत नहीं है ( )में i([a])=a।

— nimi

1

मैथमेटिका, 74 बाइट्स

0~f~0=f[]=1
f@n_=n
f[a_,b_,c___]:=f[c]a^b
#//.i_/;i>0:>f@@IntegerDigits@i&

व्याख्या

यह समाधान एक सहायक फ़ंक्शन का उपयोग करता है f, जो संख्या के अंकों को तर्क के रूप में लेता है और पावर ट्रेन ऑपरेशन के एक पुनरावृत्ति को लागू करता है। अंतिम पंक्ति एक शुद्ध फ़ंक्शन है जिसे ReplaceRepeatedफ़ंक्शन (या //.शॉर्ट के लिए) का फायदा उठाने के लिए तैयार किया जाता है , जो एक नियम को लागू करता है (इस मामले #में शुद्ध फ़ंक्शन का तर्क ) जब तक कि यह अब नहीं बदलता है। नियम अपने दशमलव अंकों पर लागू i_/;i>0:>f@@IntegerDigits@iफ़ंक्शन के साथ कुछ भी नकारात्मक नहीं बदलता है f।

— मर्फी
स्रोत

पंक्ति 2 काम नहीं करती है (उपयोग करें :=)

— CalculatorFeline

स्पष्टीकरण, कृपया?

— क्लिस्मिक

@CatsAreFluffy मैं लाइन 2 के साथ आपकी समस्या नहीं देखता हूं। यह मेरे लिए ठीक काम करता है!

— मर्फी

SetDelayed::write: Tag Times in n f[a_,b_,c___] is Protected. >>, Set::write: Tag Times in 1 f[n_] is Protected. >>दूसरी त्रुटि गायब हो जाती है जब मैं :=बनाम का उपयोग करता हूं =।

— कैलकुलेटर

क्षमा करें, उस त्रुटि को पुन: उत्पन्न नहीं कर सकता। लेकिन आपका आउटपुट इंगित करता है कि लाइन-ब्रेक समस्या का हिस्सा हैं। कृपया ;पंक्ति-विराम के बजाय संस्करण के साथ प्रयास करें :0~f~0=f[]=1;f@n_=n;f[a_,b_,c___]:=f[c]a^b;#//.i_/;i>0:>f@@IntegerDigits@i&

— मर्फी

1

MATL , 21 बाइट्स

tt0>*:"V!UtQgv9L2#)^p

आउटपुट के उत्पादन में कुछ सेकंड लग सकते हैं।

संपादित करें (30 जुलाई 2016): लिंक किए गए कोड की जगह 9Lद्वारा 1Lभाषा में हाल के परिवर्तनों के लिए अनुकूल करने के लिए।

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

यह कोड दक्षता की कीमत पर बाइट की संख्या को कम करने के लिए निम्नलिखित दो तरकीबों का उपयोग करता है:

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

कोड:

t         % implicitly take input x. Duplicate
t0>*      % duplicate. Is it greater than 0? Multiply. This gives 0 if input is negative,
          % or leaves the input unchanged otherwise
:         % Generate array [1,2,...,x]
"         % for each (repeat x times)
  V       %   convert x to string
  !       %   transpose into column char array
  U       %   convert each char into number
  tQg     %   duplicate. Add 1 so that no entry is zero. Convert to logical: gives ones
  v       %   concatenate vertically
  9L2#)   %   separate odd-indexed and even-indexed entries
  ^       %   element-wise power
  p       %   product of all entries
          % implicitly end for each
          % implicitly display

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

उह ... हे हे हे ... जब मैंने "संख्याओं के छोरों" के बारे में कहा, तो मेरा मतलब था कि संख्याएँ जो इस तरह गईं - a, b, a, bविज्ञापन इन्फिनिटम (एक से अधिक शब्द)। यदि एक शब्द दोहराया जाता है, तो आपको उस संख्या को आउटपुट करना चाहिए। क्षमा करें यदि वह वास्तव में स्पष्ट नहीं था।

— १०:१६ को २६:२६

यदि एक शब्द दोहराया जाता है, तो मैं उस नंबर को आउटपुट कर रहा हूं। मैं कई पुनरावृत्तियों के बाद परिणाम का उत्पादन करता हूं

— लुइस मेन्डो

ओह, मैं अब समझ गया हूँ ... बस पूछ रहा हूँ, यह कितने पुनरावृत्तियों (लगभग) होगा? क्योंकि जब मैं 2592इनपुट में टाइप करता हूं , तो यह कुछ समय के लिए कुछ भी आउटपुट नहीं करता है।

— क्लिस्मिक्स

पुनरावृत्तियों की संख्या इनपुट संख्या है, इसलिए उस स्थिति में 2592। हाँ, इसमें

— थोड़ा

0

पायथन 3, 169 161 बाइट्स

def f(s):
 o=[['1',s]['-'in s]]
 while s not in o:
  o+=[s];s+='1'*(len(s)%2==1);r=1;
  for i,j in zip(s[::2],s[1::2]):r*=int(i)**int(j);s=str(r);
 return o[-1]

Ungoldfed

def f(s):
 o=[['1',s]['-'in s]]
 while s not in o:
  o+=[s]
  s+='1'*(len(s)%2==1)
  r=1
  for i,j in zip(s[::2],s[1::2]):
   r*=int(i)**int(j)
  s=str(r)
 return o[-1]

परिणाम

>>> [f(i) for i in ['135', '1234', '642', '2592', '-15']]
['5', '8', '2592', '2592', '-15']

— एर्वान
स्रोत

@PeterTaylor फिक्स्ड!

— इरवान

यदि आप उन्हें ;इस तरह से अलग करते हैं, तो आप कई बयान एक पंक्ति में रख सकते हैं, जिससे आप अपने व्हाट्सएप को बचा सकते हैं। इसके अलावा आप लूप के शरीर को उसी लाइन पर रख सकते हैं।

— डेनकर

सुझाए गए गोल्फिंग:def f(s,o=[['1',s]["-"in s]],n=int): while s not in o: o+=[s];s+=1*(len(s)%2<1);r=1 for i,j in zip(s[::2],s[1::2]):r*=n(i)**n(j) s=str(r) return o[-1]

— कैलकुलेटरफाइनल

@CatsAreFluffy o=[['1',s]["-"in s]]डिफ़ॉल्ट बहस में मेरे लिए काम नहीं करते हैं यह एक त्रुटि बढ़ा `s defined` नहीं

— एर्वान

उफ़, ओ को अगली पंक्ति में ले जाएँ।

— कैलक्यूलेटरफलाइन

0

Oracle SQL 11.2, 456 बाइट्स

WITH v(n,c,i,f,t)AS(SELECT:1+0,CEIL(LENGTH(:1)/2),1,'1',0 FROM DUAL UNION ALL SELECT DECODE(SIGN(c-i+1),-1,t,n),DECODE(SIGN(c-i+1),-1,CEIL(LENGTH(t)/2),c),DECODE(SIGN(c-i+1),-1,1,i+1),DECODE(SIGN(c-i+1),-1,'1',RTRIM(f||'*'||NVL(POWER(SUBSTR(n,i*2-1,1),SUBSTR(n,i*2,1)),SUBSTR(n,i*2-1,1)),'*')),DECODE(SIGN(c-i+1),-1,0,TO_NUMBER(column_value))FROM v,XMLTABLE(f)WHERE i<=c+2 AND:1>9)CYCLE n,c,i,f,t SET s TO 1 DEFAULT 0SELECT NVL(SUM(n),:1) FROM v WHERE s=1;

संयुक्त राष्ट्र के golfed

WITH v(n,c,i,f,t) AS
(
  SELECT :1+0,CEIL(LENGTH(:1)/2),1,'1',0 FROM DUAL
  UNION ALL
  SELECT DECODE(SIGN(c-i+1),-1,t,n),
         DECODE(SIGN(c-i+1),-1,CEIL(LENGTH(t)/2),c),
         DECODE(SIGN(c-i+1),-1,1,i+1),
         DECODE(SIGN(c-i+1),-1,'1',RTRIM(f||'*'||NVL(POWER(SUBSTR(n,i*2-1,1),SUBSTR(n,i*2,1)),SUBSTR(n,i*2-1,1)),'*')),
         DECODE(SIGN(c-i+1),-1,0,TO_NUMBER(column_value))
  FROM v,XMLTABLE(f) WHERE i<=c+2 AND :1>9 
)  
CYCLE n,c,i,f,t SET s TO 1 DEFAULT 0
SELECT NVL(SUM(n),:1) FROM v WHERE s=1;

v एक पुनरावर्ती दृश्य है, पैरामीटर हैं

n: 2 अंकों के भागों में विभाजित करने के लिए संख्या

c: 2 अंकीय भागों की संख्या

i: गणना करने के लिए वर्तमान 2 अंक भाग

f: स्ट्रिंग विभाजक के रूप में * के साथ शक्तियों को समेटती है

t: f का मूल्यांकन

DECODEs चालू संख्या के सभी भागों को विभाजित करने और गणना करने के लिए अगले नंबर पर स्विच करते हैं।

XMLTABLE (f) एक अभिव्यक्ति का मूल्यांकन करता है, जो छद्म स्तंभ "column_value" में परिणाम डालता है। यह http://tkyte.blogspot.fr/2010/04/evaluating-expression-like-culcul.html.html का गोल्फ संस्करण है

CYCLE चक्र का पता लगाने में ओरेकल बिल्ड है और इसे बाहर निकलने की स्थिति के रूप में उपयोग किया जाता है।

चूंकि: 1 <10 के लिए परिणाम है: 1 और v उन मामलों के लिए कोई पंक्ति नहीं देता है, SUM मान के रूप में NULL वाली पंक्ति को बाध्य करता है। एनवीएल रिटर्न: 1 परिणाम के रूप में यदि पंक्ति शून्य है।

— Jeto
स्रोत

स्पष्टीकरण कहां है?

— १०:१६ पर २०:२१

पावरट्रेन खोजें!

विजेता (स्पष्ट रूप से) डेनिस) है, जिसने 10 बाइट के साथ जेली का उपयोग किया था!

जेली, 15 14 12 10 बाइट्स

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

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

पर्ल, 42 48 बाइट्स

व्याख्या

पायथ, 25 18 11 16 बाइट्स

व्याख्या

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

जावा 8, 265 244 229 बाइट्स

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

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

Befunge 720 490 बाइट्स

हास्केल, 100 79 77 बाइट्स

मैथमेटिका, 74 बाइट्स

MATL , 21 बाइट्स

पायथन 3, 169 161 बाइट्स

परिणाम

Oracle SQL 11.2, 456 बाइट्स