[Question]
  [
Given an input of four integers *x1*, *y1*,
*x2*, and *y2*, output whether a white king in chess
(with coordinates (*x1*, *y1*)) could catch a black pawn
(with coordinates (*x2*, *y2*)) and capture it if the
pawn is moving to promote to a queen as fast as possible.
The coordinates of the board are as follows:
```
       first coordinate (x)
             12345678
           1 .#.#.#.#
           2 #.#.#.#.
           3 .#.#.#.#
  second   4 #.#.#.#.
coordinate 5 .#.#.#.#
    (y)    6 #.#.#.#.
           7 .#.#.#.#
           8 #.#.#.#.
```
Assume it is white to move (the king's turn) and that both players play
optimally (the king will move as fast as possible to catch the pawn, and the
pawn will move as fast as possible to promote). The input coordinates will
always be distinct, and the pawn will never start with a y-coordinate of 8.
The king moves one square in any direction every turn (it can move diagonally),
and the pawn can only move one space forwards (decrease its y-coordinate),
unless it's at its initial position (with our coordinate system, y-coordinate
of 7), in which case it can move two spaces forwards.
The input can be given as a whitespace-/comma-separated string, an array of
strings/integers, or four function/command line/etc arguments. The coordinates
can be given in whichever order is most convenient/golfy (so, accepting input
as [y2, y1, x1, y2] is okay as long
as it's consistent). The output must be a [truthy or falsy
value](http://meta.codegolf.stackexchange.com/q/2190/3808).
Since this is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), the shortest code in bytes wins.
**Truthy test cases**:
`5 3 3 2`
![](https://i.stack.imgur.com/NLjW7.jpg)
`6 1 1 7`
![](https://i.stack.imgur.com/NJcsm.jpg)
`3 3 3 2`
![](https://i.imgur.com/s5av7Isb.jpg)
`4 1 4 7`
![](https://i.stack.imgur.com/FsKXP.jpg)
`7 7 1 7`
![](https://i.stack.imgur.com/hXiU5b.png)
`1 8 1 7`
![](https://i.stack.imgur.com/cL7Fib.png)
**Falsy test cases**:
`6 4 3 2`
![](https://i.stack.imgur.com/IWdfx.jpg)
`8 8 1 7`
![](https://i.stack.imgur.com/lUQDjb.png)
`3 4 3 2`
![](https://i.imgur.com/mR0w3Pib.jpg)
  
[Answer]
## Python 2, 53 40
```
lambda x,y,p,q:y-2<q>=abs(x-p)+q/7+y/8*5
```
The king has coordinates `(x, y)` and the pawn `(p, q)`.
There are three significant cases:
1. The pawn is on rank 7 and the king on rank 8. To capture the pawn, the king must be on the same file or an adjacent one.
Result: `q = 7 ⋀ y = 8 → |x - p| ≤ 1`
2. The pawn is on rank 7. To capture the pawn, the king must be within six files.
Result: `q = 7 → |x - p| ≤ 6`
3. The pawn is on a lower rank. To capture the pawn, the king must be able to reach the promotion square at most one move after the pawn.
Result: `q < 7 → |x - p| ≤ q ⋀ y - 1 ≤ q`
My solution is just these conditions golfed down. Hopefully there aren't mistakes this time.
[Answer]
# [Jelly](http://github.com/DennisMitchell/jelly), 33 [bytes](https://github.com/DennisMitchell/jelly/blob/master/docs/code-page.md)
```
‘»Ɠ_2<®
Ɠ©<7
:5+Ɠ>7$¤<1.4
Ɠ_ƓA2£Ŀ
```
This program reads the coordinates as `x2\nx1\ny2\ny1` from STDIN. [Try it online!](http://jelly.tryitonline.net/#code=4oCYwrvGk18yPMKuCsaTwqk8Nwo6NSvGkz43JMKkPDEuNArGk1_Gk0EywqPEvw&input=Mwo1CjIKMw)
### Non-competing version
Unfortunately, the Jelly interpreter had a bug when this question was posted. Said bug prevented it from accepting more than two command-line arguments. The newest version of Jelly can solve the given task in **23 bytes**.
```
⁶>7×5
_A+⁵>6$¤+¢’»⁶_2<⁵
```
[Try it online!](http://jelly.tryitonline.net/#code=4oG2PjfDlzUKX0Er4oG1PjYkwqQrwqLigJnCu-KBtl8yPOKBtQ&input=&args=Mw+NQ+Mg+Mw)
[Answer]
# Prolog, ~~48~~ 42 bytes
**Code:**
```
p(X,Y,P,Q):-Y-2<Q,Q>=abs(X-P)+Q//7+Y//8*5.
```
**Examples:**
```
p(1,8,1,7).
true
p(3,4,3,2).
false
```
Not a bad challenge for Prolog compared to most.
**Edit:** Saved 6 bytes by switching to the formula used in [grc's Python 2 answer](https://codegolf.stackexchange.com/a/68754/47066).  
Unfortunately Prolog can't chain comparisons as python can and integer division is 1 byte longer than float division.
Try it online [here](http://swish.swi-prolog.org/p/oKqhHlpM.pl)
[Answer]
# JavaScript (ES6), 52
```
(x,y,u,t,d=x>u?x-u:u-x)=>(d>=y?d:y-1)<=(d<2|t<7?t:6)
```
I hope to have saved bytes not using Math.abs, Math.min, Math.max
The pawn at row seven can escape moving 2 spaces, if and only if the king is not in a near column - that's why there is a check on `d` before substituting 7 with 6.
Test case to run in console: 
```
;[f(5,3,3,2),f(6,1,1,7),f(3,3,3,2),f(1,8,1,7),f(6,4,3,2),f(8,8,1,7),f(3,4,3,2)]
```
Result: `[true, true, true, true, false, false, false]`
[Answer]
# Ruby, 50 bytes
```
def f(a,b,c,d)(a-c).abs<=(d==7?6-b/8*5:d)&&b-d<2;end
```
Arguments are (king x, king y, pawn x, pawn y), all integers.
]