প্রথম পর্যায়ক্রমিক অঙ্ক মুছুন

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...উভয় ক্ষেত্রেই ভাবতে পারেন , পুনরাবৃত্তি অংশের প্রথম অঙ্কটি মুছলে নম্বরটি অপরিবর্তিত থাকে।

বিস্তারিত

• ইনপুটটি ইতিবাচক যুক্তিযুক্ত সংখ্যা, হয় সংখ্যার এবং ডিনোমিনেটরের প্রতিনিধিত্বকারী ধনাত্মক পূর্ণসংখ্যার জোড় হিসাবে, বা (যদি আপনার পছন্দের ভাষা এটির অনুমতি দেয় এবং আপনি চান) কিছু ধরণের যুক্তি-সংখ্যা অবজেক্ট হিসাবে।
• আউটপুটটিও একটি যুক্তিযুক্ত সংখ্যা, উভয় আকারে। ফলাফলটি যদি পূর্ণসংখ্যার হয় তবে আপনি যৌক্তিক সংখ্যার পরিবর্তে পূর্ণসংখ্যাটি ফিরিয়ে দিতে পারেন।
• যদি একজোড়া সংখ্যাকে ইনপুট হিসাবে নেওয়া হয় তবে আপনি ধরে নিতে পারেন যে তারা তুলনামূলকভাবে প্রধান; যদি আউটপুট হিসাবে একজোড়া সংখ্যার উত্পাদন করে তবে আপনাকে অবশ্যই সেগুলি তুলনামূলকভাবে প্রধান হতে হবে।
• সতর্কতা অবলম্বন করুন যে আপনি প্রথম সংখ্যাটি পুনরাবৃত্তি করার জন্য ব্লক শুরু করেন find উদাহরণস্বরূপ, কেউ 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ইনপুট মধ্যে কি ঘটতে পারে?

— ব্যবহারকারী 202729

ইনপুট যদি 120/11সঠিক উত্তর হয় 111/11বা 210/11?

— ক্যাস্পারড

@ ক্যাস্পার্ড হু, এটি এমন একটি ঘটনা যা আমি ভেবেও দেখিনি ... আমি 111/11এই মুহূর্তে সর্বাধিক উর্ধ্বমুখী উত্তরটি বাদ দিয়ে বলতে চাই 210/11, তাই আমি আপনাকে বিদ্যমান উত্তরগুলি অবৈধ হওয়া এড়াতে বেছে নেব।

— মিশা লাভরভ

Answer 1

ওল্ফ্রাম ভাষা (গণিত) , 59 বাইট matic

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 বাইট

— এরিক দি আউটগল্ফার

টুইটারে

— ব্যবহারকারী 202729

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 এটি আবার অনুপাততে রূপান্তরিত করতে।

অবরুদ্ধ সংস্করণ:

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

@ মিঃ এক্সকোডার সম্পাদিত

— নুন

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
    )
}

নোট পর্যন্ত denominators, হ্যান্ডেল করা হবে uint64.Range.maxবৃহত্তর denominators, ব্যবহার নিয়ন্ত্রণ করার জন্য FatRat(9 x$1.chars) এটি ব্যবহার করে দেখুন ।