.

Signed-off-by: Debucquoy Anthony <d.tonitch@gmail.com>

.gitignore

@@ -0,0 +1,3 @@
+__pycache__/
+*.tar
+*.class

q1/01dec/adn.txt

@@ -0,0 +1,68 @@
+ttcagttgtgaatgaatggacgtgccaaatagacgtgccgccgccgctcgattcgcactt
+tgctttcggttttgccgtcgtttcacgcgtttagttccgttcggttcattcccagttctt
+aaataccggacgtaaaaatacactctaacggtcccgcgaagaaaaagataaagacatctc
+gtagaaatattaaaataaattcctaaagtcgttggtttctcgttcactttcgctgcctgc
+tcaggacgagggccacaccaagaggcaagagaaacaaaaagagggaacataggaacagga
+accagataatagtgacataagcgaccctttcgcaaatattttggcgcaaaatgagcgggc
+gccaagtgccgcgtggtggagccgcctgaaaatgacatggaaaattcgccgaaaatcgcg
+cgttttggcagcatcaatcccaaagcacaaaattaatttctatcataatttctgggtgca
+acacggacccataattgaatcgaatatagggcttatctgatagcccggcagcaacattga
+actttccggctgcaaaggagacgacaccgagatcgccaattttcgttgggctcgttctct
+gggctccggcgataagaaatccatgctgataaggacaggaggacggtctgcggcaaattg
+aattcgattctgacctgtatgaaagccagcggagatacggatacctctgggtttatgggt
+agaaaacgcagagcgtcgcgccaacatcgaaattatttgcgtttgcatcttctcgtcctt
+tcgtttatcgttctgattgccatcgtggtggcgcggtttctattaattttgcttctgtat
+cgtttgcaaaatctcaaaagattcaaaaagttcgtcatcagcagccgcaacacaaaaacc
+aacgagtgtaaagccgagcatacaaatatcaataaaaacataaacatttacccaatctca
+atctcaaaacattcgcatcgtttccacacaaatatgcttagttcgcccaaattgtgattg
+tatatatatatttaacggcattaaatacaaaagattaagccctaaattaagtgtaaatct
+tacaaaacgtctacgtttttaaacaagaaattgtgatattatatattaatcgggaaattc
+gaagtatgagaacaaaacggtgtatatatgtaagtgggcgatgaacatcaatgaatattt
+tagctgagcaaagtacacacgaatgaatataaatatacatgaaaatatattttgggcacc
+gacttttacaccacaattatatatcgatagaaaagacacgaaaacaatcacagaaaacta
+agagtttcaaaatcaaaattgaggaataccaactagaggataaggctacttaaggatcaa
+aaaacaccaaggagacgagattttctaccaaatcgagagacgaggggcaggttaatttcg
+tcatttttggccaagacagcaaatagaggaacagcaaagcgaaaatcattttatacctca
+cacaacaactacacactaactaagattaggctacgcaactgtacattgtacttaagtgtt
+caaagtatatttagtttactttgtatataagaaaagtagctaaaagcacgcggacaggga
+ggcaggagcaccacagtcactagccactaagcagagtcacagtcacgatcacgttcactc
+caggatcaggactcggggcgggatcagcagacgctgaggaagctgccacgatgacgatga
+gtacaaacaactgcgagagcatgacctcgtacttcaccaactcgtacatgggggcggaca
+tgcatcatgggcactacccgggcaacggggtcaccgacctggacgcccagcagatgcacc
+actacagccagaacgcgaatcaccagggcaacatgccctacccgcgctttccaccctacg
+accgcatgccctactacaacggccaggggatggaccagcagcagcagcaccaggtctact
+cccgcccggacagcccctccagccaggtgggcggggtcatgccccaggcgcagaccaacg
+gtcagttgggtgttccccagcagcaacagcagcagcagcaacagccctcgcagaaccagc
+agcaacagcaggcgcagcaggccccacagcaactgcagcagcagctgccgcaggtgacgc
+aacaggtgacacatccgcagcagcaacaacagcagcccgtcgtctacgccagctgcaagt
+tgcaagcggccgttggtggactgggtatggttcccgagggcggatcgcctccgctggtgg
+atcaaatgtccggtcaccacatgaacgcccagatgacgctgccccatcacatgggacatc
+cgcaggcgcagttgggctatacggacgttggagttcccgacgtgacagaggtccatcaga
+accatcacaacatgggcatgtaccagcagcagtcgggagttccgccggtgggtgccccac
+ctcagggcatgatgcaccagggccagggtcctccacagatgcaccagggacatcctggcc
+aacacacgcctccttcccaaaacccgaactcgcagtcctcggggatgccgtctccactgt
+atccctggatgcgaagtcagtttggtaagtgtcaaggaaagtgatcgacaattccacgaa
+acgtattaagtggaatttttcttcttcttatcgtagtgggttgaagtagttagttccccg
+tttagaattggtcgtagttcccattagaatcgtaactgtgcatacaacagctagagctgt
+attatcttaaattgtataataccataactattacagcgaacctcgtgcagcgaagcaaag
+cagtaaaaagcagtctagatgtactgctttatattgtgtttcctgcttgatattagatca
+ctaagcaagcagacgcgcaagcagttcacgcagatcacgcagacgttaaaaatttaaaaa
+tgtttttgtttgcagaaagaagtaccctcttcgcttttcaattttgtagttaaaattcga
+gcaaatatatttaaattaaaaaggctcaaacttaaagtactatgtatgtcttgtattttt
+gaaaaaattctaaagtttattataaaatgcattttaaatacattttttaacctaccttgt
+cgcttgaaatatataaaatttaagttttagatatggaatagataaacaaaatatttccct
+ctgtcttaactaatttctttaattaaatgttaagccccaaagcgactacagcttcatgtc
+aaactcttaccttaaatatttagagtttgtttgcatttgaactgagaacgttttgtcgac
+gaccttgacacgtccgggtaatttcactttattgccttggccaattgcttgacatcatcc
+gtaatccatctgcaaagacatcccgatacctgacatttgttcaaatttgcgaatttccca
+aatccgagcaaatcgatgaatgcaggcagatgaaagacgaaagaggtggcggaagaggtg
+ctccttgggttccgcttgcccagaagatcgcagcacaggaggcggtcctgccagctaatg
+caaattgacaatagctcgaaatcgtgcaagaaaaaggtttgccaaaaccctaggcgtaac
+taatgagggctggaaaatagagcacactgactgcatgtggtactgctttaggcttagagg
+atgttgcataagtggggatagggctcggccgcctttcgagcgaaaaaggtgtaaggtcta
+ggaggcgagtccttttcaaatatagaattccaatggcatgtcactttcctcggagaaagt
+gaaagtaggcctcaagtggtcggtgcctttgccttgccctccagctgacctgctccctgg
+tcattacgcagtccaaggagctctagctctccccatacccagctctcaatgttgttgtgg
+ttttttgtttgtagccggctgaattttttcgccaaagccagattgagatgtaaagcacaa
+ttgatgagcgccattagttacacgttatgtgcaatggatgccatcaatttattaatctcc
+agaacacgccgaggctccattcatagcaccacttcgtcgtcttaatcccctccctcatcc

q1/01dec/compress.py

@@ -0,0 +1,90 @@
+#!/bin/python
+""" Compression
+Usage:
+    compression.py (-c|-d) -t <type> --in <input> [--out <output>]
+    compression.py -h | --help
+    compression.py --version
+
+Options:
+    -h --help   Show this screen
+    --version   Show Version
+    -c          Compress
+    -d          Decompress
+    -t          Choose Compression Type (currently supported: lz, rle)
+    --in        Input file
+    --out       Output file
+"""
+
+def read_file(filename:str) -> str:
+    try:
+        with open(filename) as file:
+            return file.read()
+    except e:
+        print(e)
+
+
+def lz_compression(text:str):
+    """compress all duplicate word
+    put each word into a list and make make a string of all the occurence
+
+    :text: string to compress
+    :returns: tuple with (list of word, decoding string)
+
+    """
+    splitted_text = text.split()
+    word_list = list()
+    key = dict()
+    key_value = 0
+    for v in splitted_text:
+        if v not in key.keys():
+            key[v] = key_value 
+            key_value += 1
+        word_list.append(key[v])
+    return word_list, key
+
+def save_lz(filename, word_list, key_list):
+    with open(filename, 'w') as file:
+        word_list = map(str, word_list)
+        file.writelines(' '.join(word_list))
+        file.writelines(' '.join(list(key_list.items())))
+
+
+def lz_decompression(text:str):
+    pass
+
+
+def rle_compression(text:str):
+    """compress all duplicate word
+    put each word into a list and make make a string of all the occurence
+
+    :text: string to compress
+    :returns: tuple with (list of word, decoding string)
+
+    """
+    splitted_text = text.split()
+
+
+def rle_decompression(text:str):
+    pass
+
+
+if __name__ == "__main__":
+    from docopt import docopt
+    argument = docopt(__doc__, version="V1")
+    print(argument)
+    if argument['<type>'].lower() == 'lz':
+        if argument['-d']:
+            result = lz_decompression(read_file(argument['<input>']))
+            print(result)
+        if argument['-c']:
+            w_list, k_list = lz_compression(read_file(argument['<input>']))
+            save_lz('test.Ltxt', w_list, k_list)
+    elif argument['<type>'].lower() == 'rle':
+        if argument['-d']:
+            result = rle_decompression(read_file(argument['<input>']))
+            print(result)
+        if argument['-c']:
+            result = rle_compression(read_file(argument['<input>']))
+            print(result)
+    else:
+        raise TypeError("choose a type between lz and rle")

q1/01dec/docopt.py

