पहला आवधिक अंक हटाएं

Question

हम सभी जानते हैं कि जब भी किसी परिमेय संख्या को दशमलव में लिखा जाता है, परिणाम या तो समाप्त होता है या (अंततः) आवधिक होता है। उदाहरण के लिए, जब दशमलव में 41/42 लिखा जाता है, तो परिणाम होता है

0.9 761904 761904 761904 761904 761904 761904 761904 ...

अनुक्रमों के प्रारंभिक अनुक्रम के साथ और फिर से 0.9अनुक्रम 761904दोहराया गया। (इसके लिए एक सुविधाजनक अंकन वह 0.9(761904)जगह है जहाँ कोष्ठक दोहराव के अंकों के ब्लॉक को घेरते हैं।)

इस चुनौती में आपका लक्ष्य एक सकारात्मक तर्कसंगत संख्या लेना है, पहले अंक को दोहराएं जो दोहराए जाने वाले अनुक्रम का हिस्सा है, और परिणामी परिमेय संख्या वापस लौटाएं। उदाहरण के लिए, यदि हम इसे 41/42 तक करते हैं, तो हम प्राप्त करते हैं

0.9  61904 761904 761904 761904 761904 761904 761904 ...

या 0.9(619047)संक्षेप में, जो 101/105 है।

यदि तर्कसंगत संख्या में एक समाप्ति दशमलव विस्तार है, जैसे 1/4 = 0.25करता है, तो कुछ भी नहीं होना चाहिए। आप 1/4 के रूप में 0.250000000...या तो के बारे में सोच सकते हैं 0.249999999..., लेकिन या तो मामले में, दोहराए गए भाग के पहले अंक को हटाने से नंबर अपरिवर्तित हो जाता है।

विवरण

• इनपुट एक सकारात्मक परिमेय संख्या है, या तो अंश और हर का प्रतिनिधित्व करने वाले धनात्मक पूर्णांकों की एक जोड़ी के रूप में, या (यदि आपकी पसंद की भाषा इसे अनुमति देती है और आप चाहते हैं) किसी प्रकार के परिमेय-संख्या वस्तु के रूप में।
• आउटपुट एक तर्कसंगत संख्या भी है, दोनों रूप में भी। यदि परिणाम एक पूर्णांक है, तो आप एक परिमेय संख्या के बजाय पूर्णांक वापस कर सकते हैं।
• यदि इनपुट के रूप में संख्याओं की एक जोड़ी लेते हैं, तो आप मान सकते हैं कि वे अपेक्षाकृत प्रमुख हैं; यदि आउटपुट के रूप में संख्याओं की एक जोड़ी का निर्माण होता है, तो आपको उन्हें अपेक्षाकृत प्रमुख बनाना होगा।
• सावधान रहें कि आप पहला अंक पाते हैं जो दोहराए जाने वाले ब्लॉक को शुरू करता है। उदाहरण के लिए, कोई 41/42 लिख सकता है, 0.97(619047)लेकिन यह 2041/2100 (दशमलव विस्तार के साथ 0.97(190476)) एक वैध उत्तर नहीं बनाता है ।
• आप मान सकते हैं कि आपके द्वारा प्राप्त इनपुट में, दशमलव के बाद पहला आवधिक अंक 120/11= 10.909090909...अमान्य इनपुट है: (इसका पहला आवधिक अंक माना जा सकता 0है 10)। इस तरह के इनपुट पर आप कुछ भी कर सकते हैं।
• यह कोड-गोल्फ है : सबसे छोटा समाधान जीतता है।

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

41/42 => 101/105
101/105 => 193/210
193/210 => 104/105
104/105 => 19/21
1/3 => 1/3
1/4 => 1/4
2017/1 => 2017/1
1/7 => 3/7
1/26 => 11/130
1234/9999 => 2341/9999

Comments

क्या हम 2017इसके बदले लौट सकते हैं 2017/1?

