Дріб до точного десяткового


23

Напишіть програму або функцію, яка задає два цілих числа a, b виводить рядок, що містить десяткове число, що точно представляє дріб a / b .

Якщо a / b є цілим числом, просто виведіть значення без десяткової крапки або провідних нулів:

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

Якщо a / b не є цілим числом, але має кінцеве подання в базі 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 секунд на сучасному настільному ПК. Найменша програма виграє в байтах.


@DestructibleWatermelon Це можливо майже на всіх мовах, включаючи тарінги Тюрінга. (Вони можуть боротися із тимчасовим обмеженням.)
Денніс

@DestructibleWatermelon У мене було враження, що більшість мов є завершеними.
orlp

Чи можемо ми спокійно припустити, що частка не буде чимось на зразок: 0,33333333333336333 ...?
brianush1

2
Це виглядає як довгодушний спосіб просити рішення щодо PE26 ;)
Conor O'Brien

Відповіді:


3

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

Перевірте це

Якщо вам не байдуже, що він буде працювати лише з знаменниками, які вписуються в 64-бітове ціле число, його можна скоротити до всього 43 байт:

{$/=($^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 Основна причина, по якій я розміщую гольфи, - це маркетинг та освіта Perl 6. Тому я залишаю старі версії, щоб показати більше мови. Ось чому я рідко розміщую її, поки не знайду там якихось пояснень. Я змінив це так, щоб різні приклади знаходилися в різних блоках коду.
Бред Гілберт b2gills

Старі версії завжди видно в історії редагування публікації.
mbomb007

@ mbomb007 Не, якщо я зачекаю до публікації, поки не спробую декілька різних способів її написати.
Бред Гілберт b2gills

Потім просто редагуйте його кожні 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

Я не зовсім впевнений у достовірності цієї відповіді, але вона працювала для вищевказаних тестових випадків та інших тестових випадків, які я на неї кинув. Це схоже на правильний безлад, тому я впевнений, що місця для гольфу є достатньо.

Початкова установка приймає абсолютні значення обох аргументів, щоб переконатися, що ми маємо справу з негативними числами (збереження обчислення знаків на потім) і делегує частку результату в арифметику довільної точності Python. Дробова частина виконується за допомогою алгоритму поділу школи-класу, поки ми не отримаємо повтор у решті. Потім ми дивимося вгору, коли ми востаннє бачили це повторення, щоб отримати період, і будуємо рядок відповідно.

Зауважте, що алгоритм насправді досить повільний через роботу O (n) 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 байт, видаливши непотрібні символи. "Безголів":

@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
Я не маю уявлення, як працює щось з цього, але я вдячний вам за те, що ви робите це у пакетній лмао
Олександр - Відновіть Моніку

Я вражений можливостями 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 довгого поділу. На кожному кроці виконайте ділення. Зберігайте обчислену цифру та залишок у двох списках. Якщо ми знову зустрінемо одну і ту ж цифру і решту, повторюється частина, і ми знаємо, з якого індексу він починається. Код або додає цифри (без повтору), або цифри, які повторюються, а потім повторні цифри, що містяться в дужках.

Це трохи більше, головним чином через BigInteger. Якщо входи не переповнені навіть longтоді, це може бути трохи коротше. І все-таки я сподіваюся, що є способи покращити цей запис.

Невикольований код з основним методом тестування:

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

@FryAmTheEggman спасибі, я не зрозумів, що статичний імпорт економив простір у більш детальних посиланнях. Це робить. Я також знайшов кілька інших речей, які я пропустив, таких як while (true)->, for (;;)що також дозволило мені помістити речі в forініціалізатор, зберігаючи ще один байт.

По-перше, як щодо розширення BigInteger? По-друге, для повторення достатньо повторного залишку; якщо ви обмежите вхід до int, ви можете використовувати int [] з залишком як індекс, а індекс як значення, якщо це має сенс.
JollyJoker

@JollyJoker розширення BigInteger вимагає написати цілий клас, щоб спробувати заощадити місце, і я серйозно сумніваюся, що компроміс спрацює. Крім того, я не можу обмежити введення даних. У будь-якому випадку, BigIntegerу моєму коді є вісім примірників тексту , і я не бачу, як додавання більшої кількості коду, щоб зменшити їх до одного імені класу символів, окупиться. І, звичайно, додавання коду для вирішення int[](що BigInteger вже робить внутрішньо) лише погіршить мою відповідь.

@JollyJoker також варто зазначити, що, якщо я не перекрию кожен BigInteger метод, який я закликаю повернути екземпляр підкласу, мені потрібно буде додати кілька каст, які ще більше роздувають код. На додаток до марних байтів для підкласу підкласу, це, безумовно, збільшить розмір коду.

1

PHP, 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

Математика 198 байт

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", "0.25", "-4. (3)", "2. (714285)", "131572.93852", "16.7 (857142)", "94.6 (428571)"}

Використовуючи наш веб-сайт, ви визнаєте, що прочитали та зрозуміли наші Політику щодо файлів cookie та Політику конфіденційності.
Licensed under cc by-sa 3.0 with attribution required.