@@ -0,0 +1,581 @@
+"""Pythonic command-line interface parser that will make you smile.
+
+ * http://docopt.org
+ * Repository and issue-tracker: https://github.com/docopt/docopt
+ * Licensed under terms of MIT license (see LICENSE-MIT)
+ * Copyright (c) 2013 Vladimir Keleshev, vladimir@keleshev.com
+
+"""
+import sys
+import re
+
+
+__all__ = ['docopt']
+__version__ = '0.6.2'
+
+
+class DocoptLanguageError(Exception):
+
+    """Error in construction of usage-message by developer."""
+
+
+class DocoptExit(SystemExit):
+
+    """Exit in case user invoked program with incorrect arguments."""
+
+    usage = ''
+
+    def __init__(self, message=''):
+        SystemExit.__init__(self, (message + '\n' + self.usage).strip())
+
+
+class Pattern(object):
+
+    def __eq__(self, other):
+        return repr(self) == repr(other)
+
+    def __hash__(self):
+        return hash(repr(self))
+
+    def fix(self):
+        self.fix_identities()
+        self.fix_repeating_arguments()
+        return self
+
+    def fix_identities(self, uniq=None):
+        """Make pattern-tree tips point to same object if they are equal."""
+        if not hasattr(self, 'children'):
+            return self
+        uniq = list(set(self.flat())) if uniq is None else uniq
+        for i, child in enumerate(self.children):
+            if not hasattr(child, 'children'):
+                assert child in uniq
+                self.children[i] = uniq[uniq.index(child)]
+            else:
+                child.fix_identities(uniq)
+
+    def fix_repeating_arguments(self):
+        """Fix elements that should accumulate/increment values."""
+        either = [list(child.children) for child in transform(self).children]
+        for case in either:
+            for e in [child for child in case if case.count(child) > 1]:
+                if type(e) is Argument or type(e) is Option and e.argcount:
+                    if e.value is None:
+                        e.value = []
+                    elif type(e.value) is not list:
+                        e.value = e.value.split()
+                if type(e) is Command or type(e) is Option and e.argcount == 0:
+                    e.value = 0
+        return self
+
+
+def transform(pattern):
+    """Expand pattern into an (almost) equivalent one, but with single Either.
+
+    Example: ((-a | -b) (-c | -d)) => (-a -c | -a -d | -b -c | -b -d)
+    Quirks: [-a] => (-a), (-a...) => (-a -a)
+
+    """
+    result = []
+    groups = [[pattern]]
+    while groups:
+        children = groups.pop(0)
+        parents = [Required, Optional, OptionsShortcut, Either, OneOrMore]
+        if any(t in map(type, children) for t in parents):
+            child = [c for c in children if type(c) in parents][0]
+            children.remove(child)
+            if type(child) is Either:
+                for c in child.children:
+                    groups.append([c] + children)
+            elif type(child) is OneOrMore:
+                groups.append(child.children * 2 + children)
+            else:
+                groups.append(child.children + children)
+        else:
+            result.append(children)
+    return Either(*[Required(*e) for e in result])
+
+
+class LeafPattern(Pattern):
+
+    """Leaf/terminal node of a pattern tree."""
+
+    def __init__(self, name, value=None):
+        self.name, self.value = name, value
+
+    def __repr__(self):
+        return '%s(%r, %r)' % (self.__class__.__name__, self.name, self.value)
+
+    def flat(self, *types):
+        return [self] if not types or type(self) in types else []
+
+    def match(self, left, collected=None):
+        collected = [] if collected is None else collected
+        pos, match = self.single_match(left)
+        if match is None:
+            return False, left, collected
+        left_ = left[:pos] + left[pos + 1:]
+        same_name = [a for a in collected if a.name == self.name]
+        if type(self.value) in (int, list):
+            if type(self.value) is int:
+                increment = 1
+            else:
+                increment = ([match.value] if type(match.value) is str
+                             else match.value)
+            if not same_name:
+                match.value = increment
+                return True, left_, collected + [match]
+            same_name[0].value += increment
+            return True, left_, collected
+        return True, left_, collected + [match]
+
+
+class BranchPattern(Pattern):
+
+    """Branch/inner node of a pattern tree."""
+
+    def __init__(self, *children):
+        self.children = list(children)
+
+    def __repr__(self):
+        return '%s(%s)' % (self.__class__.__name__,
+                           ', '.join(repr(a) for a in self.children))
+
+    def flat(self, *types):
+        if type(self) in types:
+            return [self]
+        return sum([child.flat(*types) for child in self.children], [])
+
+
+class Argument(LeafPattern):
+
+    def single_match(self, left):
+        for n, pattern in enumerate(left):
+            if type(pattern) is Argument:
+                return n, Argument(self.name, pattern.value)
+        return None, None
+
+    @classmethod
+    def parse(class_, source):
+        name = re.findall('(<\S*?>)', source)[0]
+        value = re.findall('\[default: (.*)\]', source, flags=re.I)
+        return class_(name, value[0] if value else None)
+
+
+class Command(Argument):
+
+    def __init__(self, name, value=False):
+        self.name, self.value = name, value
+
+    def single_match(self, left):
+        for n, pattern in enumerate(left):
+            if type(pattern) is Argument:
+                if pattern.value == self.name:
+                    return n, Command(self.name, True)
+                else:
+                    break
+        return None, None
+
+
+class Option(LeafPattern):
+
+    def __init__(self, short=None, long=None, argcount=0, value=False):
+        assert argcount in (0, 1)
+        self.short, self.long, self.argcount = short, long, argcount
+        self.value = None if value is False and argcount else value
+
+    @classmethod
+    def parse(class_, option_description):
+        short, long, argcount, value = None, None, 0, False
+        options, _, description = option_description.strip().partition('  ')
+        options = options.replace(',', ' ').replace('=', ' ')
+        for s in options.split():
+            if s.startswith('--'):
+                long = s
+            elif s.startswith('-'):
+                short = s
+            else:
+                argcount = 1
+        if argcount:
+            matched = re.findall('\[default: (.*)\]', description, flags=re.I)
+            value = matched[0] if matched else None
+        return class_(short, long, argcount, value)
+
+    def single_match(self, left):
+        for n, pattern in enumerate(left):
+            if self.name == pattern.name:
+                return n, pattern
+        return None, None
+
+    @property
+    def name(self):
+        return self.long or self.short
+
+    def __repr__(self):
+        return 'Option(%r, %r, %r, %r)' % (self.short, self.long,
+                                           self.argcount, self.value)
+
+
+class Required(BranchPattern):
+
+    def match(self, left, collected=None):
+        collected = [] if collected is None else collected
+        l = left
+        c = collected
+        for pattern in self.children:
+            matched, l, c = pattern.match(l, c)
+            if not matched:
+                return False, left, collected
+        return True, l, c
+
+
+class Optional(BranchPattern):
+
+    def match(self, left, collected=None):
+        collected = [] if collected is None else collected
+        for pattern in self.children:
+            m, left, collected = pattern.match(left, collected)
+        return True, left, collected
+
+
+class OptionsShortcut(Optional):
+
+    """Marker/placeholder for [options] shortcut."""
+
+
+class OneOrMore(BranchPattern):
+
+    def match(self, left, collected=None):
+        assert len(self.children) == 1
+        collected = [] if collected is None else collected
+        l = left
+        c = collected
+        l_ = None
+        matched = True
+        times = 0
+        while matched:
+            # could it be that something didn't match but changed l or c?
+            matched, l, c = self.children[0].match(l, c)
+            times += 1 if matched else 0
+            if l_ == l:
+                break
+            l_ = l
+        if times >= 1:
+            return True, l, c
+        return False, left, collected
+
+
+class Either(BranchPattern):
+
+    def match(self, left, collected=None):
+        collected = [] if collected is None else collected
+        outcomes = []
+        for pattern in self.children:
+            matched, _, _ = outcome = pattern.match(left, collected)
+            if matched:
+                outcomes.append(outcome)
+        if outcomes:
+            return min(outcomes, key=lambda outcome: len(outcome[1]))
+        return False, left, collected
+
+
+class Tokens(list):
+
+    def __init__(self, source, error=DocoptExit):
+        self += source.split() if hasattr(source, 'split') else source
+        self.error = error
+
+    @staticmethod
+    def from_pattern(source):
+        source = re.sub(r'([\[\]\(\)\|]|\.\.\.)', r' \1 ', source)
+        source = [s for s in re.split('\s+|(\S*<.*?>)', source) if s]
+        return Tokens(source, error=DocoptLanguageError)
+
+    def move(self):
+        return self.pop(0) if len(self) else None
+
+    def current(self):
+        return self[0] if len(self) else None
+
+
+def parse_long(tokens, options):
+    """long ::= '--' chars [ ( ' ' | '=' ) chars ] ;"""
+    long, eq, value = tokens.move().partition('=')
+    assert long.startswith('--')
+    value = None if eq == value == '' else value
+    similar = [o for o in options if o.long == long]
+    if tokens.error is DocoptExit and similar == []:  # if no exact match
+        similar = [o for o in options if o.long and o.long.startswith(long)]
+    if len(similar) > 1:  # might be simply specified ambiguously 2+ times?
+        raise tokens.error('%s is not a unique prefix: %s?' %
+                           (long, ', '.join(o.long for o in similar)))
+    elif len(similar) < 1:
+        argcount = 1 if eq == '=' else 0
+        o = Option(None, long, argcount)
+        options.append(o)
+        if tokens.error is DocoptExit:
+            o = Option(None, long, argcount, value if argcount else True)
+    else:
+        o = Option(similar[0].short, similar[0].long,
+                   similar[0].argcount, similar[0].value)
+        if o.argcount == 0:
+            if value is not None:
+                raise tokens.error('%s must not have an argument' % o.long)
+        else:
+            if value is None:
+                if tokens.current() in [None, '--']:
+                    raise tokens.error('%s requires argument' % o.long)
+                value = tokens.move()
+        if tokens.error is DocoptExit:
+            o.value = value if value is not None else True
+    return [o]
+
+
+def parse_shorts(tokens, options):
+    """shorts ::= '-' ( chars )* [ [ ' ' ] chars ] ;"""
+    token = tokens.move()
+    assert token.startswith('-') and not token.startswith('--')
+    left = token.lstrip('-')
+    parsed = []
+    while left != '':
+        short, left = '-' + left[0], left[1:]
+        similar = [o for o in options if o.short == short]
+        if len(similar) > 1:
+            raise tokens.error('%s is specified ambiguously %d times' %
+                               (short, len(similar)))
+        elif len(similar) < 1:
+            o = Option(short, None, 0)
+            options.append(o)
+            if tokens.error is DocoptExit:
+                o = Option(short, None, 0, True)
+        else:  # why copying is necessary here?
+            o = Option(short, similar[0].long,
+                       similar[0].argcount, similar[0].value)
+            value = None
+            if o.argcount != 0:
+                if left == '':
+                    if tokens.current() in [None, '--']:
+                        raise tokens.error('%s requires argument' % short)
+                    value = tokens.move()
+                else:
+                    value = left
+                    left = ''
+            if tokens.error is DocoptExit:
+                o.value = value if value is not None else True
+        parsed.append(o)
+    return parsed
+
+
+def parse_pattern(source, options):
+    tokens = Tokens.from_pattern(source)
+    result = parse_expr(tokens, options)
+    if tokens.current() is not None:
+        raise tokens.error('unexpected ending: %r' % ' '.join(tokens))
+    return Required(*result)
+
+
+def parse_expr(tokens, options):
+    """expr ::= seq ( '|' seq )* ;"""
+    seq = parse_seq(tokens, options)
+    if tokens.current() != '|':
+        return seq
+    result = [Required(*seq)] if len(seq) > 1 else seq
+    while tokens.current() == '|':
+        tokens.move()
+        seq = parse_seq(tokens, options)
+        result += [Required(*seq)] if len(seq) > 1 else seq
+    return [Either(*result)] if len(result) > 1 else result
+
+
+def parse_seq(tokens, options):
+    """seq ::= ( atom [ '...' ] )* ;"""
+    result = []
+    while tokens.current() not in [None, ']', ')', '|']:
+        atom = parse_atom(tokens, options)
+        if tokens.current() == '...':
+            atom = [OneOrMore(*atom)]
+            tokens.move()
+        result += atom
+    return result
+
+
+def parse_atom(tokens, options):
+    """atom ::= '(' expr ')' | '[' expr ']' | 'options'
+             | long | shorts | argument | command ;
+    """
+    token = tokens.current()
+    result = []
+    if token in '([':
+        tokens.move()
+        matching, pattern = {'(': [')', Required], '[': [']', Optional]}[token]
+        result = pattern(*parse_expr(tokens, options))
+        if tokens.move() != matching:
+            raise tokens.error("unmatched '%s'" % token)
+        return [result]
+    elif token == 'options':
+        tokens.move()
+        return [OptionsShortcut()]
+    elif token.startswith('--') and token != '--':
+        return parse_long(tokens, options)
+    elif token.startswith('-') and token not in ('-', '--'):
+        return parse_shorts(tokens, options)
+    elif token.startswith('<') and token.endswith('>') or token.isupper():
+        return [Argument(tokens.move())]
+    else:
+        return [Command(tokens.move())]
+
+
+def parse_argv(tokens, options, options_first=False):
+    """Parse command-line argument vector.
+
+    If options_first:
+        argv ::= [ long | shorts ]* [ argument ]* [ '--' [ argument ]* ] ;
+    else:
+        argv ::= [ long | shorts | argument ]* [ '--' [ argument ]* ] ;
+
+    """
+    parsed = []
+    while tokens.current() is not None:
+        if tokens.current() == '--':
+            return parsed + [Argument(None, v) for v in tokens]
+        elif tokens.current().startswith('--'):
+            parsed += parse_long(tokens, options)
+        elif tokens.current().startswith('-') and tokens.current() != '-':
+            parsed += parse_shorts(tokens, options)
+        elif options_first:
+            return parsed + [Argument(None, v) for v in tokens]
+        else:
+            parsed.append(Argument(None, tokens.move()))
+    return parsed
+
+
+def parse_defaults(doc):
+    defaults = []
+    for s in parse_section('options:', doc):
+        # FIXME corner case "bla: options: --foo"
+        _, _, s = s.partition(':')  # get rid of "options:"
+        split = re.split('\n[ \t]*(-\S+?)', '\n' + s)[1:]
+        split = [s1 + s2 for s1, s2 in zip(split[::2], split[1::2])]
+        options = [Option.parse(s) for s in split if s.startswith('-')]
+        defaults += options
+    return defaults
+
+
+def parse_section(name, source):
+    pattern = re.compile('^([^\n]*' + name + '[^\n]*\n?(?:[ \t].*?(?:\n|$))*)',
+                         re.IGNORECASE | re.MULTILINE)
+    return [s.strip() for s in pattern.findall(source)]
+
+
+def formal_usage(section):
+    _, _, section = section.partition(':')  # drop "usage:"
+    pu = section.split()
+    return '( ' + ' '.join(') | (' if s == pu[0] else s for s in pu[1:]) + ' )'
+
+
+def extras(help, version, options, doc):
+    if help and any((o.name in ('-h', '--help')) and o.value for o in options):
+        print(doc.strip("\n"))
+        sys.exit()
+    if version and any(o.name == '--version' and o.value for o in options):
+        print(version)
+        sys.exit()
+
+
+class Dict(dict):
+    def __repr__(self):
+        return '{%s}' % ',\n '.join('%r: %r' % i for i in sorted(self.items()))
+
+
+def docopt(doc, argv=None, help=True, version=None, options_first=False):
+    """Parse `argv` based on command-line interface described in `doc`.
+
+    `docopt` creates your command-line interface based on its
+    description that you pass as `doc`. Such description can contain
+    --options, <positional-argument>, commands, which could be
+    [optional], (required), (mutually | exclusive) or repeated...
+
+    Parameters
+    ----------
+    doc : str
+        Description of your command-line interface.
+    argv : list of str, optional
+        Argument vector to be parsed. sys.argv[1:] is used if not
+        provided.
+    help : bool (default: True)
+        Set to False to disable automatic help on -h or --help
+        options.
+    version : any object
+        If passed, the object will be printed if --version is in
+        `argv`.
+    options_first : bool (default: False)
+        Set to True to require options precede positional arguments,
+        i.e. to forbid options and positional arguments intermix.
+
+    Returns
+    -------
+    args : dict
+        A dictionary, where keys are names of command-line elements
+        such as e.g. "--verbose" and "<path>", and values are the
+        parsed values of those elements.
+
+    Example
+    -------
+    >>> from docopt import docopt
+    >>> doc = '''
+    ... Usage:
+    ...     my_program tcp <host> <port> [--timeout=<seconds>]
+    ...     my_program serial <port> [--baud=<n>] [--timeout=<seconds>]
+    ...     my_program (-h | --help | --version)
+    ...
+    ... Options:
+    ...     -h, --help  Show this screen and exit.
+    ...     --baud=<n>  Baudrate [default: 9600]
+    ... '''
+    >>> argv = ['tcp', '127.0.0.1', '80', '--timeout', '30']
+    >>> docopt(doc, argv)
+    {'--baud': '9600',
+     '--help': False,
+     '--timeout': '30',
+     '--version': False,
+     '<host>': '127.0.0.1',
+     '<port>': '80',
+     'serial': False,
+     'tcp': True}
+
+    See also
+    --------
+    * For video introduction see http://docopt.org
+    * Full documentation is available in README.rst as well as online
+      at https://github.com/docopt/docopt#readme
+
+    """
+    argv = sys.argv[1:] if argv is None else argv
+
+    usage_sections = parse_section('usage:', doc)
+    if len(usage_sections) == 0:
+        raise DocoptLanguageError('"usage:" (case-insensitive) not found.')
+    if len(usage_sections) > 1:
+        raise DocoptLanguageError('More than one "usage:" (case-insensitive).')
+    DocoptExit.usage = usage_sections[0]
+
+    options = parse_defaults(doc)
+    pattern = parse_pattern(formal_usage(DocoptExit.usage), options)
+    # [default] syntax for argument is disabled
+    #for a in pattern.flat(Argument):
+    #    same_name = [d for d in arguments if d.name == a.name]
+    #    if same_name:
+    #        a.value = same_name[0].value
+    argv = parse_argv(Tokens(argv), list(options), options_first)
+    pattern_options = set(pattern.flat(Option))
+    for options_shortcut in pattern.flat(OptionsShortcut):
+        doc_options = parse_defaults(doc)
+        options_shortcut.children = list(set(doc_options) - pattern_options)
+        #if any_options:
+        #    options_shortcut.children += [Option(o.short, o.long, o.argcount)
+        #                    for o in argv if type(o) is Option]
+    extras(help, version, argv, doc)
+    matched, left, collected = pattern.fix().match(argv)
+    if matched and left == []:  # better error message if left?
+        return Dict((a.name, a.value) for a in (pattern.flat() + collected))
+    raise DocoptExit()

q1/01dec/texte.txt

