समाप्ति, विशुद्ध रूप से आवधिक, या अंततः आवधिक?

Question

परिचय

एक दशमलव समाप्त हो रहा है अगर इसमें दशमलव अंकों की एक सीमित संख्या है। उदाहरण के लिए, 0.4 (2/5) समाप्त हो रहा है क्योंकि इसमें एक दशमलव अंक है।

एक दशमलव विशुद्ध रूप से आवधिक होता है यदि इसमें दशमलव अंकों की अनंत संख्या होती है और इसके दोहराव से पहले कोई दशमलव अंक नहीं होता है (दोहराए जाने वाले दशमलव का हिस्सा।) उदाहरण के लिए, 0.142857142857142 ... (1/7) शुद्ध रूप से आवधिक होता है क्योंकि इसमें दोहराव होता है। 142857, जो दशमलव बिंदु के तुरंत बाद दोहराना शुरू कर देता है।

एक दशमलव अंततः आवधिक होता है यदि इसमें दशमलव अंकों की अनंत संख्या होती है और इसके दोहराव से पहले दशमलव अंकों की एक सीमित संख्या होती है (दोहराए जाने वाले दशमलव का हिस्सा।) उदाहरण के लिए, 0.166666666666666 ... (1/6) अंततः आवधिक है। repetend 6 1 के बाद दोहराना शुरू करता है।

आपका कार्य

एक प्रोग्राम या फ़ंक्शन लिखें, जब दिए गए नंबर p और q (पूर्णांक, 0 <= p < q <= 100), यह निर्धारित करेगा कि क्या p / q का दशमलव प्रतिनिधित्व है का पूरी तरह से आवधिक है, या अंततः आवधिक है।

आप चाहिए उत्पादन aकरता है, तो यह समाप्त (यानी 0.1), bयह शुद्ध रूप से समय-समय पर अगर (यानी 0.333 ...), या cयह अंततः समय-समय पर अगर (यानी 0.166 ...), जहां a, bऔरc किसी भी अलग, अपनी पसंद का निरंतर तार कर रहे हैं।

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

0/1 => Terminating
0/2 => Terminating
1/2 => Terminating
0/3 => Terminating
1/3 => Purely Periodic
2/3 => Purely Periodic
0/4 => Terminating
1/4 => Terminating
2/4 => Terminating
3/4 => Terminating
0/5 => Terminating
1/5 => Terminating
2/5 => Terminating
3/5 => Terminating
4/5 => Terminating
0/6 => Terminating
1/6 => Eventually Periodic
2/6 => Purely Periodic
3/6 => Terminating
4/6 => Purely Periodic
5/6 => Eventually Periodic
0/7 => Terminating
1/7 => Purely Periodic
2/7 => Purely Periodic
3/7 => Purely Periodic
4/7 => Purely Periodic
5/7 => Purely Periodic
6/7 => Purely Periodic
0/8 => Terminating
1/8 => Terminating
2/8 => Terminating
3/8 => Terminating
4/8 => Terminating
5/8 => Terminating
6/8 => Terminating
7/8 => Terminating
0/9 => Terminating
1/9 => Purely Periodic
2/9 => Purely Periodic
3/9 => Purely Periodic
4/9 => Purely Periodic
5/9 => Purely Periodic
6/9 => Purely Periodic
7/9 => Purely Periodic
8/9 => Purely Periodic
0/10 => Terminating
1/10 => Terminating
2/10 => Terminating
3/10 => Terminating
4/10 => Terminating
5/10 => Terminating
6/10 => Terminating
7/10 => Terminating
8/10 => Terminating
9/10 => Terminating
0/11 => Terminating
1/11 => Purely Periodic
2/11 => Purely Periodic
3/11 => Purely Periodic
4/11 => Purely Periodic
5/11 => Purely Periodic
6/11 => Purely Periodic
7/11 => Purely Periodic
8/11 => Purely Periodic
9/11 => Purely Periodic
10/11 => Purely Periodic
0/12 => Terminating
1/12 => Eventually Periodic
2/12 => Eventually Periodic
3/12 => Terminating
4/12 => Purely Periodic
5/12 => Eventually Periodic
6/12 => Terminating
7/12 => Eventually Periodic
8/12 => Purely Periodic
9/12 => Terminating
10/12 => Eventually Periodic
11/12 => Eventually Periodic
0/13 => Terminating
1/13 => Purely Periodic
2/13 => Purely Periodic
3/13 => Purely Periodic
4/13 => Purely Periodic
5/13 => Purely Periodic
6/13 => Purely Periodic
7/13 => Purely Periodic
8/13 => Purely Periodic
9/13 => Purely Periodic
10/13 => Purely Periodic
11/13 => Purely Periodic
12/13 => Purely Periodic
0/14 => Terminating
1/14 => Eventually Periodic
2/14 => Purely Periodic
3/14 => Eventually Periodic
4/14 => Purely Periodic
5/14 => Eventually Periodic
6/14 => Purely Periodic
7/14 => Terminating
8/14 => Purely Periodic
9/14 => Eventually Periodic
10/14 => Purely Periodic
11/14 => Eventually Periodic
12/14 => Purely Periodic
13/14 => Eventually Periodic
0/15 => Terminating
1/15 => Eventually Periodic
2/15 => Eventually Periodic
3/15 => Terminating
4/15 => Eventually Periodic
5/15 => Purely Periodic
6/15 => Terminating
7/15 => Eventually Periodic
8/15 => Eventually Periodic
9/15 => Terminating
10/15 => Purely Periodic
11/15 => Eventually Periodic
12/15 => Terminating
13/15 => Eventually Periodic
14/15 => Eventually Periodic

