Jelly,  21  20 bytes

^{Probably beatable by a number of bytes using some clever mathematics...}

:g/ ǵSRRUĖ€UÐeẎÇ€Qi 

A monadic link accepting a list of [p,q] which returns the natural number assigned to p/q.

Try it online! Or see the test-suite.

How?

First note that the N^th diagonal encountered contains all of the grid's rational numbers for which the sum of the numerator and denominator equals N+1, so given a function which reduces a [p,q] pair to simplest form ([p/gcd(p,q),q/gcd(p,q)]) we can build the diagonals as far as need be*, reduce all the entries, de-duplicate and find the index of the simplified input.

* actually one further here to save a byte

:g/ - Link 1, simplify a pair: list of integers, [a, b] / - reduce using: g - Greatest Common Divisor -> gcd(a, b) : - integer division (vectorises) -> [a/gcd(a,b), b/gcd(a,b)] ǵSRRUĖ€UÐeẎÇ€Qi - Main Link: list of integers, [p, q] Ç - call last Link as a monad (simplify) µ - start a new monadic chain (call that V) S - sum -> the diagonal V will be in plus one R - range -> [1,2,3,...,diag(V)+1] R - range (vectorises) -> [[1],[1,2],[1,2,3],...,[1,2,3,...,diag(V)+1]] U - reverse each -> [[1],[2,1],[3,2,1],[diag(V)+1,...,3,2,1]] Ė€ - enumerate €ach -> [[[1,1]],[[1,2],[2,1]],[[1,3],[2,2],[3,1]],[[1,diag(V)+1],...,[diag(V)-1,3],[diag(V),2],[diag(V)+1,1]]] Ðe - apply only to the even indexed items: U - reverse each -> [[[1,1]],[[2,1],[1,2]],[[1,3],[2,2],[3,1]],[[4,1],[3,2],[2,3],[1,4]],...] Ẏ - tighten -> [[1,1],[2,1],[1,2],[1,3],[2,2],[3,1],[4,1],[3,2],[2,3],[1,4],...] Ç€ - for €ach: call last Link as a monad (simplify each) - -> [[1,1],[2,1],[1,2],[1,3],[1,1],[3,1],[4,1],[3,2],[2,3],[1,4],...] Q - de-duplicate -> [[1,1],[2,1],[1,2],[1,3],[3,1],[4,1],[3,2],[2,3],[1,4],...] i - index of V in that list 

Perl 6,  94  90 bytes

->\p,\q{(({|(1…($+=2)…1)}…*)Z/(1,{|(1…(($||=1)+=2)…1)}…*)).unique.first(p/q,:k)+1} 

Test it

{(({|(1…($+=2)…1)}…*)Z/(1,{|(1…(($||=1)+=2)…1)}…*)).unique.first($^p/$^q):k+1} 

Test it

This basically generates the entire sequence of values, and stops when it finds a match.

Expanded:

