নির্ভুল দশমিকের ভগ্নাংশ


23

একটি প্রোগ্রাম বা ফাংশন লিখুন যা দুটি পূর্ণসংখ্যাকে a, b দেয় এবং দশমিক সংখ্যা সহ একটি স্ট্রিং আউটপুট দেয় ভগ্নাংশটিকে ঠিক a / b উপস্থাপন করে ।

যদি / বি পূর্ণসংখ্যা হয়, কেবলমাত্র দশমিক বিন্দু বা নেতৃস্থানীয় শূন্যগুলি ব্যতীত মান আউটপুট করুন:

123562375921304812375087183597 / 2777 -> 44494913907563850333124661
81 / 3 -> 27
-6 / 2 -> -3

যদি / বি পূর্ণসংখ্যা না হয় তবে বেস 10 এ সীমাবদ্ধ প্রতিনিধিত্ব করে, অগ্রণী বা পিছনে শূন্য ছাড়াই মান নির্ধারণ করুন (বিন্দুর আগে একক শূন্য ব্যতীত):

1 / 2 -> 0.5
3289323463 / -250000000 -> -13.157293852

অবশেষে, যদি এবং কেবল যদি (তাই না 0.999...) a / b পূর্ণসংখ্যা না হয় এবং তার সীমাবদ্ধ প্রতিনিধিত্ব না থাকে তবে সুনির্দিষ্ট অংশটি অনুসরণ করুন যার পরে বন্ধনীতে পুনরাবৃত্তি করা হবে। পুনরাবৃত্তি অংশটি যতটা সম্ভব ছোট হওয়া উচিত এবং যত তাড়াতাড়ি সম্ভব শুরু করা উচিত।

-1 / 3 -> -0.(3)
235 / 14 -> 16.7(857142)
123 / 321 -> 0.(38317757009345794392523364485981308411214953271028037)
355 / 113 -> 3.(1415929203539823008849557522123893805309734513274336283185840707964601769911504424778761061946902654867256637168)

আপনার প্রোগ্রামটি একটি আধুনিক ডেস্কটপ পিসিতে 10 সেকেন্ডের নীচে অবশ্যই উপরের সমস্ত উদাহরণগুলির জন্য কাজ করবে। বাইটে ক্ষুদ্রতম প্রোগ্রাম


@ আবিষ্কারযোগ্য জলছবি তিউরিং তারপিসহ সমস্ত ভাষায় এটি সম্ভব । (যদিও তারা সময়সীমা নিয়ে লড়াই করতে পারে))
ডেনিস

@ আবিষ্কারযোগ্য জলছবি আমি এই ধারণার মধ্যে ছিলাম যে বেশিরভাগ ভাষা সম্পূর্ণরূপে টুরিং হয়।
orlp

আমরা কী নিরাপদে ধরে নিতে পারি ভগ্নাংশটি এর মতো হবে না: 0.33333333333336333 ...?
brianush1

2
এটি PE26 ;) এর সমাধান জিজ্ঞাসা করার মতো দীর্ঘ-বায়ুর মতো বলে মনে হচ্ছে ;)
কনর

উত্তর:


3

পার্ল 6 ,  63 58  50 বাইট

{->$a,$b {$a~"($b)"x?$b}(|($^a.FatRat/$^b).base-repeating(10))}
{->\a,$b {a~"($b)"x?$b}(|($^a.FatRat/$^b).base-repeating)}
{$/=($^a.FatRat/$^b).base-repeating;$0~"($1)"x?$1}

এটা পরীক্ষা করো

আপনি যদি খেয়াল না করেন যে এটি কেবল ডিনোমিনেটরদের সাথে কাজ করবে যা a৪ বিট পূর্ণসংখ্যার সাথে খাপ খায় এটি কেবল ৪৩ বাইটে সংক্ষিপ্ত করা যেতে পারে:

{$/=($^a/$^b).base-repeating;$0~"($1)"x?$1}

সম্প্রসারিত:

{
  # store in match variable so that we can
  # use 「$0」 and 「$1」
  $/ = (

    # turn the first value into a FatRat so that
    # it will continue to work for all Int inputs
    $^a.FatRat / $^b

  ).base-repeating;

  # 「$0」 is short for 「$/[0]」 which is the non-repeating part
  $0

  # string concatenated with
  ~

  # string repeat once if $1 is truthy (the repeating part)
  # otherwise it will be an empty Str
  "($1)" x ?$1
}