_{आप सभी परीक्षण मामलों को यहां पा सकते हैं ।}

आपको आउटपुट के लिए अपने स्वयं के 3 मूल्यों को चुनने की अनुमति है, लेकिन यह स्पष्ट होना चाहिए कि यह किसके लिए है।

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

संकेत

समाप्त:

किसी समाप्ति दशमलव के भाजक को सरलतम रूप में बदलने का मुख्य कारक केवल 2s और 5s हैं।

पूरी तरह से आवधिक:

सरल रूप में एक शुद्ध आवधिक दशमलव के भाजक के मुख्य कारक में कोई 2s या 5 s शामिल नहीं है।

अंततः आवधिक:

सरल रूप में एक अंततः आवधिक दशमलव के भाजक के मुख्य कारक में कम से कम एक 2 या 5 शामिल हैं, लेकिन अन्य संख्याएं भी शामिल हैं।

लीडरबोर्ड

यहां एक नियमित लीडरबोर्ड और भाषा के अनुसार विजेताओं का अवलोकन करने के लिए एक स्टैक स्निपेट है।

यह सुनिश्चित करने के लिए कि आपका उत्तर दिखाई देता है, कृपया अपना उत्तर शीर्षक मार्कडाउन टेम्पलेट का उपयोग करके शीर्षक के साथ शुरू करें:

# Language Name, N bytes

Nआपके सबमिशन का आकार कहां है। यदि आप अपने स्कोर में सुधार करते हैं, तो आप पुराने अंकों को हेडलाइन में रख सकते हैं , उनके माध्यम से स्ट्राइक करके। उदाहरण के लिए:

# Ruby, <s>104</s> <s>101</s> 96 bytes

यदि आप अपने हेडर में कई संख्याओं को शामिल करना चाहते हैं (जैसे कि आपका स्कोर दो फाइलों का योग है या आप दुभाषिया ध्वज दंड को अलग से सूचीबद्ध करना चाहते हैं), तो सुनिश्चित करें कि हेडर में वास्तविक अंक अंतिम संख्या है:

# Perl, 43 + 2 (-p flag) = 45 bytes

आप भाषा के नाम को एक लिंक भी बना सकते हैं जो लीडरबोर्ड स्निपेट में दिखाई देगा:

# [><>](http://esolangs.org/wiki/Fish), 121 bytes

