부적절한 분수에 대한 대분수

이 도전에서 당신은 혼합 된 숫자를 부적절한 분수로 변환 할 것입니다.

부적절한 분수는 더 적은 수의 숫자를 사용하므로 코드는 가능한 짧아야합니다.

예

4 1/2
9/2

12 2/4
50/4

0 0/2
0/2

11 23/44
507/44

사양

입력의 분모가 0이 아니라고 가정 할 수 있습니다. 입력은 항상 x y/zx, y, z가 음이 아닌 임의의 정수인 형식입니다. 출력을 단순화 할 필요는 없습니다.

이것은 코드 골프 이므로 바이트 단위의 가장 짧은 코드가 승리합니다.

apt, 10 바이트

현재 CJam을 때리고있는 Woohoo!

U*W+V+'/+W

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

작동 원리

       // Implicit: [U,V,W] = eval(input). This automatically discards the slash.
U*W+V  // Calculate the new numerator: (whole part * denominator) + numerator.
+'/+W  // Add the slash and the denominator.
       // Implicit: output last expression

LabVIEW, 29 LabVIEW 프리미티브

CJam, 16 15 14 바이트

l'/']er~:Xb'/X

또는

l'/']er~_@b'/@

여기에서 테스트하십시오.

설명

l      e# Read input.
'/']er e# Replace the "/" with a "]".
~      e# Evaluate the string as code. If the input was "i n/d", this pushes [i n] d.
:X     e# Store the denominator in X.
b      e# Treat [i n] as base-d digits. This effectively computes i*d + n.
'/     e# Push a slash.
X      e# Push the denominator.

다른 버전에서는 조금 더 스택 이동을 사용하여 변수를 사용하지 않습니다.

Mathematica, 58 바이트