{ # bare block lambda with placeholder parameters $p,$q ( ( # sequence of numerators { |( # slip into outer sequence (flatten) 1 # start at one … ( $ # state variable += 2 # increment it by two each time this block is called ) … 1 # finish at one ) } … * # never stop generating values ) Z/ # zip using &infix:« / » (generates Rats) ( # sequence of denominators 1, # start with an extra one { |( # slip into outer sequence (flatten) 1 … ( ( $ ||= 1 ) # state variable that starts with 1 (rather than 0) += 2 # increment it by two each time this is called ) … 1 ) } … * # never stop generating values ) ).unique # get only the unique values .first( $^p / $^q ) # find the first one that matches the input :k # get the index instead (0 based) + 1 # add one (1 based) } 

({1…($+=2)…1}…*) generates the infinite sequence of numerators (|(…) is used above to flatten)

(1 2 1) (1 2 3 4 3 2 1) (1 2 3 4 5 6 5 4 3 2 1) (1 2 3 4 5 6 7 8 7 6 5 4 3 2 1) (1 2 3 4 5 6 7 8 9 10 9 8 7 6 5 4 3 2 1) … 

(1,{1…(($||=1)+=2)…1}…*) generates the infinite sequence of denominators

1 (1 2 3 2 1) (1 2 3 4 5 4 3 2 1) (1 2 3 4 5 6 7 6 5 4 3 2 1) (1 2 3 4 5 6 7 8 9 8 7 6 5 4 3 2 1) (1 2 3 4 5 6 7 8 9 10 11 10 9 8 7 6 5 4 3 2 1) … 

Python 2, 157 144 137 134 126 125 bytes

def f(p,q):a=[((j-i)/(i+1.))**(j%-2|1)for j in range(p-~q)for i in range(j)];return-~sorted(set(a),key=a.index).index(p*1./q) 

Try it online!

4 bytes saved due to Mr. Xcoder; 1 byte from Jonathon Frech.

As noted by Mr. Xcoder, we can do a bit better in Python 3 since, amongst other things, integer division defaults to float results, and we can more easily unpack lists:

Python 3, 117 bytes

def f(p,q):a=[((j-i)/-~i)**(j%-2|1)for j in range(p-~q)for i in range(j)];return-~sorted({*a},key=a.index).index(p/q) 

Try it online!

Python 3, 157, 146, 140, 133 bytes

def f(p,q):a=[(i+i-abs(j-i-i))/(abs(j-i-i+.5)+.5)for i in range(p+q)for j in range(4*i)];return sorted(set(a),key=a.index).index(p/q) 

Try it online!

won 11 bytes thanks to Jonathan Frech

won 6 more bytes and then 7 thanks to Chas Brown

J, 41, 35, 30 bytes

-11 bytes thanks to FrownyFrog

%i.~0~.@,@,[:]`|./.[:%/~1+i.@* 

Try it online!

original 41 bytes post with explanation

%>:@i.~[:([:~.@;[:<@|.`</.%"1 0)~(1+i.@*) 

ungolfed

% >:@i.~ [: ([: ~.@; [: <@|.`</. %"1 0)~ 1 + i.@* 

explanation

 + | Everything to the right of this | calculates the list p (left arg) | create the divided by q | diagonals. yes, (right) | +this is a +create this list | | ++ finally rmv ^alternately |primitive ADVERB |1..(p*q), and pass | + the index | the boxes, |box, or |in J |it as both the left | | of that | | and remove |reverse and | |and right arg to the | | in the | | any dups |box, each | |middle verb, where each | | list on | | |diagonal | |element will divide the | | the right| | | | +----------+entire list, producing | | plus 1 | | | | | |the undiagonalized grid | | | | | | | | | | | | | | | | | | + | | | | | ┌+┬──|──────────┬─────────|─────────────|─────────────|───────|──────────|─────────────┐ │%│┌─+───────┬─┐│┌──┬─────|─────────────|─────────────|───────|────────┬─|────────────┐│ │ ││┌──┬─┬──┐│~│││[:│┌────|─────────────|─────────────|───────|─────┬─┐│┌+┬─┬────────┐││ │ │││>:│@│i.││ │││ ││┌──┬|───────┬─────|─────────────|───────|────┐│~│││1│+│┌──┬─┬─┐│││ │ ││└──┴─┴──┘│ │││ │││[:│+──┬─┬─┐│┌──┬─|─────────────|─┬─────|───┐││ │││ │ ││i.│@│*││││ │ │└─────────┴─┘││ │││ ││~.│@│;│││[:│┌|───────────┬─+┐│┌─┬─┬+──┐│││ │││ │ │└──┴─┴─┘│││ │ │ ││ │││ │└──┴─┴─┘││ ││+────────┬─┐│/.│││%│"│1 0││││ ││└─┴─┴────────┘││ │ │ ││ │││ │ ││ │││┌─┬─┬──┐│<││ ││└─┴─┴───┘│││ ││ ││ │ │ ││ │││ │ ││ ││││<│@│|.││ ││ ││ │││ ││ ││ │ │ ││ │││ │ ││ │││└─┴─┴──┘│ ││ ││ │││ ││ ││ │ │ ││ │││ │ ││ ││└────────┴─┘│ ││ │││ ││ ││ │ │ ││ │││ │ ││ │└────────────┴──┘│ │││ ││ ││ │ │ ││ │││ │ │└──┴─────────────────┴─────────┘││ ││ ││ │ │ ││ ││└──┴────────┴────────────────────────────────┘│ ││ ││ │ │ ││ │└──────────────────────────────────────────────┴─┘│ ││ │ │ │└──┴──────────────────────────────────────────────────┴──────────────┘│ └─┴─────────────┴──────────────────────────────────────────────────────────────────────┘ 

Try it online!

Python 3, 121 bytes

import math def o(x,y): p=q=n=1 while x*q!=p*y:a=p+q&1;p+=1+a*~-~-(p<2);q+=1-~-a*~-~-(q<2);n+=math.gcd(p,q)<2 return n 

Rust, 244 bytes

I created a simple formula to find the "plain" ordinal of a "plain" zigzag, without the constraints of the puzzle, using triangular numbers formulas: https://www.mathsisfun.com/algebra/triangular-numbers.html . This was modified with modulo 2 to account for the zig-zags flipping their direction each diagonal row in the puzzle. This is function h()

Then for the main trick of this puzzle: how to 'not count' certain repeating values, like 3/3 vs 1/1, 4/2 vs 2/1, in the zig-zag trail. I ran the 1-200 examples, and noticed the difference between a plain zig-zag triangular counter, and the one the puzzle wishes for, has a pattern. The pattern of "missing" numbers is 5, 12, 13, 14, 23, etc, which resulted in a hit in the OEIS. It is one described by Robert A Stump, at https://oeis.org/A076537 , in order to "deduplicate" numbers like 3/3, 4/2, and 1/1, you can check whether GCD>1 for the x,y of all "previous" ordinals in the zigzag. This is the 'for' loops and g() which is the gcd.

I guess with some builtin gcd it would have been shorter, but I kind of couldn't find one very easily (im kind of new at Rust and Integer confused me), and I like the fact that this one uses straight up integer arithmetic, and no builtins or libraries of any kind.

fn f(x:i64,y:i64)->i64 { fn h(x:i64,y:i64)->i64 {let s=x+y;(s*s-3*s+4)/2-1+(s+1)%2*x+s%2*y} fn g(x:i64,y:i64)->i64 {if x==0 {y} else {g(y%x,x)}} let mut a=h(x,y); for i in 1..x+y {for j in 1..y+x {if h(i,j)<h(x,y) && g(i,j)>1 {a-=1;}}} a } 

JavaScript (ES6), 86 bytes

Takes input in currying syntax (p)(q).

p=>q=>(g=x=>x*y?x*q-y*p?g(x+d,g[x/=y]=g[x]||++n,y-=d):n:g(x+!~d,y+=!~(d=-d)))(d=n=y=1) 

Try it online!

Javascript, 79 bytes

a=(p,q)=>p*q==1?1:1+((p+q)%2?q==1?a(p-1,q):a(p+1,q-1):p==1?a(p,q-1):a(p-1,q+1)) 

(I am new to code golfing, so this can probably be improved easily)

Explanation

let a = (p, q) => p * q == 1 // If they are both 1 ? 1 // Do a recursive call and increment the result by 1 : 1 + ( (p + q) % 2 // If on an even-numbered diagonal ? q == 1 // If at the beginning of the diagonal ? a(p - 1, q) // Go to previous diagonal : a(p + 1, q - 1) // Go one back : p == 1 // rougly the same ? a(p, q - 1) : a(p - 1, q + 1) )