আপনি নিজের উত্তরটি যেভাবে ফর্ম্যাট করেছেন তা বিভ্রান্তিকর। আপনার পুরানো প্রোগ্রামগুলি সরানো উচিত, কারণ এই মুহুর্তে এটি একটি বহু-লাইন প্রোগ্রামের মতো দেখাচ্ছে।
mbomb007

@ mbomb007 আমার গল্ফ পোস্ট করার মূল কারণ হ'ল বিপণন এবং পার্ল 6. এর শিক্ষা So সে কারণেই আমি সেখানে খুব কমই একটি পোস্ট করি যতক্ষণ না সেখানে আমার কিছু ধরণের ব্যাখ্যা থাকে। আমি এটি পরিবর্তন করেছি যাতে বিভিন্ন উদাহরণগুলি বিভিন্ন কোড ব্লকে থাকে।
ব্র্যাড গিলবার্ট বিপিগিল

পুরাতন সংস্করণগুলি সর্বদা পোস্টের সম্পাদনার ইতিহাসে দৃশ্যমান।
mbomb007

@ mbomb007 আমি বিভিন্নভাবে লেখার জন্য চেষ্টা করার পরে পোস্ট করার অপেক্ষায় থাকি না।
ব্র্যাড গিলবার্ট

তারপরে প্রতি 5 মিনিটে কেবল একটি সম্পাদনা করুন।
mbomb007

8

পাইথন 2, 174 বাইট

x,y=input()
a=abs(x)
b=abs(y)
r=a%b*10
L=[]
M=''
while~-(r in L):L+=r,;M+=str(r/b);r=r%b*10
i=L.index(r)
t=M[:i]+"(%s)"%M[i:]*(M[i:]>'0')
print"-%d."[x*y>=0:(t>'')+3]%(a/b)+t

আমি এই উত্তরের বৈধতা সম্পর্কে যথেষ্ট নিশ্চিত নই, তবে এটি উপরের টেস্টের ক্ষেত্রে এবং এটিতে ফেলে দেওয়া অন্যান্য পরীক্ষার ক্ষেত্রে কাজ করেছে। এটি দেখতে যদিও সঠিক গণ্ডগোলের মতো, তাই আমি নিশ্চিত গল্ফ করার জন্য প্রচুর জায়গা আছে।

প্রাথমিক সেটআপ উভয় আর্গুমেন্টের নিখুঁত মান গ্রহণ করে তা নিশ্চিত করার জন্য যে আমরা ননজেগটিভ সংখ্যার সাথে কাজ করছি (পরে সাইন ক্যালকুলেশন সাশ্রয় করছি), এবং পাইথনের স্বেচ্ছাচারিত নির্ভুল গাণিতিকের ফলাফলের ভাগফলকে অর্পণ করি। ভগ্নাংশের অংশটি গ্রেড-স্কুল বিভাগ অ্যালগরিদমের সাথে সম্পন্ন করা হয় যতক্ষণ না আমরা বাকী অংশে কোনও পুনরাবৃত্তি না পাই। পিরিয়ডটি পাওয়ার জন্য আমরা যখন শেষ বার এই পুনরাবৃত্তিটি দেখেছি এবং ততক্ষণে স্ট্রিংটি তৈরি করি তখন আমরা সন্ধান করি।

মনে রাখবেন যে ও (এন) inঅপারেশনের কারণে অ্যালগোরিদমের আসলে বেশ ধীর গতি রয়েছে , তবে উদাহরণগুলির জন্য এটি যথেষ্ট দ্রুত।


5

ব্যাচ, 349 344 বাইট

@echo off
set/ad=%2,i=%1/d,r=%1%%d
if not %r%==0 set i=%i%.&if %r% leq 0 set/ar=-r&if %i%==0 set i=-0.
set d=%d:-=%
set/ae=d
:g
if %r%==0 echo %i%&exit/b
set/ag=-~!(e%%2)*(!(e%%5)*4+1)
if not %g%==1 set/ae/=g&call:d&goto g
set/as=r
set i=%i%(
:r
call:d
if %r%==%s% echo %i%)&exit/b
goto r
:d
set/ar*=10,n=r/d,r%%=d
set i=%i%%n%

