exercises.tar

exercises/0000755000175100017510000000000012602321415012662 5ustar  mandarkmandarkexercises/004.md0000644000175100017510000000052212602321415013506 0ustar  mandarkmandark# Print Rev Alpha

Introduces: print, strings.

Write a program that print the reverse alphabet with the vowels capitalised.

Using command line, I want to see:

```bash
julien@localhost$ python3 solution.py
zyxwvUtsrqpOnmlkjIhgfEdcbA
julien@localhost$
```

## References

print : <https://docs.python.org/3/library/functions.html#print>
exercises/090.md0000644000175100017510000000112712602321415013515 0ustar  mandarkmandark# count parameters

Introduces: argv, import, len, list, for, enumerate.

Author(s): @c24b.

## Instructions

Write a script named `solution.py` that outputs the position of the
argument and its value in a new line using a `for`.

## Advice

Take a look at
[`enumerate()`](https://docs.python.org/3.3/library/functions.html#enumerate)
function.

## Example

```bash
julien@localhost$ python3 solution.py user email format
0 solution.py
1 user
2 email
3 format
julien@localhost$ python3 solution.py
0 solution.py
julien@localhost$ python3 solution2.py test
0 solution.py
1 test
julien@localhost$
```
exercises/515.md0000644000175100017510000000274412602321415013525 0ustar  mandarkmandark# Sequence Mining

Introduces: itertools, re, list, set.

Author(s): Antoine Mazières.

## Overview

Sequence mining is useful for analyzing list of events when order matters. It's used for example for DNA and natural language analysis.

Here, you'll implement an algorithm to extract common patterns among a set of sequences.

## Exercise

You must provide a function `seq_mining` that takes as argument:

+ A list of strings (representing the sequences), such as:
	- `['CFEDS', 'SKDJFGKSJDFG', 'OITOER']`

+ The minimum proportion of the number of sequences that must have this pattern for being taken into account (float between 0 and 1):
	- if `0.34`, at least a third of the sequences must have a given pattern for the function to return it.

+ The maximum pattern length that must be considered (int)

If a given pattern occures several time in a sequence, it must counted only once.

The function `seq_mining` must return a [`Counter`](https://docs.python.org/2/library/collections.html#collections.Counter).

## Exemple

```ipython
In [1]: from solution import *

In [2]: data = ['ABCD', 'ABABC', 'BCAABCD']

In [3]: seq_mining(data, 0.34, 3)
Out[3]: Counter({'BC': 3, 'C': 3, 'A': 3, 'B': 3, 'ABC': 2, 'CD': 2, 'BCD': 2, 'AB': 2, 'D': 2})

In [4]: seq_mining(data, 0.34, 4)
Out[4]: Counter({'BC': 3, 'C': 3, 'B': 3, 'A': 3, 'ABC': 2, 'BCD': 2, 'CD': 2, 'ABCD': 2, 'AB': 2, 'D': 2})

In [5]: seq_mining(data, 0.50, 2)
Out[5]: Counter({'B': 3, 'BC': 3, 'C': 3, 'A': 3, 'CD': 2, 'AB': 2, 'D': 2})
```
exercises/014.md0000644000175100017510000000141512602321415013511 0ustar  mandarkmandark# Print the first parameter

Introduces: argv, import, if, len.

## Instructions

Write a script named `solution.py` that print the first parameter
given to the script. If thereis no parameters given, it should print
the following error message : `usage: python3 solution.py PARAM`.

## Advice

Maybe you will need to import few modules in your program.

## Example

```bash
julien@localhost$ python3 solution.py antoine
antoine
julien@localhost$ python3 solution.py julien
julien
julien@localhost$ python3 solution.py
usage: python3 solution.py PARAM
julien@localhost$
```

## references

if: <https://docs.python.org/3/reference/compound_stmts.html#if>

sys.argv: <https://docs.python.org/3/library/sys.html#sys.argv>

len: <https://docs.python.org/3/library/functions.html#len>
exercises/210.md0000644000175100017510000000127512602321415013513 0ustar  mandarkmandark# Print the sum of every prime number < 1000

Introduces: module, for, numbers, functions, if.

Author(s): Julien Palard

## Instructions

Provide the script `solution.py` that prints the sum of every prime number inferior to 1000.

```bash
$ python3 solution.py
666
```
This solution is wrong of course :), you must provide the good one !


## Advice

You should copy the `solution.py` of the exercise 200 in this directory and rename it `is_prime.py`.
This way, you'll be able to import it as a module from the `solution.py` of 210, by doing so:

```python
import is_prime
print(is_prime.is_prime(999))
```

You're free to name as you want, such as `math_tools.py`, and then do `import math_tools`.
exercises/260.md0000644000175100017510000000363112602321415013516 0ustar  mandarkmandark# 3 Ways to Distance

Introduces: numpy.

Authors: Antoine Mazieres

## Description

You will calculate the distance between two points. More precisely the [euclidean distance](https://en.wikipedia.org/wiki/Euclidean_distance).

One can calculate the distance in two dimensions, ie. with two variables (like x and y) for each points.

![ED 2d](http://blogs.esri.com/esri/arcgis/files/2013/02/EuclideanDistanceGraphic_web.jpg)

Or in 3 dimensions:

![ED 3d](http://support.esri.com/fr/knowledgebase/techarticles/renderImage?ImageId=15802&ImageType=gif)

Or at N dimensions...

Look for more information on wikipedia : <https://en.wikipedia.org/wiki/Euclidean_distance>

## Instructions

You must provide a script called `solution.py` in which there is the following functions:

+ `euclidean(a, b)` where `a` and `b` are iterables containing the coordinates of a point in the euclidean space. The function should return the euclidean distance between points `a` and `b`. You should not use any module for this function.

+ `opt_euclidean(a, b)`. The same as `euclidean` but using the [math](https://docs.python.org/3.4/library/math.html) module.

+ `np_euclidean(a, b)`. The same as `euclidean` but using the [numpy](http://www.numpy.org/) module.

	You should import `numpy` like this:

	```python
	import numpy as np
	```
Calculating the euclidean distance implies the usage of power, square root and sum functions. For each functions you must provide, you should use the versions of this calculation provided in the related module (like, `** 2`, `math.pow()` and `numpy.power()`).

Such as:

```python
>>> from solution import *
>>> a = [2,3]
>>> b = [5,6]
>>> euclidean(a, b)
4.242640687119285
>>> opt_euclidean(a, b)
4.242640687119285
>>> np_euclidean(a, b)
4.2426406871192848
>>> euclidean(a,b) == opt_euclidean(a,b) == np_euclidean(a,b)
True
>>> a = [2,3,7,3,4,0,8,2,1]
>>> b = [5,3,0,7,8,6,9,4,5]
>>> euclidean(a, b)
12.12435565298214
```
exercises/332.md0000644000175100017510000000375512602321415013525 0ustar  mandarkmandark# create_a_map

Introduces: json, dict, list, pip.

Author(s): @c24b.

## Instructions

In this exercise, you'll create a map, using `the folium python
package` in a file called `velib.html` with a marker for each velib
station in the dataset. First download the
[velib.json](https://raw.githubusercontent.com/c24b/hk-hk/master/331/velib.json).

Then install `jinja2` and `folium`, typically using `pip3`, or your
prefered python package installer (depends on your operating system).

```
$ pip3 install jinja2
$ pip3 install folium
```

To create the map, start by reading the [folium
documentation](https://pypi.python.org/pypi/folium) about creating a
`BaseMap` centered in Paris. You will have to provide the `lat` and
`long` of a central point in Paris (such as Notre Dame de Paris for
example) and create an HTML file called `velib.html`.

The basic creation of the base map example:

```
import folium

map_osm = folium.Map(location=[{{lat}}, {{long}}])
map_osm.create_map(path='velib.html')
```

Then you will use you clean dataset of velib station to show on the
map:

 - Each station of velib with the number of bikes availables
 - The number of parking for bike
 - The total of bike with the name of the station and the adress

See how to create markers in the [folium
doc](https://pypi.python.org/pypi/folium).

## Advice

Clean up your dataset first!

## Optimization

Provide in popup of the marker the correct info we need.

As we are requesting all the dataset in Paris: the program will be
slow and the map will be very long to load.  Next exercice will teach
you some tips and tricks to optimise the request and the loading time.
See you in the next exercice!


## Example

Your map should be stored as `velib.html` inside you exercice directory

 -  [Full example](https://raw.githubusercontent.com/c24b/velib/master/velib.html)
 -  ![ScreenShot1](https://raw.githubusercontent.com/c24b/velib/master/velib-example.png)
 -  ![Screenshot2](https://raw.githubusercontent.com/c24b/velib/master/velib-example2.png)
exercises/204.md0000644000175100017510000000101412602321415013505 0ustar  mandarkmandark# Perfect deck shuffle

Introduces: itertools.

Author(s): Julien Palard

## Instructions

A perfect shuffle of a deck of card is splitting a deck of cards into
equal halves, and perfectly interleaving them.

Perfectly shuffling [1, 2, 3, 4, 5, 6] gives [1, 4, 2, 5, 3, 6].

You'll expose a `perfect_shuffle(deck)` function, perfectly shuffling
the given iterable.

Did you know that if you shuffle 10 times a deck of 1024 cards, the
deck returns to its initial state ? It's probably a good way to test
your implementation.
exercises/002.md0000644000175100017510000000064612602321415013513 0ustar  mandarkmandark# Numbers

Introduces: numbers.

Author(s): Julien Palard

## Instructions

For this exercise, just read the documentation about
[numbers](https://docs.python.org/3/tutorial/introduction.html#numbers).

Play with numbers in your REPL until that's clear for you.

To validate this exercise, create an empty file named `solution.py` in
the exercise directory in your `hackinscience` repository, on your
github, and push it.
exercises/015.md0000644000175100017510000000056112602321415013513 0ustar  mandarkmandark# Using operators

Introduces: operators.

Author(s): Julien Palard

## Instructions

Make a python script that print the result for `245850922 / 78256779` on
one line, and the result of `(1 + √5) / 2` on the next.

## Advice

The square root of a number is equal to this number power 0.5.

## References

Operators: <https://docs.python.org/3/library/operator.html>
exercises/742.md0000644000175100017510000000336312602321415013525 0ustar  mandarkmandark# Be creative, import math.

Introduces: pip, operators, functions, file.

Author(s): Julien Palard

## Instructions

Using the following program as a root, or not, generate the most
beautiful wallpaper your Python skils can.

You'll need a `pip3 install pngcanvas` to run my ugly solution.

```python
#!/usr/bin/env python3

from pngcanvas import PNGCanvas
import math

HEIGHT = 500
WIDTH = int(HEIGHT * (16 / 9))

canvas = PNGCanvas(WIDTH, HEIGHT,
                   bgcolor=(255, 255, 255, 255),
                   color=(0, 0, 0, 255))


def get_point(x, y):
    """
    Return (Red, Green, Blue, Alpha) for the given (x, y) point.
    """
    R = (math.sin(x / 50) ** 2) * 0xFF
    G = (math.cos(y / 50) ** 2) * 0xFF
    B = (math.sin((x - y) / 50) ** 2) * 0xFF
    A = 0xFF
    return (int(R), int(G), int(B), int(A))

for x in range(WIDTH):
    for y in range(HEIGHT):
        canvas.point(x, y, get_point(x, y))
with open('solution.png', 'wb') as solution:
    solution.write(canvas.dump())
```

## Bonus

 - Generate a wallpaper far more beautiful than any other from the class.
 - Generate a different wallpaper each run, each of a more or less equal beauty, like [imagemagic](http://www.imagemagick.org/Usage/backgrounds/).
 - Accept parameters, like "--dominant-color" "--overall-luminosity", or whatever you want.
 - Use your program in a `crontab` to automatically set a new wallpaper to your desktop every hour.
 - Make your `crontab` generate an wallpaper according to the hour of the day (Dark at night, blue on the day, kind of orange for sunrises and dawns.
 - Generate a video instead of an image, needless to say, the video have to change every frame, and it have to be pretty.
 - Generate an infinite video stream.
 - Expose your video to the LAN over RTP.
exercises/007.md0000644000175100017510000000113312602321415013510 0ustar  mandarkmandark# Simple list

Introduces: list.

Author(s): Julien Palard

## Instructions

Write a script named `solution.py` that prints the list `["Hello world", 42]`. Such as:

```
$ python solution.py
['Hello world', 42]
```

## Advice

Use the [print()](https://docs.python.org/3.4/library/functions.html#print) function.

Notice that I'm not asking to print the string '["Hello world", 42]',
(composed of 18 chars), but the list containing a string an a number.

But don't worry, print() will understand your list, and will display a
friendly version of it. Python works for you, you're not working for
Python.
exercises/008.md0000644000175100017510000000063212602321415013514 0ustar  mandarkmandark# Basic loop

Introduces: for.

Author(s): Julien Palard

## Instructions

Write a script named `solution.py` that prints "Hello World !"
vertically.

You must use the `print()` function only once in your script.

```bash
julien@localhost$ python solution.py
H
e
l
l
o

W
o
r
l
d

!
julien@localhost$
```


## Advice

You must use a [`for`](https://docs.python.org/3.4/reference/compound_stmts.html#for) loop.
exercises/300.md0000644000175100017510000000110612602321415013504 0ustar  mandarkmandark# Print the content of the file 'words'

Introduces: file.

Author(s): Julien Palard

## Instructions

Manually download the file `http://x.mdk.fr/words` to your exercice
directory.

Your program will just have to open the file 'words' and print its
content, that's all.

/!\ Do not print an empty line after the file, in other words, do not
emit two newlines, there is already one in the file.

I want to see :
```
étude
étude's
études
julien@localhost$
```

But not:
```
étude
étude's
études

julien@localhost$
```

nor:
```
étude

étude's

études

julien@localhost$
```
exercises/310.md0000644000175100017510000000076512602321415013517 0ustar  mandarkmandark# Count the lower 'e' in the 'words' file

Introduces: file.

Author(s): Julien Palard

## Instructions

Manually download the file `http://x.mdk.fr/words` to your exercice
directory.

Your programm have to open the file 'words', count the 'e', print the
count.

Remember :

```bash
julien@localhost$ python3
Python 3.3.5 (default, Mar 22 2014, 13:24:53)
[GCC 4.8.2] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> for i in "foo":
...     print(i)
...
f
o
o
>>>
```exercises/100.md0000644000175100017510000000123212602321415013502 0ustar  mandarkmandark# Manipulate your first dictionnary

Introduces: dict, print.

Author(s): @c24b.

## Instructions

Your first dictionnary will be a velib station

```python
station = {
 'address': 'RUE DES CHAMPEAUX (PRES DE LA GARE ROUTIERE) - 93170 BAGNOLET',
 'number': 31705,
 'latitude': 48.8645278209514,
 'name': 'CHAMPEAUX (BAGNOLET)',
 'longitude': 2.416170724425901
}
```

Copy paste this dictionnary into your `solution.py` that must print
one key and one value per line, such as:

```bash
$ python3 solution.py
latitude 48.864527821
longitude 2.41617072443
number 31705
name CHAMPEAUX (BAGNOLET)
address RUE DES CHAMPEAUX (PRES DE LA GARE ROUTIERE) - 93170 BAGNOLET
```
exercises/020.md0000644000175100017510000000073612602321415013513 0ustar  mandarkmandark# my sub

Introduces: argv, if, cast.

Author(s): Julien Palard.

## Instructions

Write a script named `solution.py` that print the result of simple substraction. If no parameters is given, you must print the following error message: `usage: python3 solution.py OP1 OP2`.

## Example

```bash
julien@localhost$ python3 solution.py 1 2
-1
julien@localhost$ python3 solution.py 4 2
2
julien@localhost$ python3 solution.py
usage: python3 solution.py OP1 OP2
julien@localhost$
```
exercises/203.md0000644000175100017510000000030012602321415013501 0ustar  mandarkmandark# is_multiple_of

Introduces: numbers, bool.

Author(s): c24b

## Instruction

Write a function is_multiple(a, b) that takes 2 arguments return True
if a is a multiple of b, otherwhise False.
exercises/329.md0000644000175100017510000000037112602321415013522 0ustar  mandarkmandark# Largest product in a series

Introduces: functions, slice, cast.

Author(s): Julien Palard

## Instructions

Resolve the [8th euler problem](https://projecteuler.net/problem=8).

You just have to print the solution, the number, alone in its line.
exercises/705.md0000644000175100017510000000557512602321415013533 0ustar  mandarkmandark# Evolve mind

Introduces: evolution.

Author(s): Antoine Mazières.

## Overview

During this exercise you will implement a [Genetic Algorithm](https://en.wikipedia.org/wiki/Genetic_algorithm) to solve  the game [Master Mind](https://en.wikipedia.org/wiki/Mastermind_(board_game)) you implemented in exercise 455.

The idea is to generate a population of code candidates and measure the fitness of all of them. We select then a proportion of this population with the higher fitness (*elite*) and modify its individuals to generate a new population. We continue this process until one of the code candidate is the real code.

You must copy your `solution.py` of exercise 455 to this directory, rename it `master_mind.py`, and import it from this exercise solution by doing `from master_mind import *`.

## Create the first population

Write the function `init_pop` that takes as argument the size of the code, a string of possible colors and the population size to be produced as a list of string.

## Measure the fitness of all candidates

Write the function `fitness` that takes as arguments a population of candidates and the code to be broken. It must return a dictionnary with candidates string as keys and the fitness measure.

You're free to use any fitness measure you would like as long as it is a single int or float.

If one of he candidates is the right code, `fitness` should return `True`.

## Select the elite

Write the function `select_elite` that takes as argument a dictionnary of your population and its fitness, and the percentage you want to select from it. It must return a list of all elite's candidates as string.

## Generate the next population

Write the function `next_pop` that takes as arguments the elite, the colors and the population size, and returns the new population.

The idea is to modify the elite candidates to compose the new population. You're free to apply any kind of modification you would like.

## Evolve to the code.

Write the function `evolv_mind` taking as parameter the code size, the number of colors, the population size and, optionnally the percentage chosen for the elite selection.

It must returns the number of generations that was needed to break the code.

## Example

```ipython
In [1]: from solution import *

In [2]: colors = gen_colors(6)

In [3]: code = gen_code(4, colors)

In [4]: pop = init_pop(4, colors, 6)

In [5]: pop
Out[5]: ['ACAC', 'EDDA', 'FDCF', 'BBED', 'EDEE', 'BFEF']

In [6]: fit = fitness(pop, code)

In [7]: fit
Out[7]: {'ACAC': 3, 'BBED': 6, 'BFEF': 5, 'EDDA': 1, 'EDEE': 3, 'FDCF': 4}

In [8]: fitness(['AB', 'AA'], 'AA')
Out[8]: True

In [9]: elite = select_elite(fit, 0.5)

In [10]: elite
Out[10]: ['BBED', 'BFEF', 'FDCF']

In [12]: new_pop = next_pop(elite, colors, 6)

In [13]: new_pop
Out[13]: ['CFEF', 'BDCF', 'BBAD', 'BFEF', 'FDCF', 'FDCF']

In [14]: evolv_mind(4, 6, 6, percent=0.4)
Out[14]: 12

In [15]: evolv_mind(4, 6, 6)
Out[15]: 10
```





exercises/001.md0000644000175100017510000000064712602321415013513 0ustar  mandarkmandark# Strings

Introduces: strings.

Author(s): Julien Palard

## Instructions

For this exercise, just read the documentation about
[strings](https://docs.python.org/3/tutorial/introduction.html#strings).

Play with strings in your REPL until that's clear for you.

To validate this exercise, create an empty file named `solution.py` in
the exercise directory, in your `hackinscience` repository, on your
github, and push it.
exercises/060.md0000644000175100017510000000052112602321415013507 0ustar  mandarkmandark# Print every two letters pairs

Introduces: strings, operators, for.

Author(s): Julien Palard

## Instructions

Provide the script `solution.py` that prints every possible pairs of
two letters, only lower case, one by line, ordered alphabetically.

So your output should look like:
```
$ python3 solution.py
aa
ab
...
ba
bb
...
zz
```
exercises/080.md0000644000175100017510000000062512602321415013516 0ustar  mandarkmandark# Print combinations of two lower case letters

Introduces: strings, for, if.

Author(s): Julien Palard

## Instructions

Print every possible **combinations** of 2 lowercase letters, one by line.

A combination skips a lots of pairs, make sure you understand : <https://en.wikipedia.org/wiki/Combination>

```bash
$ python3 solution.py
ab
ac
ad
ae
af
ag
ah
ai
aj
ak
...
vw
vx
vy
vz
wx
wy
wz
xy
xz
yz
```
exercises/202.md0000644000175100017510000000072012602321415013506 0ustar  mandarkmandark# starts_with

Introduces: bool, functions, if.

Authors(s): c24b

## Instructions

Write your own function `starts_with(haystack, needle)` with
`haystack` and `needle` of type string and returning a booléan.

`starts_with` will return True if the string in the `haystack` parameter starts
with `needle`, and False otherwise.

So it will look like:
```python
def starts_with(input, value):
    ...
    ... ...
    ... return False
    ... ...
    return True
```
exercises/013.md0000644000175100017510000000055412602321415013513 0ustar  mandarkmandark# Maybe for very large values of 2

Introduces: comparisons.

Author(s): Antoine Mazieres, Julien Palard

## Instructions

Provide a script `solution.py` that prints what python think about 2 + 2 not being equal to 5.

```bash
mbp|~-$ python3 solution.py
True
mbp|~-$
```

## References

Comparaisons: <https://docs.python.org/3/library/stdtypes.html#comparisons>
exercises/097.md0000644000175100017510000000373112602321415013527 0ustar  mandarkmandark# Sets of love

Introduces: set.

Author(s): Constance de Quatrebarbes, Antoine Mazières.

## From Pyris, with love.

Once upon a time, in Paris, the city of romance, Bob and Alice met and fall in love with each other. 

![Love](http://www.lutheranhospital.com/images/icons/heart.png)

## Exercise 1

To fullfill their romance, they want to meet as much as possible, and share their daily path over Paris districts, in order to know where they can find each other in the same place.

As you know there is 20 disctrics in Paris: `['I', 'II','III', 'IV', 'V', 'VI', 'VII', 'VIII', 'IX', 'X', 'XI', 'XII', 'XIII', 'XIV', 'XV', 'XVI', 'XVII', 'XVIII', 'XIX', 'XX']`.

If you provided a function `love_meet` taking bob and alice's daily paths as 2 lists and returning a set of the districts they both visit during the day, they would be very happy.

```ipython
In [1]: from solution import love_meet

In [2]: alice = ['II', 'IV', 'II', 'XIX', 'XV', 'IV', 'II']

In [3]: bob = ['IV', 'III', 'II', 'XX', 'II', 'XX']

In [4]: love_meet(bob, alice)
Out[4]: {'II', 'IV'}
```

## Exercise 2

Time goes on, and love goes by...

![broke](http://plouhinec.spa.asso.fr/sites/all/libraries/ckeditor/plugins/smiley/images/broken_heart.png)

Alice is bored and get a crush for the strong and handsome Silvester. In order to have an affair with Silvester she must find out where Silvester and her go during the day. But to avoid an unfortunate encounter with Bob, she must be sure Bob doesn't go there also.

For the sake of her new love, provide Alice the function `affair_meet` that takes Bob, Alice and Silvester daily path in Paris, and returns a set of all places where Alice and Silvester can meet and be sure Bob won't be.

```ipython
In [1]: from solution import affair_meet

In [2]: alice = ['II', 'IV', 'II', 'XIX', 'XV', 'IV', 'II']

In [3]: bob = ['IV', 'III', 'II', 'XX', 'II', 'XX']

In [4]: silvester = ['XVIII', 'XIX', 'III', 'I', 'III', 'XVIII']

In [5]: affair_meet(bob, alice, silvester)
Out[5]: {'XIX'}
```
exercises/010.md0000644000175100017510000000154712602321415013513 0ustar  mandarkmandark# Counting Words

Introduces: split, list, len.

## Instructions

Provide the script `solution.py` that prints the number of words of the paragraph:

```python
phantom_menace = """Turmoil has engulfed the Galactic Republic. The\
 taxation of trade routes to outlying star systems is in\
 dispute. Hoping to resolve the matter with a blockade of deadly\
 battleships, the greedy Trade Federation has stopped all shipping to\
 the small planet of Naboo. While the congress of the Republic\
 endlessly debates this alarming chain of events, the Supreme\
 Chancellor has secretly dispatched two Jedi Knights, the guardians of\
 peace and justice in the galaxy, to settle the conflict"""
```

(You should copy the paragraph to your script.)


## Advice

A string is also a list.

Take a look at the method [`split`](https://docs.python.org/2/library/stdtypes.html#str.split).
exercises/240.md0000644000175100017510000000064112602321415013512 0ustar  mandarkmandark# Print the head of the fibonacci sequence

Introduces: range.

Author(s): Julien Palard

## Instructions

Consider the [fibonacci sequence](https://en.wikipedia.org/wiki/Fibonacci_number) starting with 1, 2, 3.

Provide the script `solution.py` that print the 10 first numbers of this sequence, separated by comas and spaces, end with a
dot. Such as:

```bash
$ python3 solution.py
1, 2, 3, X, X, X, X, X, X, X.
```
exercises/003.md0000644000175100017510000000061612602321415013511 0ustar  mandarkmandark# Hello World

Introduces: print, strings.

Author(s): Julien Palard

## Instructions

Write a script named `solution.py` that prints "Hello World".

## Advice

Use the [`print()`](https://docs.python.org/3.4/library/functions.html#print) function.

## Evaluation

The correction Robot will test your script such as:

```bash
julien@localhost$ python3 solution.py
Hello World
julien@localhost$
```
exercises/328.md0000644000175100017510000000042512602321415013521 0ustar  mandarkmandark# Multiply all the given parameters

Introduces: list.

Author(s): Julien Palard

## Instructions

Write a function, mul, that multiplies all numbers of the given
list of numbers.

like:
```python
print(mul([1, 2, 3]))
6
print(mul([0, 1, 2, 3]))
0
print(mul([2, 3, 4]))
24
```
exercises/501.md0000644000175100017510000000143212602321415013511 0ustar  mandarkmandark# Change for 42€

Introduces: dynamic_programming.

Author(s): Julien Palard

## Instructions

Given the € currency without cents, with change of:
1, 2, 5, 10, 20, 50, 100, 200, 500

There is 4 ways to make change for 5 euros:

 - 5
 - 2 + 2 + 1
 - 2 + 1 + 1 + 1
 - 1 + 1 + 1 + 1 + 1

Write a function `changes` to count how many ways are there to make
change for a given amount and set of change:

    def changes(amount, coins)

Moulinette will call your programm like this:

    from solution import changes
    changes(42, (1, 2, 5, 10, 20, 50, 100, 200, 500))

For this one, I expect to get 271, in less than 100ms.

Yep I'll try with other set of pieces and other amounts.

Here are some hints: Search for dynamic programming or recursive with
memoization. Try to divide and conquer.
exercises/350.md0000644000175100017510000000143512602321415013516 0ustar  mandarkmandark# bencode / bdecode

Introduces: bytes, functions.

Author(s): Julien Palard

## Instructions

Expose two functions `encode` and `decode`.

 + `encode` take one object as a parameter and return a `byte`.
 + `decode` take a `bytes` as a parameter and return an object.

objects may be of `type`:

 + `bytes`
 + `int`
 + `list`
 + `dict`

You have to follow the `bencode` encoding and decoding algorithm, see
[Wikipedia bencode page](http://en.wikipedia.org/wiki/Bencode).

## Hints

You may code other `helper` functions in your module,
functions to help `encode` and `decode` in their work. You also can
store module variables and use them, like in exercice 450, but only
for you to use.

You may not use `str` in this project, only `bytes`, so I can use
b'\x00' as a dictionary key, and I will !
exercises/330.md0000644000175100017510000000277112602321415013520 0ustar  mandarkmandark# my json

Introduces: functions, print, json, file, dict.

Author(s): Constance de Quatrebarbes.

## Instructions

[JSON](https://en.wikipedia.org/wiki/JSON) is a file format that helps structuring data like a dictionnary. It's widely used for the web and communication between machines.

Your script must provide the function `load_json` that takes as argument the path to the json file to load, and returns the data as a dictionnary.

You must download an example of JSON file [here](https://github.com/c24b/hk-hk/blob/master/021/example.json) and place it this exercise directory.

## Example

```ipython
In [1]: from solution import *

In [3]: d= load_json("./example.json")

In [4]: d
Out[4]:
{'data': [{'actions': [{'link': 'http://www.facebook.com/X999/posts/Y999',
     'name': 'Comment'},
    {'link': 'http://www.facebook.com/X999/posts/Y999', 'name': 'Like'}],
   'created_time': '2010-08-02T21:27:44+0000',
   'from': {'id': 'X12', 'name': 'Tom Brady'},
   'id': 'X999_Y999',
   'message': 'Looking forward to 2010!',
   'type': 'status',
   'updated_time': '2010-08-02T21:27:44+0000'},
  {'actions': [{'link': 'http://www.facebook.com/X998/posts/Y998',
     'name': 'Comment'},
    {'link': 'http://www.facebook.com/X998/posts/Y998', 'name': 'Like'}],
   'created_time': '2010-08-02T21:27:44+0000',
   'from': {'id': 'X18', 'name': 'Peyton Manning'},
   'id': 'X998_Y998',
   'message': "Where's my contract?",
   'type': 'status',
   'updated_time': '2010-08-02T21:27:44+0000'}]}

In [5]: type(d)
Out[5]: dict
```
exercises/215.md0000644000175100017510000000157612602321415013524 0ustar  mandarkmandark# Pernicious numbers

Introduces: functions, if, operators, range.

Author(s): Julien Palard

## Instructions

Build a program, still named solution.py, taking no parameter.

The program will print the [pernicious
numbers](https://en.wikipedia.org/wiki/Pernicious_number) in the
`range(222281, 222381)`

This exercises may be hard if you don't understand what a `pernicious
number` is, and is not mandatory to continue, so you can skip it.

One number per line, nothing else.

If the exercice were to be in the `range(100, 110)` should print:

```
$ ./solution.py
100
103
104
107
109
```

Because:

 - 100 is 1100100 in base 2, 3 ones: prime number of ones.
 - 103 is 1100111 in base 2, 5 ones: prime number of ones.
 - 104 is 1101000 in base 2, 3 ones: prime number of ones.
 - 107 is 1101011 in base 2, 5 ones: prime number of ones.
 - 109 is 1101101 in base 2, 5 ones: prime number of ones.
exercises/525.md0000644000175100017510000000027512602321415013523 0ustar  mandarkmandark# Longest Collatz sequence

Introduces: memoization.

Author(s): Julien Palard

## Instructions

Resolve the [14th euler problem](https://projecteuler.net/problem=14)

## Advice

Have fun.
exercises/285.md0000644000175100017510000000175612602321415013533 0ustar  mandarkmandark# Doing HTTP requests

Introduces: requests, exceptions.

Authors: Julien Palard

## Description

This is a short introduction to the `requests` module, a Python module that make grabbing content from the web quite easy.

Requests is _NOT_ in the python distribution, but that is usually installed along with Anaconda. 

If it's not installed, try: `pip install requests`.

Then, you better read the
[requests](http://www.python-requests.org/en/latest/) documentation.

Now, your exercice will just have to `GET` the content of the page `http://mdk.fr/ip`, and
print the first line.

BEWARE, sometimes, your computer have no internet connectivity. In
this case I don't want your program to print an enormous error with a
lot of stacktraces.  You'll have to catch the `exception`, and simply
print `No internet connectivity.` on the standard output.

## Example

```ipython
$ python solution.py
109.24.212.143
```

Oh Damn ! The wifi is down !

```ipython
$ python solution.py
No internet connectivity.
```
exercises/201.md0000644000175100017510000000064212602321415013510 0ustar  mandarkmandark# is_alpha

Introduces: bool, functions, if.

Authors(s): c24b

## Instructions

Write a function is_alpha that takes one string as parameter and
returns the boolean value True if every characters of the given
parameter are letters, False otherwise.

So it will look like:
```python
def is_alpha(input):
    ...
    ... ...
    ... return False
    ... ...
    return True
```
##Advice

Input will always be a string.
exercises/700.md0000644000175100017510000001330512602321415013514 0ustar  mandarkmandark# Make your own 2048 in python !

Introduces: numpy, input.

Author(s): Antoine Mazieres

During this exercise you will build your own [2048](https://gabrielecirulli.github.io/2048/) game ! If you never played, have some fun [here](https://gabrielecirulli.github.io/2048/) for a moment :)

## Introducing Numpy

There is a lot of way to do this, but here we will consider the game's board as a matrice and use [numpy](http://www.numpy.org/) to program the game.

[Numpy](http://www.numpy.org/) is a python module introducing [matrices](https://en.wikipedia.org/wiki/Matrix_(mathematics)) and used in almost all python scientific modules.

If you're familiar with matlab or octave, have a look at [this page](http://mathesaurus.sourceforge.net/matlab-numpy.html) which compare most famous operations form one language to the other.

Here are a few examples:

+ By convention, we import numpy as np.
```python
>>> import numpy as np
```
+ Initiate a 4x4 matrice of zeros considered as integers
```python
>>> m = np.zeros((4,4), dtype=int)
>>> print(m)
[[0 0 0 0]
 [0 0 0 0]
 [0 0 0 0]
 [0 0 0 0]]
>>> type(m)
<class 'numpy.ndarray'>
```
+ Changing the value of one or many elements
```python
>>> m[3,2] = 1
>>> print(m)
[[0 0 0 0]
 [0 0 0 0]
 [0 0 0 0]
 [0 0 1 0]]
>>> m[3,:] = 1
>>> print(m)
[[0 0 0 0]
 [0 0 0 0]
 [0 0 0 0]
 [1 1 1 1]]
```
+ Getting the position of specific values
```python
>>> np.where(m == 1)
(array([3, 3, 3, 3]), array([0, 1, 2, 3]))
```

Some core elements of Numpy are implemented in the C language making it super disco fast.

## 2048 Rules

The board is a 4 by 4 matrice (ie. a list of 4 lists of length 4). When initialized, all positions are empty except 2 randomly chosen positions set to 2.

Then, the player interact with the game by entering a direction (up, down, right, left) and 3 things happens:
- All elements fall such as gravity whose pulling in that direction.
- If two positions are one under the other when "falling", they merge by adding their values into one single position.
- A new elements pops in a random empty position, of value 2 80% of the time and of value 4 20% of the time.

The player looses if no empty position are available to add new elements.

The player wins if one position reach the value 2048.

You must implement the game's logic and not merely the examples given as illustrations of the exercises which don't span all possible cases.

## Exercise 1 :: Initiate the grid

Provide the function `init_grid()` that returns a random board for starting the game.

The correction robot will import your script and execute the `init_grid()` function,
expecting things like:

```python
>>> import numpy as np
>>> from solution import *
>>> grid = init_grid()
>>> print(grid)
[[0 0 0 0]
 [0 0 0 0]
 [0 0 0 2]
 [0 0 0 2]]
>>> type(grid)
<class 'numpy.ndarray'>
```

## Exercise 2 :: Add new element to the grid

Provide the function `add_new(grid)` that will add either a 2 (80% of the time) or a 4 (20% of the time) somewhere empty in any board. If no empty position is available, `add_new` should just return the board passed as argument.

```python
>>> import numpy as np
>>> from solution import *
>>> grid = init_grid()
>>> print(grid)
[[0 0 0 0]
 [2 0 2 0]
 [0 0 0 0]
 [0 0 0 0]]
>>> grid = add_new(grid)
>>> print(grid)
[[0 0 0 0]
 [2 0 2 0]
 [0 0 0 4]
 [0 0 0 0]]
>>> type(grid)
<class 'numpy.ndarray'>
```

## Exercise 3 :: Roll some row

Provide the function `rollin_row(row)` that will roll the row to the left and returns it, such as:

```python
>>> from solution import *
>>> row = [2, 0, 0, 2]
>>> row = rollin_row(row)
>>> print(row)
[4, 0, 0, 0]
>>> row = [2, 4, 4, 2]
>>> row = rollin_row(row)
>>> print(row)
[2, 8, 2, 0]
```

Here it doesn't matter if `row` is a numpy object or a classic python list.

## Exercise 4 :: Roll the grid

Provide the function `rollin(grid, direction)` where `grid` is the grid to be moved and the direction to be taken, `l` (left), `r` (right), `u` (up) and `d` (down). `move_grid` should return the new grid.

```python
>>> print(grid)
[[ 8  0 16  0]
 [ 4  0  0  0]
 [ 4  0  2  0]
 [ 0 32  2  0]]
>>> grid = rollin(grid, 'd')
>>> print(grid)
[[ 0  0  0  0]
 [ 0  0  0  0]
 [ 8  0 16  0]
 [ 8 32  4  0]]
>>> type(grid)
<class 'numpy.ndarray'>
```

## Exercise 5 :: Create an interactive 2048 game !

You have already built important elements of the game. A few things still need to be done, among which:

+ add a new element (2 or 4) at each turn, when possible
+ Make it playable from a terminal according to player's [inputs](https://docs.python.org/3/library/functions.html#input)
+ Handle when the grid is stuck or a wrong command is entered, why not with [Exceptions](https://docs.python.org/3.4/tutorial/errors.html)
+ Analyse the grid to know when the user wins or looses.

Provide the function `my2048()` that let the user play 2048, such as:

```python
>>> my2048()
[[0 0 0 2]
 [0 0 0 0]
 [0 0 0 0]
 [0 0 0 2]]
u
[[0 0 2 4]
 [0 0 0 0]
 [0 0 0 0]
 [0 0 0 0]]
l
[[2 4 0 0]
 [0 0 0 0]
 [2 0 0 0]
 [0 0 0 0]]
l
The grid is stuck.
Move in another direction.
[[2 4 0 0]
 [0 0 0 0]
 [2 0 0 0]
 [0 0 0 0]]
u
[[4 4 0 0]
 [0 2 0 0]
 [0 0 0 0]
 [0 0 0 0]]
e
Unknown command.
Press l, r, u or d + Enter.
[[4 4 0 0]
 [0 2 0 0]
 [0 0 0 0]
 [0 0 0 0]]
r
[[0 0 0 8]
 [0 0 2 2]
 [0 0 0 0]
 [0 0 0 0]]
```

```python
[[ 2  8  8  4]
 [ 8 32 16 64]
 [16  8  4  2]
 [ 8  4  2  4]]
l
[[ 2 16  4  4]
 [ 8 32 16 64]
 [16  8  4  2]
 [ 8  4  2  4]]
l
[[ 2 16  8  2]
 [ 8 32 16 64]
 [16  8  4  2]
 [ 8  4  2  4]]
Game Over ! :(
```

## Exercise 6 :: Make python play for you !

Provide another version of `my2048()` named `ai2048()` that will choose itself which direction to go until the game ends.

**Super disco Bonus** :: make an AI that wins !

**Exercises 5 and 6 are not corrected automatically, ask a teacher to check them for you**.

exercises/102.md0000644000175100017510000000432112602321415013506 0ustar  mandarkmandark# Check_my_city

Introduces: dict.

Author(s): @c24b.

## Instructions

Here is a list of different velib's stations stored in a dictionnary.
Write a function check_my_city that take a city name in parameter.
This functions check the number of stations available. If nothing is
found it should return: "Sorry! No station for your city has been
found!", otherwise it returns the total number of stations with the
associated zip codes. See example to write the proper format.

```python


velib = \
[{  'address': 'RUE DES CHAMPEAUX (PRES DE LA GARE ROUTIERE) - 93170 BAGNOLET',
        'zip': '93170-',
        'number': 31705, 'latitude': 48.8645278209514, 'city': 'BAGNOLET',
        'name': 'CHAMPEAUX (BAGNOLET)-',
        'longitude': 2.416170724425901
    },
    {   'address': "52 RUE D'ENGHIEN / ANGLE RUE DU FAUBOURG POISSONIERE - 75010 PARIS", 
        'zip': '75010',
        'number': 10042, 'latitude': 48.87242006305313, 'city': 'PARIS-',
        'name': 'ENGHIEN-',
        'longitude': 2.348395236282807
    },
    {
        'address': '74 BOULEVARD DES BATIGNOLLES - 75008 PARIS-',
        'zip': '75008-',
        'number': 8020, 'latitude': 48.882148945631904, 'city': 'PARIS-',
        'name': 'METRO ROME-',
        'longitude': 2.319860054774211
    },
    {   'address': '37 RUE CASANOVA - 75001 PARIS-',
        'zip': '75001-',
        'number': 1022, 'latitude': 48.8682170167744, 'city': 'PARIS-',
        'name': 'RUE DE LA PAIX-',
        'longitude': 2.330493511399174
    },
    {
        'address': '139 AVENUE JEAN LOLIVE / MAIL CHARLES DE GAULLE - 93500 PANTIN-',
        'zip': '93500-',
        'number': 35014, 
        'latitude': 48.893268664697416, 
        'city': 'PANTIN-',
        'name': 'DE GAULLE (PANTIN)-',
        'longitude': 2.412715733388685
    }
]
```

## Advice

Be ***very*** careful of the output format. 
"The devil is in the details". 
Check, check and re-check!

##Example

```python 

def check_my_city(city_name):
    if ...
        return "Sorry! No station for your city has been found!"
    else:
        ...
        #here it's obviously an example to give you an idea!
        return {"stations_nb": 2, 
                "zip_code": ['93170', '93320'],
                "city": 'pantin'}

```
exercises/030.md0000644000175100017510000000034112602321415013504 0ustar  mandarkmandark# Print even numbers in the range [1; 100]

Introduces: range, if.

Author(s): Julien Palard

## Instructions

Write a script names `solution.py` that prints every even numbers
between 1 and 100 inclusive, one line per each.
exercises/334.md0000644000175100017510000000206712602321415013522 0ustar  mandarkmandark# locate_by_geoposition

Introduces: json, file, list, dict.

Author(s): @c24b.

## Instructions

This exercice requires the dataset `solution.json` of exercice 331.
Write a function `locate()` that take two arguments (a latitude and a longitude) 
and returns in a dictionnary representing the nearest station  with all its information and the distance as shown in example.
Your `locate()` function will return the nearest station by requesting the `solution.json` file created in exercice 331.

## Advice

Given the dataset provided as `solution.json`, you can easily
calculate the distance between two points considering Paris is almost
a plane surface and return the nearest station.

## Example

```python

>>> from solution import locate
>>> nearest_station = locate(47.09999999, 2.87468748489))
>>> print nearest_station
{'latitude': 48.8645278209514, 'city': 'BAGNOLET', 'zip_code': '93170', 'longitude': 2.416170724425901, 'name': 'CHAMPEAUX (BAGNOLET)', 'address': 'RUE DES CHAMPEAUX (PRES DE LA GARE ROUTIERE)', 'number': 31705, 'distance': 9.947602265722844e-13}

```
exercises/500.md0000644000175100017510000000027512602321415013514 0ustar  mandarkmandark# Largest product in a grid

Introduces: generators.

Author(s): Julien Palard

## Instructions

Resolve the [11th euler problem](https://projecteuler.net/problem=11)

## Advice

Have fun.
exercises/456.md0000644000175100017510000000235312602321415013525 0ustar  mandarkmandark# Solve Mind

Introduces: random, list, functions, itertools.

Author(s): Antoine Mazières.

# Solving the MasterMind

In order to solve the master mind in a minimum number of guesses, you must:

1. Generate the list of all possible candidate secret codes.
2. Choose a random element of the list
3. If the element chosen is the secret code, stop.
4. Eliminate from the list of candidates all codes that would not have produced the same answer if they were the secret code.
5. Repeat from step 2.

# Exercise

In this exercise, you'll create a function that solves the Master Mind game you've implemented in the previous exercise (455).

You must copy your `solution.py` from 455 in the 456 directory and rename it `master_mind.py`.

You must provide the function `solve_mind` that takes as argument the string of colors available and the code to be cracked and returns the winning guess and the number of guesses necessary to reach the good combination. Such as:

```ipython
In [2]: from solution import *

In [3]: colors = gen_colors(6)

In [4]: code = gen_code(4, colors)

In [5]: code
Out[5]: 'EBBF'

In [6]: solve_mind(colors, code)
Out[6]: ('EBBF', 5)
```

**We will only consider the case where there is 6 colors available and the code length is 4.**

exercises/016.md0000644000175100017510000000061512602321415013514 0ustar  mandarkmandark# Print Alpha

Introduces: print, strings.

Author(s): Julien Palard

Write a script named `solution.py` that prints
"abcdefghijklnmopqrstuvwxyz", using the
[`print()`](https://docs.python.org/3.4/library/functions.html#print)
function.

Using command line, I want to see:

```bash
julien@localhost$ python3 solution.py
abcdefghijklnmopqrstuvwxyz
julien@localhost$
```

Keep cool, and eyes open !
exercises/440.md0000644000175100017510000000421312602321415013513 0ustar  mandarkmandark# Lambda expressions

Introduces: functions, lambda, list.

Author(s): Julien Palard

## Instructions

There's a concise way to express a function, that's particularly
usefull to give a minimalist function directly as a parameter of
another function, typically, the builtin
[sorted](https://docs.python.org/3/library/functions.html#sorted).

This concise way is often called a [lambda
expression](https://en.wikipedia.org/wiki/Anonymous_function) or an
anonymous function. Anonymous because it don't have a name, like a
function has.

The function syntax is:

```
def the_name(parameter):
    return parameter * 2
```

The lambda syntax is:

```
lambda x: x * 2
```

As you see it has no nane, and it's very concise.

In this exercise, you'll write a function, named `filtered`, taking
two parameters, an `iterable`, typically a list, and a `filter`, a
lambda expression.

Obviously your `filtered` function will also work giving it function names:

```
items = [1, 2, 3, 4, 5, 6]
even = filtered(items, lambda x: x % 2 == 0)
odds = filtered(items, lambda x: x % 2 == 1)
```

Will work exactly like:

```
items = [1, 2, 3, 4, 5, 6]


def is_even(x):
    return x % 2 == 0


def is_odd(x):
    return x % 2 == 1


even = filtered(items, is_even)
odds = filtered(items, is_odd)

```

But now you see why we use lambda.

After your `filtered` function, you'll write three lines using your
filtered function and lambdas:

 - print all numbers from 0 to 100 included that are multiple of 3
 - print all numbers from 0 to 100 included that are multiple of 5
 - print all numbers from 0 to 100 included that are multiple of 15

Your numbers should be separated by comas, each list on its line, like:

```
0, 1, 2
2, 3, 4, 5
6, 7, 8, 9, 10, 11
```

`BUT`, in order to allow anybody to `import` your file to use your
`filtered` function (that everybody want) without printing the three
lines of number (that nobody want), you'll put those three lines in an
`if` statement, this one: `if __name__ == '__main__':`. This if
statement is very common in python, and used exactly for this:
Allowing to import a file without executing a part of it. This part is
typically some tests, like you just done.exercises/012.md0000644000175100017510000000116012602321415013504 0ustar  mandarkmandark# Import

Introduces: import, numbers.

Author(s): Julien Palard

## Instructions

Write a script named `solution.py` that print the factorial of 27, by using the [factorial](https://docs.python.org/3/library/math.html#math.factorial) function from the [math module](https://docs.python.org/3/library/math.html).

## Advice

You'll need to `import` the `math` module. The `math` module, as well
as many others, are packaged with python, you don't have nothing to
install on your computer, if you have python it's already here.

Have a look at
[import statement](https://docs.python.org/3/reference/simple_stmts.html#import)
exercises/461.md0000644000175100017510000000407112602321415013520 0ustar  mandarkmandark# Optimization 101

Introduces: numpy, timeit, functions, lambda.

Author(s): Antoine Mazieres

## Description

See exercise 260 for more info on [euclidean distance](https://en.wikipedia.org/wiki/Euclidean_distance) and necessary functions to complete the exercise.

In this exercise you will benchmark (ie. compare) the performance of the different versions of the functions for calculating euclidean distance that we have implemented in the exercise 260.

## Instructions

You must provide a script called `solution.py` in which the function `benchmark(funcs, a, b)` returns a dictionnary where keys are the function names and their values the time it took to execute the given function ten times measured in seconds as a float number.

`funcs` is a list of the function to be tested, which are the one of the exercise 260 (`euclidean(a, b)` ; `opt_euclidean(a, b)` ; `np_euclidean(a, b)`)

`a` and `b` are the coordinates of the two points between which the distance must be measured. We assume that `a` and `b` are of the type `numpy.ndarray`.

Less formally the function `benchmark` you must provide will test every function passed in `funcs`, execute them ten times each with the parameters `a` and `b`, and return their respective score in a dictionnary. Such as:

```python
>>> from solution import *
>>> a = np.random.randint(100, size=100)
>>> b = np.random.randint(100, size=100)
>>> funcs = [euclidean, opt_euclidean, np_euclidean]
>>> benchs = benchmark(funcs, a, b)
>>> print(benchs)
{'opt_euclidean': 0.009175331972073764, 'euclidean': 0.02502306899987161, 'np_euclidean': 0.002547977026551962}
```

## Advice

+ You should initialize the variables `a` and `b` like this to test your function `benchmark`, using [numpy.random](http://docs.scipy.org/doc/numpy/reference/routines.random.html):

	```python
	>>> a = np.random.randint(100, size=100)
	>>> b = np.random.randint(100, size=100)
	```

	This generates a numpy list (called *array*) of 100 numbers between 0 and 100.

+ To measure time of execution, have a look at the module [timeit](https://docs.python.org/2/library/timeit.html)
exercises/715.md0000644000175100017510000000510712602321415013523 0ustar  mandarkmandark# Sapin

Introduces: generators.

Author(s): Julien Palard

## Instructions

You'll write a Python 3 program drawing a fir tree.

The size of the drawed fir tree will depend on the single parameter
given to your program. As always, print a human error message if no
parameter are given to your program.

Given 0, your program should display nothing.

## Advice

You can test is for several values of the parameter here:

<http://sapin.hackinscience.org/?n=10>

<http://sapin.hackinscience.org/?n=5>

etc...

Here is what it should look like:

```
$ for i in $(seq 5); do  python3 solution.py $i; done
   *
  ***
 *****
*******
   |
      *
     ***
    *****
   *******
    *****
   *******
  *********
 ***********
*************
     |||
     |||
          *
         ***
        *****
       *******
        *****
       *******
      *********
     ***********
    *************
     ***********
    *************
   ***************
  *****************
 *******************
*********************
         |||
         |||
         |||
              *
             ***
            *****
           *******
            *****
           *******
          *********
         ***********
        *************
         ***********
        *************
       ***************
      *****************
     *******************
    *********************
      *****************
     *******************
    *********************
   ***********************
  *************************
 ***************************
*****************************
            |||||
            |||||
            |||||
            |||||
                   *
                  ***
                 *****
                *******
                 *****
                *******
               *********
              ***********
             *************
              ***********
             *************
            ***************
           *****************
          *******************
         *********************
           *****************
          *******************
         *********************
        ***********************
       *************************
      ***************************
     *****************************
       *************************
      ***************************
     *****************************
    *******************************
   *********************************
  ***********************************
 *************************************
***************************************
                 |||||
                 |||||
                 |||||
                 |||||
                 |||||
```
exercises/085.md0000644000175100017510000000345312602321415013525 0ustar  mandarkmandark# sort_students

Introduces: functions, sorted, operators.

Author(s): Constance de Quatrebarbes, Antoine Mazières

## Instructions

### Exercise 1

Write a function `sort_a_list` that takes a list as argument and return the list sorted in the descending order, such as:

```ipython
In [1]: from solution import sort_a_list

In [2]: l = [1, 3, 2, 4, 6, 5, 9, 7]

In [3]: sort_a_list(l)
Out[3]: [9, 7, 6, 5, 4, 3, 2, 1]
```

### Exercise 2

Given a list where each element is a list of a mark, and a student name, such as:

```
[[37, 'Jeanette Wafer'], [6, 'Joshua Tran'], [85, 'Susan Maddox']]
```

Write a function `sort_by_mark` that take as argument a similar list and returns it sorted by mark in the descending order. Such as:

```ipython
In [1]: from solution import sort_by_mark

In [4]: my_class = [[6, 'Joshua Tran'], [37, 'Jeanette Wafer'], [85, 'Susan Maddox'], [84, 'Joseph Pedersen'], [12, 'Bonnie Torres'], [36, 'John Freeman'], [27, 'Betty Askins'], [22, 'Mark Osbourne'], [42, 'Lidia Robel']]

In [5]: sort_by_mark(my_class)
Out[5]:
[[85, 'Susan Maddox'],
 [84, 'Joseph Pedersen'],
 [42, 'Lidia Robel'],
 [37, 'Jeanette Wafer'],
 [36, 'John Freeman'],
 [27, 'Betty Askins'],
 [22, 'Mark Osbourne'],
 [12, 'Bonnie Torres'],
 [6, 'Joshua Tran']]
```

### Exercise 3

Write a function `sort_by_name` that take as argument a similar list and returns it sorted by name in the ascending order. Such as:

```ipython
In [1]: from solution import sort_by_name

In [6]: sort_by_name(my_class)
Out[6]:
[[27, 'Betty Askins'],
 [12, 'Bonnie Torres'],
 [37, 'Jeanette Wafer'],
 [36, 'John Freeman'],
 [84, 'Joseph Pedersen'],
 [6, 'Joshua Tran'],
 [42, 'Lidia Robel'],
 [22, 'Mark Osbourne'],
 [85, 'Susan Maddox']]
```

## Advice

Have a look at [`itemgetter`](https://docs.python.org/2/library/operator.html#operator.itemgetter).
exercises/009.md0000644000175100017510000000151512602321415013516 0ustar  mandarkmandark# Characters counting

Introduces: len, strings, list.

## Instructions

Write a script named `solution.py` that prints the number of characters in `paragraph`.

You must copy the following in your script:

```python
phantom_menace = """Turmoil has engulfed the Galactic Republic. The\
 taxation of trade routes to outlying star systems is in\
 dispute. Hoping to resolve the matter with a blockade of deadly\
 battleships, the greedy Trade Federation has stopped all shipping to\
 the small planet of Naboo. While the congress of the Republic\
 endlessly debates this alarming chain of events, the Supreme\
 Chancellor has secretly dispatched two Jedi Knights, the guardians of\
 peace and justice in the galaxy, to settle the conflict"""
```

## Advice

Take a look at [`len()`](https://docs.python.org/3/library/functions.html#len) function.
exercises/280.md0000644000175100017510000000110612602321415013513 0ustar  mandarkmandark# Exceptions

Introduces: exceptions, argv, list.

Authors: Julien Palard

## Description

This is a rapid introduction about exception.

In this exercice you'll just:

```
print(sys.argv[1])
```

BUT without actually checking if `len(sys.argv)` is long enough to have it.

So, sometimes, it will fail with an
[IndexError](https://docs.python.org/3/library/exceptions.html#IndexError).

You'll have to catch this IndexError and print `Not enough parameters.`.

## Advice

I'll search of `if` in your code, if I see it, I'll reject your
solution, so don't try to cheat, use a `try`.
exercises/600.md0000644000175100017510000001002112602321415013503 0ustar  mandarkmandark# Elementary cellular automaton

Introduces: list_comprehensions, bool, dict, slice, functions.

Author(s): Julien Palard

## Instructions

Build a program, still named solution.py, taking a single parameter,
an integer.

This integer is a rule number in the [Wolfram
code](https://en.wikipedia.org/wiki/Wolfram_code).

Your program will display a 79×40 table filled with `#` for 1s and `.`
for zeroes, of the result of running the given (the int parameter,
which is a rule number) [elementary
automata](https://en.wikipedia.org/wiki/Elementary_cellular_automaton).

The first line will always be filled with zeroes except for a single
cell with a 1 right in the middle.

So, here is an example, so you can check your implementation visually:

```
julien@prof$ ./exercises/600/solution.py 90
.......................................#.......................................
......................................#.#......................................
.....................................#...#.....................................
....................................#.#.#.#....................................
...................................#.......#...................................
..................................#.#.....#.#..................................
.................................#...#...#...#.................................
................................#.#.#.#.#.#.#.#................................
...............................#...............#...............................
..............................#.#.............#.#..............................
.............................#...#...........#...#.............................
............................#.#.#.#.........#.#.#.#............................
...........................#.......#.......#.......#...........................
..........................#.#.....#.#.....#.#.....#.#..........................
.........................#...#...#...#...#...#...#...#.........................
........................#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#........................
.......................#...............................#.......................
......................#.#.............................#.#......................
.....................#...#...........................#...#.....................
....................#.#.#.#.........................#.#.#.#....................
...................#.......#.......................#.......#...................
..................#.#.....#.#.....................#.#.....#.#..................
.................#...#...#...#...................#...#...#...#.................
................#.#.#.#.#.#.#.#.................#.#.#.#.#.#.#.#................
...............#...............#...............#...............#...............
..............#.#.............#.#.............#.#.............#.#..............
.............#...#...........#...#...........#...#...........#...#.............
............#.#.#.#.........#.#.#.#.........#.#.#.#.........#.#.#.#............
...........#.......#.......#.......#.......#.......#.......#.......#...........
..........#.#.....#.#.....#.#.....#.#.....#.#.....#.#.....#.#.....#.#..........
.........#...#...#...#...#...#...#...#...#...#...#...#...#...#...#...#.........
........#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#........
.......#...............................................................#.......
......#.#.............................................................#.#......
.....#...#...........................................................#...#.....
....#.#.#.#.........................................................#.#.#.#....
...#.......#.......................................................#.......#...
..#.#.....#.#.....................................................#.#.....#.#..
.#...#...#...#...................................................#...#...#...#.
#.#.#.#.#.#.#.#.................................................#.#.#.#.#.#.#.#
```

Don't forget to print something friendly if the human forgot to give
the rule number as a parater of your program.
exercises/230.md0000644000175100017510000000055612602321415013516 0ustar  mandarkmandark# Print the fist prime number after the given one

Introduces: itertools, module.

Author(s): Julien Palard

## Instructions

Provide the script `solution.py` that prints the first prime number greater than 100000000.

```bash
$ python3 solution.py
666
```

Yes, 666 is not the right answer:)


## Advice

You may use itertools.count(), and you may need sys.exit().
exercises/320.md0000644000175100017510000000111712602321415013510 0ustar  mandarkmandark# Give the frequency of letters in the 'words' file

Introduces: file, format, dict.

Author(s): Julien Palard

## Instructions

Manually download the file `http://x.mdk.fr/words` to your exercice
directory.

Your programme will have to open the file 'words', compute the
frequency of every letters, and display it according to this format:

```
b: 0.02
p: 0.02
a: 0.07
o: 0.05
s: 0.09
d: 0.03
i: 0.07
m: 0.02
c: 0.03
```

## Advice

I do not care about the order, only the values. No more precision, no
less precision, and we'll not take "new lines" into account while
counting characters.
exercises/450.md0000644000175100017510000000443512602321415013522 0ustar  mandarkmandark# Caesar Cypher

Introduces: list, functions, operators.

Author(s): Antoine Mazières

## Description

[Caesar cypher](https://en.wikipedia.org/wiki/Caesar_cipher) is a
method to hide information from being read by some other people,
that's called cryptography. [Caesar
cypher](https://en.wikipedia.org/wiki/Caesar_cipher) is antique
cryptographic method.

Think of one only letter such as `a` you would like to transmit to
someone, but you don't want other people to be able read it.

Now, think of the alphabet as an ordered list of letters:

```python
>>> from string import ascii_lowercase
>>> list(ascii_lowercase)
['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n',
'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']
```

Each letter has an index in this list. `a` is 1, `b` is 2, `j` is 10, etc...

The [Caesar cypher](https://en.wikipedia.org/wiki/Caesar_cipher) hide
information by using a *key* which is a positive number added to the
index of the original letter, the result being the index of the
encrypted letter.

`a` with `key == 2` gives `c`

If the key brings you to the end of the alphabet, you continue to
count from the begining, such as:

`a` with `key == 28` gives `c`

To decypher, or decrypt, the message, you apply the same procedure
moving backward on the alphabet.

## Instructions

You must provide the function `caesar_cypher(s, key, method)` where:

+ `s` is a string (letter, word, sentence, etc).
+ `key` is a positive integer, the key of the [caesar cypher](https://en.wikipedia.org/wiki/Caesar_cipher).
+ `method` which is either `forward` or `backward`, wether to cypher or decypher a message.

`caesar_cypher` should only transform uppercase and lowercase ascii
letters. Special characters, numbers and letters with accents should
not be transformed.

Your function shall not print but return the encoded/decoded string.

```python
>>> from solution import caesar_cypher, forward, backward
>>> caesar_cypher("a", 2, forward)
'c'
>>> caesar_cypher("c", 2, backward)
'a'
>>> caesar_cypher("Python is super disco !", 31, forward)
'Udymts nx xzujw inxht !'
>>> caesar_cypher("Udymts nx xzujw inxht !", 31, backward)
'Python is super disco !'
```

## Hints

forward and backward are actually global variable in your solution,
imported using the "from solution import ...".
exercises/220.md0000644000175100017510000000056112602321415013511 0ustar  mandarkmandark# Print every prime numbers in a range

Introduces: list, strings, functions, module.

Author(s): Julien Palard

## Instructions

Provide the script `solution.py` that print every prime number in the
range [10000;10050], on one line, separated by comas and spaces.

The output of your program have to look like this:

```bash
$ python3 solution.py
1, 2, 3, 4, 5, 6
```
exercises/005.md0000644000175100017510000000061412602321415013511 0ustar  mandarkmandark# 42

Introduces: print, numbers.

Author(s): Julien Palard

## Instructions

Write a script named `solution.py` that prints 42, such as:

```bash
julien@localhost$ python3 solution.py
42
julien@localhost$
```

## Advice

Use the [`print()`](https://docs.python.org/3.4/library/functions.html#print) function.

I'm not asking to print the string "42", (composed of two chars), but the number 42.
exercises/200.md0000644000175100017510000000074312602321415013511 0ustar  mandarkmandark# Create a function, is_prime, that check if its given number is a prime one

Introduces: bool, functions, if.

Author(s): Julien Palard

## Instructions

Provide the script `solution.py` where you define the function `is_prime(num)`.

`num` is number that the function `is_prime` takes as a parameter.

The function `is_prime` return `True` if `num` is a prime number, `False` otherwise. Such as:

```python
>>> from solution import *
>>> is_prime(3)
True
>>> is_prime(4)
False
```
exercises/040.md0000644000175100017510000000030612602321415013506 0ustar  mandarkmandark# SUM of pairs numbers <= 100

Introduces: variables, for.

Author(s): Julien Palard

## Instructions

Provide a script `solution.py` that prints the sum of every even numbers in the range [0; 100]
exercises/110.md0000644000175100017510000000231412602321415013505 0ustar  mandarkmandark# calculator1

Introduces: argv, import, len, list, for, enumerate.

Contact(s): Antoine A

## Instructions

Write a program named `solution.py` that do basic calculations.
You need to be able to get basic operators such as +, - , *, /, % and ^.
Input will integer numbers.

Your program will give a usage message if you don't give the three parameters.

For every other errors like if an operand is not an integer, you'll
print an `input error`.

## Examples

```bash
oa@localhost$ ./solution.py 1 + 1
2
oa@localhost$ ./solution.py
usage: ./solution.py a_number (an_operator +-*/%^) a_number
oa@localhost$ ./solution.py 1 / 0
input error
oa@localhost$
```

## Advices

(**SHELL (OSX, Linux...)**) To input a asterix to a python script you must type '\*', such as:

```bash
mbp|110-$ python solution.py 3 / 5
0.6
mbp|110-$ python solution.py 3 + 5
8
mbp|110-$ python solution.py 3 - 5
-2
mbp|110-$ python solution.py 3 * 5
usage: python3 ./solution.py a_number (an_operator +-*/%^) a_number
mbp|110-$ python solution.py 3 \* 5
15
```

(**WINDOWS**) The same apply for Git Bash (the terminal) on windows for `*`. Moreover, `/` must be passed as `//`.
Such as:

![110 erratum](https://hackinscience.github.io/img/110_erratum.png)
exercises/070.md0000644000175100017510000000061512602321415013514 0ustar  mandarkmandark# Print every two letters pairs, without duplicates

Introduces: for, if.

Author(s): Julien Palard

## Instructions

Provide the script `solution.py` that prints every possible pairs of two letters, only lower case, one by
line, ordered alphabetically, but that skip duplicates, such as 'aa', 'bb', etc...

So your output should look like:

```bash
$ python3 solution.py
ab
..
az
ba
bc
,,
zy
```
exercises/011.md0000644000175100017510000000053012602321415013503 0ustar  mandarkmandark# Print Hello World, 100 times

Introduces: for, range.

Author(s): Julien Palard

## Instructions

Provide a script `solution.py` that prints `Hello World` one hundred times, one line per each.

## References

range: <https://docs.python.org/3/library/functions.html>

for: <https://docs.python.org/3/tutorial/controlflow.html#for-statements>
exercises/025.md0000644000175100017510000000037712602321415013521 0ustar  mandarkmandark# my date

Introduces: print, import, datetime.

## Instructions

Write a program called `solution.py` that print the actual date (day
month year hour minute and seconds) in a human readable format such
as:

```
Today is 2015-09-17 and it is 18:34:35
```
exercises/019.md0000644000175100017510000000070012602321415013512 0ustar  mandarkmandark# my add

Introduces: argv, if, cast.

## Instructions

Write a script named `solution.py` that print the result of simple addition. If no parameters are given, you must print the following error message : `usage: python3 solution.py OP1 OP2`.

## Example

```bash
julien@localhost$ python3 solution.py 1 2
3
julien@localhost$ python3 solution.py 2 3
5
julien@localhost$ python3 solution.py
usage: python3 solution.py OP1 OP2
julien@localhost$
```
exercises/107.md0000644000175100017510000000202112602321415013506 0ustar  mandarkmandark# Select students

Introduces: sorted, dict, operators, list.

Author(s): Constance de Quatrebarbes, Antoine Mazières.

## Instructions

Write a function `select_student` taking as arguments:

 - A list where each element is a list of a student name, and his mark.
 - The mark his must be superior or equal to be accepted.

Your function must return a dictionnary with two entries:

 - `Accepted` which list the accepted students sorted by marks in the
   descending order.
 - `Refused` which list the refused students sorted by marks in ascending order.

## Example

```ipython
In [1]: from solution import *

In [2]: my_class = [['Kermit Wade', 27], ['Hattie Schleusner', 67], ['Ben Ball', 5], ['William Lee', 2]]

In [3]: select_student(my_class, 20)
Out[3]:
{'Accepted': [['Hattie Schleusner', 67], ['Kermit Wade', 27]],
 'Refused': [['William Lee', 2], ['Ben Ball', 5]]}

In [4]: select_student(my_class, 50)
Out[4]:
{'Accepted': [['Hattie Schleusner', 67]],
 'Refused': [['William Lee', 2], ['Ben Ball', 5], ['Kermit Wade', 27]]}
```
exercises/250.md0000644000175100017510000000135312602321415013514 0ustar  mandarkmandark# Draw N Squares

Introduces: functions, strings, print, for, range.

Author(s): Antoine Mazieres

## Instructions

You must provide the function `draw_n_squares(n)` that **returns** a string of squares, such as:

```python
>>> from solution import *
>>> print(draw_n_squares(1))
+---+
|   |
+---+
>>> print(draw_n_squares(3))
+---+---+---+
|   |   |   |
+---+---+---+
|   |   |   |
+---+---+---+
|   |   |   |
+---+---+---+
>>> print(draw_n_squares(5))
+---+---+---+---+---+
|   |   |   |   |   |
+---+---+---+---+---+
|   |   |   |   |   |
+---+---+---+---+---+
|   |   |   |   |   |
+---+---+---+---+---+
|   |   |   |   |   |
+---+---+---+---+---+
|   |   |   |   |   |
+---+---+---+---+---+
```

`n` is the number of squares on the diagonal.
exercises/050.md0000644000175100017510000000046212602321415013512 0ustar  mandarkmandark# Multiples of 3 and 5

Introduces: operators, range.

## Instructions

If we list all the natural numbers below 10 that are multiples of 3 or 5, we get 3, 5, 6 and 9. The sum of these multiples is 23.

Find the sum of all the multiples of 3 or 5 below 1000 and print it with a script named `solution.py`.
exercises/006.md0000644000175100017510000000074012602321415013512 0ustar  mandarkmandark# Print parameters

Introduces: argv.

Author(s): Julien Palard

## Instructions

Write a script named `solution.py` print its own file name.

## Advice

Have a look at
[sys.argv](https://docs.python.org/3/library/sys.html#sys.argv) and
how to [import](https://docs.python.org/3.4/tutorial/modules.html) it.

## Example

```bash
julien@localhost$ python3 solution.py
solution.py
julien@localhost$ mv solution.py solution2.py
julien@localhost$ python solution2.py
solution2.py
```
exercises/455.md0000644000175100017510000000622112602321415013522 0ustar  mandarkmandark# Py Master Mind

Introduces: random, strings, list, input, functions, tuples.

Author: Antoine Mazières.

# About the game

During this exercise you will implement the game [Master Mind](https://en.wikipedia.org/wiki/Mastermind_(board_game)). The game is about cracking a code of colors chosen by the program, given we know his length and the possible colors. At every attempts, the player is given information about how well he performed, so he can improve his next guess.

We'll represent here colors by uppercase letters, starting at the begining of the alphabet.

Let's say the program is asked to generate a code of **size 4** with **six colors 'ABCDEF'**, such as, for example:

```
$ python solution.py
Possible colors are ABCDEF
Code is size 4.
CODE = BFEB
0 --> ABCD
(0, 1)
1 --> BFDE
(2, 1)
2 --> BFEB
Congrats, you won after 3 attempts !
```

The player is given feedback with a tuple of length 2. the first number indicate the number of elements in the correct position AND of the correct color. The second number indicates the number of elements with a color present in the code but not at the accurate position.

# Exercises

## Generate colors

You must provide a function `gen_colors` that takes as argument the number of colors and return a string of the corresponding uppercase letters. If the argument is superior to the number of letters in the alphabet, it should return only the alphabet. Such as:

```ipython
In [2]: gen_colors(6)
Out[2]: 'ABCDEF'

In [4]: gen_colors(295)
Out[4]: 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
```

## Generate the code

You must provide a function `gen_code` that takes as argument the code size and the string containing all colors. Such as:

```ipython
In [5]: gen_code(4, 'ABCDEF')
Out[5]: 'DCBF'
```

## Check guess

You must provide a function `check_guess` that takes as arguments the guess, the code size and the string of colors. The function should check if the guess as the same length as the code, and if each of his colors is part of the colors' list. Such as:

```ipython
In [6]: check_guess('ZZZZ', 4, 'ABCDEF')
Out[6]: False

In [7]: check_guess('EEBBAA', 4, 'ABCDEF')
Out[7]: False

In [8]: check_guess('AABB', 4, 'ABCDEF')
Out[8]: True
```

## Score guess

You must provide a function `score_guess` that takes as arguments the guess and the code and returns a tuple indicating 1) the number of elements in the right position with the right color, and 2) the number of elements in the wrong position but with the right color. Such as:

```ipython
In [9]: score_guess('ABCD', 'ABCD')
Out[9]: (4, 0)

In [10]: score_guess('AAAA', 'ABCD')
Out[10]: (1, 0)

In [11]: score_guess('AADA', 'ABCD')
Out[11]: (1, 1)

In [12]: score_guess('ADDA', 'ABCD')
Out[12]: (1, 1)

In [13]: score_guess('ADDB', 'ABCD')
Out[13]: (1, 2)
```

## Play on the command-line

Put it all together ! You must provide a function `play_cli` taking as argument the size of the code and the number of colors, such as someone executing the script can play your game:

```
$ python solution.py
Possible colors are ABCDEF
Code is size 4.
0 --> FFRJ
Wrong size or color !
0 --> FFFFF
Wrong size or color !
0 --> ABCD
(0, 0)
1 --> FFEE
(3, 0)
2 --> FFFE
Congrats, you won after 3 attempts !
```



exercises/331.md0000644000175100017510000000235412602321415013516 0ustar  mandarkmandark#clean_my_dataset: Json reading and writing

Introduces: json, list, split, join, file.

Author(s): @c24b.

## Instructions

Download the
[velib.json](https://raw.githubusercontent.com/c24b/hk-hk/master/331/velib.json)
file into your directory. This file contain a list of velib stations
in Ile de France stored as a `list` of `dict`. Your program have to
clean it and store the clean version in a new file called
`solution.json`

To clean the file, you'll have to:

 - Add `zip_code` for each station
 - Add `city` for each station
 - Drop the station number for the station `name`
 - Drop the zip_code and city name from the `address`

## Advice

To read and write a json file take a look at the 'json' module.
You can solve this problem using split() and join() function.

## Example for station 31705

Before:

```
{"number": 31705,
 "name": "31705 - CHAMPEAUX (BAGNOLET)",
 "longitude": 2.416170724425901,
 "address": "RUE DES CHAMPEAUX (PRES DE LA GARE ROUTIERE) - 93170 BAGNOLET",
 "latitude": 48.8645278209514},
```

After:

```
{"number": 31705,
 "zip_code": "93170",
 "name": "CHAMPEAUX (BAGNOLET)",
 "longitude": 2.416170724425901,
 "address": "RUE DES CHAMPEAUX (PRES DE LA GARE ROUTIERE)",
 "city": "BAGNOLET",
 "latitude": 48.8645278209514},
```
exercises/045.md0000644000175100017510000000064212602321415013516 0ustar  mandarkmandark# First function

Introduces: functions.

Author(s): Julien Palard

## Instructions

Provide the script solution.py where you define a function
`sqrt(num)`, where `num` is a number and `sqrt` a funtion that returns
the square root of `num`.

We will import your function and try it with different values, such as:

```python
>>> from solution import *
>>> sqrt(3)
1.7320508075688772
>>> sqrt(2)
1.4142135623730951
```