Write a class Random that does the following:

1. Accepts a seed
```python
>>> random = Random(10)
>>> random.seed
10
```

2. Gives a random number between 0 and 1
```python
>>> random.random()
0.347957
>>> random.random()
0.932959
```

3. Gives a random int from a range
```python
>>> random.randint(0, 100)
67
>>> random.randint(0, 100)
93
```

Modules `random` and `os` are forbidden.
Dont forget to give feedback and your opinion on this kata even if you didn't solve it!

Difficulty: introductory

Starter code:

def __init__(self, seed):
	

Solutions:
import hashlib

class Random():
    HASH_MAX = (1 << 32 * 4) - 1

    def __init__(self, seed):
        self.seed = seed
    def random(self):
        x = int(hashlib.md5(str(self.seed).encode()).hexdigest(), 16)
        self.seed += 1
        return x / self.HASH_MAX
    def randint(self, start, end):
        return start + int(self.random() * (end+1-start))

del __import__("sys").modules['random']
import random as random_

# Yeah, security isn't perfect yet
class Random():
    def __init__(self, seed):
        self.rand = random_.Random(seed)
        
    def __setattr__(self, name, value):
        if name == "seed": self.rand.seed(value)
        else: super(Random, self).__setattr__(name, value)
    
    def random(self):
        return self.rand.uniform(0, 1)
        
    def randint(self, start, end):
        return self.rand.randint(start, end)

class Random:
    """A shitty pseudo random number generator."""
    
    def __init__(self, seed):
        """Initilize with 'seed'."""
        self.seed = seed
        
    def random(self):
        """Generate a pseudo random number x (0.0 <= x < 1.0)."""
        self.seed = self.seed * 1103515245 + 12345
        return ((self.seed // 65536) % 32768) / 32768
          
    def randint(self, start, end):
        """Generate a pseudo random integer x ('start' <= x <= 'end')."""
        return start + int(self.random() * (end - start + 1))

class Random():
  def __init__(self, seed):
    self.seed = (seed if seed else 0x12345678) & 0xffffffff
  def randint(self, start, end):
    return int(self.random()*(end - start + 1) + start)
  def random(self): # xorshift
    x = self.seed
    x ^= (x << 13) & 0xffffffff
    x ^= (x >> 17)
    x ^= (x <<  5) & 0xffffffff
    self.seed = x
    return x/(1 << 32)

import math
class Random():
    def __init__(self, seed):
        self.seed = seed
    def random(self):
        x= math.sin(self.seed) * 10000;
        self.seed = x
        return x-math.floor(x)
    def randint(self, start, end):
        return math.floor(self.random()*(end-start+1)) + start

class Random():
    def __init__(self, seed):
        self.seed = seed
    def random(self):
        self.seed = (432544*self.seed+1)%1000000
        return self.seed/1000000
    def randint(self, start, end):
        self.seed = (13*self.seed + 1)%(end-start+1)
        return self.seed + start


class Random():
    def __init__(self, seed):
        self.seed = seed
        self.r_it = self.r()
        
    def random(self):
        return next(self.r_it) / 2**32
    
    def randint(self, start, end):
        return int(start + (1 + end - start) * next(self.r_it) / 2**32)
    
    def r(self, m=2**32, a=1103515245, c=12345):
        while True:
            self.seed = (a * self.seed + c) % m
            yield self.seed


from datetime import datetime
class Random():
    def __init__(self, seed):
        self.seed=seed
        self.x=self.next_x(self.seed)
    
    @property
    def seed(self):
        return self.__seed

    @seed.setter
    def seed(self,seed):
        self.x=self.next_x(seed)
        self.__seed=seed
    
    def next_x(self,x):
        x=x^(x<<13&0xFFFFFFFF)
        x=x^(x>>17&0xFFFFFFFF)
        x=x^(x<<15&0xFFFFFFFF)
        return x&0xFFFFFFFF
    
    def random(self):
        x=self.x
        self.x=self.next_x(x)
        return x/(2**32)
        
    def randint(self, start, end):
        x=self.x
        self.x=self.next_x(x)
        return (end-start)*x//(2**32)+start

class Random():
    def __init__(self, seed):
        self.seed = seed
    def random(self):
        import math
        x= math.sin(self.seed) * 10000;
        self.seed = x
        return x-math.floor(x)
    def randint(self, start, end):
        import math
        return math.floor(self.random()*(end-start+1)) + start

class Random():
    def __init__(self, seed):
        self.seed = seed
    def random(self):
        self.seed = (4123*self.seed+4321)%4096 #whatever
        return self.seed/4096
    def randint(self, start, end):
        return int(start + (end-start)*self.random())