@@ -0,0 +1,417 @@
+CHARLES BAUDELAIRE 
+
+
+
+Les Fleurs du Mal 
+
+AVEC UNE ÉTUDE 
+
+SUR LA VIE ET LES OEUVRES DE BAUDELAIRE 
+
+Par CAMILLE VERGNIOL 
+
+Illustrations de TONY GEORGE-ROUX 
+Gravées par CH. CLÉMENT 
+
+
+
+
+PARIS 
+
+LIBRAIRIE ALPHONSE LEMERRE 
+
+^3'53> po-^^^tge Choiseul, 2}-^^ 
+
+
+
+Les Fleurs du Mal 
+
+
+
+CHARLES BAUDELAIRE 
+
+
+
+f'f 
+
+
+
+Les Fleurs du Mal 
+
+AVEC UNE ÉTUDE 
+
+SUR LA VIE ET LES ŒUVRES DE BAUDELAIRE 
+
+Par CAMILLE VERGNIOL 
+
+Illustrations de TONY GEORGE-ROUX 
+Gravées par CH. CLÉMENT 
+
+
+
+
+PARIS 
+LIBRAIRIE ALPHONSE LEMERRE 
+
+23-33, PASSAGE CHOISEUL, 23-33 
+
+
+
+
+fh 
+
+Uf-^ 689502 
+
+51 ia.5-,p 
+
+
+
+
+LA VIE ET L'OEUVRE DE BAUDELAIRE 
+
+
+
+Charles-Pierre Baudelaire est né à Paris le 
+9 avril 182 1 . Son père avait 62 ans; sa mère, 27. 
+Il perdit son père en 1 827. L'an d'après, sa mère épousa 
+le commandant Aupick. Celui-ci, nommé lieutenant- 
+colonel, puis général en i8]o (il devait être, par la 
+suite, ambassadeur à Constantinople, à Londres et à 
+Madrid), alla tenir garnison à Lyon. L'enfant fut mis 
+au collège de la ville, en qualité d'interne. Interne 
+également au lycée Louis-le-Grand, lorsque le général, 
+en bon crédit auprès du duc d'Orléans, eut été rap- 
+pelé à Paris (1836). Charles souffrit ce que souffrent 
+les enfants au sang vif, à l'imagination ardente et au 
+cœur tendre, dont la mère se remarie et qui sont 
+tenus à l'écart de la famille. Il a écrit plus tard : 
+« ... Batailles avec les professeurs... Lourde mclan- 
+
+
+
+LA VIE ET L OEUVRE 
+
+
+
+colie... Sentiment de solitude, de destinée éternelle- 
+ment solitaire. Cependant, goût très vif de la vie et du 
+plaisir... » Élève médiocre, peu laborieux et rebelle 
+à la discipline, avec des élans brefs et un enthou- 
+siasme fragile, il montre du goût pour les lettres et 
+fait des vers. Des camarades (mais il faut se défier de 
+souvenirs notés après vingt ou trente ans, et lorsque 
+l'objet en est devenu célèbre) le dépeignent comme 
+ce un esprit exalté, plein parfois de mysticisme et par- 
+fois d'une immoralité et d'un cynisme qui dépassaient 
+toute mesure..., un excentrique, un cerveau à l'en- 
+vers ». D'autres témoignages prouvent qu'il tint un 
+des premiers rangs dans sa classe, — de façon à justi- 
+fier le mot de son beau-père qui le présentait au 
+proviseur: « Voici un cadeau que je viens vous faire. 
+Voici un' élève qui vous fera honneur... »; — qu'il 
+emporta des succès scolaires, et même un second 
+prix de vers latins au Concours général. Il quitta le 
+lycée dans le courant de 1839, et peut-être — puis- 
+qu'il le dit, mais sans détails — en fut-il renvoyé, 
+pour des causes que l'on devine, à cet âge. Il obtint 
+à grand'peine le baccalauréat. Tout ceci ne marque 
+pas une rare originalité. 
+
+La suite n'est guère moins banale. Baudelaire fré- 
+quente, au quartier latin, selon son goût, parmi les 
+obscurs cénacles littéraires. 11 connaît Leconte de 
+Lisle, Gérard de Nerval, L. Ménard, etc., et déclare 
+qu'il veut, lui aussi, « être auteur ». Cette belle réso- 
+lution achève de le brouiller avec sa famille. Le géné- 
+ral est un honnête homme et même un brave homme. 
+Sa femme affirme qu' « il adorait Charles ». C'est 
+beaucoup dire, sans doute ; mais il ne l'a point du tout 
+
+
+
+DE BAUDELAIRE III 
+
+
+
+négligé et rudoyé. 11 prétendait, au contraire, à s'oc- 
+cuper de lui, à le pousser, à le faire « arriver à une 
+haute position sociale », digne de sa naissance et de 
+ses relations. Il fut donc fort déçu et irrité de cette 
+résistance et il n'avait pas en vain l'habitude de l'auto- 
+rité militaire. M""* Aupick aime tendrement son fils, — 
+et l'aimera toujours, — avec un peu de pitié et de 
+crainte. Mais elle se plie docilement à l'influence de 
+son mari; elle a l'âme bourgeoise et même fonction- 
+naire, l'esprit assez court, et indigent en somme. Elle 
+mène, elle veut pour les siens une vie régulière. Alors, 
+le conflit ordinaire. Les parents, humiliés, blessés, 
+courroucés des goûts, des amitiés et des desseins du 
+jeune homme et tâchant à l'en détourner, — et celui-ci 
+s'obstinant et se raidissant à mesure, opposant sa 
+<£ vocation » à tous les conseils de prudence, toutes 
+les exhortations à la sagesse pratique. Piques et dis- 
+putes qui s'enveniment. Puis, après une scène plus 
+violente, et toute conciliation jugée impossible, le 
+grand moyen. On forme une petite pacotille à Charles, 
+— mis, d'abord, aux arrêts par son beau-père, — on 
+l'embarque sur un navire en partance pour les Iles et 
+l'Inde. Les voyages forment la jeunesse. Il verra du 
+pays et reviendra à la raison (1841). Baudelaire se 
+laissa embarquer mais n'alla pas très loin. Il montra 
+une telle force d'inertie, un si morne ennui, une si 
+invincible obstination à ne pas faire de commerce, et 
+même à ne rien faire du tout, hormis de la « littéra- 
+ture », que le capitaine marchand profita d'une 
+relâche à Saint-Denis de Bourbon pour le renvoyer à 
+Bordeaux (mai 1842). Cette aventure ne fut pas tout 
+à fait inutile. Elle fournit quelques souvenirs, quel- 
+
+
+
+i. 
+
+
+
+LA VIE ET L OEUVRE 
+
+
+
+ques images à Baudelaire, et suscita peut-être, ou 
+servit, ses goûts d'exotisme. Mais il ne fit qu'entrevoir 
+le Tropique et ne vit jamais l'Inde, quoi qu'il en ait dit 
+et affecté de dire plus tard. La nostalgie qu'il marquait 
+de ces pays merveilleux est purement imaginaire. 
+
+Le général et M™' Aupick reconnurent qu'il n'y 
+avait rien à faire. Charles était majeur, au reste. Il 
+entra en possession de l'héritage paternel, environ 
+yf.ooofr. Il se trouvait maître enfin de se livrer à ses 
+goûts et il se croyait riche. Il habite quai de Béthune, 
+rue Vaneau, quai d'Anjou, à l'hôtel Pimodan (qui a 
+repris, aujourd'hui, son nom d'hôtel Lauzun), où le 
+rencontra Gautier. Il n'eut jamais le désir ni le sens 
+d'une vie stable, ni de la maison. Il changea quelque 
+cinquante fois de logement, et, vers la fin, passait 
+presque toute la journée au café ou dans la rue, 
+et allait demander asile, pour la nuit, à un ami. Mais, 
+dans l'instant, il jouit de son luxe. Les brocanteurs 
+lui ont composé un mobilier disparate, somptueux et 
+affligeant*, avec force « objets d'art » de rencontre, 
+camelote et bric-à-brac, à des prix dignes d'un fils de 
+famille et jeune poète bien rente. Il se compose lui- 
+même une tête, un costume et une attitude. Il ne peut 
+pas s'empêcher d'être fort gentil garçon. Le portrait 
+de Deroy, commenté par le bon Gautier % montre 
+une taille moyenne, bien prise et robuste, un large 
+front bien modelé, « une peau ambrée, des yeux de 
+velours », la bouche fine et ironique, de longs che- 
+
+1. Voir la Préface de Gautier aux Fleurs du Mal, et les Souvenirs 
+de Théodore de Banville. 
+
+2. Voir aussi les Lettres ou Souvenirs de Le Vavasscur, E. Prarond, 
+Hignard, etc. 
+
+
+
+DE BAUDELAIRE 
+
+
+
+veux crespelés et d'un noir chatoyant, une barbe 
+légère et frisée. Dans le vêtement, il poursuit une 
+élégance laborieuse et indiscrète: l'habit ample et 
+flottant, le gilet à quinze boutons, la cravate aux 
+nuances éclatantes et négligemment nouée sous un col 
+rabattu, des escarpins ouverts comme des mules de 
+petite maîtresse, un chapeau de soie à bords vastes et 
+plats, en forme de cône tronqué et haut d'une coudée, 
+— ce fameux chapeau auquel il demeura fidèle, — 
+car l'on pense bien que le costume varia plus d'une 
+fois, et l'habit, par exemple, devint un paletot-sac, 
+une sorte de blouse, non moins notoire que le cha- 
+peau. Il soignait particulièrement le linge, blanc, 
+souple et fin, qui devait être sa suprême coquetterie. 
+Il se flattait ainsi d'avoir « le déshabillé le plus habillé 
+et l'habillé le plus déshabillé », et se proposait pour 
+modèle « Byron, habillé par Brummel ». Aussi bien, 
+c'est l'époque de son « dandysme », physique et 
+moral. Il a été pauvre, il a subi une gêne fort voisine 
+de la misère ; il n'a jamais été bohème. Il avait la 
+bohème en horreur, — vie, tenue et style, et tout 
+le débraillé. Le Dandy n'est pas seulement pour lui 
+l'être supérieur, qui doit « aspirer au sublime », et, 
+pour cela, « ne rien faire, car être un homme utile 
+est quelque chose de hideux ». Le Dandy est tout 
+l'opposé des oc autres hommes de lettres, pour la plu- 
+part vils piocheurs très ignorants ». Il s'évertue donc 
+à se distinguer encore des hommes de lettres, par son 
+attitude et son langage. Des gestes brefs, une parole 
+lente, une voix grave, qui débite paisiblement des 
+mots choisis et précieux ; une politesse calculée, 
+raffinée, quasi cérémonieuse, qui fuit tout éclat et 
+
+
+
+VI LA VIE ET L OEUVRE 
+
+tout excès. Tout cela est un peu ridicule et bien 
+puéril, mais pas beaucoup plus que les moeurs du 
+temps, où les artistes et les écrivains avaient grand 
+soin de se séparer du commun, par n'importe quel 
+moyen. Tout cela, au reste, n'empêchait pas Baude- 
+laire d'avoir vingt-cinq ans. Il ne peut se contraindre 
+assez, ou assez longtemps, pour refouler toujours le 
+naturel. Il mène la vie qui lui plaît. II est jeune, il a de 
+l'entrain, il est gai. Il aime les longues promenades 
+en joyeuse compagnie; il aime les controverses esthé- 
+tiques, où il écoute plus qu'il ne parle ; il aime les 
+bons repas à la Tour d'Argent, ou sous les tonnelles 
+des guinguettes de banlieue. Il fait des vers, sans 
+autre dessein et autre joie que d'en faire, car il ne 
+les publie pas, et, toujours modeste, ou discret, ou 
+mystérieux, il ne les lit, « d'une voix monotone et 
+impérieuse », que si on l'en prie avec instances. 
+Mais on sait qu'il a une vingtaine de pièces, qu'il 
+retouche et polit sans cesse. Il est heureux (1842-45-). 
+Ce bonheur ne dura guère. En deux ans, Baudelaire 
+avait dissipé plus de la moitié de son patrimoine. Il fût 
+mort de faim plutôt que de demander aide à sa fa- 
+mille. Mais le général Aupick, qui triomphait d'avoir 
+trop prévu ce qui arrivait, lui infligea un conseil judi- 
+ciaire (le brave, l'excellent homme quefutM'Ancelle). 
+Le poète vécut dès lors du maigre revenu d'une tren- 
+taine de mille francs, toujours écorné ou dépensé par 
+avance, auquel s'ajoutent le produit plus maigre en- 
+core de sa plume*, et, sur la fin, les sommes assez 
+
+I. Vers 186), faisant le calcul de ce que lui avaient rapporté ses 
+œuvres, — vers et prose, — il n'arrivait pas à 15.000 fr. Il n'a 
+jamais sollicité d'emploi, ni de sinécures. Mais on le voit demander 
+
+
+
+DE BAUDELAIRE VII 
+
+
+
+fortes que lui fit tenir, assez souvent, sa mère. C'est 
+la gêne, et ce sera bientôt le dénûment, que n'allège, 
+ni ne dissimule, la fierté qui les porte. Baudelaire se 
+débat parmi les emprunts, billets, protêts, rongé par 
+les usuriers. Sa correspondance est toute pleine de 
+ces luttes. Mais comme ses besoins sont modiques, — 
+et qu'en dépit de son dandysme et de ses artifices 
+il a gardé un fonds d'ordre et de décence bourgeoise, 
+
+— il s'accommode de cette indigence. En vingt ans, il 
+ne dépasse pas dix mille francs de dettes, avec le 
+constant souci et le très sincère désir de les payer, 
+sans tarder. Il a d'autres misères et d'autres tares. Il 
+s'est acoquiné avec Jeanne Duval, — la Vénus noire, 
+
+— dénuée de tout charme et agrément apparents, 
+sotte, fausse et méchante. Elle le trompe à la journée, 
+elle lui tire tout l'argent qu'elle peut; il la méprise et 
+la rudoie, mais il lui revient toujours, soit qu'il la 
+prenne avec lui, soit qu'il paye ses mois d'hôpital. Sa 
+santé s'altère. A vingt-sept ans, les tempes se dénudent 
+et s'argentent; — et, quant au moral, il essaie — ou 
+fait semblant — de se suicider. Pourtant, il travaille. 
+Il a le goût de l'art, formé dans les ateliers de l'hôtel 
+Pimodan, des connaissances techniques, un joli talent 
+d'amateur, fantasque et macabre. Il publie un Salon 
+en 1845', ce qui lui vaut d'entrer au Corsaire, où il 
+donne des chroniques et des fantaisies, justement 
+dignes d'oubli. Entre temps, il ajoute quelques pièces 
+ou quelques vers à son volume, qui s'appelle, à ce 
+moment, les Limbes. Il semble donc en bonne voie. 
+
+de petites avances à la Société des Gens de Lettres : 100 fr., — 80, 
+
+— deux louis, — et avec force excuses et promesses. Quelle 
+pitié 1 • 
+
+
+
+VIII LAVIEETL OEUVRE 
+
+Mais non. La Révolution de 1848 le jette dans la poli- 
+tique, et, du premier coup, il va à l'extrême, naturel- 
+lement. Lui qui, l'année précédente, flétrissait le parti 
+républicain comme « l'ennemi acharné des Beaux- 
+Arts et des Belles-Lettres », il traverse une crise 
+aiguë de démocratie, à forme socialo-humanitaire. Il 
+se lie avec Proudhon, fraye avec les innombrables 
+tribuns de réunions publiques. Aux journées de Fé- 
+vrier, des amis le voient mêlé à la foule qui pille les 
+boutiques d'armuriers, brandissant un fusil à deux 
+coups, « pour tuer le général Aupick ». D'autres le 
+rencontrent au Palais-Royal, où il gesticule, tonne, 
+prêche la banqueroute et réclame a la mort des 
+tyrans ». Ce dernier propos est possible, le premier 
+certain. L'accès dure assez longtemps pour le lancer 
+dans les velléités électorales et les campagnes de 
+presse. En 185'!, il rédige un journal de Châteauroux, 
+et voici le début de son premier article: « Lorsque 
+Marat, cet homme doux, et Robespierre, cet homme 
+propre, demandaient, celui-là, 300.000 têtes, celui-ci, 
+la permanence de la guillotine, ils obéissaient à l'iné- 
+luctable logique de leur système... » Les abonnés 
+blêmissent, braves gens qui ne savaient pas ce que 
+c'est que mystifier le lecteur. Baudelaire fut congédié 
+sur l'heure, ravi de cette bonne plaisanterie, et guéri, 
+non seulement de la politique, mais de la démocratie. 
+Il sauta à l'autre bord, et ne cessa plus de proclamer 
+son horreur et sa haine de la République, de la libre 
+pensée, de l'humanitarisme, « toute cette sottise et 
+cette canaille ». Au surplus, « il se f... du genre hu- 
+main ». Il finit par se reconnaître et déclarer catho- 
+lique et grand admirateur des Jésuites. Il fut catholi- 
+
+
+
+DE BAUDELAIRE IX 
+
+
+
+que de la même façon qu'il avait été démocrate. 
+Mais, à la différence de la République, la religion — 
+et non pas du tout la foi — devait lui fournir des 
+souvenirs et des sensations, que l'on retrouve — sans 
+plus — dans son œuvre. 
+
+De cette crise, il tomba dans une autre. — « En 
+1846-47, dit-il, j'eus connaissance de quelques frag- 
+ments d'Edgar Poe. J'éprouvai une commotion singu- 
+lière. Je trouvai — croyez-moi, si vous voulez — 
+des poèmes et des nouvelles dont j'avais eu la pensée, 
+mais vague et confuse, mal ordonnée, et que Poe avait 
+su combiner et mener à la perfection... » Il en conçut 
+une admiration frénétique. Il se voua tout entier à la 
+gloire de Poe, impatient de le révéler au public, 
+comme un bonheur et un bienfait. Il en devient exact 
+et ponctuel. Il travaille assidûment. C'est la seule 
+période où il ait travaillé, le seul sujet qui l'ait fait 
+travailler, et jusqu'à la fin. Traduction excellente, 
+tant les deux hommes — Poe, avec une imagination 
+bien autrement riche et puissante — sont en parfaite 
+communion de goûts et de sensations. Il savait l'anglais 
+dès l'enfance. Pour se rendre mieux maître du texte, 
+pour s'assimiler le savoureux dialecte populaire, il 
+allait l'apprendre dans les tavernes anglaises, buvant 
+le gin et le whisky avec les grooms et les lads. Il est 
+payé de sa ferveur, car cette traduction l'a mis en 
+vue. 11 place, de divers côtés, des articles de critique 
+et des Petits Poèmes en Prose. En i8f6, la Revue des 
+Deux-Mondes publie dix-huit poésies. Oh ! choisies 
+parmi les moins pernicieuses, avec toute sorte de 
+réserves et d'atténuations qui frisent le désaveu! Mais 
+cet acte de hardiesse — car ce n'est rien de moins 
+
+
+
+LA VIE ET L OEUVRE 
+
+
+

