Số hỗn hợp thành một phân số không đúng

Trong thử thách này, bạn sẽ chuyển đổi một số hỗn hợp thành một phần không chính xác.

Vì các phân số không chính xác sử dụng số lượng ít hơn, mã của bạn sẽ cần phải càng ngắn càng tốt.

Ví dụ

4 1/2
9/2

12 2/4
50/4

0 0/2
0/2

11 23/44
507/44

Đặc điểm kỹ thuật

Bạn có thể giả sử mẫu số của đầu vào sẽ không bao giờ bằng 0. Đầu vào sẽ luôn ở định dạng x y/ztrong đó x, y, z là các số nguyên không âm tùy ý. Bạn không cần đơn giản hóa đầu ra.

Đây là mã golf để mã ngắn nhất tính theo byte thắng.

Japt, 10 byte

Woohoo, hiện đang đánh bại CJam!

U*W+V+'/+W

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

       // 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 Nguyên thủy

CJam, 16 15 14 byte

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

hoặc là

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

Kiểm tra nó ở đây.

Giải trình

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.

Phiên bản khác tránh sử dụng một biến bằng cách sử dụng dịch chuyển ngăn xếp nhiều hơn một chút.

Toán học, 58 byte

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

Điều này trả về kết quả đơn giản hóa. Nếu xuất ra một số hữu tỷ thay vì một chuỗi là tốt, chúng ta có thể lưu 19 byte:

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

PowerShell, 47 44 42 byte