সম্পাদনা করুন: অপ্রয়োজনীয় অক্ষরগুলি সরিয়ে 5 বাইট সংরক্ষণ করা হয়েছে। "Ungolfed":

@echo off
set /a d = %2
set /a i = %1 / d
set /a r = %1 % d
if not %r%==0 (
    set i=%i%.                  Decimal point is required
    if %r% leq 0 (
        set /a r = -r           Get absolute value of remainder
        if %i%==0 set i=-0.     Fix edge case (-1/3 = 0 remainder -1)
    )
)
set d = %d:-=%                  Get absolute value of divisor
set /a e = d
:g
if %r%==0 echo %i% & exit /b    Finished if there's no remainder
set /a g = gcd(e, 10)           Loop through nonrecurring decimals
if not %g%==1 (
    set /a e /= g
    call :d
    goto g
)
set /a s = r                    Save remainder to know when loop ends
set i=%i%(
:r
call :d
if %r%==%s% echo %i%)&exit/b
goto r
:d                              Add the next decimal place
set /a r *= 10
set /a n = r / d
set /a r %= d
set i=%i%%n%

2
এগুলির কোনওটি কীভাবে কাজ করে তা সম্পর্কে আমার কোনও ধারণা নেই তবে এটি ব্যাচ lmao এ করার জন্য আমি আপনাকে প্রশংসা করি
আলেকজান্ডার - মনিকা

আমি এর ক্ষমতা দিয়ে মুগ্ধ set /a
জো

2

জাভা, 625 605

গল্ফ কোড:

import static java.math.BigInteger.*;
String f(BigInteger a, BigInteger b){BigInteger[]r=a.divideAndRemainder(b);String s=r[0].toString();if(r[1].signum()<0)s="-"+s;if(!ZERO.equals(r[1])){s+='.';List<BigInteger>x=new ArrayList();List<BigInteger>y=new ArrayList();for(BigInteger d=TEN.multiply(r[1].abs());;){BigInteger[]z=d.divideAndRemainder(b.abs());int i=y.indexOf(z[1]);if(i>-1&&i==x.indexOf(z[0])){for(int j=0;j<i;++j)s+=x.get(j);s+='(';for(int j=i;j<x.size();++j)s+=x.get(j);s+=')';break;}x.add(z[0]);y.add(z[1]);if(ZERO.equals(z[1])){for(BigInteger j:x)s+=j;break;}d=TEN.multiply(z[1]);}}return s;}

দ্রষ্টব্য: আমি গল্ফিংয়ের উদ্দেশ্যে ফাংশনের অংশ হিসাবে স্থিতিশীল আমদানি গণনা করি।

এই ফাংশনটি বিভাগের ফলাফল পেয়ে শুরু হয়। এটি অবিচ্ছেদ্য অংশ যোগ করে এবং প্রয়োজনে সাইন করে। তারপরে যদি কোনও অবশিষ্ট থাকে, তবে এটি বেস 10 দীর্ঘ বিভাগ করে per প্রতিটি পদক্ষেপে, বিভাগ সঞ্চালন। গণিত অঙ্ক এবং বাকীটি দুটি তালিকায় সংরক্ষণ করুন। যদি আমরা আবার একই অঙ্কটির মুখোমুখি হয়ে থাকি এবং অবশিষ্টটি আবার খুঁজে পাই, তবে একটি পুনরাবৃত্ত অংশ রয়েছে এবং আমরা জানি এটি সূচকটি শুরু হয়। কোড হয় অঙ্কগুলি যোগ করে (পুনরাবৃত্তি হয় না) বা প্রাক-পুনরাবৃত্ত অঙ্কগুলি, তারপরে বার্থে বন্ধিত পুনরাবৃত্তি সংখ্যাগুলি।

এটি বেশিরভাগ কারণেই কিছুটা বড় BigInteger। ইনপুটগুলি ওভারফ্লো না হলে along তবে এটি কিছুটা ছোট হতে পারে। তবুও, আমি আশা করি এই প্রবেশের উন্নতির উপায় আছে।

পরীক্ষার জন্য প্রধান পদ্ধতির সাথে অলোভিত কোড:

