연속 분수는 분수를 반복적으로 설명하는 표현식입니다. 그것들은 그래픽으로 표현 될 수 있습니다 :

또는 값 목록으로 표시 될 수 있습니다. [a0; a1, a2, a3, ... an]

도전 과제 :

기수 : 및 분모 값 목록 : 연속 분수를 단순화 된 합리적인 분수로 단순화합니다 : 분자 및 분모를 개별적으로 반환 또는 인쇄합니다.a0[a1, a2, a3, ... an]

예 :

• √19 : [4;2,1,3,1,2]: 170/39
• ℯ: [1;0,1,1,2,1,1]: 19/7
• π: [3;7,15,1,292,1]: 104348/33215
• ϕ: [1;1,1,1,1,1]: 13/8

구현 예 : (python)

def foo(base, sequence):
    numerator = 1
    denominator = sequence[-1]
    for d in sequence[-2::-1]:
        temp = denominator
        denominator = d * denominator + numerator
        numerator = temp
    return numerator + base * denominator, denominator

승리:

J, 8 5 바이트

이것 과 동일 하지만 이성에 내장을 사용합니다.

인수는 J 확장 정밀도 유리수 목록으로 {a0, a1, a2, a3, ...}입니다. 결과는 J 확장 정밀도 유리수로서의 분수입니다.

(+%)/

(+%) 더하기의 더하기

/ 이상 감소

온라인으로 사용해보십시오!

마일 덕분에 -3 .

하스켈, 37 36 18 바이트

foldr1$(.(1/)).(+)

이 함수는 하스켈 Ratio타입을 입력으로 예상 합니다. 사용 예 :

Prelude Data.Ratio> ( foldr1$(.(1/)).(+) )  [4%1,2,1,3,1,2] 
170 % 39

참고 : Ratio입력 목록 ( 4%1)에 명시 된 것 하나만으로 충분합니다. 유형 시스템은 다른 것 Ratio역시 s 이어야한다고합니다 .

편집 : @ Lin은 바이트를 저장했습니다. 감사!

편집 II : 제거했습니다 import(이 메타에 대한 토론 참조 ).

GolfScript , 13 바이트

~]-1%{\-1?+}*

온라인으로 사용해보십시오!

GolfScript의 숨겨진 합리성에 대한 예 . :)

설명

GolfScript의 유일한 "공식"숫자 유형은 정수입니다. 그러나 지수 연산자는 결과를 정수로 변환하지 않으며 Ruby (GolfScript의 인터프리터 언어)의 정수 지수의 기본 결과는 합리적인 수입니다. 따라서 우리는 -1의 거듭 제곱으로 무언가를 올림으로써 쉽게 분수를 얻을 수 있습니다. 편리하게, 우리는 어쨌든 상호를 원합니다 ...

~]     # Evaluate input and wrap all a_i in a list.
-1%    # Reverse the list so that a_n is at the start and a_0 at the end.
{      # Fold... (apply this block to each element from a_n-1 down to a_0, with
       # the previous result on the stack)
  \    #   Swap previous result with current a_i.
  -1?  #   Raise previous result to the power of -1, computing its reciprocal
       #   as a rational number.
  +    #   Add a_i.
}*

매스 매 티카, 23 22 바이트

