Have you heard about Megamind? Megamind and Metro Man are two aliens who came to earth. Megamind wanted to destroy the earth, while Metro Man wanted to stop him and protect mankind. After a lot of fighting, Megamind finally threw Metro Man up into the sky. Metro Man was defeated and was never seen again. Megamind wanted to be a super villain. He believed that the difference between a villain and a super villain is nothing but presentation. Megamind became bored, as he had nobody or nothing to fight against since Metro Man was gone. So, he wanted to create another hero against whom he would fight for recreation. But accidentally, another villain named Hal Stewart was created in the process, who also wanted to destroy the earth. Also, at some point Megamind had fallen in love with a pretty girl named Roxanne Ritchi. This changed him into a new man. Now he wants to stop Hal Stewart for the sake of his love. So, the ultimate fight starts now.

* Megamind has unlimited supply of guns named Magic-48. Each of these guns has `shots` rounds of magic spells.
* Megamind has perfect aim. If he shoots a magic spell it will definitely hit Hal Stewart. Once hit, it decreases the energy level of Hal Stewart by `dps` units.
* However, since there are exactly `shots` rounds of magic spells in each of these guns, he may need to swap an old gun with a fully loaded one. This takes some time. Let’s call it swapping period. 
* Since Hal Stewart is a mutant, he has regeneration power. His energy level increases by `regen` unit during a swapping period. 
* Hal Stewart will be defeated immediately once his energy level becomes zero or negative. 
* Hal Stewart initially has the energy level of `hp` and Megamind has a fully loaded gun in his hand.
* Given the values of `hp`, `dps`, `shots` and `regen`, find the minimum number of times Megamind needs to shoot to defeat Hal Stewart. If it is not possible to defeat him,  return `-1` instead.

# Example
Suppose, `hp` = 13, `dps` = 4, `shots` = 3 and `regen` = 1. There are 3 rounds of spells in the gun. Megamind shoots all of them. Hal Stewart’s energy level decreases by 12 units, and thus his energy level becomes 1. Since Megamind’s gun is now empty, he will get a new gun and thus it’s a swapping period. At this time, Hal Stewart’s energy level will increase by 1 unit and will become 2. However, when Megamind shoots the next spell, Hal’s energy level will drop by 4 units and will become −2, thus defeating him. So it takes 4 shoots in total to defeat Hal Stewart. However, in this same example if Hal’s regeneration power was 50 instead of 1, it would have been impossible to defeat Hal.

Difficulty: introductory

Starter code:

def mega_mind(hp, dps, shots, regen):
	

Solutions:
from math import ceil

def mega_mind(hp, dps, shots, regen):
    if dps*shots >= hp: return ceil(hp / dps)
    if dps*shots <= regen: return -1

    number_of_regenerations = ceil((hp - dps*shots) / (dps*shots - regen))
    return ceil((hp + regen*number_of_regenerations) / dps)

from math import ceil

def mega_mind(hp, dps, shots, regen):
    if hp > dps * shots <= regen:
        return -1
    n = 0
    while True:
        s = min(int(ceil(hp / dps)), shots)
        n += s
        hp -= dps * s
        if hp <= 0:
            break
        hp += regen
    return n

def mega_mind(hp, dps, shots, regen):
    chp = hp
    ans = 0
    while True:
        r = (chp + dps - 1) // dps
        if r <= shots:
            return ans + r
        chp -= (dps * shots - regen)
        ans += shots
        if chp >= hp:
            return -1

from math import ceil

def mega_mind(hp, dps, shots, regen):
    damage = dps * shots
    if hp > damage <= regen: return -1
    if hp <= damage: return ceil(hp / dps)
    full = (hp - regen) // (damage - regen)
    if damage*full == hp + (full-1)*regen: return full*shots
    left = hp + full*(regen - damage)
    return full*shots + ceil(left / dps)

from math import ceil
def mega_mind(hp, dps, shots, regen):
    print(hp,dps,shots,regen)
    if hp>dps*shots and regen>=dps*shots: return -1
    if hp<=dps*shots:
        return ceil(hp/dps)
    a=ceil((hp-dps*shots)/(-regen+dps*shots))
    return a*shots + ceil((hp+a*regen-a*dps*shots)/dps)

def mega_mind(hp, dps, shots, regen):
    if (hp > dps*shots) and dps * shots <= regen:
        return -1
    res = 0; num_shots = 0
    if hp > dps*shots:
        num_rounds = (hp-dps*shots)//(dps*shots-regen)
        res = num_rounds * shots
        hp -= num_rounds * (dps*shots-regen)
    while hp > 0:
        hp -= dps
        res += 1
        num_shots += 1
        if hp > 0 and num_shots == shots:
            hp += regen
            num_shots = 0
    return res

import math

def mega_mind(hp, dps, shots, regen):
    if regen - dps * shots >= 0 and hp - dps * shots > 0:
        return -1
    if hp - dps * shots <= 0:
        return math.ceil(hp / dps)
    n = 0
    while hp - dps * shots > 0:
        hp -= (dps * shots - regen)
        n += 1
    return math.ceil(hp / dps) + n * shots

def mega_mind(hp, dps, shots, regen):
    if hp> dps*shots and dps*shots<=regen:
        return -1
    total_shot = 0            #Initalize shot counter
    barell = shots            #Initalize first gun
    while hp>0:
        if hp>dps*shots:      #Machine gun mode
            if barell==0:     #Reload
                barell+=shots
                hp+=regen
            else:             #Shoot
                barell-=shots
                hp-=dps*shots
                total_shot+=shots
        else:                 #Gun mode
            if barell==0:     #Reload
                barell+=shots
                hp+=regen
            else:             #Shoot
                barell-=1
                hp-=dps
                total_shot+=1
    return total_shot


def mega_mind(hp, dps, shots, regen):
    print((hp, dps, shots, regen))
    if dps * shots < hp and dps * shots <= regen: 
        return -1
    dps_round = dps * shots
    if hp - dps_round <= 0:
        return hp // dps + (0 if hp % dps == 0 else 1)
    hp -= dps_round
    round = hp // (dps_round - regen)
    hp -= round * (dps_round - regen)
    if hp == 0:
        return (round + 1) * shots
    hp += regen
    print((round, hp))
    return shots * (round + 1) + hp // dps + (0 if hp % dps == 0 else 1)
    
    


def mega_mind(hp, dps, shots, regen):
    if regen < dps*shots or hp <= shots*dps:
        cnt = 0
        while hp > shots*dps:
            hp = hp - shots*dps + regen
            cnt += shots
            
        for i in range(hp):
            hp = hp - dps
            cnt+= 1
            if hp <= 0:
                return cnt
    return -1