q1/03nov/main.py

@@ -0,0 +1,111 @@
+from umage import load, save, show_image
+from math import atan2, cos 
+
+def grayscale(img_mat):
+    """Transform an image into gray
+
+    :img_mat: image en entree
+    :returns: grayscale de limage em entree
+
+    """
+    new_matrix = list()
+    for row in range(len(img_mat)):
+        new_matrix.append(list())
+        for column in img_mat[row]:
+            _r, _g, _b = column
+            gray = round(0.2125 * _r + 0.7154 * _g + 0.0721 * _b)
+            new_matrix[row].append((gray, gray, gray))
+
+    return new_matrix
+
+def convolution(img_mat, mat):
+    """effectue le passage d'une matrice de convolution sur une image grise
+    TODO: image de couleurs
+
+    :img_mat: image en entree
+    :mat: matrice de convolution
+    :returns: image retouchee
+
+    """
+
+    new_matrix = list()
+    for row in range(len(img_mat)):
+        new_matrix.append(list())
+        for column in range(len(img_mat[row])):
+            # _gray = img_mat[row][column][0]
+            _sum = 0
+            for mat_row in range(len(mat)):
+                for mat_column in range(len(mat[mat_row])):
+                    diff_row = mat_row - len(mat)//2
+                    diff_col = mat_column - len(mat[mat_column])//2
+                    if dans_image(img_mat, row+diff_row, column+ diff_col):
+                        _sum += mat[mat_row][mat_column] * img_mat[row + diff_row][column + diff_col][0]
+            new_matrix[row].append((_sum, _sum, _sum))
+    return new_matrix
+
+def dans_image(img_mat, row, col):
+    if row < len(img_mat)-1 and row > 0 and col < len(img_mat[0])-1 and col > 0:
+        return True
+    return False
+
+def calculate_direction(img1, img2):
+    """Calculate the image direction of 2 image that has been trough gx and gy of phobels formula
+
+    :img1: x image of fobel 
+    :img2: y image of fobel 
+    :returns: matrix of direction 
+
+    """
+    res = list()
+    for row in range(len(img1)):
+        res.append(list())
+        for col in range(len(img1[row])):
+            res[row].append(atan2(img2[row][col][0], img1[row][col][0]))
+    return res
+
+
+def dir_mat_to_img(mat):
+    """take a matrix with direction and transform it in image with direction hue """
+    res = list()
+    for row in range(len(mat)):
+        res.append(list())
+        for col in range(len(mat[row])):
+            res[row].append((round(256*cos(mat[row][col])), round(256*cos(mat[row][col] + 120)), round(256*cos(mat[row][col]  - 120))))
+    return res
+
+
+
+if __name__ == "__main__":
+    unit = [
+            [0, 1, 0],
+            [0, 0, 0],
+            [0, 0, 0]]
+    convolution1 = [
+            [-1, -1, -1],
+            [-1,  8, -1],
+            [-1, -1, -1]]
+    convolution2 = [
+            [-1, -1, -1],
+            [-1,  9, -1],
+            [-1, -1, -1]]
+    convolution3 = [
+            [-2, 0, 0],
+            [ 0, 1, 0],
+            [ 0, 0, 2]]
+
+    phobel1 = [
+            [ 1, 0, -1],
+            [ 2, 1, -2],
+            [ 1, 0, -1]]
+    phobel2 = [
+            [ 1, 2, 1],
+            [ 0, 0, 0],
+            [ -1, -2, -1]]
+
+    img = load('./myimg.jpg')
+    new_image = grayscale(img)
+    convolution(new_image, convolution2)
+    phob1_img = convolution(new_image, phobel1)
+    phob2_img = convolution(new_image, phobel2)
+    final = dir_mat_to_img(calculate_direction(phob2_img, phob1_img))
+    save(final, 'final2')

q1/03nov/traceback.txt

@@ -0,0 +1,13 @@
+Traceback (most recent call last):
+  File "/home/tonitch/.local/lib/python3.10/site-packages/pudb/__init__.py", line 148, in runscript
+    dbg._runscript(mainpyfile)
+  File "/home/tonitch/.local/lib/python3.10/site-packages/pudb/debugger.py", line 519, in _runscript
+    self.run(statement)
+  File "/usr/lib/python3.10/bdb.py", line 597, in run
+    exec(cmd, globals, locals)
+  File "<string>", line 1, in <module>
+  File "main.py", line 65, in <module>
+    final_img = convolution(new_image, unit)
+  File "main.py", line 41, in convolution
+    _sum += mat[mat_row][mat_column] * img_mat[row + diff_row][column + diff_col][0]
+IndexError: list index out of range

q1/03nov/umage.py

@@ -0,0 +1,35 @@
+#!/usr/bin/env python3
+
+from PIL import Image  # Requires python-image-library (pillow)
+import itertools
+
+
+def load(filename):
+    """ Given a filename that matches an image file,
+    return a list of lists of tuples corresponding to the list of
+    lines of pixels (R, G, B) of the image. """
+
+    with Image.open(filename, 'r') as image:
+        image = image.convert('RGB')
+        content = list(image.getdata())
+        size_x, size_y = image.size
+        return [content[i:i + size_x] for i in range(0, len(content), size_x)]
+
+
+def save(image, filename='new', extension='jpg'):
+    """ Stores the given image into a file. The name
+    of the file is set to <filename>.<extension> which is
+    'new.jpg' by default. """
+
+    size_x, size_y = len(image), len(image[0])
+    new_image = Image.new('RGB', (size_y, size_x))
+    new_image.putdata(list(itertools.chain.from_iterable(image)))
+    new_image.save('%s.%s' % (filename, extension))
+
+def show_image(image):
+    """ Show the image to the user. """
+
+    size_x, size_y = len(image), len(image[0])
+    new_image = Image.new('RGB', (size_y, size_x))
+    new_image.putdata(list(itertools.chain.from_iterable(image)))
+    new_image.show()

q1/04oct/ex2.py

@@ -0,0 +1,28 @@
+from uturtle import *
+
+def triangle(t, n, size):
+    if n == 0:
+        moveForward(t, size)
+        turnLeft(t, 120)
+        moveForward(t, size)
+        turnLeft(t, 120)
+        moveForward(t, size)
+        turnLeft(t, 120)
+    else:
+        triangle(t, n-1, size/2)
+        moveForward(t, size/2)
+        triangle(t, n-1, size/2)
+        moveBackward(t, size/2)
+        turnLeft(t, 60)
+        moveForward(t, size/2)
+        turnRight(t, 60)
+        triangle(t, n-1, size/2)
+        turnLeft(t, 60)
+        moveBackward(t, size/2)
+        turnRight(t, 60)
+
+if __name__ == "__main__":
+    t= umonsTurtle()
+    moveBackward(t, 250)
+    triangle(t, 5, 500)
+    wait()

q1/04oct/ex3.py

@@ -0,0 +1,36 @@
+from uturtle import (
+    umonsTurtle, wait,
+    moveForward, moveBackward,
+    turnLeft, turnRight,
+    dropPen, usePen)
+
+
+def koch(t: umonsTurtle, x: int, seuil: int):
+    """Dessine une courbe de koch
+
+    :t: the turtle used
+    :x: the length
+    :seuil: seuil of smallest step
+    :returns: None
+
+    """
+    if x < seuil:
+        moveForward(t, x)
+    else:
+        koch(t, x/3, seuil)
+        turnLeft(t, 60)
+        koch(t, x/3, seuil)
+        turnRight(t, 120)
+        koch(t, x/3, seuil)
+        turnLeft(t, 60)
+        koch(t, x/3, seuil)
+
+
+if __name__ == "__main__":
+    turtle = umonsTurtle()
+    turtle.speed(0)
+    dropPen(turtle)
+    moveBackward(turtle, 250)
+    usePen(turtle)
+    koch(turtle, 500, 20)
+    wait()

q1/04oct/ex4.py

@@ -0,0 +1,27 @@
+from uturtle import (
+    umonsTurtle, wait,
+    moveForward, moveBackward,
+    turnLeft, turnRight,
+    dropPen, usePen)
+
+from ex3 import koch
+
+
+def flocon(t, x, seuil, sides=3):
+    """draw a star with koch """
+    flocon_rec(t, x, seuil, sides, sides)
+
+
+def flocon_rec(t, x, seuil, sides, i):
+    """recursion function of flocon()"""
+    if i > 0:
+        koch(t, x, seuil)
+        turnRight(t, 360/sides)
+        flocon_rec(t, x, seuil, sides, i-1)
+
+
+if __name__ == "__main__":
+    turtle = umonsTurtle()
+    turtle.speed(0)
+    flocon(turtle, 100, 6, sides=4)
+    wait()

q1/04oct/ex5.py

@@ -0,0 +1,28 @@
+from uturtle import (
+    umonsTurtle, wait,
+    moveForward, moveBackward,
+    turnLeft, turnRight,
+    dropPen, usePen)
+
+
+def carre(t: umonsTurtle, x: int, seuil: int):
+    """draw an alternative to koch witch is based on squares"""
+    if x < seuil:
+        moveForward(t, x)
+        return
+    carre(t, x/3, seuil)
+    turnLeft(t)
+    carre(t, x/3, seuil)
+    turnRight(t)
+    carre(t, x/3, seuil)
+    turnRight(t)
+    carre(t, x/3, seuil)
+    turnLeft(t)
+    carre(t, x/3, seuil)
+
+
+if __name__ == "__main__":
+    turtle = umonsTurtle()
+    turtle.speed(0)
+    carre(turtle, 200, 5)
+    wait()

q1/04oct/ex6.py

@@ -0,0 +1,40 @@
+from uturtle import (
+    umonsTurtle, wait,
+    moveForward, moveBackward,
+    turnLeft, turnRight,
+    dropPen, usePen)
+
+
+def arbre(t, x, a, n):
+    """draw a tree
+
+    :t: turtle
+    :x: taille du tronc de base
+    :a: angle des branches
+    :n: profondeur de l'arbre
+    """
+    moveForward(t, x)
+    arbre_rec(t, x, a, n)
+
+
+def arbre_rec(t, x, a, n):
+    if n == 0:
+        return
+    turnLeft(t, a/2)
+    moveForward(t, x)
+    arbre_rec(t, x*5/6, a*5/6, n-1)
+    moveBackward(t, x)
+
+    turnRight(t, a)
+    moveForward(t, x)
+    arbre_rec(t, x*5/6, a*5/6, n-1)
+    moveBackward(t, x)
+
+    turnLeft(t, a/2)
+
+
+if __name__ == "__main__":
+    turtle = umonsTurtle()
+    turnLeft(turtle)
+    arbre(turtle, 50, 45, 4)
+    wait()

q1/04oct/recursifs.py

@@ -0,0 +1,31 @@
+def somme1(n):
+    if n == 0:
+        return 0
+    else:
+        somme1(n-1)+n
+
+
+def somme2(n):
+    if n == 0:
+        return 0
+    else:
+        return somme2(n)+n
+
+
+def somme3(n):
+    if n == 0:
+        return 0
+    else:
+        return n+somme3(n-1)
+
+
+def somme4(n):
+    if n == 0:
+        res = 0
+    else:
+        somme4(n)+n
+        return res
+
+
+def somme5(n):
+    return somme5(n-1)+n

q1/04oct/uturtle.py

@@ -0,0 +1,88 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+
+""" Module permettant de manipuler une tortue en mode procédural
+    Utilisé dans le cadre du cours de Programmation et Algorithmique 1
+    (H. Mélot, Université de Mons, à partir de 2013)
+"""
+
+
+import turtle
+turtle.setup(500, 400)
+
+def umonsTurtle():
+    """ Retourne une tortue qui peut évoluer dans un écran
+    (déjà initialisé).
+
+    """
+    t = turtle.Turtle()
+    return t
+
+def wait(msg = 'Press enter to quit.'):
+    """ Affichage un message à l'écran et attend une interaction de
+    l'utilisateur.
+
+    msg - le message à afficher.
+
+    """
+    input(msg)
+
+def moveForward(t, x):
+    """ Fait avancer une tortue t de x pixels.
+
+    t - une tortue
+    x - nombre de pixels
+
+    """
+    t.fd(x)
+
+def moveBackward(t, x):
+    """ Fait reculer une tortue t de x pixels.
+
+    t - une tortue
+    x - nombre de pixels
+
+    """
+    t.bk(x)
+
+def turnRight(t, a=90):
+    """ Fait tourner une tortue t de a degrés vers la droite.
+
+    t - une tortue
+    a - angle en degrés
+    """
+    t.rt(a)
+
+def turnLeft(t, a=90):
+    """ Fait tourner une tortue t de a degrés vers la gauche.
+
+    t - une tortue
+    a - angle en degrés
+
+    """
+    t.lt(a)
+
+def dropPen(t):
+    """ Demande à une tortue t de soulever son stylo
+
+    t - une tortue
+
+    """
+    t.up()
+
+def usePen(t):
+    """ Demande à une tortue t d'abaisser son stylo
+
+    t - une tortue
+
+    """
+    t.down()
+
+
+if __name__ == '__main__':
+    bob = umonsTurtle()
+    moveForward(bob, 100)
+    turnRight(bob)
+    moveForward(bob, 100)
+    wait()
+

q1/13oct/hangman.py

@@ -0,0 +1,58 @@
+from hangmantui import hangman, clear
+from userInput import ask_word_in_dictionary, ask_letter
+
+
+def hangman_start(score: int):
+    """start the hangman """
+    life = 10
+    choosed_word = ask_word_in_dictionary()
+    found_letters = '*' * len(choosed_word)
+    not_in_word = ''
+    while life > 0:
+        draw(life, found_letters)
+        in_letter = ask_letter(not_in_word)
+        if in_letter in choosed_word:
+            found_letters = unhide_letters(choosed_word, in_letter, found_letters)
+        else:
+            not_in_word += in_letter
+            life -= 1
+
+        if found_letters == choosed_word:
+            clear()
+            print('CONGRATS!! the word was: ', choosed_word)
+            score += len(list(dict.fromkeys(choosed_word[:]))) + life - len(not_in_word)
+            break
+
+    return score
+
+
+def unhide_letters(choosed_word, letter, found_letters):
+    """take a letter and unhide it in the found letters
+    :choosed_word: the original word
+    :letter: the letter to unhide
+    :found_letters: the current found letter
+    :returns: found letter with unhiden letters
+    """
+    ret = ''
+    for i in range(len(choosed_word)):
+        if letter in choosed_word[i]:
+            ret += letter
+        else:
+            ret += found_letters[i]
+    return ret
+
+
+def draw(life, word):
+    """draw the main screen with hangman, life remaining and word with * on unknown letters
+    :life: int of life remaining
+    :word: current word with * on unknown letters and other letters on found
+    """
+    clear()
+    print(life)
+    hangman(life)
+    print(word)
+
+
+if __name__ == "__main__":
+    print("your score is", hangman_start(0))
+