Fold[#2+1/#&]@*Reverse

본질적 으로 내 GolfScript 답변의 포트입니다 . 대안은 다음과 같습니다.

24 바이트의 경우 재귀 가변성 함수를 작성할 수 있습니다.

f@n_=n
n_~f~m__:=n+1/f@m

21 바이트의 경우 "가변 연산자"를 정의 할 수도 있지만 호출 규칙이 너무 이상해서 이것을 계산하는 것을 꺼려합니다.

±n_=n
n_ ±m__:=n+1/±m

또는 일련 의 입력 값으로 이를 호출해야 합니다 (예 : ±Sequence[3, 7, 15, 1, 292, 1]또는) ±##&[3, 7, 15, 1, 292, 1].

또한 21 바이트의 경우 (금지 된) 내장 기능이 있습니다.

FromContinuedFraction

LabVIEW, 36 바이트

OP의 알고리즘을 사용하여 순진한 순진한 구현. 더 좋은 방법이 있습니까?

Dyalog APL , 10 바이트

합리성에 대해 내장 기능을 사용하지 않습니다.

{a ₀ , a ₁ , a ₂ , a ₃ , ...}을 인수로 취하여 {분모, 분자}를 반환합니다.

1(,÷∨)+∘÷/

1(,÷∨) 1 앞에-를 1의 GCD로 나눈 값

+∘÷ 더하기의 역수

/ 이상 감소

TryAPL 온라인!

파이썬 2, 62 바이트

a=d=0
b=c=1
for n in input():a,b=b,n*b+a;c,d=d,n*d+c
print b,d

불행히도 골치 아픈 것은 아니지만 ( @xnor의 대답 은 더 짧음 참조) 입력을 되돌릴 필요없이 분수를 계산합니다. 이것은 마지막 두 분수 와 다음 분수는 수렴에 대해 "매직 테이블" 접근 방식을 사용합니다 .a/cb/d(n*b+a)/(n*c+d)

예를 들어, pi의 경우 :

          3    7    15     1      292        1

  0   1   3   22   333   355   103993   104348
  1   0   1    7   106   113    33102    33215

우리는 볼 수있다 15*22 + 3 = 333, 15*7 + 1 = 106, 1*333 + 22 = 355, 1*106 + 7 = 113, 등

M, 5 바이트

Ṛİ+¥/

입력 값은 값의 목록이며 [a0, a1, ..., aN]유리수를 출력합니다.

온라인으로 사용해보십시오! 또는 모든 테스트 사례를 확인하십시오.

설명

Ṛİ+¥/  Input: list A
Ṛ      Reverse A
    /  Reduce A from left to right using
   ¥     A dyadic chain
 İ         Take the reciprocal of the left value
  +        Add the reciprocal to the right value
       Return and print implicitly

하스켈, 30 바이트

foldr(\h(n,d)->(h*n+d,n))(1,0)

재귀 각 층은 바깥쪽으로가는 업데이트에 추가 n/d로 h+(1/(n/d))같아지는, h+d/n또는 (h*n+d)/n. 분수는의 튜플로 저장됩니다 (num,denom). (1,0)뒤집기 의 초기 부분은 0/1입니다 0.

파이썬, 50 바이트

f=lambda l,n=1,d=0:l and f(l,l.pop()*n+d,n)or(n,d)

목록의 끝에서 계속 분수 반복 부분 업데이트, 뒤로가는 빌드 n/d마지막 요소에 x등을 n/d -> 1+1/(n/d) == (x*n+d)/n.

 커먼 리스프, 54

다소 장황한 오른쪽 :

(lambda(s)(reduce(lambda(a r)(+(/ r)a))s :from-end t))

테스트

PASS  NAME  ACTUAL               EXPECTED
===============================================
T     √19   170/39               170/39              
T     ℯ     19/7                 19/7                
T     π     104348/33215         104348/33215        
T     ϕ     13/8                 13/8                

줄리아 (53 바이트)

Julia를 사용한 것은 이번이 처음입니다. 반복자를 간과 한 경우 더 많은 바이트를 잃어 버릴 수 있었으면 알려주세요. 다음은이 특정 과제에 어떤 언어를 선택해야할지 모르는 사람을위한 힌트입니다. https://en.wikipedia.org/wiki/Rational_data_type

f(x,c)=(a=0;for b in x[end:-1:1];a=1//(b+a);end;a+c;)

• 입력 배열을 뒤집습니다.
• 합리적인 나눗셈으로 반복합니다.
• 소수점 결과에 c를 더합니다.

자바 스크립트 (ES6), 55 바이트

s=>eval('for(F=[1,0];s+"";)F=[s.pop()*F[0]+F[1],F[0]]')

테스트 사례

var f =
s=>eval('for(F=[1,0];s+"";)F=[s.pop()*F[0]+F[1],F[0]]')

console.log(f([4, 2, 1, 3, 1, 2]));
console.log(f([1, 0, 1, 1, 2, 1, 1]));
console.log(f([3, 7, 15, 1, 292, 1]));
console.log(f([1, 1, 1, 1, 1, 1]));

CJam , 18 16 바이트

XUq~W%{2$*+\}/]p

온라인 통역사 .

XU                  Push 1 and 0 to the stack
  q~W%              Push input, eval and reverse it
      {     }/      For each n in the reversed input...
       2$             Copy numerator
         *+           Calculate n*denominator + numerator
           \          Swap numerator and denominator
              ]p   Wrap in array and output

05AB1E , 19 17 바이트

R¬V¦vyY*X+YUV}YX)

설명

숫자 목록으로 가져온 입력

                     # variable X is initialized as 1
R¬V¦                 # reverse the list, remove the first item and store it in variable Y
    v        }       # for each item N left in list
     yY*X+  V        # store N*Y+X in Y
          YU         # store Y in X
              YX)    # wrap X and Y in a list

온라인으로 사용해보십시오!

자바 스크립트 (ES6), 44 바이트

a=>a.reduceRight(([n,d],v)=>[v*n+d,n],[1,0])

자바 스크립트 (ES6), 50 바이트