var QUESTION_ID=95926,OVERRIDE_USER=12537;function answersUrl(e){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"https://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/<a/.test(o)&&(o=jQuery(o).text()),s[o]=s[o]||{lang:e.language,user:e.user,size:e.size,link:e.link}});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){return e.lang>s.lang?1:e.lang<s.lang?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;

body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr></thead> <tbody id="answers"> </tbody> </table> </div><div id="language-list"> <h2>Winners by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr></thead> <tbody id="languages"> </tbody> </table> </div><table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table>

Comments

लगभग डुप्लिकेट

— पीटर टेलर

अगर मुझे लगता है कि यह वास्तव में एक डुप्लिकेट था, तो मैंने एक करीबी वोट डाला। एक कारण है कि मैंने " लगभग " शब्द का उपयोग किया है ।

— पीटर टेलर

फार्म में एक अंश दिया पी / क्यू कैसे दिया? क्या हम अलग-अलग फ़ंक्शन तर्कों के रूप में अंश और हर ले सकते हैं?

— डेनिस

क्या हम एक गैर-स्थिर मूल्य को एक विशिष्ट स्थिति को पूरा करने के लिए आउटपुट कर सकते हैं, जैसे कि समाप्ति के लिए कुछ भी गलत, पूर्ण रूप से आवधिक के लिए 1 और अंततः आवधिक के लिए 1 से अधिक कुछ भी?

— ETHproductions

नहीं, 1/13 विशुद्ध रूप से आवधिक है क्योंकि दोहराव '076923' है। 0 दोहराव के साथ दोहराता है।

— ओलिवर नी

Answer 1

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

:gÆfḍ⁵ṢQ¬Ḅ

तर्क के रूप में हर और अंश (उस क्रम में) को स्वीकार करता है। समाप्त करने के लिए रिटर्न 0 , विशुद्ध रूप से आवधिक के लिए 1 , और 2 अंततः आवधिक के लिए । इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें ।

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

:gÆfḍ⁵ṢQ¬Ḅ  Main link. Arguments: d (denominator), n (numerator)

 g          Compute the GCD of d and n.
:           Divide d by the GCD, yielding the denominator of the simplified form.
  Æf        Yield all prime factors of the previous result.
    ḍ⁵      Test 10 for divisibility by each prime factor.
            This yields 1 for 2 and 5, 0 for all other primes.
      Ṣ     Sort the resulting Booleans.
       Q    Unique; deduplicate the sorted Booleans.
        ¬   Logical NOT; replace 0 with 1 and vice versa to yield one of the
            following arrays.
              [    ]  <- no prime factors (denominator 1)
              [   0]  <- only 2 and 5
              [1   ]  <- neither 2 nor 5
              [1, 0]  <- mixed
         Ḅ  Unbinary; convert from base 2 to integer.
            This maps [] and [0] to 0, [1] to 1, and [1, 0] to 2.

Answer 2

जावास्क्रिप्ट (ईएस 6), 70 .. 68 53 बाइट्स

f=(a,b,s=[],x)=>a?(s[a]^=a)?f(a*10%b,b,s,x||a):x==a:0

समाप्त करने के लिए रिटर्न 0 , सच शुद्ध रूप से आवधिक के लिए और अंततः आवधिक के लिए गलत है ।

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

हम यहाँ क्या कर रहे हैं वास्तव में हाथ से एक विभाजन अनुकरण कर रहा है:

1. a?...:0- यदि अंश शून्य है, तो हम यहां रुकते हैं और वापस लौटते हैं 0। अनुक्रम समाप्त हो रहा है ।
2. (s[a]^=a)?...:x==a- अगर हम पहले ही इस अंश का सामना कर चुके हैं, तो इसका मतलब है कि अनुक्रम आवधिक है और हमेशा के लिए दोहराने जा रहा है। हम यहां रुकते हैं और या trueतो अनुक्रम aके पहले मूल्य x( विशुद्ध आवधिक ) के बराबर होते हैं या falseयदि यह नहीं है ( अंत में आवधिक )।
3. f(a*10%b,b,s,x||a)- और, हम अंश aको 10 से गुणा करते हैं । हम भाजक द्वारा शेष भाग की गणना करते हैं b। और हम इस शेष को नए अंश के रूप में उपयोग करके प्रक्रिया को दोहराते हैं। (हम aअनुक्रम के पहले मूल्य के रूप में भी गुजरते हैं अगर यह पहले से ही संग्रहीत नहीं हैx ।)

उदाहरण

• नीला : अंश = १
• हरा : हर = =
• लाल : 10 से गुणा
• काला : अवशेष
• ग्रे : भागफल अंक (हम वास्तव में उनके बारे में यहाँ परवाह नहीं करते हैं, और उपरोक्त कोड उन्हें बिल्कुल भी गणना नहीं कर रहा है)

Answer 3

पायथन, 62 61 59 बाइट्स

f=lambda n,d,r=[0,0]:(r[:3]+r).count(n)or f(10*n%d,d,r+[n])

अंततः आवधिक के लिए प्रिंट 1 , विशुद्ध रूप से आवधिक के लिए 2 , और समाप्ति के लिए 4 ।

Repl.it पर सभी परीक्षण मामलों की जाँच करें ।

Comments

चित्त आकर्षण करनेवाला! क्या करता *rहै?

— ETHproductions

यह ट्यूपल आर को अनपैक करता है । f(1, *(2, 3), 4)के बराबर है f(1, 2, 3, 4)।

— डेनिस

तो यह जेएस में 56 बाइट्स होगा:f=(n,d,...r)=>n in r?~(n>0?n==r[0]:2):f(10*n%d,d,...r,n)

— ETHproductions

मेरी खराब, 63 बाइट्स (मैं भूल गया कि inजेएस में पायथन की तुलना में बहुत अलग उद्देश्य से काम करता है):f=(n,d,...r)=>~r.indexOf(r)?~(n>0?n==r[0]:2):f(10*n%d,d,...r,n)

— ETHproductions

@ETHproductions नीट। मुझे लगता है कि f=(n,d,...r)=>~(i=r.indexOf(n))?n&&!i:f(10*n%d,d,...r,n)यह भी काम करेगा।

— डेनिस

Answer 4

पर्ल, 49 46 45 बाइट्स

के लिए +3 शामिल है -p

डेनिस पर आधारित है के सुरुचिपूर्ण विचार के लेकिन एक शानदार तरीके से लागू किया गया

STDIN पर इनपुट नंबर दें

terminating.pl <<< "2 26"

termninating.pl:

#!/usr/bin/perl -p
/ /;1until$a{$_=$_*10%$' or$`}++;$_=$a{$`}

एक 2 प्रिंट करता है अगर समाप्ति। 1 यदि आवधिक और कुछ नहीं तो अंततः आवधिक

Comments

एक निश्चित समूह के सभी नंबरों को समान मूल्य देना होगा।

— ओलिवर नी

@ ऑलिवरनी वे अब करते हैं

— टन हास्पेल

Answer 5

बैच, 247 बाइट्स

@set/af=%1,g=%2
:g
@if not %f%==0 set/ah=g,g=f,f=h%%g&goto g
@set/ae=d=%2/g
:l
@set/ag=-~!(d%%2)*(!(d%%5)*4+1)
@if not %g%==1 set/ad/=g&goto l
@if %d%==1 (echo Terminating)else if %d%==%e% (echo Purely Periodic)else echo Eventually Periodic

सटीक तेजी से दशमलव के लिए मेरी तेजी से gcd10 चाल का उपयोग करता है । जाहिर है मैं एक कस्टम आउटपुट प्रारूप का उपयोग करके बाइट्स का एक गुच्छा बचा सकता है।

Comments

आप केवल @if %d%==1 (echo T)else if %d%==%e% (echo P)else echo E42 बाइट्स को बचाने के लिए क्यों नहीं करते हैं ?

— ETHproductions

जाहिर है मैं एक कस्टम आउटपुट प्रारूप का उपयोग करके बाइट्स का एक गुच्छा बचा सकता है।

— ओलिवर नी

@ETHproductions मुझे लगता है कि वह नहीं चाहता, जैसा कि ओलिवर ने एक उद्धरण के साथ नोट किया है।

— आउटगॉल्फ

Answer 6

जावास्क्रिप्ट (ईएस 6), 91 88 85 79 75 74 78 बाइट्स

f=(n,d,g=(a,b)=>b?g(b,a%b):a,t=g(d/=c=g(n,d),10))=>n*~-d?t-1?f(n/c,d/t)/0:1:+f

NaNसमाप्त करने के लिए आउटपुट , 1विशुद्ध रूप से आवधिक के लिए, और Infinityअंततः आवधिक के लिए।

टेस्ट स्निपेट

f=(n,d,g=(a,b)=>b?g(b,a%b):a,t=g(d/=c=g(n,d),10))=>n*~-d?t-1?f(n/c,d/t)/0:1:+f

l=(n,d)=>console.log(n+"/"+d+":",f(n,d))

for(i=1;i<10;i++)for(j=0;j<i;j++)l(j,i);

व्याख्या

सबसे पहले, हम n और d दोनों को gcd (d, n) से विभाजित करते हैं , ताकि अंश को सरलतम रूप में घटाया जा सके। इससे हम 2/6 जैसी स्थितियों से बच सकते हैं, जहाँ परिणाम की अन्यथा शुद्ध रूप से आवधिक गणना की जाएगी। हम परिवर्तनशील टी को gcd (d, 10) के रूप में भी परिभाषित करते हैं ; यह बाद में उपयोग किया जाएगा।

पहली जांच है कि क्या है n है 0 या घ है 1 । यदि n * (d-1) 0 है, तो हम लौटते हैं +f, या NaN : अंश समाप्त हो रहा है ।

आगे के चेक कि क्या है टी है 1 । यदि ऐसा है, तो हम 1 : अंश शुद्ध रूप से आवधिक है ।

अगर टी है नहीं 1 , हम विभाजित घ द्वारा टी 0 द्वारा, पूरे समारोह को फिर से चलाएँ, और विभाजित हैं n / (घ / टी) को समाप्त कर रहा है, इस रिटर्न NaN / 0 = NaN : अंश है समाप्त । अन्यथा, यह 1/0 = इन्फिनिटी देता है : अंश अंततः आवधिक है ।

Comments

सबसे सरल रूप में कमी कहां है?

— टन हास्पेल

@ टोनहोस्ट फिक्स्ड।

— ETHproductions

@Arnauld मुझे यकीन नहीं है कि आपका क्या मतलब है। यह Infinityउन सभी मूल्यों के लिए लौटता है ।

— ETHproductions

@Arnauld Aw, यार, मुझे लगा कि मैं कभी भी एडजस्ट नहीं कर पा रहा हूं n... इस ओर इशारा करने के लिए धन्यवाद।

— ETHproductions

Answer 7

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

Ordering@{d=Denominator@#,GCD[d,10^d],1}&

आउटपुट {3,1,2}इनपुट, एक समाप्त दशमलव विस्तार है अगर {2,3,1}है, तो इनपुट एक विशुद्ध रूप से समय-समय पर दशमलव विस्तार है, और {3,2,1}इनपुट एक अंत में समय-समय पर दशमलव विस्तार है या नहीं।

डरपोक चाल के आधार पर: यदि dसबसे कम शब्दों में एक अंश का हर होता है, तो सबसे बड़ा सामान्य भाजक dऔर 10^dबराबर होता है dयदि dइसके मुख्य कारक में केवल 2s और 5s हों; बराबर होता है 1यदि dइसके मुख्य कारक में न तो 2s है और न ही 5s; और अगर d2s / 5s और अन्य primes के बीच में कुछ पूर्णांक के बराबर है ।

Orderingसमारोह सिर्फ रिपोर्ट जहां ट्रिपल की सबसे छोटी, अगले सबसे छोटा, और सबसे बड़ा तत्व हैं, संबंधों से तोडा बाएँ-से-सही।

फ़्लाव: के {1,2,3}बजाय भिन्न आउटपुट देता है{3,1,2} इनपुट 0 है तो है।

गणितज्ञ, 46 बाइट्स, विकृत

b[a][[Log[d=Denominator@#,GCD[d,10^d]]]][[1]]&

रिटर्न a[[1]]यदि इनपुट, एक समाप्त दशमलव विस्तार है b[[1]]यदि इनपुट एक विशुद्ध रूप से समय-समय पर दशमलव विस्तार है, और b[a]इनपुट एक अंत में समय-समय पर दशमलव विस्तार है या नहीं। सभी मामलों में एक त्रुटि फेंकता है!

जैसा कि ऊपर, हम जानना चाहते हैं कि क्या यह सबसे बड़ा सामान्य भाजक 1, d या कहीं के बीच में है। उस gcd का आधार-डी लघुगणक 0, 1, या बीच में कुछ के बराबर होता है।

अब हम गणितज्ञों पर अत्याचार करने लगे। अभिव्यक्ति b[a][[n]]के nवें भाग को दर्शाता है b[a]। तो b[a][[1]]लौटता है a; b[a][[0]]रिटर्न b; और b[a][[x]], जहां x0 और 1 के बीच एक संख्या होती है, गणितज्ञ को त्रुटि "भाग :: pkspec1: फेंक देता है। अभिव्यक्ति xको भाग विनिर्देश के रूप में उपयोग नहीं किया जा सकता है।" और b[a][[x]]अविकसित रिटर्न देता है ।

यह पहले से ही तीन मामलों को उचित रूप से अलग करता है, सिवाय इसके कि अंततः आवधिक मामले के लिए आउटपुट है b[a][[x]], जो गैर-स्थिर है क्योंकि xकिसी चीज का वास्तविक लघुगणक है। तो फिर हम [[1]]पहले से वर्णित आउटपुट पर लागू होते हैं । क्योंकि Mathematica आंतरिक रूप से किस तरह का प्रतिनिधित्व करता है b[a][[x]], इसका परिणाम b[a][[x]][[1]]बस है b[a]। दूसरी ओर, एक अलग त्रुटि "भाग :: partd: भाग विनिर्देशन [[1]] में परिणाम के [[1]]लिए आवेदन करना aवस्तु की गहराई से अधिक लंबा है।" और बिना a[[1]]शर्त (और इसी तरह b) रिटर्न करता है ।

दोष: इनपुट 0 के बारे में है, b[a]इसके बजाय लौट रहा है a[[1]]।

Answer 8

C 173 बाइट्स

स्टड से दो पूर्णांक लेता है, शुद्ध आवधिक के लिए 1 प्रिंट करता है, अंततः आवधिक के लिए -1 और समाप्ति के लिए 0।

int r;main(_,n,d){_-1?_-2?d-1?d%2&&d%5?r=1:d%2?main(3,n,d/5):main(3,n,d/2),r=r?-1:0:r=0:d?main(2,d,n%d):r=n:scanf("%d %d",&n,&d),main(2,n,d),main(3,n/r,d/r),printf("%d",r);}

Ungolfed:

// returns 1 for periodic, 0 for terminating, <0 for eventually periodic
int periodic(int num, int den) { // 3
    if (den == 1) return 0;
    if (den % 2 && den % 5) // pure periodic
        return 1;
    if (den % 2) return periodic(num,den/5) ? -1 : 0;
    return periodic(num,den/2) ? -1 : 0;
}

int gcd(int num, int den) { // 2
    if (den) 
        return gcd(den,num%den);
    return num;
}

int main(n,d) // 1
{
    scanf("%d %d",&n,&d);
    printf("%d",periodic(n/gcd(n,d),d/gcd(n,d)));
    return 0;
}   

आधा golfed:

int r;main(_,n,d){
    _-1? 
    _-2?
    // periodic
    d-1?
        d%2&&d%5?
            r=1:
                d%2?
                    main(3,n,d/5): //periodic
                    main(3,n,d/2), //periodic
                        r=r?-1:0:
                r=0
    // gcd
    :d?main(2,d,n%d):r=n // gcd
    // main
    :scanf("%d %d",&n,&d),
     main(2,n,d), // gcd
     main(3,n/r,d/r), // periodic
     printf("%d",r);
}

Answer 9

दरअसल , 15 बाइट्स

यह डेनिस के जेली उत्तर पर आधारित है । 0 समाप्त हो रहा है, 1 विशुद्ध रूप से आवधिक है, और 2 अंततः आवधिक है। गोल्फ सुझाव का स्वागत करते हैं। इसे ऑनलाइन आज़माएं!

▼Ny9u♀%SR♂b╔2@¿

Ungolfing

      Implicit input [a, b].
▼     Divide a and b by gcd(a,b).
Ny    Get the unique prime divisors of the reduced denominator.
9u    Push 10.
♀%    10 mod every member of uniq_p_d.
SR    Sort the mods and reverse.
♂b    Logical buffer. Converts every (10 % p != 0) to 1, and everything else to 0.
        Meaning if 2 or 5 divided b, they are now 0, and every other prime is now 1.
╔     Uniquify the list.
        If terminating, return [0].
        If purely periodic, return [1].
        If eventually periodic, return [1, 0].
        Else, (if b was 1), return [].
2@¿   Convert from binary to decimal. Return 0, 1, or 2.
      Implicit return.

Answer 10

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

If[ListQ@Last@#,Length@#==1]&@@RealDigits@#&

रिटर्न Nullसमाप्त करने के लिए, Trueशुद्ध रूप से आवधिक के लिए, और Falseअंततः आवधिक के लिए ।

व्याख्या

RealDigits

एन के दशमलव विस्तार का पता लगाएं (बार-बार अंक एक अतिरिक्त सिर से घिरे हैं List {} )।

ListQ@Last@#

जांचें कि क्या दशमलव विस्तार का अंतिम तत्व ए है List ।

Length@#==1

यदि उपरोक्त स्थिति है True, तो जांचें कि क्या पूरे दशमलव विस्तार में एक चीज शामिल है। (एList एक इकाई के रूप में एक मायने रखता है)। (रिटर्न Trueया False)

(यदि शर्त है False, तो एक Nullलौटा दी जाती है क्योंकि कोई तीसरा तर्क नहीं है If)

Answer 11

पायथ , 31 27 बाइट्स

AQ={P/HiGH?l@H=j25T?l-HT1Z2

इनपुट

4,12

आप इसे यहाँ आज़मा सकते हैं । अंततः आवधिक के लिए प्रिंट 1 , विशुद्ध रूप से आवधिक के लिए 2 , और 0 समाप्ति के लिए । कोडगॉल्फ में जवाब देने का यह मेरा पहला मौका है। किसी भी सुझाव का स्वागत है।

व्याख्या

AQ                                              // 1st element to G and 2nd element to H
    ={P                                         // Assign unique prime factors to H
        /H                                      // Simplify denominator
            iGH                                 // Find GCD
                ?l                              // Check length of filtered H
                    @H                          // Filter H by Y
                        =j25T                   // Assign a set [2,5] to T
                                ?l-HT           // Check length of H - T
                                        1Z2     // Print result

ध्यान दें कि [2,3] फ़िल्टर [2,5] = [2] लेकिन [2,3,5] - [2,5] = [3]।

Answer 12

PARI / जीपी, 64 बाइट्स

f(x,y)=if(setminus(factor(y=y/gcd(x,y))[,1]~,[2,5]),gcd(y,10)>1)

समाप्ति के लिए आउटपुट कुछ नहीं, विशुद्ध रूप से 0 के लिए और अंततः आवधिक के लिए 1।

बहुत फैंसी नहीं है, जब मैंने शुरुआत की तो मुझे कुछ बेहतर होने की उम्मीद थी।

Answer 13

05AB1E , 16 11 बाइट्स

@ अदनान को धन्यवाद, 5 बाइट्स बचाए!

¿²r/fTrÖbÙJ

प्योरली पीरियोडिक के लिए प्रिंट्स ०, टर्मिनेटिंग के लिए १ और आखिरकार पीरियड के लिए १०।

स्पष्टीकरण:

                 # Implicit input
                 # Implicit input
  ¿              # Take GCD of numbers
   ²             # Push top value from input register
    r            # Reverse stack order
     /           # Divide (denominator by GCD)
      f          # Find unique prime factors
       TrÖ       # Test 10 for divisibility
          b      # Convert (True -> 1, False -> 0)
           Ù     # Deduplicate array
            J    # Join chars in array
                 # Implicit print

इनपुट को p newline q के रूप में लिया जाता है ।

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

Comments

आपको 05AB1E :) का उपयोग करके देखना अच्छा लगा। ओसबी भी अंतर्निहित इनपुट का उपयोग करता है जो हमें पहले दो को निकालने की अनुमति देता है I। इसके अलावा, एक निरंतर पूर्वनिर्धारित 10है T। उसी के लिए 2B, जो b:) है।

— अदनान

आप इनपुट रजिस्टरों का भी उपयोग कर सकते हैं, जो हमें ¿²r/fTrÖbÙJअंतिम कोड के रूप में देता है :)।

— अदनान

Answer 14

PHP, 126 बाइट्स

$d=$argv[2];$a[]=$n=$argv[1];while($n%$d&&!$t){$n*=10;$t=in_array($n%=$d,$a);$a[]=$n;}if($a[1]&&$t)$t+=$a[0]!=end($a);echo+$t;

अंततः समाप्त के लिए प्रिंट 0 के लिए और अंतिम रूप से आवधिक 2 के लिए 1 प्रिंट। यदि कोई अंश दो बार सरणी में है, तो मुझे समझाएं कि यदि यह अवधि समाप्त हो जाती है, तो यह आवधिक सत्र शुरू होता echo end($a);है, 0 यदि आप मुझ पर भरोसा नहीं करते हैं$t=count($a)>$d?2:0; पाश में

इसे और अधिक स्पष्ट करने के लिए कृपया जोड़ें print_r($a);या var_dump($a);याjson_encode($a); पाश के बाद

यदि आप एक अंश दो बार दो वस्तुओं के बीच की वस्तुओं की गिनती करते हैं और आप आवधिक की लंबाई प्राप्त कर सकते हैं, तो आप सरणी के अंत में दो या एक शून्य देख सकते हैं और आप पहले अंश द्वारा स्थिति देख सकते हैं जहां आवधिक शुरू होता है

तो उसके बाद हम आवधिक अनुक्रम की स्थिति और लंबाई का पता लगा सकते हैं if($t){echo $p=array_search(end($a),$a);echo $l=count($a)-$p-1;}

आवधिक कल्पना करें

$d=$argv[2];
$a[]=$n=$argv[1]; #array numerator
$r[]=$n/$d^0; #array result of the division
$r[]=".";
while($n%$d&&!$t){
    $n*=10; 
    $n-=$d*$r[]=$n/$d^0;
    $t=in_array($n%=$d,$a); #stop if numerator is twice 
    $a[]=$n;
}
if($a[1]&&$t)$t+=$a[0]!=end($a); #periodic term starts directly?
if($t){
    echo $p=array_search(end($a),$a)."\n"; #output the beginning position of the periodic term
    echo $l=count($a)-$p-1; #output the length of the periodic term
    echo "\n";
    echo str_repeat(" ",2+$p).str_repeat("_",$l-1)."\n"; #visualize the periodic term
    #echo join(array_slice($r,0,1+$p)).join(array_slice($r,1+$p))."\n";# if you want only the periodic term 
    echo join($r); #result if the division
}
echo+$t; # 0 terminated 1+2 periodic 2 periodic start not directly

आउटपुट आवधिक शब्द की कल्पना करता है

1/18
   _
0.05

1/12
    _
0.083

1/13
  ______
0.076923

1/14
   ______
0.0714285

130 बाइट्स के साथ एक अन्य तरीका

$r=bcdiv(($z=$argv)[1],$z[2],400);for($p=2;$i++<200;)if(substr($r,2,$i)==substr($r,2+$i,$i))$p=1;echo strlen(rtrim($r,0))<50?0:$p;

विस्तारित संस्करण

$r=bcdiv(($z=$argv)[1],$z[2],400); # 100 is the maximal denominator 
# we need a string length with the double value of the sum the length from 1 until the denominator
for($p=2;$i++<200;)if(substr($r,2,$i)==substr($r,2+$i,$i))$p=1;
# all results begin with 0. 
#take two substrings with the same length after that and comparize both. 
#if we found 2 same substrings we have a periodic which starts at the first decimal place
echo strlen(rtrim($r,0))<50?0:$p; 
# if we can trim the length of the result we have a terminated result

Comments

सटीक दशमलव के लिए अंश भी देखें ।

— नील

@ क्या आपका मतलब है कि मुझे दूसरे प्रश्न का उत्तर देने के लिए कोड को संशोधित करना चाहिए?

— जोर्ग हल्सरमन 20

खैर, मैं सिर्फ यह सोच रहा था कि दूसरे प्रश्न का PHP उत्तर नहीं है; शायद आप एक प्रदान करना चाहते हैं।

— नील

@RosLuP उदाहरण 3/53 के लिए यह व्यूह बनाया जाएगा[3,30,35,32,2,20,41,39,19,31,45,26,48,3]

— Jörg Hülsermann

3/103 = 0.0291262135922330097087378640776699029126213592233009708 और इसी अवधि में एक ही अंक दिखाई दे सकता है (उदाहरण के लिए अंक 7 के बीच 00 ... 00 ऊपर) लेकिन अगर आप जिस सरणी के बारे में बात करते हैं, वह अंकों में से एक नहीं है, लेकिन {d} के सरणी = 10 * (d% b)} जहां अंक d / c है जितना मुझे लगता है कि यह ठीक है, प्रत्येक अवधि के लिए केवल एक मान d_i है ...

— RosLuP