Let's say that in a hypothetical platform that resembles Codewars there is a clan with 2 warriors. The 2nd one in ranking (lets call him **D**) wants to at least reach the honor score of his ally (lets call her **M**). 
*(Let's say that there is no antagonism here, he just wants to prove his ally that she should be proud to have him in the clan and sees this as the only way to achieve it! :P )*

Your task is to help **D** by providing him with the **quickest path** to reach **M**'s honor score.

In this hypothetical platform there are 2 kinds of kata to be solved:
```
'2kyu' worth of 1 point 
'1kyu' worth of 2 points 
```

So if for example:
```
M has honor 11
D has honor 2
```
**D** could reach **M`s** honor by solving kata worth of `9`. He has many options to do this:
```
Solve 9 '2kyus' (9*1 -> 9) => Solve 9 kata
Solve 4 '1kyus' and 1 '2kyus' (4*2 + 1*1-> 9) => Solve 5 kata
Solve 2 '1kyus' and 5 '2kyus' (2*2 + 5*1 -> 9) => Solve 7 kata
etc etc...
```
The **quickest path** to reach the honor score is: 
```
4 '1kyus' and 1 '2kyus' => Solve only 5 kata
```

Create a function `getHonorPath` that accepts 2 arguments `honorScore` & `targetHonorScore` with score integers of 2 warriors and returns an object with the **quickest path** for the first one to reach the 2nd's honor. For example:

```
getHonorPath(2, 11) should return { '1kyus': 4, '2kyus': 1 }
getHonorPath(20, 11) should return {}
```

**For the purpose of this kata you do not have to worry about any non-integer arguments for honor scores**

Source: codewars | Difficulty: EASY
Tags: Fundamentals

Mathematics

Starter code: def get_honor_path(honor_score, target_honor_score):
	

Solutions:
def get_honor_path(honor, target):
	return dict(list(zip(['1kyus', '2kyus'], divmod(target - honor, 2)))) if target > honor else {}


def get_honor_path(score, target):
	return {'1kyus': (target - score) // 2, '2kyus': (target - score) % 2} if target > score else {}


def get_honor_path(honor_score, target_honor_score):
	(k1, k2) = divmod(target_honor_score - honor_score, 2)
	return {'2kyus': k2, '1kyus': k1} if honor_score < target_honor_score else {}


def get_honor_path(honor_score, target_honor_score):
	return {} if honor_score >= target_honor_score else {'2kyus': (target_honor_score - honor_score) % 2, '1kyus': (target_honor_score - honor_score) // 2}


def get_honor_path(hs, ths):
	return {'2kyus': (ths - hs) % 2, '1kyus': int((ths - hs) / 2)} if ths > hs else {}


def get_honor_path(honorScore, targetHonorScore):
	return {'1kyus': (targetHonorScore - honorScore) // 2, '2kyus': (targetHonorScore - honorScore) % 2} if targetHonorScore > honorScore else {}


def get_honor_path(honor_score, target_honor_score):
	return {} if honor_score >= target_honor_score else {'2kyus': divmod(target_honor_score - honor_score, 2)[1], '1kyus': divmod(target_honor_score - honor_score, 2)[0]}


def get_honor_path(honor_score, target_honor_score):
	honor_needed = target_honor_score - honor_score
	kyus = {}
	if honor_score < target_honor_score and honor_needed != 0:
		kyus['1kyus'] = honor_needed // 2
		kyus['2kyus'] = honor_needed % 2
	return kyus


get_honor_path = lambda s, o: o > s and {'%skyus' % k: n for (k, n) in enumerate(divmod(o - s, 2), 1)} or {}


def get_honor_path(h, t):
	return {k + 'kyus': v for (k, v) in zip('12', divmod(t - h, 2))} if t > h else {}