f=(s,n=1,d=s.pop())=>s+""?f(s,d,s.pop()*d+n):[d,n]

Arnauld의 답변 덕분에 66 바이트에 붙어 있다는 것을 알았습니다.

f=(b,s,i=s.length-1,n=1,d=s[i])=>i?f(b,s,--i,d,s[i]*d+n):[n+b*d,d]

예 :
전화 : f([1, 0, 1, 1, 2, 1, 1])
출력 :Array [ 19, 7 ]

펄 6 , 24 바이트

{[R[&(1/*+*)]](@_).nude}

설명:

• 1 / * + *는 *첫 번째의 역수를 취하고 두 번째를 더하는 두 개의 매개 변수 ( ) 가있는 람다입니다 . ( 쥐를 돌려줍니다 )

• R[&(…)]마치 마치 마치 마치 연산자처럼 사용하고 반대로합니다.
  (올바른 연관 만들기 포함)

• […](@_) 그것을 입력을 줄이기 위해 사용합니다.

• … .nude반품 뉴 merator와 드 의 추천인 쥐 .

• { … }암시 적 매개 변수를 사용하여 베어 블록 람다로 만드십시오 @_.

용법:

say {[R[&(1/*+*)]](@_).nude}(3,7,15,1,292,1) #*/# (104348 33215)

my &code = {[R[&(1/*+*)]](@_).nude}; # stupid highlighter */

say code 4,2,1,3,1,2;    # (170 39)
say code 1,0,1,1,2,1,1;  # (19 7)
say code 1,1,1,1,1,1;    # (13 8)

제퍼 , 145 바이트

input n as Integer
set a to Array(n)
for i from 1to n
input a[i]as Integer
next
set r to a[n]
for i from 1to n-1
set r to(/r)+a[n-i]
next
print r

Zephyr은 내가 만든 최초의 프로그래밍 언어입니다. 간결성을 유지하기 위해 직관적이고 깔끔한 구문을 갖도록 설계되었습니다. 내가 왜 골프를합니까? 그 이후로 쓴 언어와 달리 내장 언어가 있기 때문 Fraction입니다. 나눗셈 연산자 /를 "inverse"(Pip에 빌린 기능)의 단항 연산자 로 사용할 수도 있습니다 .

이제 중요한 한계가 있습니다. 이 문제의 가장 큰 문제는 배열을 고정 크기로 정의해야한다는 것입니다. 즉, 프로그램은 사용자로부터 배열의 크기를 읽어 시작합니다. (이것이 좋기를 바랍니다. 대안은 크기를 하드 코딩합니다.) 연산자 우선 순위가 존재하지 않는 사소한 문제도 있습니다. 즉, 다중 연산자 식에는 괄호가 있어야합니다.

다음은 예제 실행입니다.

C:\Zephyr> python zephyr.py contfrac.zeph
6
1
1
1
1
1
1
13/8

루비, 34 바이트

->a{a.reverse.inject{|b,i|i+1r/b}}

이렇게하면 오른쪽 접힘 (반전 한 다음 왼쪽 접힘)을 수행하여 누적 합계 (오른쪽 요소)보다 1에 각 요소를 추가합니다. 루비에는 합리적인 타입이 있는데 정말 좋습니다. 리터럴 합리에는 접미사가 붙은 숫자입니다 r.

Stax , 4 바이트

╣╩┼►

실행 및 디버깅

작은 크기로 내장되어 있지 않습니다. 내장 이론은 상당히 도움이됩니다. ascii에 압축이 풀린 프로그램은 rksu+입니다.

1. 배열을 뒤집습니다.
2. 을 사용하여 배열을 접습니다 (a, b) => (a + 1/b).

APL (NARS), 15 + 1 자, 30 + 2 바이트

{1=≢⍵:↑⍵⋄+∘÷/⍵}

Adam J 솔루션의 Apl (Nars) 변환 ... 해당 함수에 허용 된 입력은 모든 정수 목록이며 첫 번째 요소는 합리적 유형입니다. 테스트:

  f←{1=≢⍵:↑⍵⋄+∘÷/⍵}      
  f 4x 2 1 3 1 2
170r39 
  f 1x 0 1 1 2 1 1
19r7 
  f 3x 7 15 1 292 1
104348r33215 
  f 1x 1 1 1 1 1
13r8 
  f 3x 89 888 999 11 222 373 7282 9272 3839 2828 
158824716824887954093160207727r52744031585005490644982548907 
  f ,0x
0 
  f ,9x
9 

그래서 함수의 길이는 15 문자이고 원하는 입력 유형을 입력하고 원하는 유형을 종료하는 경우 "x"는 1 문자입니다 ...