text:
Rollover Calendar
This is inspired by one of Downgoat's questions in Sandbox, where I suggested that he include April 31 as Pi day for people who use day/month format, only for him to inform me that there is no April 31!
Given a date string in month/day format that might be invalid, output the correct date using rollover. (First rollover the month, then rollover the day).
Examples:
"15/43" - This reads as the 43rd day of the 15th month. First, we roll over the month to the next year, so we end up with 3 (March). Now, since March only has 31 days, we rollover the extra days to April, so we output the actual date as "4/12" (April 12th).
"3/16" - This is a valid date (March 16th). Return it as is.
"12/64" - Ah, so many fond memories from December 64th... December has 31 days, January has 31 days, so what I really mean is "2/2" (February 2nd).
"19/99" - First, the 19 becomes a 7 (July). July has 31 days, August has 31 days, September has 30 days, so the output is "10/7" (October 7th).
"1/99999" - A year has 365 days. 99999 (mod 365) = 354. The 354 day of the year is "12/20".
"9999999/10" - Apparently, 9999999 (mod 12) = 3, so this is "3/10" (March 10th).
Criteria:
Input month is an integer > 0. Input day is an integer > 0. Year never needs to be specified, as such there are no leap years to deal with.
Update:
As I think it would overly simplify the challenge, calendar functions, such as those in the Java Calendar class, are banned. Date parsing/formatting functions are still allowed though.

Related.

Another important test case would be one with enough days to roll over more than 8 years, such that answers which use built-ins have to pay attention to those built-ins using leap years.

Oh, that answers that... I was just about to post a Mathematica answer which uses a built-in. :/

@Martin Sorry about that ;).

For reference, the Mathematica solution was still 90 bytes long (although that was massively dominated by the string processing). If you want to add such a test case nevertheless, 1/99999 should yield 12/19 I think.

@Martin Hm, I got 12/20. Which one of us is right?

@geokavel You're right, there was a bug in my code (in fact, I had 12/20 earlier).

LabVIEW, 32 LabVIEW Primitives

That was quick.

Can you assure me there are no calendar functions used here?

The good thing about LabVIEW is that its basically what it looks to be. First thing scans numbers from a string 2 modulos, the box is a switch case structure that gives out 28,30 or 31 and then it gets put together as a string again.

C#, 269 223
string v(string n){var x=new[]{31,28,31,30,31,30,31,31,30,31,30,31};var s=n.Split('/');Func<string,int> p=int.Parse;var m=p(s[0]);var d=p(s[1]);m=m>=12?m%12:m;while(d>x[m]){d-=x[m];m=++m>=12?m%12:m;}return(m==0?1:m)+"/"+d;}

Edit: Fixed to work for cases like 24/1, 36/1, etc. and golfed a little. Thanks for the comments, there are several places I saved a bit!
Ungolfed:
string v(string n)
{
    var x = new [] { 31 ,28, 31, 30, 31, 30,31, 31, 30, 31, 30, 31 };

    var s = n.Split('/');
    Func<string,int> p = int.Parse;
    var m = p(s[0]);
    var d = p(s[1]);
    m = m >= 12 ? m % 12 : m;
    while (d > x[m])
    {
        d -= x[m];
        m = ++m >= 12 ? m % 12 : m;
    }
    return (m==0?1:m) + "/" + d;
}