q1/13oct/hangmantui.py

@@ -0,0 +1,66 @@
+# -*- encoding:utf-8 -*-
+"""Terminal User Interface for the hangman."""
+
+
+def clear():
+    """Clear the terminal screen."""
+    print(chr(27) + "[2J")
+
+
+def hangman(lives):
+    """
+    Display a hangman state on terminal with maximum 10 lives.
+
+    lives is the remaining number of lives between 0 and 10. When lives is 0,
+    the hangman is completed/dead.
+    """
+    # Top
+    print("  __________")
+    print("  | /     |")
+    # Head
+    if lives <= 5:
+        print("  |/      O")
+    else:
+        print("  |/")
+    # Arms and torso
+    if lives <= 2:
+        print("  |      /|\\")
+    elif lives <= 3:
+        print("  |      /|")
+    elif lives <= 4:
+        print("  |       |")
+    else:
+        print("  |")
+    # Torso
+    if lives <= 4:
+        print("  |       |")
+    else:
+        print("  |")
+    # Legs
+    if lives <= 0:
+        print("  |      / \\")
+    elif lives <= 1:
+        print("  |      /")
+    else:
+        print("  |")
+    # Bottom / Stool
+    if lives <= 6:
+        print("  |       _")
+    else:
+        print("  |)")
+    if lives <= 7:
+        print(" /|\\     /|\\")
+    elif lives <= 8:
+        print(" /|\\     / \\")
+    elif lives <= 9:
+        print(" /|\\     /")
+    else:
+        print(" /|\\")
+
+
+if __name__ == "__main__":
+    for i in range(10, -1, -1):
+        clear()
+        print("%i lives left:" % i)
+        hangman(i)
+        print("")

q1/13oct/userInput.py

@@ -0,0 +1,58 @@
+def belongs_to_dictionary(word):
+    """check if a word is in dictionary
+    :word: the word to check
+    :returns: true if in word.txt else false
+    """
+    with open("words.txt") as wl:
+        word_list = wl.read().split()
+        return word in word_list
+
+
+def ask_word_in_dictionary():
+    """ ask a word, if not in word.txt redo
+    :returns: word of word.txt
+    """
+    while(True):
+        in_word = input("insert a word that belongs to the file words.txt: ")
+        if belongs_to_dictionary(in_word):
+            return in_word
+        print(f"{in_word} is not in word.txt")
+
+
+def ask_letter(tried_letters):
+    """ ask for a letter and check if it is not in trie_letters else redo
+    :tried_letters: list of already tried letters
+    :returns: the letter that is not in tried letters
+    """
+    while(True):
+        in_letter = input(f"insert a letter that is not tested yet: {tried_letters.split()}: ")
+        if in_letter not in tried_letters:
+            return in_letter
+        print(f"{in_letter} is already guessed")
+
+
+if __name__ == "__main__":  # Only tests
+    print("Test de la fonction, belongs_to_dictionary")
+    testing_words = {'banana': True,
+                     'patatas': False,
+                     'tonitch': False,
+                     'other': True,
+                     'lol': False,
+                     1: False,
+                     False: False}
+    for value, result in testing_words.items():
+        if belongs_to_dictionary(value) == result:
+            print(f"{value} has been tested, returned {result} -- SUCCESS!")
+        else:
+            print(f"{value} has been tested, returned {result} -- ERROR!")
+
+    print("Test de la fonction, ask_word_in_dictionary")
+    value = ask_word_in_dictionary()
+    print(f"The function returned value {value}")
+
+    print("Test de la fonction, ask_letter")
+    value = ask_letter("")
+    print(f"The function returned value {value}")
+    value = ask_letter("aeiou")
+    print(f"The function returned value {value}")
+    print("Test are finished")

q1/15dec/fonctions.py

@@ -0,0 +1,27 @@
+def plus_grand_bord(w):
+    for k, v in enumerate(w[1:]):
+        if v == w[0]:
+            if w[k+1:] == w[:len(w[k+1:])]:
+                return w[k+1:]
+    return None
+
+def intersection(v, w):
+    max_inter = ''
+    for (k, v) in enumerate(v):
+        if v in w:
+            i = 1
+            while v[k:k+i] in w:
+                i += 1
+                if i >= len(w):
+                    break
+            if len(v[k:k+i]) > len(max_inter):
+                max_inter = v[k:k+i]
+    return max_inter
+
+
+def palyndrome(mot):
+    inv = [mot[len(mot)-1-i] for i in range(len(mot))]
+    return inv
+
+if __name__ == "__main__":
+    print(palyndrome('anticonstitutionnelement'))

q1/17nov/displayCpu.py

@@ -0,0 +1,72 @@
+"""Pour executer ce script, vous devez installer matplotlib"""
+
+import matplotlib.pyplot as plt
+import itertools
+
+
+class CpuPlot(object):
+    def __init__(self, n):
+        """
+        Initialize an object that will be used to display data points on the
+        screen.
+        n   --  An array of x-values.
+        """
+
+        self.n = n
+        self.courbes = []
+        self.labels = []
+
+    def prepare(self, data, label=None):
+        """
+        Add a data points.
+        """
+
+        self.courbes.append(data)
+        self.labels.append(label)
+
+    def reset(self):
+        """
+        Reset data points. Note that x-values are keeped.
+        """
+
+        self.courbes = []
+
+    def draw(self):
+        """
+        Draw the data points on the screen.
+        """
+
+        plt.xlim(max(0, min(self.n) - 5), max(self.n) + 5)
+        plt.ylim(0, max([max(t) for t in self.courbes]) + 5)
+
+        plt.xlabel('input size')
+        plt.ylabel('milliseconds')
+        plt.title('CPU time charts')
+
+        color = itertools.cycle('bgrcmyk')
+
+        for i, t in enumerate(self.courbes):
+            if self.labels[i] is None:
+                plt.plot(self.n, t, '%s-o' % next(color),
+                        label='Data points %d' % i)
+            else:
+                plt.plot(self.n, t, '%s-o' % next(color),
+                        label=self.labels[i])
+
+        plt.legend()
+        plt.show()
+
+
+if __name__ == '__main__':
+    # Create a CpuPlot object for x-values 10, 20, 30, 40
+    afficheur = CpuPlot([10, 20, 30, 40])
+
+    # Add two sets of data points
+    afficheur.prepare([1.1, 2.4, 2.8, 4.1], "Points 1")
+    afficheur.prepare([1.2, 4.5, 8.4, 16.5])
+
+    # Display
+    afficheur.draw()
+
+    # Don't exit too fast
+    input("Press [Enter] to exit.")

q1/17nov/ex5.py

@@ -0,0 +1,25 @@
+
+def bubble_sort(liste:list):
+    """Sort the list with bubble sort inline """
+    Order = False
+    while not Order:
+        Order = True
+        for i in range(len(liste)-1):
+            if liste[i] > liste[i+1]:
+                liste[i], liste[i+1] = liste[i+1], liste[i]
+                Order = False
+
+
+if __name__ == "__main__":
+    from random import shuffle
+
+    from displayCpu import CpuPlot
+    from umons_cpu import cpu_time
+    from sort import dicho_search, insertion_sort,  merge_sort, selection_sort
+
+    test_bubble = [cpu_time(bubble_sort, [i for i in range(j)]) for j in range(10)]
+    
+    graph = CpuPlot(list(range(10)))
+    graph.prepare(test_bubble)
+    graph.draw()
+

q1/17nov/sort.py

@@ -0,0 +1,107 @@
+"""
+Voir commentaires concernant ce module dans l'enonce de la serie de TP.
+"""
+
+import random
+import umons_cpu
+
+def python_sort(t):
+    t.sort()
+
+def insertion_sort(t):
+    n = len(t)
+    for i in range(1,n):
+        clef = t[i]
+        j = i - 1
+        while j >= 0 and t[j] > clef:
+            t[j+1] = t[j]
+            j = j - 1
+        t[j+1] = clef
+
+def selection_sort(t):
+    n = len(t)
+    for i in range(n-1):
+        small = i
+        for j in range(i+1,n):
+            if t[j] < t[small]:
+                small = j
+        (t[i], t[small]) = (t[small], t[i])
+
+# permet d'avoir une interface in place, similaire aux autres tris
+def merge_sort(t):
+    t[:] = merge_sort_functionnal(t)
+
+def merge_sort_functionnal(t):
+    n = len(t)
+    if n > 1:
+        (t1, t2) = split(t)
+        t1 = merge_sort_functionnal(t1)
+        t2 = merge_sort_functionnal(t2)
+        return merge(t1, t2)
+    else:
+        return t
+
+def split(t):
+    """ precondition: len(t) >= 2 """
+    mid = len(t) // 2
+    t1 = t[:mid]
+    t2 = t[mid:]
+    return (t1, t2)
+
+def merge(t1, t2):
+    if len(t1) == 0:
+        return t2
+    elif len(t2) == 0:
+        return t1
+    elif t1[0] < t2[0]:
+        return [t1[0]] + merge(t1[1:], t2)
+    else:
+        return [t2[0]] + merge(t1, t2[1:])
+
+def dicho_search(t, x):
+    start = 0
+    end = len(t) - 1
+    mid = start + (end - start) // 2
+    while (end - start > 0) and x != t[mid]:
+        if x < t[mid]:
+            end = mid - 1
+        else:
+            start = mid + 1
+        mid = start + (end - start) // 2
+    if len(t) > 0 and x == t[mid]:
+        return mid
+    else:
+        return None
+
+def test(n):
+    t1 = list(range(n))
+    t2 = list(range(n,0,-1))
+    t3 = []
+    for i in range(n):
+        t3.append(random.randint(0,n))
+    print('%7d %7.2f %7.2f %7.2f %7.2f %7.2f %7.2f %7.2f %7.2f %7.2f' % (
+        n,
+        umons_cpu.cpu_time(selection_sort, t1),
+        umons_cpu.cpu_time(insertion_sort, t1),
+        umons_cpu.cpu_time(merge_sort, t1),
+        umons_cpu.cpu_time(selection_sort, t2),
+        umons_cpu.cpu_time(insertion_sort, t2),
+        umons_cpu.cpu_time(merge_sort, t2),
+        umons_cpu.cpu_time(selection_sort, t3),
+        umons_cpu.cpu_time(insertion_sort, t3),
+        umons_cpu.cpu_time(merge_sort, t3)))
+
+if __name__ == '__main__':
+    print('Temps affiches en msec')
+    print('      n '
+          't1: sel '
+          '    ins '
+          '    mer '
+          't2: sel '
+          '    ins '
+          '    mer '
+          't3: sel '
+          '    ins '
+          '    mer')
+    for i in range(100, 901, 100):
+        test(i)

q1/17nov/umons_cpu.py

@@ -0,0 +1,109 @@
+"""
+Module utilisé à l'UMONS dans le cadre des cours de Programmation et
+Algorithmique 1 et Structure de Données 1 pour faciliter le calcul
+des temps CPU.
+
+Auteur: Pierre Hauweele et Hadrien Mélot (Université de Mons), 2016
+"""
+
+import timeit
+import pickle
+
+
+def __init_timer__(f, *args):
+    fs = pickle.dumps(f)
+    argss = pickle.dumps(args)
+    setup = \
+"""
+import pickle
+import copy
+f = pickle.loads(%s)
+args = pickle.loads(%s)
+""" % (fs, argss)
+    stmt = 'f(*copy.deepcopy(args))'
+    return timeit.Timer(stmt, setup)
+
+
+def __calibrate__(t):
+    calibrate_test = 0
+    n = 1
+
+    while calibrate_test < 0.1:
+        n *= 10
+        calibrate_test = t.timeit(n)
+
+    return n, calibrate_test
+
+
+def cpu_time(f, *args):
+    """ Retourne un temps CPU exprimé en millisecondes (ms)
+            - f : fonction ou méthode à tester
+            - *args : liste d'arguments pour f. Ces arguments ne sont pas
+              modifiés, même si la fonction f a des effets de bord (ils sont
+              copiés avant l'exécution).
+
+            Exemples :
+                cputime(math.sqrt, 4)
+                   pour calculer le temps CPU de math.sqrt(4)
+                cputime(str.upper, 'hello')
+                   pour calculer le temps CPU de 'hello'.upper()
+                cputime(myfunc, x, y, z)
+                   pour calculer le temps CPU de myfunc(x, y, z)
+    """
+    t = __init_timer__(f, *args)
+
+    n, cal_time = __calibrate__(t)
+
+    res = min([cal_time] + t.repeat(2, n))
+
+    return (res / n) * 1000
+
+
+def calibrate(f, *args):
+    """ Retourne un nombre de tests qui rend le calcul du temps CPU
+        a priori raisonnable.
+            - f : fonction ou méthode à tester
+            - *args : liste d'arguments pour f. Ces arguments ne sont pas
+              modifiés, même si la fonction f a des effets de bord (ils sont
+              copiés avant l'exécution).
+
+        Le nombre de tests retourné est une puissance de 10 (au minimum 10). Il
+        sera d'autant plus grand si la fonction semble rapide.
+    """
+    t = __init_timer__(f, *args)
+
+    n, cal_time = __calibrate__(t)
+
+    return n
+
+
+def cpu_time_without_copy(f, *args):
+    """ Retourne un temps CPU exprimé en millisecondes (ms)
+            - f : fonction ou méthode à tester
+            - *args : liste d'arguments pour f.
+            Cette version ne copie pas les arguments:
+            il ne faut donc l'utiliser qu'avec des fonctions
+            sans effet de bord !
+    """
+    fs = pickle.dumps(f)
+    argss = pickle.dumps(args)
+    setup = \
+"""
+import pickle
+f = pickle.loads(%s)
+args = pickle.loads(%s)
+""" % (fs, argss)
+    stmt = 'f(*args)'
+    t = timeit.Timer(stmt, setup)
+
+    calibrate_test = 0
+    n = 1
+
+    while calibrate_test < 0.1:
+        n *= 10
+        calibrate_test = t.timeit(n)
+
+    res = min([calibrate_test] + t.repeat(2, n))
+
+    return (res / n) * 1000
+

q1/20oct/myList.py

