from unittest import TestCase

ranks = list(range(-8, 0)) + list(range(1, 9))

class User:

# Using a getter take abstraction of the no 0 rank rule

def get_rank(self):

return ranks[self.rank_index]

rank = property(get_rank)

def __init__(self):

self.rank_index = 0

self.progress = 0

def get_progress_points(self, new_rank_index):

rank_diff = new_rank_index - self.rank_index

print("rank_diff: {}, new_index: {}, current_index: {}".format(rank_diff, new_rank_index, self.rank_index))

if rank_diff <= -2:

return 0

elif rank_diff == -1:

return 1

elif rank_diff == 0:

return 3

else:

return 10 * rank_diff * rank_diff

def level_up(self):

self.progress -= 100

self.rank_index += 1

if self.rank == 8:

self.progress = 0

def inc_progress(self, rank):

print("u: {}, ex: {}".format(self.rank, rank))

new_rank_index = ranks.index(rank)

print("new_rank is {} ({})".format(new_rank_index, ranks[new_rank_index]))

self.progress += self.get_progress_points(new_rank_index)

print("before level flushing: {}".format(self.progress))

while self.progress >= 100:

self.level_up()

print("levelup - new progress: {} - new rank: {}".format(self.progress, self.rank))

class Test4CodewarsStyleRankingSystem(TestCase):

def test_1(self):

user = User()

self.assertEqual(user.rank, -8)

self.assertEqual(user.progress, 0)

user.inc_progress(-7)

self.assertEqual(user.progress, 10)

user.inc_progress(-5)

self.assertEqual(user.progress, 0)

self.assertEqual(user.rank, -7)

from unittest import TestCase

from functools import lru_cache

def cached_pow(nb, pow):

return nb ** pow

def box_force(k, n):

return 1 / (k * cached_pow(n + 1, 2 * k))

def doubles(maxk, maxn):

return sum([box_force(k, n) for k in range(1, maxk + 1) for n in range(1, maxn + 1)])

class TestDoubles(TestCase):

def assertFuzzyEquals(self, actual, expected, msg=""):

merr = 1e-9

msg = "Tested at 1e-9; Expected value must be {:0.16f} but got {:0.16f}".format(expected, actual)

return self.assertAlmostEqual(actual, expected, delta=merr, msg=msg)

def test_box_force(self):

self.assertEqual(box_force(1, 1), 0.25)

def test_basic(self):

self.assertFuzzyEquals(doubles(20, 10000), 0.6930471955575918)

def test_basic_2(self):

self.assertFuzzyEquals(doubles(1, 10), 0.5580321939764581)

self.assertFuzzyEquals(doubles(10, 1000), 0.6921486500921933)

self.assertFuzzyEquals(doubles(10, 10000), 0.6930471674194457)

def test_long(self):

doubles(40, 150000)

from itertools import groupby

import unittest

from unittest import TestCase

def stringify_pair(r):

if r[0] == r[1]:

return str(r[0])

elif r[1] - r[0] >= 2:

return f"{r[0]}-{r[1]}"

else:

return ",".join([str(u) for u in range(r[0], r[1] + 1)])

def stringify_ranges(ranges):

return ",".join([stringify_pair(x) for x in ranges])

def ranges(integers):

def group_by_function(pair):

return pair[1] - pair[0]

# It's brilliant, but sadly not mine, found it here :

# https://stackoverflow.com/questions/4628333/converting-a-list-of-integers-into-range-in-python

# However it may be error prone in real world code

for a, b in groupby(enumerate(integers), group_by_function):

# This makes a subgroup calling the grouper once again

b = list(b)

yield b[0][1], b[-1][1]

def solution(args):

return stringify_ranges(ranges(args))

class SolutionTest(TestCase):

def test_basic_cases(self):

self.assertEqual(solution([-6, -3, -2, -1, 0, 1, 3, 4, 5, 7, 8, 9, 10, 11, 14, 15, 17, 18, 19, 20]),

'-6,-3-1,3-5,7-11,14,15,17-20')

self.assertEqual(solution([-3, -2, -1, 2, 10, 15, 16, 18, 19, 20]), '-3--1,2,10,15,16,18-20')

if __name__ == "__main__":

unittest.main()