First of all: Welcome to the community! I would guess you could save some Bytes by assigning the dictionary in a loop or using a switch function (no C# pro here though). Also directly printing ´m + "/" + d´ might help a little. And last (this might or might not work) using char* instead of string in the arguments.

This fails on certain test cases, e.g. 24/1.

@Eumel thanks! Directly printing uses Console.Write which is more than return, and in C# I would use char[] as a replacement for string, but it's the same amount of chars, and makes splitting on the / more problematic. But, your note on the Dictionary did lead me to a way better version!

R, 208 182 bytes
m=c(31,28,31,30,31,30,31,31,30,31,30,31)
e=scan(sep="/");n=(e[1]/12-1)*12;if(!n%%12)n=12;if(n<0)n=e[1];j=e[2];while((j<-j-m[n])>0){n=n+1;if(n>12)n=1};j=m[n]+j;cat(n,j,sep="/")

Get the month by dividing by 12, then loop, removing the number of days of the current month until you get a negative number., inverse last step and print.
On multiple lines (need to use a file and source it):
m=c(31,28,31,30,31,30,31,31,30,31,30,31)
e=scan(sep="/")
n=(e[1]/12-1)*12
if(!n%%12)n=12
if(n<0)n=e[1]
j=e[2]
while((j<-j-m[n])>0){n=n+1;if(n>12)n=1}
j=m[n]+j;cat(n,j,sep="/")

This is the message I get when trying to run your program in R: http://pastebin.com/dPh1n64a

Strange I'll recheck later

I also got this message. Your program seems to have problems with some months. Otherwise it's running. http://pastebin.com/g3BCUDi8

thanks for the feedback.  I'm on road actually, I'll correct it

I understand. It seems like your program breaks with the "TRUE/FALSE" error message if the month is higher than 24.

Got it, should be n<1 as first if condition

@geokavel Sorry for the late feedback, I corrected the multiple of 12 months to give valid results now.

@plannapus Yes, thanks. It default to double according to my doc, but should not be a problem.

@Tensibai yes you're right, my bad (i should have remembered that the error message says that it expects "a real").

PHP >= 5.5, 181 bytes
list($m,$d)=explode("/",$argv[1]);$m%=12;$d%=365;$i=0;while($d>100)$d-=[31,28,31,30,31,30,31,31,30,31,30,31][$i++];$m+=$i;echo date_create_from_format("m/d","$m/$d")->format("n/j");

PHP almost supports rollover with date parsing and formatting instructions alone. For example:
echo date_create_from_format("m/d","12/64")->format("n/j"); // Output: 2/2

However, once either number gets bigger than 100, PHP rejects parsing it and returns an error (probably for some arbitrary reason). So, the theory with this answer is to get it back down to where PHP will parse it, then submit it to date_create_from_format().
Ungolfed:
list($month, $day) = explode("/", $argv[1]);
$month = $month % 12;
$day = $day % 365;
$i = 0;
$days = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
while($day > 31) $day -= $days[$i++];
$month += $i;
echo DateTime::createFromFormat("m/d", $month . "/" . $day)->format("n/j");

Try it online

You need to give me a way to input the date string,  or make it a function.

GET parameters are not acceptable as an input method in PHP. You will need to either make this a function and pass the input as function parameters, or get input from $argv or STDIN.

@Mego Jeeze, give me some time to update my answer since the OP didn't state any requirements for input - it's simple enough to change $t to $argv[1] and now it reads from command line input.

The OP stating requirements for input is irrelevant; we have a list of default acceptable I/O methods (which I linked) so that challenge authors don't have to specify them on every challenge.

JavaScript (ES6), 106 bytes
s=>eval('q="030101001010";p=s.split`/`;for(d=i=p[1],m=p[0]-1;i--;d>n&&(m++,d-=n))n=31-q[m%=12];m+1+"/"+d')

Explanation
s=>
  eval(`              // use eval to enable for loop without needing to write {} or return
    q="030101001010"; // q = array of 31 - days in each month
    p=s.split\`/\`;   // p = array of [ month, day ]
    for(
      d=i=p[1],       // d = day
        m=p[0]-1;     // m = month - 1
      i--;            // loop for each day, this is more iterations than needed but extra
                      //     iterations do not affect the result and it's the shortest way
                      //     to guarantee all months have been subtracted from d, it also
                      //     ensures the loop runs at least once to get m % 12
      d>n&&(m++,d-=n) // if too many days, subtract the month's days and increment month
    )
      n=31-q[m%=12];  // n = number of days in month, get m % 12
    m+1+"/"+d         // return the result
  `)

Test

var solution = s=>eval('q="030101001010";p=s.split`/`;for(d=i=p[1],m=p[0]-1;i--;d>n&&(m++,d-=n))n=31-q[m%=12];m+1+"/"+d')
<input type="text" id="input" value="19/99" />
<button onclick="result.textContent=solution(input.value)">Go</button>


text:
Mixed Number to an Improper Fraction
In this challenge you will be converting a mixed number to an improper fraction.
Because improper fractions use fewer numbers, your code will need to be as short as possible.

Examples
4 1/2
9/2

12 2/4
50/4

0 0/2
0/2

11 23/44
507/44

Specification
You may assume the denominator of the input will never be 0. The input will always be in the format x y/z where x,y,z are arbitrary nonnegative integers. You do not need to simplify the output.

This is code-golf so shortest code in bytes wins.

Related. Related. Related. (More or less. These are all about mixed fractions.)

You should add the tag "parsing". I'm sure most answers will spend more bytes on parsing the input and formatting the output than on doing the math.

Can the output be a rational number type or does it have to be a string?

@nimi Parsing isn't the primary goal of the challenge though.

@AlexA.: ... but a large part of the challenge. According to it's description the tag should be used in such cases.

Can x, y and z be negative?

@Dennis no, it can't

Is it okay to output 0 for the third test case?

Is the output format strict, or is the numerator on one line and the denominator on another line acceptable (i.e., instead of a / between, it's a newline)?

Can we take the input as an array of ASCII values? (This is basically what strings are in C).

@Challenger5 If your language is natively uses pointers for strings, you can take it in as a null-terminated string (array of ascii-values)

@Downgoat Well it's not actually a C submission, I just added that as justification for why it should be allowed.

@Challenger5 If your language is JS/Python/Java/one which has a native string datatype a string is a string so you can't take an array of integers for example in those languages.

@Downgoat Mine has no string datatype, only arrays and numbers.

@Downgoat Actually, can I assume it's null terminated anyways? (This is a stretch but it's helpful for golfing)

Based on the challenge I'm assuming it is, but is the input format "x y/z" mandatory, or can the space be a new-line,  and/or the x,y,z be separated inputs? Most answers are assuming the input format is indeed mandatory to be x y/z, but some aren't, hence this question to have a definitive answer.

@KevinCruijssen Well, the question body does mention The input will always be in the format x y/z, so I think it's mandatory (although that's not very recommended).