@@ -0,0 +1,148 @@
+"""
+    Nous ne pouvons utiliser que pop et append pour les lists
+"""
+
+import math
+
+
+def map(fun, it):
+    """execute la fonction sur chaques elements de la liste """
+    ret = list()
+    for i in it:
+        ret.append(fun(i))
+    return ret
+
+
+def filter(test_fun, it):
+    """return a list of all el of it that passes test fun """
+    ret = list()
+    for i in it:
+        v = test_fun(i)
+        if v:
+            ret.append(i)
+    return ret
+
+
+def reduce(fun, it):
+    ret = fun(it[0], it[1])
+    for i in range(2, len(it)):
+        ret = fun(ret, it[i])
+    return ret
+
+
+def prime_numbers(n):
+    """make a list of n first prime elements """
+    ret = list()
+    cursor = 2
+    while len(ret) < n:
+        check = True
+        for i in range(2, cursor):
+            if cursor % i == 0:
+                check = False
+        if check:
+            ret.append(cursor)
+        cursor += 1
+    return ret
+
+
+def is_prime(n):
+    if n == 0 or n == 1:
+        return False
+    for i in range(2, n):
+        if n % i == 0:
+            return False
+    return True
+
+
+def insert(seq, n):
+    """insert n in the seq at the right position
+    :seq: List par ordre croissant
+    """
+    ret = list()
+    cursor = None
+    for i in range(len(seq)):
+        if seq[i] < n:
+            ret.append(seq[i])
+        else:
+            cursor = i
+            break
+    ret.append(n)
+    if cursor is None:
+        return ret
+    for j in seq[cursor:]:
+        ret.append(j)
+    return ret
+
+
+def produit_matriciel(matrice1, matrice2):
+    """fait le produit matriciel de 2 matrices """
+    if len(matrice1[0]) != len(matrice2):
+        return None
+    ret = list()
+    for i in range(len(matrice1)):
+        temp = list()
+        for j in range(len(matrice1)):
+            temp.append(sum_for_matrices(matrice1, i, matrice2, j))
+        ret.append(temp)
+    if len(ret) == 1:
+        return ret[0][0]
+    return ret
+
+
+def sum_for_matrices(a, i, b, j):
+    tot = 0
+    for k in range(0, len(b)):
+        tot += a[i][k] * b[k][j]
+    return tot
+
+
+def test(fun, *args, result):
+    if len(args) == 1:
+        test = fun(args[0])
+        if test == result:
+            print(f"✅{fun.__name__}({args[0]}) == {result} -- SUCCESS!")
+        else:
+            print(f"❌{fun.__name__}({args[0]}) == {result} -- ERROR! (returned {test})")
+    elif len(args) == 2 and hasattr(args[0], '__name__'):
+        test = fun(args[0], args[1])
+        if test == result:
+            print(f"✅{fun.__name__}({args[0].__name__}, {args[1]}) == {result} -- SUCCESS!")
+        else:
+            print(f"❌{fun.__name__}({args[0].__name__}, {args[1]}) == {result} -- ERROR! (returned {test})")
+    elif len(args) == 2:
+        test = fun(args[0], args[1])
+        if test == result:
+            print(f"✅{fun.__name__}({args[0]}, {args[1]}) == {result} -- SUCCESS!")
+        else:
+            print(f"❌{fun.__name__}({args[0]}, {args[1]}) == {result} -- ERROR! (returned {test})")
+
+
+if __name__ == "__main__":
+    test(map, math.sqrt, [], result=[])
+    test(map, math.sqrt, [2.0, 4.0, 6.0, 100.0], result=[1.4142135623730951, 2.0, 2.449489742783178, 10.0])
+    test(map, str.upper, list('hello'), result=['H', 'E', 'L', 'L', 'O'])
+
+    test(filter, is_prime, range(20), result=[2, 3, 5, 7, 11, 13, 17, 19])
+    test(filter, str.isalpha, list('r2d2'), result=['r', 'd'])
+
+    test(reduce, math.pow, [2, 2], result=4.0)
+    test(reduce, math.pow, [2, 3, 4], result=4096.0)
+
+    test(prime_numbers, 1, result=[2])
+    test(prime_numbers, 12, result=[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37])
+
+    test(is_prime, 1, result=False)
+    test(is_prime, 2, result=True)
+    test(is_prime, 3, result=True)
+    test(is_prime, 33, result=False)
+
+    test(insert, [], 1, result=[1])
+    test(insert, list(range(6)), -1, result=[-1, 0, 1, 2, 3, 4, 5])
+    test(insert, list(range(6)), 3, result=[0, 1, 2, 3, 3, 4, 5])
+    test(insert, list(range(6)), 10, result=[0, 1, 2, 3, 4, 5, 10])
+
+    test(produit_matriciel, [[2, 0, 1], [3, 6, 2]], [[1, 5], [2, 6], [3, 7]], result=[[5, 17], [21, 65]])
+    test(produit_matriciel, [[1, 5], [2, 6], [3, 7]], [[2, 0, 1], [3, 6, 2]], result=[[17, 30, 11], [22, 36, 14], [27, 42, 17]])
+    test(produit_matriciel, [[1.0, 2.5]], [[3.0], [4.5]], result=14.25)
+    test(produit_matriciel, [[1.0, 2.5]], [[3.0, 4.5]], result=None)
+    test(produit_matriciel, [[1, 5], [2, 6], [3, 7]], [[1, 5], [2, 6], [3, 7]], result=None)

q1/24nov/decalage.txt

@@ -0,0 +1 @@
+xzujwrtsnruqjrjsyfyntsjxyhtwwjhyjojujzcrfnsyjsfsyufxxjwfqjcjwhnhjxznafsy

q1/24nov/dico.txt

@@ -0,0 +1,26 @@
+a d
+b c
+c q
+d r
+e k
+f n
+g g
+h v
+i u
+j t
+k x
+l o
+m i
+n l
+o a
+p j
+q y
+r b
+s s
+t z
+u m
+v p
+w h
+x w
+y f
+z e

q1/24nov/encryption.py

@@ -0,0 +1,105 @@
+def lecture(nom : str) -> str:
+    """get all character of a file
+
+    :nom: file name
+    :returns: string of the file's content
+
+    """
+    with open(nom, 'r') as file:
+        return file.read()
+
+
+def nettoyage(texte : str) -> str:
+    """clean the text from it's space and uppsercase
+
+    :texte: Sentence to cclean
+    :returns: the string cleaned
+
+    """
+    texte = texte.lower()
+    alphabet = 'abcdefghijklmnopqrstuvwxyz'
+    ret = ''
+    for char in texte:
+        if char in alphabet:
+            ret += char
+    return ret
+
+
+def chiffrement_decalage(texte : str, u : int) -> str:
+    """Encrypt a string with cesar
+
+    :texte: String to encrypt
+    :u: Key for ceasar encryption
+    :returns: encrypted text
+
+    """
+    alphabet = 'abcdefghijklmnopqrstuvwxyz'
+    decalage = dict()
+    for k, l in enumerate(alphabet):
+        decalage[l] = alphabet[(k+u) % len(alphabet)]
+    ret = ''
+    for l in texte:
+        ret += decalage[l]
+    return ret
+
+
+def dechiffrement_decalage(texte, u):
+    """decrypt text encoded with cesar
+
+    :texte: the string to decode
+    :u: ceasar key to decode
+    :returns: the string decoded with the key 
+
+    """
+    return chiffrement_decalage(texte, -u)
+
+
+def chiffrement_substitution(texte, dico):
+    ret = ''
+    for l in texte:
+        if l in dico:
+            ret += dico[l]
+        else:
+            ret += l
+    return ret
+
+
+def dechiffrement_substitution(texte, dico):
+    invert = dict()
+    for k, v in dico.items():
+        invert[v] = k
+    return chiffrement_substitution(texte, invert)
+
+
+
+def file_to_dict(filename):
+    ret = dict()
+    with open(filename) as f:
+        for l in f:
+            ret[l.split()[0]] = l.split()[1]
+    return ret
+
+
+
+if __name__ == "__main__":
+    import sys
+    if(len(sys.argv) == 5):
+        if sys.argv[1] == 'd':
+            if sys.argv[2] == 'c':
+                text = nettoyage(lecture(sys.argv[3]))
+                print(chiffrement_decalage(text, int(sys.argv[4])))
+            if sys.argv[2] == 'd':
+                text = nettoyage(lecture(sys.argv[3]))
+                print(dechiffrement_decalage(text, sys.argv[4]))
+
+        if sys.argv[1] == 's':
+            if sys.argv[2] == 'c':
+                text = nettoyage(lecture(sys.argv[3]))
+                dico = file_to_dict(sys.argv[4])
+                print(chiffrement_substitution(text, dico))
+            if sys.argv[2] == 'd':
+                text = nettoyage(lecture(sys.argv[3]))
+                dico = file_to_dict(sys.argv[4])
+                print(dechiffrement_substitution(text, dico))
+
+

q1/24nov/substitution.txt

@@ -0,0 +1 @@
+zbdpduookbrmbldtdiduszmkjkbsallkidusjambymaujbklrbkokbusymk

q1/24nov/test.py

@@ -0,0 +1,24 @@
+from encryption import (
+        lecture,
+        nettoyage,
+        chiffrement_decalage,
+        chiffrement_substitution
+        )
+
+def test1():
+   print(lecture("test.txt"))
+
+def test2():
+   print(nettoyage("     this is a TestsS  "))
+
+def test3():
+   print(chiffrement_decalage("blablabla", -42))
+
+def test4():
+    print(chiffrement_substitution("blablabla", {'a': 'b', 'b': 'd'}))
+
+if __name__ == "__main__":
+    # test1()
+    # test2()
+    # test3()
+    test4()

q1/24nov/vigenere.txt

@@ -0,0 +1 @@
+yzadgqxqmmtpxazvblxitapsgmnedinexsikallqotgvrp

q1/27oct/ex4.py

@@ -0,0 +1,15 @@
+import random
+
+
+def creer_enchevetrements(bag, i, max_en):
+    """creer une suite d'enchevetrement aleatoire """
+    autre_baguettes = bag[:]
+    autre_baguettes.pop(i)
+    return [(random.choice(autre_baguettes), i) for _ in range(random.randint(1, max_en))]
+
+
+if __name__ == "__main__":
+    for _ in range(100):
+        p = list(range(42))
+        random.shuffle(p)
+        print(creer_enchevetrements(p, 8, 10))

q1/27oct/ex5.py

@@ -0,0 +1,18 @@
+import random
+from ex4 import creer_enchevetrements
+
+
+def creer_mikado(bag):
+    """creer un sac de mikado avec des enchevetrement aleatoire """
+    game = list()
+    nombre_enchevetrements = random.randint(1, len(bag))
+    while len(game) < nombre_enchevetrements:
+        game.append(creer_enchevetrements(bag, random.choice(bag), 1)[0])
+    return game
+
+
+if __name__ == "__main__":
+    for _ in range(100):
+        bag = list(range(random.randint(2, 42)))
+        random.shuffle(bag)
+        print(creer_mikado(bag))

q1/27oct/ex6.py

@@ -0,0 +1,27 @@
+def peut_retirer(i, bag, jeu):
+    """verifie si une baguette peut etre retiree """
+    on_top = bag[:]
+    for intersection in jeu:
+        if intersection[1] in on_top:
+            on_top.remove(intersection[1])
+    return i in on_top
+
+
+def retirer(i, bag, jeu):
+    bag.remove(i)
+    for intersection in jeu:
+        if i in intersection:
+            jeu.remove(intersection)
+
+
+if __name__ == "__main__":
+    from ex5 import creer_mikado
+
+    bag = list(range(10))
+    game = creer_mikado(bag)
+    print(game)
+    retirer(5, bag, game)
+    print(game)
+    # print(bag)
+    # print(game)
+    # print(peut_retirer(5, bag, game))

q1/27oct/ex7.py

@@ -0,0 +1,33 @@
+from ex6 import peut_retirer, retirer
+
+
+def quel_ordre(_bag, jeu):
+    """retourne un ordre possible sinon None """
+    bag = _bag[:]
+    order = list()
+    last_order = None
+    while order != last_order:
+        last_order = order[:]
+        print(last_order)
+        for i in bag:
+            if peut_retirer(i, bag, jeu):
+                order.append(i)
+                retirer(i, bag, jeu)
+    bag_t, order_t = bag[:], order[:]
+    bag_t.sort()
+    order_t.sort()
+    print(order_t, bag_t)
+    if(order_t == bag_t):
+        return order
+    else:
+        return None
+
+
+if __name__ == "__main__":
+    from ex5 import creer_mikado
+
+    bag = list(range(10))
+    game = creer_mikado(bag)
+    print(bag)
+    print(game)
+    print(quel_ordre(bag, game))

q1/29sept/ex2-1/droite.py

@@ -1,4 +1,25 @@
-def droite(p1: tuple,p2: tuple) -> tuple:
+from math import floor, sqrt
+
+
+def transform_mp_to_abc(m, p):
+    """transforme une équation de la forme y = mx + p to ax + by = c
+
+    :returns: 3-uple of a, b, c
+
+    """
+    return -m, 1, p
+
+
+def transform_abc_to_mp(a, b, c):
+    """transforme une équation de la forme to ax + by = c to y = mx + p
+
+    :returns: tuple of m, x
+
+    """
+    return -a/b, c
+
+
+def droite(p1: tuple, p2: tuple) -> tuple:
     """retourne un 3-uple d'une droite selon ax+by=c
 
     :p1: tuple du point 1
@@ -64,27 +85,40 @@ def intersection(d1, d2):
 
 
 def droite_normale(d, p):
-    """TODO: trouve la normale dune droite passant par un point.
+    """trouve la normale dune droite passant par un point.
 
     :d: droite
     :p: point
     :returns: retourne la normale de la droite passant par le point
 
     """
+    a, b, c = d
+    x, y = p
 
+    m, p = transform_abc_to_mp(a, b, c)
+    return transform_mp_to_abc(-1/m, y-(-1/m)*x)
 
 
 def symetrie_orthogonale(d, p):
-    """TODO: Docstring for symetrie_orthogonale(d, p.
-    :returns: TODO
+    """ retourne la symétrie orthogonale par le point p de la droite d
+    :returns: symétrie orthogonale
 
     """
-    pass
+    a, b, c = d
+    x, y = p
+    ap, bp, cp = droite_normale(d, p) # perpendiculaire passant par le point
+    xi, yi = intersection((a, b, c), (ap, bp, cp))
+    return round((2*xi - x)*10)/10, round((2*yi - y)*10)/10
+
 
 def distance_droite_point(d, p):
-    """TODO: Docstring for distance_droite_point.
-    :returns: TODO
+    """ donne la distance entre une droite et un point
+    :returns: distance la plus courte entre le point et la droite
 
     """
-    pass
+    a, b, c = d
+    x, y = p
+    ap, bp, cp = droite_normale(d,p) # perpendiculaire passant par le point
+    xi, yi = intersection((a,b,c), (ap, bp, cp))
+    return sqrt((xi-x)**2 + (yi-y)**2)
 

q1/29sept/ex2-1/droite_test.py

@@ -27,8 +27,9 @@ def tests():
     test(droite_normale, (-0.5, 1, 1.0), (3, 4), (2.0, 1, 10.0))
 
     test(symetrie_orthogonale, (-0.5, 1, 1.0), (-2, 0), (-2.0, 0.0))
-    test(symetrie_orthogonale, (-0.5, 1, 1.0), (3, 4), (2.0, 1, 10.0))
+    test(symetrie_orthogonale, (-0.5, 1, 1.0), (3, 4), (4.2, 1.6))
 
+    test(distance_droite_point, (-0.5, 1, 1.0), (3, 4), 1.3416407864998738)
     test(distance_droite_point, (-0.5, 1, 1.0), (-2, 0), 0.0)
 
 

q1/livres/ex_cpp/Makefile

@@ -0,0 +1,16 @@
+CXX = c++
+CXXFLAGS = -Wall -g
+LDFLAGS= -lm
+
+SOURCE_POINTS= points.cpp main.cpp
+
+all: points
+
+points: $(SOURCE_POINTS)
+	$(CXX) $(CXXFLAGS) -o $@ $(SOURCE_POINTS) $(LDFLAGS)
+
+run: points
+	./points
+
+clean:
+	rm -f *.o ./points