— जंगहवान मिन

हां, यदि आप तर्कसंगत संख्या की बात कर रहे हैं। (यदि आप जोड़ी-पूर्णांक की बात कर रहे हैं, तो मुझे यकीन नहीं है कि आप जोड़ी के अलावा और क्या करेंगे (2017,1)।)

— मीशा लावरोव

इनपुट रिड्यूसबल (पूरी तरह सरलीकृत नहीं) हो सकता है? उदाहरण के लिए, 2/4इनपुट में हो सकता है?

— user202729

यदि इनपुट 120/11सही उत्तर है 111/11या 210/11?

— कैस्परल्ड

@kasperd हुह, यह एक ऐसा मामला है जिसके बारे में मैंने सोचा नहीं था ... मैं कहना चाहूंगा 111/11कि इस समय सबसे ज्यादा उत्थान का जवाब है 210/11, इसलिए मैं आपको मौजूदा उत्तरों को अमान्य करने से बचने के लिए चुनूंगा।

— मिशा लावरोव

Answer 1

वोल्फ्राम लैंग्वेज (गणितज्ञ) , 59 बाइट्स

FromDigits@MapAt[RotateLeft@*List@@#&,RealDigits@#,{1,-1}]&

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

व्याख्या

RealDigits@#

इनपुट के दशमलव अंक का पता लगाएं।

MapAt[RotateLeft@*List@@#&, ..., {1,-1}]

यदि दोहराए जाने वाले अंक हैं, तो RotateLeftउन्हें। ( List@@#यदि तर्कसंगत संख्या समाप्त हो रही है तो कोड को अंतिम दशमलव अंक को घुमाने के प्रयास से रोकता है)।

FromDigits@

तर्कसंगत में बदलें।

Comments

वास्तव में बहुत चालाक!

— डेविड डिक

Answer 2

जेली , 36 32 31 30 बाइट्स

-1 बाइट थैंक्स टू एरिक द आउटगोलर !

ọ2,5Ṁ⁵*©×Ɠ÷µ×⁵_Ḟ$+Ḟ,®×³+.Ḟ÷g/$

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

सही होना चाहिए। फ्लोटिंग पॉइंट इंप्रेशन के लिए 3 बाइट्स जोड़ें +.Ḟ।

इनपुट अप्रतिबंधित होने पर निर्भर करता है।

---

व्याख्या

यह पर निर्भर करता है:

• अंश n/dको उसके सरलतम रूप में होने दें । फिर लिंक पर ọ2,5Ṁआवेदन कियाd मूलांक के बाद गैर-आवधिक अंक की संख्या देगा।

ọ2,5Ṁ⁵*©×Ɠ÷µ×⁵_Ḟ$+Ḟ,®×³+.Ḟ÷g/$     Main link (monad take d as input)

    Ṁ                              Maximum
ọ                                  order of
 2,5                               2 or 5 on d
     ⁵*                            10 power
       ©                           Store value to register ®.
        ×Ɠ                         Multiply by eval(input()) (n)
          ÷                        Divide by first argument (d).
                                   Now the current value is n÷d×®.
           µ                       With that value,
            ×⁵                     Multiply by ⁵ = 10
              _Ḟ$                  subtract floor of self
                 +Ḟ                add floor or value (above)
                                   Given 123.45678, will get 123.5678
                                   (this remove first digit after `.`)
                   ,®              Pair with ®.
                     ׳            Scale
                       +.Ḟ         Round to integer
                          ÷g/$     Simplify fraction

Comments

30 बाइट्स

— एरिक आउटोलॉफ़र

@EriktheOutgolfer धन्यवाद!

— user202729

Answer 3

अजगर 2 , 237 235 214 बाइट्स

^{-21 बाइट्स मिस्टर एक्सकोडर का धन्यवाद}

from fractions import*
F=Fraction
n,d=input()
i=n/d
n%=d
R=[]
D=[]
while~-(n in R):R+=n,;n*=10;g=n/d;n%=d;D+=g,
x=R.index(n)
r=D[x+1:]+[D[x]]
print i+F(`r`[1::3])/F('9'*len(r))/10**x+F("0."+"".join(map(str,D[:x])))

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

इनपुट एक ट्यूल के रूप में किया जाता है (numerator, denominator); आउटपुट ए हैfractions.Fraction वस्तु है।

यह उत्तर के शुरुआती और दोहराए गए अंकों को प्राप्त करने के लिए एक लंबी-विभाजन-शैली की विधि का उपयोग करता है, फिर पहले दोहराए जाने वाले अंक को अंत तक ले जाता है और स्ट्रिंग हेरफेर का उपयोग करता है और fraction.Fractionइसे वापस अनुपात में परिवर्तित करता है।

Ungolfed संस्करण:

import fractions

num, denom = input()
integer_part, num = divmod(num, denom)

remainders = []
digits = []
current_remainder = num
while current_remainder not in remainders:
    remainders.append(current_remainder)
    current_remainder *= 10
    digit, current_remainder = divmod(current_remainder, denom)
    digits.append(digit)

remainder_index = remainders.index(current_remainder)
start_digits = digits[:remainder_index]
repeated_digits = digits[remainder_index:]

repeated_digits.append(repeated_digits.pop(0))

start_digits_str = "".join(map(str, start_digits))
repeated_digits_str = "".join(map(str, repeated_digits))

print(integer_part+int(repeated_digits_str)/fractions.Fraction('9'*(len(repeated_digits_str)))/10**len(start_digits_str)+fractions.Fraction("0."+start_digits_str))

Answer 4

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

from fractions import*
def f(n,d):
 i=1;r=[]
 while~-(i%d in r):r+=[i%d];i*=10
 r=10**r.index(i%d);u=i-r;v=i//r-1;t=u//d*n
 return Fraction(t-t%v+t%v*10//v+t%v*10%-~v,u)

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

Comments

@ Mr.Xcoder संपादित

— लीक नून

Answer 5

वोल्फ्राम लैंग्वेज (गणितज्ञ) , 70 67 बाइट्स

-3 बाइट के लिए इस टिप (अब हटाए गए) के लिए धन्यवाद !

(x=10^Max@IntegerExponent[#,{2,5}];(Floor@#+Mod[10#,1])/x&[x#2/#])&

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

मेरा एक बंदरगाह जेली उत्तर । मौजूदा मैथेमेटिका से 8 बाइट्स तक का उत्तर ...

फ़ंक्शन 2 इनपुट लेता है [denominator, numerator], जैसे कि GCD[denominator, numerator] == 1।

Answer 6

पर्ल 6 , 102 बाइट्स

{$/=.base-repeating;(+$0//$0~0)+([~]([$1.comb].rotate)/(9 x$1.chars)*.1**(($0~~/\.<(.*/).chars)if $1)}

कोशिश करो

एक परिमेय संख्या लेता है और एक परिमेय या इंट लौटाता है संख्या देता है।

विस्तारित:

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

  $/ = .base-repeating; # store in ｢$/｣ the two strings '0.9' '761904'

    # handle the non-repeating part
    (
      +$0        # turn into a number
      // $0 ~ 0  # if that fails append 0 (handle cases like '0.')
    )

  +

    # handle the repeating part
    (
          [~]( [$1.comb].rotate ) # rotate the repeating part
        /
          ( 9 x $1.chars )        # use a divisor that will result in a repeating number

        *

         # offset it an appropriate amount

         .1 ** (
           ( $0 ~~ / \. <( .* / ).chars # count the characters after '.'
         )

      if $1  # only do the repeating part if there was a repeating part
    )
}

नोट uint64.Range.maxबड़े भाजक को संभालने के लिए अप करने के लिए हर जगह का उपयोग FatRat(9 x$1.chars) करेगा ।