Is extra whitespace allowed in the output? I have this potential answer that prints an extra newline in the middle

Japt, 10 bytes
Woohoo, currently beating CJam!
U*W+V+'/+W

Try it online!
How it works
       // 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

I spent a good bit of time yesterday trying to figure out how I had earned 15 rep off of an answer, until I realized: my first green checkmark! \o/

LabVIEW, 29 LabVIEW Primitives

CJam, 16 15 14 bytes
l'/']er~:Xb'/X

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

Test it here.
Explanation
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.

The other version avoids using a variable by using a bit more stack shifting.

I really need to start using base conversion in CJam more.

An alternate version: '//~\S/1$b'/@, this is 13 bytes. Edit: oh I forgot the input l.

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

This returns the simplified result. If outputting a rational number instead of a string is fine, we can save 19 bytes:
ToExpression@StringReplace[#," "->"+"]&

PowerShell, 47 44 42 Bytes
Crossed out 44 is still regular 44 ;(
$l,$n,$d=$args-split'\D';"$(+$l*$d+$n)/$d"

Golfed a couple bytes by using regex -split. Golfed a couple more thanks to TessellatingHeckler by swapping the regex.
The $args-split'\D' takes our input argument and splits on non-digit characters. Here it performs two splits, one on whitespace, the other on the / character. The results are then stored in the three variables using a simultaneous assignment. We then formulate the string output as (the $left number times the $denominator plus the $numerator) executed as a code block, a / slash, and then the $denominator again.

Hi, I think you can do -split ' |/' to save one character with a "match either this|or that" regex, or use -split '\D' to split on anything which isn't a digit and s(h)ave two characters. If @Downgoat is willing to be slightly flexible on the output format, '{0}*{2}+{1};{2}'-f($args-split'\D')|iex is 40 bytes and has much cooler output because the numbers are even one above the other!

@TessellatingHeckler Thanks for the regex assist. I've asked Downgoat for input. But $l,$n,$d=$args-split'\D';+$l*$d+$n;$d is shorter yet at 37, and logically follows the same pattern as here.

Oh yeah, just math! (That would be enough to beat a Perl answer, too)

Java with Ten Foot Laser Pole 1.03, 79+25 (import) = 104 bytes
Requires import sj224.tflp.math.*;
String m(String[]a){return ""+new BigRational(a[0]).add(new BigRational(a[1]));}

This will almost certainly work with 1.04 as well, but so far I've only tested it with 1.03 because I already happened to have a java project set up with 1.03 in the build path.

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

Saved 3 bytes thanks to @ETHproductions!
Explanation
Very simple.
m=>
  ([x,y,z]=m.match(/\d+/g), // x, y and z = numbers from input
    +y+x*z                  // numerator
    +"/"+z                  // denominator
  )

Test
Test is without destructuring assignment to work in most browsers.

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>

Nice! You can use [p,q,r]= in place of p=, then replace p[0], p[1], and p[2] with p, q, and r, respectively. After this change, I get 41:m=>([p,q,r]=m.match(/\d+/g),+q+p*r+"/"+r)

@ETHproductions Thanks for the tip! I actually did consider using a destructuring assignment but they don't work in Chrome and I didn't have Firefox on hand to test it. :P

My first crossed out 44! :D

You can use m.split(/\W/g) instead to save a byte

Bash + coreutils, 28
dc<<<${@/\// }sarla*+n47Plap

$@ expands to all command-line parameters, so ${@/\// } expands to all command-line parameters with / replaced with  , which is put on dc's stack.  The rest is simple stack manipulation and arithmetic.

Julia, 58 50 bytes
s->eval(parse((r=replace)(r(s," ","+"),"/","//")))

This is an anonymous function that accepts a string and returns a Rational type object. To call it, give it a name, e.g. f=s->....
We can take advantage of the fact that the input can be manipulated slightly to be an expression that evaluates to a rational. In particular, an integer plus a rational is a rational, and rationals are denoted with double slashes. So if we turn 4 1/2 into 4+1//2, the evaluated result will be 9//2.
Ungolfed:
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 characters
The input exactly matches the array delimiter and inherent fraction representation of Smalltalk. If it just weren't so verbose, it could have been a serious contender!
Compiler evaluate:'|p|p:=0.#(',FileStream stdin nextLine,')do:[:q|p:=p+q].p'

It's too bad simplification wasn't a requirement, Smalltalk does it automatically!

Stax, 1 byte
+

Run and debug it (although there's not much to debug)
The challenge specification says "You do not need to simplify the output."  Assuming it's allowed to simplify, then there's a built-in instruction in stax to do this.  The input is implicitly interpreted as an integer and a rational number.  The + instruction widens both to rationals, adds, and simplifies.  The result is implicitly printed.

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

Try it online!
Explanation
As H.PWiz figured out we can use Haskell's lexer here to break up the string into it's parts. (Earlier I was using span(>'/')) And Laikoni pointed out that <$> works just like mapSnd from Data.Tuple.
The pattern guard breaks up our code into the three numbers we want using lex.  lex invokes haskell's lexer to break off the first token.  It returns a list with each element representing a possible way to parse the string.  These elements are tuples with the first element being the first token and the rest of the string being the second element.  Now since the input format is very regular we are only ever going to have exactly one parse, so we can always take the first one.  The first thing we do is invoke lex on the input
lex x

Then we unwrap it from it's list giving us a 2-tuple
lex x!!0

The first token will be the whole part of the mixed fraction leaving the fraction prepended by a space to still parse.  Then since tuples are Functors we can use (<$>) an alias for fmap to apply lex to the second element of the tuple.
lex<$>lex x!!0

This eats through the space and breaks off the next token, the numerator of our fraction.  Now we bind this to a pattern match using <-.  Our pattern is
(a,(c,s:d):_)

a grabs the whole part of the fraction, our first token. :_ unwraps the list resulting from our second lex.  c grabs the second token we lexed, that is the numerator of the fraction.  Everything that remains is bound to s:d which splits it into its first character, guaranteed by the format to be a / and the remainder which will be the denominator.
Now that we have parsed the input we do the actual computation:
show(r a*r d+r c)++s:d

Where r is the read function we bound earlier.
It is important to note that lex returns a list empty if it fails and non-empty if it succeeds.  Why this is not a Maybe I do not know.

67 bytes

@H.PWiz That is a great use of lex.

lex is just a handy, rarely used function that splits a string into the first token and the rest. It returns as a list, so it can fail with []

@H.PWiz Do you know why it doesn't return a Maybe?

No, I don;t know a whole lot about it. It uses Reads, which I am somewhat ignorant of

Ok, thanks for the tip, I'll snoop around to find out for myself.  I do think ReadS is just a type alias btw.

65 bytes: Try it online!

You should be able to save another 2 by matching on the /

59 bytes

bump ^ .-.-.-.-.-

@H.PWiz tbh, I think that could be it's own answer.

05AB1E, 17 15 bytes
#`'/¡R`Š©*+®'/ý

-2 bytes thanks to @MagicOctopusUrn.
Try it online or verify all test cases.
Explanation:
#`         # 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"

With flexible input- and output-format, taking the integers in the order x,z,y and outputting the nominator and denominator on separated lines it would be 4 bytes (which is why I added the parsing-tag to the challenge..):
*+²»

Try it online or verify all test cases.
Explanation:
*        # 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

@MagicOctopusUrn Thanks, but the input-format is different than in the challenge description. Apparently the format (as single string) 4 1/2 is mandatory for this particular challenge. Otherwise I would have used my 4-byte version (or if output was mandatory, but input flexible I would use this 6-byter: *+'/²J)

15-bytes

@MagicOctopusUrn Oh, didn't even knew about "Push all the items of a into the stack".. o.Ô Exactly what I needed for this challenge! And smart with the join by "/". Thanks! :)

I hate using the "Push all items of a into the stack" command because it's "`" and it can't be tamed by inline code-tags.

@MagicOctopusUrn yeah, it's also a bit annoying in comments (which is why I quoted "Push all the items of a into the stack" instead of using '`'..

@MagicOctopusUrn Using '  instead of tile it would be: ''>'<''. Unfortunately it doesn't work with just a tile and spaces, so it has to be surrounded by other text to use the double-tile.

''Oh man, yesss, I've needed this like 10 times''

Forth (gforth), 92 bytes
: f 0 -rot 3. do 0 -rot >number 1 m+ loop 2drop + >r swap i * + r> <# 0 #s '/ hold + #s #> ;

Try it online!
The pain of parsing and formatting...
Takes a string as pointer length (gforth standard), and returns a string in the same format.
How it works
: f ( addr u -- addr u )  \ take a string and return a string
  0 -rot      \ ( 0 addr u )
  3. do       \ repeat 3 times...
    0 -rot      \ ( ... 0 0 addr u )
    >number     \ ( ... num 0 addr u ) parse an integer;
                \ `addr` now points to right after the parsed int
    1 m+        \ increment the addr to point to the next integer
  loop        \ end loop ( x y z 0 addr u )
  2drop +     \ discard input string and zero on the top
  >r          \ ( x y R:z ) so the value of z can be copied by `i`
  swap i * +  \ ( x*z+y R:z )
  r>          \ ( x*z+y z )
  <#          \ start formatting the output from the end
  0 #s        \ push z to the output; formatting built-ins take double cells
  '/ hold     \ push a slash
  + #s        \ #s leaves two zeros at the top, so discard one and push x*z+y
  #>          \ finish formatting and get the string ( pointer length )
;

Vyxal, 3 bytes
⌈E∑

Try it Online! -4 thanks to lyxal
⌈   # Split on spaces
 E  # Evaluate each
  ∑ # Sum

Try it Online! for 7 bytes

This doesn't seem to work anymore (no clue why, maybe it was a 2.5 build specific thing, it would have been valid at the time though.). Try it Online! works though, for 3 bytes.

@lyxal That doesn't work either, try 0 0/2 for instance

Husk does it too, so it seems to be allowable

As does the wolfram answer

The question says "You do not need to simplify the output.", which means you can if you want - 0/2 simplified is 0

@lyxal Ah okay.

2 bytes with s flag

Wolfram|Alpha, 0 or 1 byte
=

The challenge says it's not necessary to simplify the output, but doesn't disallow it.  If it's not disallowed, then:
1)The online Wolfram|Alpha interpreter will automatically convert mixed numbers to improper fractions (0 bytes). E.g.:

2)The Wolfram|Alpha interpreter can be called within Mathematica by entering = followed by the input (1 byte):

Thunno 2, 18 bytes
OẸ'//ẸsNṭẊ,p+x,'/j

Try it online!
Explanation
OẸ'//ẸsNṭẊ,p+x,'/j  # Implicit input ("x y/z")
OẸ                  # Split on spaces, then dump onto the stack
  '//Ẹ             '# Split the fraction on "/", then dump again
      sN            # Swap and convert the numerator to integer
        ṭ           # Triple swap to get the order [y, x, z]
         Ẋ          # Copy z to the register without popping
          ,p        # Multiply x and z (implicit conversion to int)
            +       # Add this to y (which we converted earlier)
             x,     # Pair this with z (from the register)
               '/j '# Join this pair on "/"
                    # Implicit output

Factor, 43 bytes
[ eval( -- x x ) + >fraction [I ${}/${}I] ]

Attempt This Online!
Assumes the input must be a string, otherwise this can be shorter. Simplifies the output.

Perl, 82 61 38 bytes
#!perl -paF/\D/
$_=$F[0]*$F[2]+$F[1]."/$F[2]"

This can probably be golfed more.
Changes

Saved 16 bytes by using a regex in split, and 5 by using <> instead of <STDIN>.
Saved another 16 bytes thanks to Dennis.

With shebang #!perl -paF/\D/ (9 bytes), you can use $_=$F[0]*$F[2]+$F[1]."/$F[2]".

@Dennis I've added that in. Thanks!

The #!perl part of the shebang and the linefeed do not count. This is only 38 bytes.

@Dennis Oh, OK. I'll correct it now. (On the bright side I think this is the second-shortest non-esoteric answer)

Java, 159 148 142 120 110 bytes
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;}

Saved a bunch of bytes thanks to FlagAsSpam.

@FlagAsSpam Done.

@FlagAsSpam But then the variables will be left undeclared!

Disregard all of what I just said - a short way doing what you're doing is Long b=new Long(a[0]),c=new Long((a=a[1].split("/"))[0]),d=new Long(a[1]);

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

Pretty nice! Some tips: You can use [b,c]= in place of b=, then use b in place of b[0] and c in place of b[1]. Also, you can rearrange the equation so you don't need parentheses at all: p=prompt;[b,c]=p(a=+p()).split/;alert(+b+c*a+"/"+c)

Mathematica, 51 bytes
Interpreter["ComputedNumber"]@#~ToString~InputForm&

Interestingly, Mathematica supports this with a built-in. If outputting a number is allowed, than we only need 28 bytes:
Interpreter@"ComputedNumber"

Ruby, 23 bytes
->x{eval x.split*?++?r}

Try it online!

Ouroboros, 16 15 bytes
rrry@*+n47oMn1(

Try it here!
Explanation
The reason why Ouroboros is great for this challenge: its integer-reading primitive, r, skips over any non-digit characters until it comes to a number. So no parsing is required; we just read three numbers and process them. The example below uses the input 23 11/44.
rrr              Read all three numbers to the local stack
                  Local: 23 11 44
   y             Push a copy of the top of the local stack to the shared stack
                  Local: 23 11 44   Shared: 44
    @            Rotate (moving third item to top of stack)
                  Local: 11 44 23   Shared: 44
     *           Multiply
                  Local: 11 1012    Shared: 44
      +          Add
                  Local: 1023       Shared: 44
       n         Output as number
                                    Shared: 44   Output: 1023
        47       Push 47
                  Local: 47         Shared: 44   Output: 1023
          o      Output as character
                                    Shared: 44   Output: 1023/
           M     Move the top value from the shared stack to the local stack
                  Local: 44                      Output: 1023/
            n    Output as number
                                                 Output: 1023/44
             1(  Terminate

ARBLE, 13 bytes
a*c+b.."/"..c

Try it online!

I'm pretty sure the input format "x y/z" is mandatory for this particular challenge, but just in case I've asked OP to verify.

Perl 5 with -la -Mfeature=say, 32 bytes 25 bytes
m|/|;say$_*$'+$F[1],"/$'"

Try it online!
(-7 bytes thanks to Dom Hastings)
$_ is the whole input x y/z, which evaluates the value of x in numeric contexts (like the * here). $' is the regex post-match string, which here contains whatever comes after / - so, z. To get the y value, we use the -a flag which splits the input on spaces and places them in the @F array. So here, @F = ("x", "y/z"), which means $F[1]="y/z" which evaluates in y in numeric contexts (since y is the initial contiguous sequence of digits with $F[1]).

You do not have to count the -p flag in your byte count; instead you count the language as Perl 5 with -p flag, 32 bytes. See this meta post for the current consensus.

Nice approach! I just had a little go at this and managed to make a 25 byte version: Try it online!. Using $' was the only real difference there really!

The combination of using both regex-$' and -a-$F[n] to get parts of the string is a pretty good idea, I have to remember that! Thanks, updated the post.

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

Try it online!

return'%s/'%(int(a)*int(c)+int(b))+c is 2 bytes shorter

Husk, 4 bytes
Σmrw

Try it online!
ṁrw is supposed to work, but there's some bug that returns an empty list. Anyway, hooray for native rational number support.

GNU AWK, 5+16 = 21 bytes
Command-line argument: -F |/
Source code:
$0=$1*$3+$2"/"$3

Try it online!
The command-line argument sets the field separator to the regex / |\//. Thus, it is easy to map the input as three fields.

Itr, 1 byte
+
Itr has built-in support for rational numbers, including for parsing input numbers.
online interpreter
Explanation
   ; implicit input, by default numbers are separated by spaces
   ; two integers with a '/' between them are interpreted as a fraction
 + ; add the integer part to the fractional part
   ; implicitly output the fraction

Headass, 80 bytes
-(----[]]]][]]][{{U]>)D^^D^^^^^R]^}:DON-)}:NE.U[UOUO{^)N+E:]OD-}.U^U[{U^)DPD]P:}

Try It Online! Takes character codes as input and outputs as two numbers Numerator, Denominator.
Explanation:
Fairly straightforward, parses by looping through digits, subtracting 48, and then multiplying by 10 before adding each new number. when it hits a charcode less than 48, it knows to move on to the next number. There's not an easy way to multiply within a single code block to my knowledge, so the next two code blocks respectively copy a bunch of x onto the queue and then add them all up. Probably still golfable within the same approach, I found a few golfs while writing up the explanation, even.
-(----[]]]][]]][{{U]>)D^^D^^^^^R]^}:DON-)}:NE. block 0: parses input
-(                                             r3 = -1
  ----[]]]][]]][                               r2 = -48
                {                     N-)}:    while input remains
                 {U]>)            }:             while input + r2 > r3
                      D^^D^^^^^                    r1 *= 10
                               R]^                 r1 += input + r2
                                    DO           enqueue and reset r1
                                           NE  go to block 1
                                             . end block

U[UOUO{^)N+E:]OD-}. block 1: copies x z times onto queue
U[                  r2 = x
  UO                enqueue y
    UO              enqueue z
    U  ^            r1 = z
      {^)   :  D-}  while(r1--){
             ]O       enqueue x
                    }
         N+E        go to block 2
                  . end code block

U^U[{U^)DPD]P:} block 2: sums copies of x and adds y, prints x*z+y and z
U^              r1 = y
  U[            r2 = z
    {U )     :} while items remain unvisited on the queue (all of which are x)
     U^           r1 += x
        DP      print r1
          D]P   print r2

Raku, 25 bytes
{m:g/\d+/;$0*$2+$1~"/$2"}

Try it online!
m:g/\d+/ matches all sequences of digits in the input string, setting the variable $/ to a list of the matches as a side effect.  $0 is equivalent to $/[0] and so on, so the rest of the function constructs a the output string with the appropriate arithmetic.

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

Reads input from STDIN.  Fairly self-explanatory, I think.

Lua, 123 Bytes
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)

Milky Way 1.6.0, 31 bytes
'" "\="/"\=>;*;A+"/"+<+!

Ended up being much longer than I thought it would be.

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

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

Python 2.7, 88 Bytes

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

Try it online!
You have to type the input in quotes.
Probably not the best ...

76 bytes

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

Try it online!
I might be able to save some bytes by not trying to reuse the parsing loop (the second line). That way I could make the loop more specific, avoid the huge mess of conditionals, and I could use the register for other things.

C#, 112 bytes
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;}

Full/Formatted Version:
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();
        }
    }
}

PHP, 65 Bytes
Try it online
Code
<?=(($a=preg_split("/[\s,\/]/",$argv))[0]*$a[2]+$a[1])."/".$a[2];

Explanation
$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 bytes
A lambda from String to String.
s->{var p=s.split(" |/");return new Long(p[0])*new Long(p[2])+new Long(p[1])+"/"+p[2];}

Try It Online

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

Try it online!
Thanks to ngn for the ⊃⊥1∘↓ trick

source: Stack Exchange

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/

sort: votes


text:
Find the XOR Primes
In this challenge posed by xnor, we were asked to implement XOR multiplication. In this challenge the goal is to find the first n XOR primes. XOR primes are very similar to regular primes as you can see by the following definitions:
Definition of Prime Number: A positive number greater than 1 which cannot be formed through multiplication of two numbers except through the multiplication of 1 and itself.
Definition of XOR Prime: A positive number greater than 1 which cannot be formed through XOR multiplication of two numbers except through the XOR multiplication of 1 and itself. Note that the XOR primes compose oeis sequence A014580.
XOR multiplication is defined as binary long multiplication without carrying. You can find more information about XOR multiplication in xnor's challenge.
Input:
An integer n.
Output:
The first n XOR primes.
Here are the XOR primes under 500:
2 3 7 11 13 19 25 31 37 41 47 55 59 61 67 73 87 91 97 103 109 115 117 131 137 143 145 157 167 171 185 191 193 203 211 213 229 239 241 247 253 283 285 299 301 313 319 333 351 355 357 361 369 375 379 391 395 397 415 419 425 433 445 451 463 471 477 487 499

FWIW these are the prime elements of the unique factorisation domain F_2[x].

Uhm what exactly is the challenge? Shortest code? Fastest code?

@Eumel The tag is code-golf, so shortest code in bytes is the default.

OEIS A014580

Pyth, 26 bytes
.fq2/muxyG*Hhdjed2 0^SZ2ZQ

Demonstration
To test whether a number is a XOR-prime, we generate the complete multiplication table up to that number using the algorithm from here, and then count how many times that number appears. If it's exactly 2, the number is prime.
Then, .f returns the first n primes.

Ceylon, 166 bytes
Of course this can't compete with Pyth & Co ...
{Integer*}p(Integer n)=>loop(2)(1.plus).filter((m)=>{for(i in 2:m-2)for(j in 2:m-2)if(m==[for(k in 0:64)if(j.get(k))i*2^k].fold(0)((y,z)=>y.xor(z)))i}.empty).take(n);

Formatted:
{Integer*} p(Integer n) =>
        loop(2)(1.plus).filter((m) => {
            for (i in 2 : m-2)
                for (j in 2 : m-2)
                    if (m == [
                            for (k in 0:64)
                                if (j.get(k))
                                    i * 2^k
                        ].fold(0)((y, z) => y.xor(z))) i
        }.empty).take(n);

This creates an infinite iterable of integers (starting with 2), filters it by checking if a number is an XOR-prime, and takes the first n elements of that.
This filtering works by looping over all elements from 2 to m-1 (which are m-2 ones), and checking each pair if the xor-product give m. If the iterable created by that is empty, m is an xor-prime, and therefore included.
The xor-product itself is calculated using the same algorithm (and almost the same code) as in my answer for the XOR product calculation.

Mathematica, 100 99 bytes
As noted by xnor, XOR multiplication is just multiplication in the polynomial ring \$\mathbb{F}_2[x]\$.
For[p=i=0,i<#,If[IrreduciblePolynomialQ[++p~IntegerDigits~2~FromDigits~x,Modulus->2],Print@p;i++]]&

Pari/GP, 74 bytes
Saved 4 bytes thanks to Charles.
As noted by xnor, XOR multiplication is just multiplication in the polynomial ring \$\mathbb{F}_2[x]\$.
n->p=0;while(n,if(polisirreducible(Mod(Pol(binary(p++)),2)),print(p);n--))

Try it online!
Basically the same as my Mathematica answer, but PARI/GP has shorter function names.

Nice, an improvement on the version at A014580. You can shave off 4 bytes if you decrement instead: n->p=0;while(n,if(polisirreducible(Mod(Pol(binary(p++)),2)),print(p);n--)).

Julia, 116 bytes
f(a,b)=b%2*a$(b>0&&f(2a,b÷2))
n->(A=[i=2];while endof(A)<n i+=1;i∈[f(a,b)for a=2:i-1,b=2:i-1]||push!(A,i)end;A[n])

The primary function is the anonymous function on the second line. It calls a helper function f (which is incidentally my submission for xnor's challenge).
Ungolfed:
function xor_mult(a::Integer, b::Integer)
    return b % 2 * a $ (b > 0 && f(2a, b÷2))
end

function xor_prime(n::Integer)
    # Initialize an array to hold the generated XOR primes as well as
    # an index at which to start the search
    A = [i = 2]

    # Loop while we've generated fewer than n XOR primes
    while endof(A) < n
        # Increment the prime candidate
        i += 1

        # If the number does not appear in the XOR multiplication
        # table of all numbers from 2 to n-1, it's an XOR prime
        i ∈ [xor_mult(a, b) for a in 2:i-1, b in 2:i-1] || push!(A, i)
    end

    # Return the nth XOR prime
    return A[n]
end

Jelly, 21 bytes
BJ’2*U×B{×^/ðþFċ=2
ÇƇ

Try it online!
How it works
ÇƇ - Main link. Takes an integer n on the left
 Ƈ - Yield the range [1, 2, ..., n] and filter on:
Ç  -   The helper function

BJ’2*U×B{×^/ðþFċ=2 - Help function. Takes an integer k on the left
            ð      - Define a dyadic link f(i, j):
B                  -   Convert i to binary
 J                 -   Replace with their indices
  ’                -   Decrement each
   2*              -   2 to the power of each
     U             -   Reverse
       B{          -   Yield i in binary
      ×            -   Multiply the powers by the bits
         ×         -   Multiply by j
          ^/       -   Reduce by XOR
             þ     - Yield the range [1, 2, ..., k] and create a multiplication table using f(i, j)
              F    - Flatten
               ċ   - Count the occurrences of k
                =2 - Does this equal 2?

R, 138 bytes
function(n,f=function(x,y)`if`(y,bitwXor(x*y%%2,2*f(x,y%/%2)),0)){while(n)if(sum(outer(1:(T=T+1),1:T,Vectorize(f))==T)<3)F[1+(n=n-1)]=T;F}

Try it online!
Outputs the first n XOR primes in reverse order.
Sequentially tests each integer T (starting at 2) for XOR primality by checking whether the results of all values of 1..T XOR multiplied (using helper function f) by 1..T contain only 2 instances of T.

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/