q1/livres/ex_cpp/main.cpp

@@ -0,0 +1,16 @@
+#include "points.h"
+#include <iostream>
+
+int main(int argc, char *argv[])
+{
+	Points p(5,5);
+	std::cout << p.abscisse() << ' ' << p.ordonnee() << std::endl;
+
+	std::cout << p.rho() << ' ' << p.theta() << std::endl;
+
+	p.deplace(3.1, 2);
+	std::cout << p.abscisse() << ' ' << p.ordonnee() << std::endl;
+
+	
+	return 0;
+}

q1/livres/ex_cpp/points.cpp

@@ -0,0 +1,39 @@
+#include "points.h"
+#include "math.h"
+
+Points::Points(float m_x, float m_y)
+: x(m_x), y(m_y){}
+
+// SETTERS
+
+void Points::deplace(float m_dx, float m_dy){
+	x += m_dx;
+	y += m_dy;
+}
+
+void Points::homothetie(float k){
+	x *= k;
+	y *= k;
+}
+
+void Points::rotation(float angle){
+
+}
+
+// GETTERS
+
+float Points::abscisse(){
+	return x;
+}
+
+float Points::ordonnee(){
+	return y;
+}
+
+float Points::rho(){
+	return sqrt(x*x + y*y);
+}
+
+float Points::theta(){
+	return atan(y/x);
+}

q1/livres/ex_cpp/points.h

@@ -0,0 +1,24 @@
+#ifndef POINTS_H
+#define POINTS_H
+
+class Points
+{
+private:
+	float x, y;
+
+
+public:
+	Points(float x, float y);
+
+	void deplace(float, float);
+	void homothetie(float);
+	void rotation(float);
+
+	float abscisse();
+	float ordonnee();
+	float rho();
+	float theta();
+
+};
+
+#endif /* POINTS_H */

q1/renforcement/entrainement_0311/ex1.py

@@ -0,0 +1,27 @@
+
+def find(chambre, etiquette):
+    """Find all occurence of etiquette in chambre and return a list of all his position
+
+    :chambre: matrice of item in chambre
+    :etiquette: Element to find in chambre as string
+    :returns: list of positions
+
+    """
+    ret = list()
+    for x in range(len(chambre)):
+        for y in range(len(chambre[x])):
+            if etiquette == chambre[x][y]:
+                ret.append((x,y))
+    return ret
+
+# Tests
+if __name__ == "__main__":
+    chambre = [
+            [ "A" , "A" , "B" , "D"  ],
+            [ "C" , "P" , "U" , "A"  ],
+            [ "M" , "O" , "N" , "S " ],
+            [ "A" , "B" , "D" , "A"  ]
+             ]
+    print(find(chambre, 'A'), "should print 5 elemets")
+    print(find(chambre, 'C'), "Should print 1 element")
+    print(find(chambre, 'Elephant'), "Should print nothing")

q1/renforcement/entrainement_0311/ex2.py

@@ -0,0 +1,32 @@
+def champ():
+    """Create a field, ask for size, amount of orni and position of said orni
+    :returns: number of plan 
+    """
+    (N, M) = tuple(input("Size Quantity:").split()[:2])
+    field = [['🌱' for y in range(int(N))] for x in range(int(N))]
+    for i in range(int(M)):
+        (_X, _Y) = tuple(input(f"(orni {i}) X Y:").split()[:2])
+        field[int(_Y)][int(_X)] = '🦝'
+
+    for x in range(int(N)):
+        for y in range(int(N)):
+            if field[y][x] == '🦝':
+                for i in range(x-1, x+2):
+                    for j in range(y-1, y+2):
+                        if field[j][i] == '🥕':
+                            field[j][i] = '💀'
+                        if field[j][i] == '🌱':
+                            field[j][i] = '🥕'
+    return field
+
+def draw_field(field):
+    """draw a field """
+    for x in range(len(field)):
+        for y in range(len(field[x])):
+            print(field[x][y], end=' ')
+        print()
+
+
+
+if __name__ == "__main__":
+    draw_field(champ())

q1/renforcement/entrainement_0311/ex3.py

@@ -0,0 +1,7 @@
+def check_ticket(ticket):
+    while(:)
+    tosumuup = [int(i)for i in list(ticket)]
+    return sum(tosumuup)
+
+if __name__ == "__main__":
+    print(check_ticket('999999'))

q1/renforcement/entrainement_0311/ex4.py

@@ -0,0 +1,24 @@
+
+def permutation(mot):
+    """find all permutation of a word
+
+    :mot: TODO
+    :returns: list of all permutations
+
+    """
+    return permutation_rec('' , mot)
+
+def permutation_rec(pre, post):
+    print(pre, post)
+    if (post == ''):
+        return pre
+    ret = list()
+    for i in list(post):
+        _post = list(post)
+        _post.remove(i)
+        ret.append(permutation_rec(pre + i, str(_post)))
+    return ret
+
+if __name__ == "__main__":
+    permutation('abc')
+

q1/renforcement/entrainement_0712/cup.py

@@ -0,0 +1,16 @@
+tab = map(int, input().split)
+
+def nombre_tasse(tab):
+    """count the ammount of tasse following weird set of rules """
+    start_cup = 0 
+    in_cup = False
+    for k, v in enumerate(tab):
+        if v < tab[k+1]:
+            in_cup = True
+            start_cup = k
+        elif v < tab[k-1]:
+            if 
+
+    return count
+
+print(nombre_tasse(tab))

q1/renforcement/entrainement_0712/member_list.py

@@ -0,0 +1,68 @@
+from datetime import datetime
+
+class Member:
+
+    """Represente un membre dans la base de donnee de l'umons """
+
+    def __init__(self, name, surname, faculty, section, register_date = datetime.now().strftime("%Y%m%d"), seen = 0, seen_dates = list()):
+        """TODO: to be defined.
+
+        :seen: number of time he came to CPUMONS 
+        :seen_dates: date when he came 
+
+        """
+
+        self._name = name
+        self._surname = surname
+        self._mail = f"{name}.{surname}@studen.umons.ac.be"
+        self._faculty = faculty
+        self._section = section
+        self._register_date = register_date
+        self._seen = seen
+        self._seen_dates = seen_dates
+
+    def __str__(self):
+        return f"{self._name} {self._surname}, {self._faculty} -> {self._section}; seen {self._seen} time(s)"
+
+    def addSeen(self, date = datetime.now().strftime("%Y%m%d")):
+        self._seen += 1
+        self._seen_dates.append(date)
+
+def interaction_menu(mbr_list):
+    print("""
+1) Insert new member
+2) List members
+3) Delete a member
+4) Update member
+5) Quit
+          """)
+    try:
+        menu_selection = int(input("select your action: "))
+    except:
+        return True
+
+    if menu_selection == 1:  # Insert new member
+        name, surname, faculty, section = input("enter: <name surname faculty section> (with space between each input): ").split(' ')
+        mbr_list.append(Member(name, surname, faculty, section))
+    elif menu_selection == 2:  # List members
+        for k, v in enumerate(mbr_list):
+            print(k, v)
+    elif menu_selection == 3:  # Delete a member
+        toDelUser = input("enter the index of the user you want to delete: ")
+        mbr_list.pop(toDelUser)
+    elif menu_selection == 4:  # Update member
+        toUpdateUser = int(input("enter the index of the user you want to update: "))
+        datetime = input("enter the date where he has been seen ( let blank for the current date ): ")
+        if not datetime:
+            mbr_list[toUpdateUser].addSeen()
+        else:
+            mbr_list[toUpdateUser].addSeen(datetime)
+    else:  # Menu error/quit
+        return False
+    return True
+
+if __name__ == "__main__":
+    user_list = list()
+    exit = False
+    while not exit:
+        exit = not interaction_menu(user_list)

q1/renforcement/entrainement_0712/stringdiff.py

@@ -0,0 +1,14 @@
+def diff(in1: str, in2: str) -> list:
+    ret = list()
+    for k, v in enumerate(in1):
+        if in2[k] != v :
+            ret.append((k, v, in2[k]))
+    return ret
+
+if __name__ == "__main__":
+    in1, in2 = input("entrez la phrase 1:") , input("entrez la phrase 2")
+    diff_ins = diff(in1, in2)
+    if len(diff_ins) == 0:
+        print("Phrases identiques")
+    else:
+        print(diff_ins)

q1/renforcement/renforcement_2510/ex1.py

@@ -0,0 +1,39 @@
+def ChangeInMatrix(tab, n, m):
+    """Prend tab et le repartie sur n rangee et m colones
+
+    :tab: liste des eleves
+    :n: row
+    :m: culumn
+    :returns: matrix nxm with tab
+
+    """
+    ret = list()
+    for i in range(n):
+        ret.append(list())
+        for j in range(m):
+            ret[i].append(0)
+    for i in range(len(tab)):
+        ret[i // n][i % m] = tab[i]
+    return ret
+
+
+def printMatrix(matrix: list):
+    """TODO: print a matrix in console
+
+    :matrix: matrix en entrée
+
+    """
+    max_char = 0
+    for i in matrix:
+        for j in i:
+            if len(str(j)) > max_char:
+                max_char = len(str(j))
+
+    for i in matrix:
+        for j in i:
+            print(f'{j} {" " * (max_char - len(str(j)))}', end='')
+        print('')
+
+
+if __name__ == "__main__":
+    printMatrix(ChangeInMatrix(list(range(1, 45)), 21, 14))

q1/renforcement/renforcement_2510/ex2.py

@@ -0,0 +1,46 @@
+def ask_row_column_amount():
+    """just ask row and column and amount and return it
+    :returns: (row, culumn, amount)
+
+    """
+    row, column = tuple(input().split())
+    rect_amount = input()
+    return row, column, rect_amount
+
+
+def add_rectangle(screen):
+    """add a rectangle to the screen
+
+    :screen: TODO
+    :returns: TODO
+
+    """
+    x1, y1, x2, y2, char = tuple(input().split())
+    for i in range(int(x1), int(x2)):
+        for j in range(int(y1), int(y2)):
+            screen[i][j] = char
+
+
+def draw(screen):
+    """draw the matrix
+
+    :screen: TODO
+    :returns: TODO
+
+    """
+    for i in screen:
+        for j in i:
+            print(j, end='')
+        print()
+
+
+def main():
+    r, c, a = ask_row_column_amount()
+    screen = [['.' for i in range(int(r))] for j in range(int(c))]
+    for i in range(int(a)):
+        add_rectangle(screen)
+    draw(screen)
+
+
+if __name__ == "__main__":
+    main()

q1/renforcement/renforcement_2510/ex3.py

@@ -0,0 +1,43 @@
+def find_max_count(in_list):
+    max_count = 0
+    for i in in_list:
+        count = 0
+        for j in in_list:
+            if j == i:
+                count += 1
+        if max_count < count:
+            el = i
+            max_count = count
+    return el
+
+
+def ask_word():
+    word = input('input your encrypted word separated with space ' ' : ')
+    return word.split()
+
+
+def new_alphabet(translation):
+    alphabet = 'abcdefghijklmnopqrstuvwxyz'
+    ret = alphabet[translation:] + alphabet[:translation]
+    return ret
+
+
+def decode(to_decode):
+    """decode en trouvant le e qui est la chaine de character la plus presente
+
+    :to_decode: TODO
+    :returns: TODO
+
+    """
+    max_char = int(find_max_count(to_decode))
+    decalage = 5 - max_char
+    language = new_alphabet(decalage)
+    decoded = [language[int(i) - 1] for i in to_decode]
+
+    return decoded
+
+
+if __name__ == "__main__":
+    letters = ask_word()
+    d = decode(letters)
+    [print(i, end='') for i in d]

q1/renforcement/renforcement_2510/renforcement.txt

@@ -0,0 +1,149 @@
+Séance de renforcement
+CPUMons
+25 octobre 2022
+
+Ce document comporte plusieurs exercices dont la diculté est renseignée
+par un nombre et est globalement croissante. Il est évidemment fortement recommandé de rééchir au
+préalable sur papier avant de se lancer dans la partie implémentation.
+Répartition de la diculté :
+ Niveau 1 : problème facile, ne nécessite pas de code complexe pour être mis en ÷uvre;
+ Niveau 2 : problème moyen, demande une réexion plus poussée sur la présentation du code;
+ Niveau 3 : problème délicat, demande une réexion poussée sur le problème en soi.
+ Niveau 4 : problème dicile.
+Avant de commencer...
+
+1
+
+Exercice 1 (Niveau 2)
+
+Le professeur Molét a reçu un télégraphe urgent venant de Laponie pour un problème sur le logiciel
+de détection d'enfant sage et doit donc partir de toute urgence.Il vous cone la lourde tâche, à vous son
+assistant, de préparer la salle pour son prochain examen. Il vous informe que pour faciliter la correction,
+les étudiants sont triés suivant une liste et vous donne aussi le local où aura lieu le test.
+Faisant de la programmation, vous visualiser directement la classe comme une matrice de m rangée contenant n sièges et décidez donc d'écrire un programme qui transforme la liste en une matrice représentant
+la classe.
+Votre tâche, implémentez une fonction
+qui prend en paramètre une liste tab (par
+exemple [1,2,3,4,5,6]), le nombre de lignes n et le nombre de colonnes m et qui retourne la matrice associée à ces valeurs. (Ici : Si n = 2 et m = 3 alors on a [[1,2,3], [4,5,6]])
+Ps : N'oubliez d'implémenter correctement la visualisation de la matrice an de vous facilitez la vie
+lors de la distribution de copies.
+Pss : On considère que tout les étudiants pourront entrer dans le local et que si il reste des places
+libres alors le programme retournera un zéro à l'endroit vide.
+1
+
+2
+
+changeInMatrix
+
+1. aucune ressemblance avec un de vos enseignants
+2. représenté par un matricule
+
+1
+
+2
+
+Exercice 2 (Niveau 2.5)
+
+Pour votre projet de n de BAC1, vous avez besoin de dessiner plusieurs images en 3D, ne voyant pas
+très bien comment faire vous allez voir un infographiste qui vous explique que pour dessiner une gure
+en 3D il faut dessiner chaque face dans un ordre précis. En eet, il sera beaucoup plus compliqué de
+dessiner la face arrière d'un objet si la face avant bloque le chemin. Pour être sûr d'avoir compris, vous
+allez vous entraîner à dessiner des boîtes se superposant.
+: Vous devez réaliser un code représentant l'image attendue en 2D. L'image a nbLignes lignes
+et nbColonnes colonnes. Les lignes sont numérotées de 0 à nbLignes - 1 et les colonnes de 0 à nbColonnes
+- 1. La couleur de chaque rectangle est dénie par un caractère. Par défaut, chaque pixel est de la couleur
+'.' .
+:
+La première ligne de l'entrée contient deux entiers : nbLignes et nbColonnes séparés par un espace.
+La seconde ligne contient un unique entier : nbRectangles qui est le nombre de rectangles qui vont être
+ajoutés à l'image.
+Les nbRectangles lignes suivantes contiennent chacune quatre entiers iLig1, iCol1, iLig2 et iCol2 décrivant les coins respectivement en haut à gauche et en bas à droite du rectangle considéré, ainsi qu'un
+caractère couleur indiquant la couleur du rectangle.
+Les rectangles doivent être dessinés dans l'ordre dans lequel ils sont donnés en entrée.
+:
+Votre programme doit acher nbLignes lignes de nbColonnes caractères chacune décrivant l'image obtenue.
+Exemple :
+9 19
+4
+1375o
+5 2 6 16 1 12 7 14 u
+2 1 2 16 s
+Donnera :
+Tâche
+
+Entrée
+
+Sortie
+
+2
+
+3
+
+Exercice 3 (Niveau 3)
+
+Suite à une guerre entre deux pays, vous êtes mobilisé pour aider le pays à vaincre l'ennemi! Votre
+rôle : Intercepter les communications adverses et décoder leurs messages.
+La structure de leur message est présenté comme ceci : composé uniquement d'une suite de chire compris entre 0 et 25. Chaque chire représente une lettre de l'alphabet. Comme l'ennemi parle dans une
+langue où la fréquence de e est très importante, vous pouvez utiliser cette information pour décoder leurs
+messages. En plus de ça, les chires sont décalé de manière à ce qu'on ne trouve pas la lettre tout de suite.
+Voici un exemple de message : 18 16 13 3 17 18 10 3 16 2 3 16 7 20 25 18 7 20 3 17 21 6 25 18 3 10 17 3.
+: Créer une fonction qui demande en entrée une chaine de caractère composé de chire. La
+fonction doit retourner le message décodé. Pour rendre les choses plus faciles, chaque nombre est distancé
+d'un espace. Hypothèse en plus, le message contient un nombre de e tels qu'il l'est le plus fréquent.
+: Faites plusieurs fonctions pour ne pas vous perdre dans le code.
+Exercice
+
+Petit conseil
+
+3
+
+4
+
+Exercice 4 (Niveau 1.5)
+
+Comme vous avez pu voir en cours, les algorithmes récursifs sont fort pratique à implémenter mais
+en contre partie la rapidité n'est pas forcement au rendez-vous.
+1) Pour commencer, codez un algorithme
+qui prends en paramètre un naturel n et qui
+vous renvoies le n-ieme nombre de la suite de bonacci.
+La suite de bonacci en commençant par 0 et 1, chaque élément suivant est la somme des deux derniers
+éléments de la suite.
+: bo(35) donnera 9227465 (prends environ 2.5 secondes)
+RÉCURSIF
+
+Exemple
+
+(Niveau 3)
+
+2) Vous remarquez sûrement que pour des valeurs "assez grandes", l'algorithme récursif est assez lent à
+calculer.
+Observons pour bo(6) :
+
+Vous voyez qu'il faut calculer plusieurs fois de façon séparée les même bo(), vous pensez qu'il serait
+préférable de stocker cette valeur pour ne pas la recalculer plusieurs fois.
+Vous tentez donc d'implémenter un algorithme
+de bonacci prenant les même paramètre
+que précédemment qui utilise ce que vous venez de remarquer.
+ITÉRATIF
+
+4
+
+5
+
+Concours
+
+Pour ceux qui veulent s'entraîner pour participer aux concours, voici quelques liens pour vous permettre de travailler sur ce qui vous intéresse à votre propre rythme :
+1. FranceIOI : nécessite de débloquer les premiers niveaux, mais recouvre une très grande variété
+d'algorithmes et de problèmes diérents rangés par thématique;
+2. Isograd : sur ce site, vous retrouverez de nombreux anciens concours dont, en particulier, les
+BattleDev précédentes qui constituent un excellent point de départ dans le monde des concours;
+3. Google Code Jam : les énoncés des années précédentes y sont disponibles. Le niveau requis est,
+bien évidemment, progressif et les problèmes sont en général assez intéressants;
+4. Kattis : site reprenant de très nombreux problèmes. Il vous est conseillé de tester un ou deux
+problèmes "triviaux" an de bien vérier si vous n'avez pas de problèmes avec les entrées et
+sorties; puis, de passer aux faciles et, rapidement, aux moyens (les diciles portant très bien leur
+nom).
+
+5
+
+