import java.math.BigInteger;
import java.util.ArrayList;
import java.util.List;

import static java.math.BigInteger.*;

public class FractionToExactDecimal {

  public static void main(String[] args) {
    // @formatter:off
    String[][] testData = new String[][] {
      { "123562375921304812375087183597", "2777", "44494913907563850333124661" },
      { "81", "3", "27" },
      { "-6", "2", "-3" },
      { "1", "2", "0.5" },
      { "3289323463", "-250000000", "-13.157293852" },
      { "-1", "3", "-0.(3)" },
      { "235", "14", "16.7(857142)" },
      { "123", "321", "0.(38317757009345794392523364485981308411214953271028037)" },
      { "355", "113", "3.(1415929203539823008849557522123893805309734513274336283185840707964601769911504424778761061946902654867256637168)" }
    };
    // @formatter:on

    for (String[] data : testData) {
      System.out.println(data[0] + " / " + data[1]);
      System.out.println("  Expected -> " + data[2]);
      System.out.print("    Actual -> ");
      System.out.println(new FractionToExactDecimal().f(new BigInteger(data[0]), new BigInteger(data[1])));
      System.out.println();
    }
  }

  // Begin golf
  String f(BigInteger a, BigInteger b) {
    BigInteger[] r = a.divideAndRemainder(b);
    String s = r[0].toString();
    if (r[1].signum() < 0) s = "-" + s;
    if (!ZERO.equals(r[1])) {
      s += '.';
      List<BigInteger> x = new ArrayList();
      List<BigInteger> y = new ArrayList();
      for (BigInteger d = TEN.multiply(r[1].abs());;) {
        BigInteger[] z = d.divideAndRemainder(b.abs());
        int i = y.indexOf(z[1]);
        if (i > -1 && i == x.indexOf(z[0])) {
          for (int j = 0; j < i; ++j)
            s += x.get(j);
          s += '(';
          for (int j = i; j < x.size(); ++j)
            s += x.get(j);
          s += ')';
          break;
        }
        x.add(z[0]);
        y.add(z[1]);
        if (ZERO.equals(z[1])) {
          for (BigInteger j : x)
            s += j;
          break;
        }
        d = TEN.multiply(z[1]);
      }
    }
    return s;
  }
  // End golf
}

প্রোগ্রাম আউটপুট:

123562375921304812375087183597 / 2777
  Expected -> 44494913907563850333124661
    Actual -> 44494913907563850333124661

81 / 3
  Expected -> 27
    Actual -> 27

-6 / 2
  Expected -> -3
    Actual -> -3

1 / 2
  Expected -> 0.5
    Actual -> 0.5

3289323463 / -250000000
  Expected -> -13.157293852
    Actual -> -13.157293852

-1 / 3
  Expected -> -0.(3)
    Actual -> -0.(3)

235 / 14
  Expected -> 16.7(857142)
    Actual -> 16.7(857142)

123 / 321
  Expected -> 0.(38317757009345794392523364485981308411214953271028037)
    Actual -> 0.(38317757009345794392523364485981308411214953271028037)

355 / 113
  Expected -> 3.(1415929203539823008849557522123893805309734513274336283185840707964601769911504424778761061946902654867256637168)
    Actual -> 3.(1415929203539823008849557522123893805309734513274336283185840707964601769911504424778761061946902654867256637168)

নিস! আমি মনে করি আপনি একটি স্ট্রিং ফিরিয়ে ফাংশন তৈরি করে এবং সেই এক জায়গাটি সরিয়ে দিয়ে কয়েকটি বাইট সংরক্ষণ করতে পারেন a, BigInteger। আমিও মনে করি আপনি উরফ করতে পারেন BigInteger.TENএবং BigInteger.ZERO
FryAmTheEggman

@ ফ্রাইআম দ্য এজিগম্যান ধন্যবাদ, আমি আরও ভার্জোজ রেফারেন্সের তুলনায় স্থির আমদানি সংরক্ষণের স্থানটি বুঝতে পারি নি। এটা করে. আমি মিস করেছি এমন আরও কয়েকটি জিনিসও পেয়েছি যেমন while (true)-> for (;;)যা আমাকে forআর একটি বাইট সংরক্ষণ করে আরম্ভকারীতে জিনিসপত্র রাখার অনুমতি দেয়।