_{Vượt qua 44 vẫn là 44 thường xuyên (}

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

Đánh gôn một vài byte bằng cách sử dụng regex -split. Chơi gôn nhiều hơn nhờ TessellatingHeckler bằng cách hoán đổi regex.

Các $args-split'\D'đối số đầu vào của chúng tôi và phân chia trên các ký tự không chữ số. Ở đây nó thực hiện hai phần tách, một phần trên khoảng trắng, phần còn lại trên /ký tự. Các kết quả sau đó được lưu trữ trong ba biến bằng cách sử dụng một phép gán đồng thời. Sau đó, chúng tôi xây dựng đầu ra chuỗi là ( $lsố eft nhân với số $dmẫu cộng với bộ điều $nchỉnh) được thực thi dưới dạng khối mã, /dấu gạch chéo và sau đó là $dmẫu số.

Java với Mười chân Laser 1.03, 79 + 25 (nhập) = 104 byte

Đòi hỏi import sj224.tflp.math.*;

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

Điều này gần như chắc chắn cũng sẽ hoạt động với 1.04, nhưng cho đến nay tôi chỉ thử nghiệm nó với 1.03 vì tôi đã có một dự án java được thiết lập với 1.03 trong đường dẫn xây dựng.

JavaScript (ES6), 44 41 byte

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

Đã lưu 3 byte nhờ @ETHproductions !

Giải trình

Rất đơn giản.

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

Kiểm tra

Kiểm tra là không phá hủy sự phân công để làm việc trong hầu hết các trình duyệt.

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>

Julia, 58 50 byte

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

Đây là một hàm ẩn danh chấp nhận một chuỗi và trả về một Rational đối tượng kiểu. Để gọi nó, đặt tên cho nó, vd f=s->....

Chúng ta có thể lợi dụng thực tế là đầu vào có thể được thao tác một chút để trở thành một biểu thức đánh giá một tỷ lệ hợp lý. Cụ thể, một số nguyên cộng với một số hữu tỷ là một số hữu tỷ và các số hữu tỷ được biểu thị bằng dấu gạch chéo kép. Vì vậy, nếu chúng ta biến 4 1/2thành4+1//2 , kết quả được đánh giá sẽ là 9//2.

Ung dung:

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

Smalltalk - 76 ký tự

Đầu vào khớp chính xác với dấu phân cách mảng và biểu diễn phần vốn có của Smalltalk. Nếu nó không quá dài dòng, thì đó có thể là một ứng cử viên nặng ký!

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

Đơn giản hóa quá tệ không phải là một yêu cầu, Smalltalk tự động thực hiện!

Bash + coreutils, 28

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

$@mở rộng cho tất cả các tham số dòng lệnh, do đó ${@/\// }mở rộng ra tất cả các tham số dòng lệnh được /thay thế bằng , được đặt trên dcngăn xếp của. Phần còn lại là thao tác ngăn xếp đơn giản và số học.

Haskell , 74 67 63 byte

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

Hãy thử trực tuyến!

Giải trình

Như H.PWiz đã tìm ra, chúng ta có thể sử dụng từ vựng của Haskell ở đây để chia chuỗi thành các phần của nó. (Trước đó tôi đã sử dụng span(>'/')) Và Laikoni đã chỉ ra rằng <$>hoạt động giống như mapSndtừData.Tuple .

Bộ bảo vệ mẫu chia mã của chúng tôi thành ba số chúng tôi muốn sử dụng lex. lexgọi lexer của haskell để phá vỡ mã thông báo đầu tiên. Nó trả về một danh sách với mỗi phần tử đại diện cho một cách có thể để phân tích chuỗi. Các phần tử này là các bộ dữ liệu với phần tử đầu tiên là mã thông báo đầu tiên và phần còn lại của chuỗi là phần tử thứ hai. Bây giờ vì định dạng đầu vào rất đều đặn, chúng tôi sẽ chỉ có chính xác một phân tích cú pháp, vì vậy chúng tôi luôn có thể lấy cái đầu tiên. Điều đầu tiên chúng ta làm là gọi lexvào đầu vào

lex x

Sau đó, chúng tôi mở khóa nó từ danh sách của nó cho chúng tôi 2 tuple

lex x!!0

Mã thông báo đầu tiên sẽ là toàn bộ phần của phần hỗn hợp để lại phần được dự phòng bởi một khoảng trắng để phân tích cú pháp. Sau đó, vì các bộ dữ liệu là Functorschúng ta có thể sử dụng (<$>)một bí danh fmapđể áp dụng lexcho phần tử thứ hai của bộ dữ liệu.

lex<$>lex x!!0

Điều này ăn xuyên qua không gian và phá vỡ mã thông báo tiếp theo, tử số của phân số của chúng tôi. Bây giờ chúng tôi liên kết này với một mô hình phù hợp bằng cách sử dụng <-. Mô hình của chúng tôi là

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

alấy toàn bộ phần của phân số, mã thông báo đầu tiên của chúng tôi. :_mở ra danh sách kết quả từ thứ hai của chúng tôi lex. clấy mã thông báo thứ hai mà chúng tôi đã lấy, đó là tử số của phân số. Mọi thứ còn lại bị ràng buộc để s:dphân tách nó thành ký tự đầu tiên của nó, được đảm bảo bởi định dạng là một/ và phần còn lại sẽ là mẫu số.

Bây giờ chúng tôi đã phân tích cú pháp đầu vào, chúng tôi thực hiện tính toán thực tế:

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

Trong trường hợp rlà chức năng đọc chúng ta bị ràng buộc trước đó.

Điều quan trọng cần lưu ý là lextrả về một danh sách trống nếu nó thất bại và không trống nếu nó thành công. Tại sao đây không phải là một Maybetôi không biết.

Javascript ES6, 62 byte

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

Perl, 82 61 38 byte

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

Điều này có thể có thể được chơi golf nhiều hơn.

Thay đổi

• Đã lưu 16 byte bằng cách sử dụng regex trong splitvà 5 bằng cách sử dụng <>thay vì <STDIN>.
• Đã lưu thêm 16 byte nhờ Dennis.

Toán học, 51 byte

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

Thật thú vị, Mathicala hỗ trợ điều này với một tích hợp. Nếu đầu ra một số được cho phép, hơn chúng ta chỉ cần 28 byte:

Interpreter@"ComputedNumber"

Java, 159 148 142 120 110 byte

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

Đã lưu một loạt byte nhờ FlagAsSpam.

CẠNH , 13 byte

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

Hãy thử trực tuyến!

05AB1E , 17 15 byte

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

-2 byte nhờ @MagicOctopusUrn .

Hãy thử trực tuyến hoặc xác minh tất cả các trường hợp thử nghiệm .

Giải trình:

#`         # 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"

Với định dạng đầu vào và đầu ra linh hoạt, lấy các số nguyên theo thứ tự x,z,yvà xuất ra chỉ định và mẫu số trên các dòng riêng biệt sẽ là 4 byte (đó là lý do tại sao tôi đã thêm phân tích cú pháp -tag vào thử thách ..):

*+²»

Hãy thử trực tuyến hoặc xác minh tất cả các trường hợp thử nghiệm .

Giải trình:

*        # 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

Python 3 , 78 76 byte

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

Hãy thử trực tuyến!

Stax , 1 byte

+

Chạy và gỡ lỗi nó (mặc dù không có nhiều thứ để gỡ lỗi)

Đặc tả thách thức cho biết "Bạn không cần đơn giản hóa đầu ra." Giả sử nó được phép đơn giản hóa, thì sẽ có một hướng dẫn tích hợp sẵn để thực hiện điều này. Đầu vào được hiểu ngầm là một số nguyên và một số hữu tỷ. Các+ hướng dẫn mở rộng cả hai để hợp lý, thêm và đơn giản hóa. Kết quả được in ngầm.

Perl 5 với -la -Mfeature = say, 32 byte 25 byte

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

Hãy thử trực tuyến!

(-7 byte nhờ vào Dom Hastings)

$_là toàn bộ đầu vào x y/z, để đánh giá giá trị của xtrong bối cảnh số (như *ở đây). $'là chuỗi sau trận đấu regex, ở đây có chứa bất cứ điều gì đến sau /- vì vậy , z. Để có được ygiá trị, chúng tôi sử dụng -acờ phân tách đầu vào trên khoảng trắng và đặt chúng vào @Fmảng. Vì vậy, ở đây, @F = ("x", "y/z")có nghĩa là $F[1]="y/z"đánh giá trong ybối cảnh số (vì ylà chuỗi các chữ số liền kề ban đầu với $F[1]).

Lua, 123 byte

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)

Dải ngân hà 1.6.0 , 31 byte

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

Kết thúc là lâu hơn tôi nghĩ nó sẽ được.

Giải trình

'" "\="/"\=>;<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

Sử dụng

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

Python 2.7, 88 byte

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

Hãy thử trực tuyến !

Bạn phải gõ đầu vào trong dấu ngoặc kép.

Có lẽ không phải là tốt nhất ...

C, 64

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

Đọc đầu vào từ STDIN. Khá tự giải thích, tôi nghĩ.

Kiểm tra , 120 byte

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

Hãy thử trực tuyến!

Tôi có thể có thể lưu một số byte bằng cách không sử dụng lại vòng lặp phân tích cú pháp (dòng thứ hai). Bằng cách đó tôi có thể làm cho vòng lặp cụ thể hơn, tránh sự lộn xộn lớn của các điều kiện và tôi có thể sử dụng đăng ký cho những thứ khác.

Hồng ngọc , 23 byte

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

Hãy thử trực tuyến!

C #, 112 byte

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

Phiên bản đầy đủ / định dạng:

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 byte

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

Hãy thử trực tuyến!

Cảm ơn ngn vì ⊃⊥1∘↓mánh khóe

PHP, 65 byte

Dùng thử trực tuyến

Mã

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

Giải trình

$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

Java 10, 87 byte

Một lambda từ Stringđến String.

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

Dùng thử trực tuyến