q1/uturtle.py

@@ -0,0 +1,88 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+
+""" Module permettant de manipuler une tortue en mode procédural
+    Utilisé dans le cadre du cours de Programmation et Algorithmique 1
+    (H. Mélot, Université de Mons, à partir de 2013)
+"""
+
+
+import turtle
+turtle.setup(500, 400)
+
+def umonsTurtle():
+    """ Retourne une tortue qui peut évoluer dans un écran
+    (déjà initialisé).
+
+    """
+    t = turtle.Turtle()
+    return t
+
+def wait(msg = 'Press enter to quit.'):
+    """ Affichage un message à l'écran et attend une interaction de
+    l'utilisateur.
+
+    msg - le message à afficher.
+
+    """
+    input(msg)
+
+def moveForward(t, x):
+    """ Fait avancer une tortue t de x pixels.
+
+    t - une tortue
+    x - nombre de pixels
+
+    """
+    t.fd(x)
+
+def moveBackward(t, x):
+    """ Fait reculer une tortue t de x pixels.
+
+    t - une tortue
+    x - nombre de pixels
+
+    """
+    t.bk(x)
+
+def turnRight(t, a=90):
+    """ Fait tourner une tortue t de a degrés vers la droite.
+
+    t - une tortue
+    a - angle en degrés
+    """
+    t.rt(a)
+
+def turnLeft(t, a=90):
+    """ Fait tourner une tortue t de a degrés vers la gauche.
+
+    t - une tortue
+    a - angle en degrés
+
+    """
+    t.lt(a)
+
+def dropPen(t):
+    """ Demande à une tortue t de soulever son stylo
+
+    t - une tortue
+
+    """
+    t.up()
+
+def usePen(t):
+    """ Demande à une tortue t d'abaisser son stylo
+
+    t - une tortue
+
+    """
+    t.down()
+
+
+if __name__ == '__main__':
+    bob = umonsTurtle()
+    moveForward(bob, 100)
+    turnRight(bob)
+    moveForward(bob, 100)
+    wait()
+

q2/algo/cours2/Couple.java

@@ -0,0 +1,27 @@
+public class Couple {
+
+	private int q;
+	private int r;
+
+	public Couple(int q, int r) {
+		this.q = q;
+		this.r = r;
+	}
+
+	public void setQ(int q) {
+		this.q = q;
+	}
+
+	public int getQ() {
+		return q;
+	}
+
+	public void setR(int r) {
+		this.r = r;
+	}
+
+	public int getR() {
+		return r;
+	}
+
+}

q2/algo/cours2/Division.java

@@ -0,0 +1,11 @@
+public class Division {
+	public static void main(String[] args) {
+		Couple test = Division(5, 3);
+		System.out.println(test.getQ() + ": " + test.getR());
+
+	}
+	public static Couple Division(int a, int b){
+		return new Couple(a/b, a%b);
+		
+	}
+}

q2/algo/cours3/test.java

@@ -0,0 +1,8 @@
+public class test {
+	public String testM(){
+		return "yay";
+	}
+	public static void main(String[] args) {
+		System.out.println(testM());
+	}
+}

q2/algo/cours6/Question.java

@@ -0,0 +1,21 @@
+public class Question {
+	private String text;
+	private String response;
+
+	private String user_input;
+
+	public Question(text, response){
+		this.text = text;
+		this.response = response;
+	}
+
+	public void Poser(){
+		Scanner resp = new Scanner(System.in);
+		System.out.println(text + ": ")
+		user_input = resp.nextLine();
+	}
+
+	public boolean Verifier(){
+		return user_input == response;
+	}
+}

q2/algo/cours6/Questionnaire.java

@@ -0,0 +1,18 @@
+public class Questionnaire {
+	private Question[] questions;
+
+	public void add_question;
+
+	public void poser_tout(){
+		for(Question q: questions){
+			q.Poser();
+			if(q.Verifier())
+				System.out.println("Bravo");
+			else
+				System.out.println("Pas ouf");
+
+		}
+	}
+
+
+}

q2/algo/cours6/TestsQuestionnaire.java

@@ -0,0 +1,4 @@
+public class TestsQuestionnaire {
+	public static void main(String[] args) {
+	}
+}

q2/algo/hashmap.java

@@ -0,0 +1,48 @@
+public class hashmap implements Map{
+
+	public static final TAB_SIZE = 1024;
+	Object[] values = new Object[TAB_SIZE];
+	class tuple{ public Object key, values; 
+		public tuple(Object key, Object value){
+			this.key = key;
+			this.value = value;
+		}
+	
+	}
+
+	public hashmap() {
+	}
+
+	public void put(Object key, Object value){
+		int pos = key.hashCode() % values.lenght();
+		if (values[pos] == null){
+			values[pos] = value;
+			return;
+		}
+		if(value[pos] instanceof ArrayList<tuple> t){
+			t.add(new tuple(key, value));
+			return;
+		}
+		Object temp = values[pos];
+		values[pos] = new ArrayList<tuple>;
+		value[pos].add(temp);
+		value[pos].add(new tuple(key, value));
+	}
+
+	public Object get(Object key){
+		int pos = key.hashCode() % values.lenght();
+		if(values[pos].equals(key)){
+			return values[pos].value;
+		}
+		if(values[pos] instanceof ArrayList<tuple> t){
+			for (v : t) {
+				if (v.key.equals(key)){
+					return v.value
+				}
+			}
+		}
+		return null;
+
+	}
+}
+

q2/algo/tp1/Cercle.java

@@ -0,0 +1,18 @@
+public class Cercle {
+	public static final double PI = 3.14159265;
+
+	public static void main(String[] args) {
+		for (int i = 1; i <= 50; i++) {
+			System.out.println("pour un cercle de rayon : " + i + " Perimetre:" +  perimetre(i)+ " aire:" +  aire(i));
+		}
+		
+	}
+
+	public static double perimetre(double rayon){
+		return 2*PI*rayon;
+	}
+
+	public static double aire(double rayon){
+		return PI*rayon*rayon;
+	}
+}

q2/algo/tp1/Droites.java

@@ -0,0 +1,20 @@
+public class Droites {
+	public static void main(String[] args) {
+		droite(1, 1, 2, 2);
+		if(appartient(-1,1, 0, 2, 2)){
+			System.out.println("yay");
+		}
+		
+	}
+	public static void droite(double x1, double y1, double x2, double y2){
+		double dir_x = x2 - x1, dir_y = y2 - y1;
+		double a = -dir_y, b = dir_x;
+		double c = a*x1 + b*y1;
+		System.out.println("equation de la droite: " + a + "x + " + b + "y = " + c);
+	}
+
+	public static boolean appartient(double a, double b, double c, double x, double y){
+		return a * x + b * y == c ;
+
+	}
+}

q2/algo/tp1/HelloWorld.java

@@ -0,0 +1,18 @@
+public class HelloWorld {
+	public static void main(String[] args) {
+		String prenom = "Anthony";
+		int age = 21;
+		double taille = 1.85;
+		printHello(prenom, age, taille);
+
+	}
+
+	public static void printHello(String prenom, int age, double taille)
+	{
+		System.out.println("Hello World");
+		System.out.println("Mon nom est " + prenom);
+		System.out.println("J'ai " + age + "ans et je mesure " + taille + "m :)");
+	}
+
+	
+}

q2/algo/tp1/Suite.java

@@ -0,0 +1,32 @@
+public class Suite {
+	public static void main(String[] args) {
+		// suiteArithmetique(5, 5, 3);
+		// suiteGeometrique(5, 5, 3);
+		suiteFibonacci(15);
+	
+	}
+
+	public static void suiteArithmetique(int depart, int raison, int k){
+		for (int i = 0; i < k; i++) {
+			System.out.println(depart + raison * i);
+		}
+	}
+
+	public static void suiteGeometrique(int depart, int raison, int k){
+		for (int i = 0; i < k; i++) {
+			System.out.println(depart + (int)Math.pow(raison, i));
+		}
+	}
+
+	public static void suiteFibonacci(int k){
+		int el1 = 1;
+		int el2 = 1;
+		int temp;
+		for (int i = 0; i < k-2; i++) {
+			temp = el1;
+			el1 = el2;
+			el2 = temp + el2 ;
+		}
+		System.out.println(el2);
+	}
+}

q2/algo/tp2/Droite.java

@@ -0,0 +1,60 @@
+public class Droite {
+	public double a, b, c;
+
+	public String toString(){
+		return a + "x + " + b + "y = " + c;
+	}
+
+	/*
+	 * Represent a line in the space with the equation ax + by = c
+	 * @param a ax
+	 * @param b by
+	 * @param c c
+	 */
+	Droite(double a, double b, double c){
+		this.a = a;
+		this.b = b;
+		this.c = c;
+	}
+
+	/*
+	 * Check if the line is horizontal
+	 * @return true if the line is horizontal
+	 * @return false if the line is not horizontal
+	 */
+	public boolean isHorizontal(){
+		if(a == 0)
+			return true;
+		return false;
+	}
+
+	/*
+	 * Find the intersection by 2 lines
+	 * @param other the other line you should find the intersection with
+	 * @return Point The Point of the intersection
+	 * @return Null if the lines are not intersecting
+	 * @return Null if the lines are the sames
+	 */
+	public Point intersection(Droite other){
+		if(a * other.b - b * other.a == 0)
+			return null;
+		return new Point((other.b*c - b*other.c)/(a*other.b + b * other.a), (other.c - other.a*((other.b*c - b*other.c)/(a*other.b + b * other.a)))/other.b );
+
+
+	}
+
+	/*
+	 * Create a new line with the two points given
+	 * @param p1 the first point
+	 * @param p2 the second point
+	 * @return Droite the line that is between the given points
+	 */
+	public static Droite create(Point p1, Point p2){
+		System.out.println(p1 + "; " + p2);
+		Point directeur = new Point(p2.getX() - p1.getX(), p2.getY() - p2.getY());
+		System.out.println(directeur);
+		double a = -directeur.getY();
+		double b = directeur.getX();
+		return new Droite(a, b, a*p1.getX() + b*p1.getY());
+	}
+}

q2/algo/tp2/DroiteTest.java

@@ -0,0 +1,33 @@
+public class DroiteTest {
+	public static void main(String[] args) {
+		Point p1 = new Point(1, 1);
+		Point p2 = new Point(5, 3);
+		Point p3 = new Point(0, 4);
+		Point p4 = new Point(4, 6);
+
+		Droite d1 = new Droite(0, 1, 2);
+		System.out.println(d1);
+
+		Droite d2 = Droite.create(p1, p2);
+		Droite d3 = Droite.create(p3, p4);
+		System.out.println(d2);
+		System.out.println(d3);
+
+		if(d2.isHorizontal())
+			System.out.println("d2 is horizontal");
+		if(d3.isHorizontal())
+			System.out.println("d3 is horizontal");
+		
+		Point int1 = d1.intersection(d2);
+		if(int1 == null)
+			System.out.println("d1 et d2 sont paralleles ou confondues");
+
+		Point int2 = d1.intersection(d3);
+		if(int2 == null)
+			System.out.println("d1 et d3 sont paralleles ou confondues");
+
+		Point int3 = d2.intersection(d3);
+		if(int3 == null)
+			System.out.println("d2 et d3 sont paralleles ou confondues");
+	}
+}

q2/algo/tp2/Point.java

@@ -0,0 +1,26 @@
+public class Point {
+	private double x, y;
+
+	public String toString(){
+		return "("+ x+ ":" + y + ")";
+	}
+
+	Point(){
+		x = 0;
+		y = 0;
+	}
+
+	Point(double x, double y){
+		this.x = x;
+		this.y = y;
+	}
+
+	public double getX() {
+		return x;
+	}
+
+	public double getY() {
+		return y;
+	}
+
+}