প্রথমত, বিগইন্টিজার বাড়ানো সম্পর্কে কীভাবে? দ্বিতীয়ত, এটির পুনরাবৃত্তি দেখানোর জন্য একটি পুনরাবৃত্তি অবশিষ্ট যথেষ্ট; যদি আপনি ইনপুটটিকে ইনটিতে সীমাবদ্ধ করেন তবে আপনি বাকী বাক্যটি সূচক হিসাবে এবং সূচককে মান হিসাবে ব্যবহার করতে পারেন, যদি তা বোঝা যায়।
জলি জোকর

@ জলিজোকার বিগইন্টিজারের প্রসারিত করতে স্থান বাঁচানোর চেষ্টা করার জন্য একটি পুরো ক্লাস লেখার প্রয়োজন ছিল, এবং আমি গুরুতরভাবে সন্দেহ করি যে ট্রেডঅফ কাজ করবে। এছাড়াও, আমি ইনপুট সীমাবদ্ধ করতে পারি না । যাইহোক, আমার কোডটিতে টেক্সটটির আটটি উদাহরণ রয়েছে BigIntegerএবং আমি দেখতে পাচ্ছি না যে কীভাবে একটি একক অক্ষর শ্রেণীর নামের সাথে সংকুচিত করতে আরও কোড যুক্ত করা বন্ধ হবে। এবং অবশ্যই এর সাথে ডিল করার জন্য কোড যুক্ত করা int[](যা বিগইন্টিজার ইতিমধ্যে অভ্যন্তরীণভাবে করেন) কেবল আমার উত্তরটি ফুটিয়ে তুলবে।

@ জলি জোকার এটিও উল্লেখযোগ্য যে আমি সাবক্লাসের একটি উদাহরণ ফিরিয়ে আনার জন্য যে সমস্ত BigInteger কল আমি কল করি না সেই সমস্ত পদ্ধতিকে আমি যদি ওভাররাইড না করি তবে আমাকে বেশ কয়েকটি ক্যাসেট যুক্ত করতে হবে যা কোডটি আরও ফুটিয়ে তোলে । সাবক্লাসের ওভারহেডের জন্য নষ্ট বাইটগুলির উপরে, এটি অবশ্যই কোডের আকার বাড়িয়ে তুলবে।

1

পিএইচপি, 277 বাইট

list(,$n,$d)=$argv;$a[]=$n;$n-=$d*$r[]=$n/$d^0;!$n?:$r[]=".";while($n&&!$t){$n*=10;$n-=$d*$r[]=$n/$d^0;$t=in_array($n%=$d,$a);$a[]=$n;}if($t){$l=count($a)-($p=array_search(end($a),$a));echo join(array_slice($r,0,2+$p))."(".join(array_slice($r,2+$p,$l)).")";}else echo join($r);

0

গণিত 1988 বাইট

i=Integer;t=ToString;a_~h~b_:=f[a/b];f@q_i:= t@q;
f@q_:=""<>{t@IntegerPart[q],".",RealDigits[FractionalPart[q]][[1]]//.{{x___,{k__i}}:> {x,"("<>(t/@{k})<>")"},{x__i,j___String}:>""<> {""<>t/@{x},j}}}

UnGolfed

(* hand over quotient of a, b to function f *)
h[a_, b_] := f[a/b];

(* if the quotient is an integer, return it as a string *)
f[q_Integer] := ToString@q;

(* otherwise, return the integer part, followed by a decimal point ...*)
f[q_] := "" <> {ToString@IntegerPart[q], ".", 

   (* replacing the repeating part (if it exists) between parentheses *)
   RealDigits[FractionalPart[q]][[1]] //. {{x___, {i__Integer}} :> {x, "(" <>(ToString /@ {i}) <> ")"},

   (* and the non-repeating part (if it exists) without parentheses *)
   {x__Integer, i___String} :> "" <> {"" <> ToString /@ {x}, i}}}

টেস্ট

h @@@ {{81, 3}, {-81, 3}, {1, 4}, {-13, 3}, {19, 7}, {3289323463, 25000}, {235, 14}, {1325, 14}}

27 "27", "-27", "0.25", "-4। (3)", "2. (714285)", "131572.93852", "16.7 (857142)", "94.6 (428571)"}

আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.