ToExpression@StringReplace[#," "->"+"]~ToString~InputForm&

단순화 된 결과를 반환합니다. 문자열 대신에 합리적인 숫자를 출력하는 것이 좋습니다.

ToExpression@StringReplace[#," "->"+"]&

PowerShell, 47 44 42 바이트

_{44가 여전히 똑같습니다. 44; (}

$l,$n,$d=$args-split'\D';"$(+$l*$d+$n)/$d"

regex를 사용하여 몇 바이트를 골프화했습니다 -split. TessellatingHeckler 덕분에 정규 표현식을 교체하여 몇 가지 더 골프를 쳤습니다 .

은 $args-split'\D'우리의 입력 인자를 가지고 숫자가 아닌 문자 분할합니다. 여기서는 공백과 문자에 각각 하나씩 두 개의 분할을 수행 /합니다. 그런 다음 결과는 동시 할당을 사용하여 세 가지 변수에 저장됩니다. 그런 다음 문자열 출력을 코드 블록, 슬래시 및 분모로 다시 실행 된 ( 분모 $l수에 $d분모 + $n분자)를 공식화합니다./$d

Ten Foot Laser Pole이있는 Java 1.03, 79 + 25 (가져 오기) = 104 바이트

필요 import sj224.tflp.math.*;

String m(String[]a){return ""+new BigRational(a[0]).add(new BigRational(a[1]));}

이것은 거의 확실히 1.04에서도 작동하지만 지금까지 빌드 경로에 1.03으로 Java 프로젝트를 설정했기 때문에 1.03으로 만 테스트했습니다.

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

m=>([x,y,z]=m.match(/\d+/g),+y+x*z+"/"+z)

@ETHproductions 덕분에 3 바이트를 절약했습니다 !

설명

매우 간단합니다.

m=>
  ([x,y,z]=m.match(/\d+/g), // x, y and z = numbers from input
    +y+x*z                  // numerator
    +"/"+z                  // denominator
  )

테스트

테스트는 대부분의 브라우저에서 작동하도록 할당을 파괴하지 않습니다.

var solution = m=>+(p=m.match(/\d+/g))[1]+p[0]*p[2]+"/"+p[2]

<input type="text" id="input" value="11 23/44" />
<button onclick="result.textContent=solution(input.value)">Go</button>
<pre id="result"></pre>

줄리아, 58 50 바이트

s->eval(parse((r=replace)(r(s," ","+"),"/","//")))

이것은 문자열을 받아들이고 Rational형식 객체를 반환하는 익명 함수입니다 . 호출하려면 이름을 지정하십시오 (예 :) f=s->....

입력을 합리적으로 평가하는 표현으로 약간 조작 할 수 있다는 사실을 활용할 수 있습니다. 특히, 정수 + 유리수는 유리수이며 유리수는 이중 슬래시로 표시됩니다. 우리가 설정 한 경우 그래서 4 1/2으로 4+1//2, 평가 결과가 될 것입니다 9//2.

언 골프 드 :

function f(s::AbstractString)
    # Replace the space in the input with a plus
    r1 = replace(s, " ", "+")

    # Replace the / with //
    r2 = replace(r1, "/", "//")

    # Parse the resulting expression as a rational
    return eval(parse(r2))
end

스몰 토크 – 76 자

입력은 배열 구분자와 스몰 토크의 고유 분수 표현과 정확히 일치합니다. 그것이 너무 장황하지 않았다면, 그것은 심각한 경쟁자가 될 수 있습니다!

Compiler evaluate:'|p|p:=0.#(',FileStream stdin nextLine,')do:[:q|p:=p+q].p'

너무 나쁘다 단순화가 요구 사항이 아니 었습니다.

배쉬 + 코어 유틸리티, 28

dc<<<${@/\// }sarla*+n47Plap

$@는 모든 명령 줄 매개 변수로 ${@/\// }확장 되므로 모든 명령 줄 매개 변수는 /로 대체되어 의 스택 에 배치됩니다 dc. 나머지는 간단한 스택 조작 및 산술입니다.

하스켈 , 74 67 63 바이트

r=read
f x|(a,(c,s:d):_)<-lex<$>lex x!!0=show(r a*r d+r c)++s:d

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

설명

H.PWiz가 알아 낸 것처럼 여기에서 Haskell의 어휘 분석기를 사용하여 문자열을 부분으로 나눌 수 있습니다. (이전 내가 사용했다 span(>'/')) 그리고 Laikoni는 지적이 <$>단지 같은 작품 mapSnd에서 Data.Tuple.

패턴 가드는 코드를 사용하고자하는 세 개의 숫자로 나눕니다 lex. lex첫 번째 토큰을 해제하기 위해 haskell의 어휘 분석기를 호출합니다. 문자열을 구문 분석하는 가능한 방법을 나타내는 각 요소가있는 목록을 리턴합니다. 이 요소는 첫 번째 요소가 첫 번째 토큰이고 나머지 문자열은 두 번째 요소 인 튜플입니다. 입력 형식이 매우 규칙적이기 때문에 정확히 하나의 구문 분석 만 할 수 있으므로 항상 첫 번째 형식을 취할 수 있습니다. 가장 먼저 할 일은 lex입력을 호출 하는 것입니다

lex x

그런 다음 목록에서 풀어서 2 튜플을 제공합니다.

lex x!!0

첫 번째 토큰은 혼합 된 분수의 전체 부분으로, 여전히 파싱 할 공백이 앞에옵니다. 그런 다음 튜플이기 때문에 Functors우리가 사용할 수있는 (<$>)별칭 fmap적용하는 lex튜플의 두 번째 요소입니다.

lex<$>lex x!!0

이것은 공간을 통해 먹고 우리의 분수의 분자 인 다음 토큰을 끊습니다. 이제 이것을 사용하여 패턴 일치에 바인딩합니다 <-. 우리의 패턴은

(a,(c,s:d):_)

a분수의 전체 부분 인 첫 번째 토큰을 가져옵니다. :_우리의 두 번째 결과 목록을 해제합니다 lex. c우리가 어셈블 한 두 번째 토큰, 즉 분수의 분자를 잡습니다. 남아있는 모든 것은 바인딩되어 s:d첫 번째 문자로 분할되며 형식은 a /이며 나머지는 분모가됩니다.

이제 입력을 파싱 했으므로 실제 계산을 수행합니다.

show(r a*r d+r c)++s:d

r이전에 바인딩 한 읽기 기능은 어디에 있습니까 ?

lex목록이 실패하면 비어 있고 성공하면 비어 있지 않은 것을 반환하는 것이 중요 합니다. 이것이 Maybe내가 모르는 이유는 무엇입니까?

자바 스크립트 ES6, 62 바이트

p=prompt;b=p(a=+p()).split`/`;alert((+b[1]*a+ +b[0])+"/"+b[1])

펄, 82 61 38 바이트

#!perl -paF/\D/
$_=$F[0]*$F[2]+$F[1]."/$F[2]"

이것은 아마도 더 골프를 칠 수 있습니다.

변경

• 에서 정규 표현식을 사용하여 16 바이트를 절약 split하고 <>대신 5를 사용하여 5 바이트를 절약했습니다 <STDIN>.
• Dennis 덕분에 16 바이트를 더 절약했습니다.

수학, 51 바이트

Interpreter["ComputedNumber"]@#~ToString~InputForm&

흥미롭게도 Mathematica는 내장 기능을 지원합니다. 숫자 출력이 허용되면 28 바이트 만 필요합니다.

Interpreter@"ComputedNumber"

자바 159 148 142 120 110 바이트

String m(String[]a){Long b=new Long(a[0]),d=new Long((a=a[1].split("/"))[1]);return b*d+new Long(a[0])+"/"+d;}

FlagAsSpam 덕분에 많은 바이트를 절약했습니다.

ARBLE , 13 바이트

a*c+b.."/"..c

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

05AB1E , 17 15 바이트

#`'/¡R`Š©*+®'/ý

@MagicOctopusUrn 덕분에 -2 바이트 .

온라인으로 시도 하거나 모든 테스트 사례를 확인하십시오 .

설명:

#`         # Split input by spaces and push all items to the stack
           #  i.e. "4 1/2" → "4" and "1/2"
  '/¡      # Push the second item by "/"
           #  i.e. "1/2" → [1,2]
     R`    # Revert the list, and also push all items to the stack
           #  i.e. [1,2] → [2,1] → 2 and 1
Š          # Triple-swap the stack
           #  [4,2,1] → [1,4,2]
 ©         # Store the 2 in the register
  *        # Multiple the top two items
           #  4 and 2 → 8
   +       # Add the top two items
           #  1 and 8 → 9
®          # Push the 2 from the register to the stack again
 '/ý       # Join the two items by "/"
           #  9 and 2 → "9/2"

유연한 입력 및 출력 형식을 사용하면 순서대로 정수를 가져 와서 x,z,y구분 기호로 노미 네이터와 분모를 출력하면 4 바이트가됩니다 (따라서 구문 분석 태그를 챌린지에 추가 했습니다.).

*+²»

온라인으로 시도 하거나 모든 테스트 사례를 확인하십시오 .

설명:

*        # Multiply the first two inputs (x and z)
         #  i.e. 4 and 2 → 8
 +       # Add the third input (y)
         #  i.e. 8 and 1 → 9
  ²      # Take the second input again (z)
   »     # Join the stack by newlines and implicitly print it

파이썬 3 , 78 76 바이트

def f(s):a,b=s.split();b,c=b.split('/');return'%s/'%(int(a)*int(c)+int(b))+c

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

Stax , 1 바이트

+

실행 및 디버깅 (디버그가 많지는 않지만)

챌린지 사양에는 "출력을 단순화 할 필요가 없습니다"라고 나와 있습니다. 단순화 할 수 있다고 가정하면 stax에 내장 명령이 있습니다. 입력은 내재적으로 정수 및 유리수로 해석됩니다. 이 +명령은 합리적, 추가 및 단순화로 확장됩니다. 결과는 암시 적으로 인쇄됩니다.

-la -Mfeature = say를 사용하는 Perl 5 , 32 바이트 25 바이트

m|/|;say$_*$'+$F[1],"/$'"

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

(Dom Hastings 덕분에 7 바이트)

$_전체 입력 으로 숫자 컨텍스트 x y/z의 값을 평가합니다 x(예 : *here). $'다음에 오는 어떤 여기에 들어있는 정규 표현식 경기 후 문자열이며, /그래서는 - z. y값 을 얻기 위해 -a입력을 공백으로 나누고 @F배열에 배치 하는 플래그를 사용합니다 . 따라서 여기에서는 숫자 컨텍스트에서 평가 @F = ("x", "y/z")하는 것을 의미 합니다 ( 와 함께 초기 연속 된 숫자 시퀀스이므로 ).$F[1]="y/z"yy$F[1]

루아, 123 바이트

m=io.read()z=string x=z.find c=z.sub b=tonumber s=x(m," ")f=x(m,"/")d=c(m,f+1)print(b(c(m,1,s))*b(d)+b(c(m,s,f-1)).."/"..d)

은하수 1.6.0 , 31 바이트

'" "\="/"\=>;<A;A;:>*;A+"/"+<+!

내가 생각했던 것보다 훨씬 길어졌습니다.

설명

'" "\="/"\=>;<A;A;:>*;A+"/"+<+!

'                                # read input from the command line
 " "  "/"               "/"      # push a string to the stack
    \    \                       # split the STOS at the TOS
     =    =                      # dump the TOS to the stack
           >       >             # rotate the stack rightward
            ;  ; ;   ;           # swap the TOS and STOS
             <              <    # rotate the stack leftward
              A A     A          # push the integer representation of the TOS
                  :              # duplicate the TOS
                    *            # multiply the STOS by the TOS
                       +   + +   # add the TOS and STOS
                              !  # output the TOS

용법

./mw <path-to-code> -i <input>

파이썬 2.7, 88 바이트

a = input (). split ( '/'); print int (a [-1]) * int (a [0] .split () [0]) + int (a [0] .split () [1 ]), '/', a [1]

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

입력을 따옴표로 입력해야합니다.

아마 최고는 아닙니다 ...

C, 64

main(i,d,n){scanf("%d %d/%d",&i,&n,&d);printf("%d/%d",i*d+n,d);}

STDIN에서 입력을 읽습니다. 상당히 설명이 필요하다고 생각합니다.

120 바이트 확인

>]+>:>32r#v
#d@0+\)  ##:>4;:>5'=:>48-\R-?
dd)R>32-#v
#>15-#v  #?
47r@>@   #v
#dd#v #?
r@>@     #v
    #\d@\: @*@+pd"/"op

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

구문 분석 루프 (두 번째 줄)를 재사용하지 않고 일부 바이트를 절약 할 수 있습니다. 그렇게하면 루프를보다 구체적으로 만들고 조건부에서 큰 혼란을 피할 수 있으며 레지스터를 다른 용도로 사용할 수 있습니다.

루비 , 23 바이트

->x{eval x.split*?++?r}

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

C #, 112 바이트

s=>{string[]a=s.Split(),b=a[1].Split('/');int o=int.Parse(b[1]);return int.Parse(a[0])*o+int.Parse(b[0])+"/"+o;}

풀 / 포맷 버전 :

namespace System.Linq
{
    class P
    {
        static void Main()
        {
            Func<string, string> f = s =>
            {
                string[] a = s.Split(), b = a[1].Split('/');
                int o = int.Parse(b[1]);
                return int.Parse(a[0]) * o + int.Parse(b[0]) + "/" + o;
            };

            Console.WriteLine(f("4 1/2"));
            Console.WriteLine(f("12 2/4"));
            Console.WriteLine(f("0 0/2"));
            Console.WriteLine(f("11 23/44"));

            Console.ReadLine();
        }
    }
}

APL (Dyalog Unicode) , 31 바이트

∊∘(⍕¨⊃,⍨'/',⍨⊃⊥1∘↓)¯1⌽#⍎¨∊∘⎕D⊆⊢

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

⊃⊥1∘↓트릭을 위한 ngn에게 감사합니다

PHP, 65 바이트

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

암호

<?=(($a=preg_split("/[\s,\/]/",$argv))[0]*$a[2]+$a[1])."/".$a[2];

설명

$a=preg_split("/[\s,\/]/",$argv); # Split the string on "/" and " "
(($a)[0]*$a[2]+$a[1]) # as always denominator*whole number + numerator 
."/"                  # echo an slash
.$a[2];               # echo de denominator

자바 10, 87 바이트

발 람다 String로 String.

s->{var p=s.split(" |/");return new Long(p[0])*new Long(p[2])+new Long(p[1])+"/"+p[2];}

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