uml

Alone because I have not friend haha (jk)

.gitignore

@@ -1,2 +1,16 @@
 __pycache__/
 *.tar
+*.class
+*.toc
+*.synctex.gz
+*.snm
+*.out
+*.aux
+*.fbd_latexmk
+*.fls
+*.log
+*.nav
+*.fdb_latexmk
+a.out
+*.o
+ex[0-9]

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "bac2/latex/beamer-umons"]
+	path = bac2/latex/beamer-umons
+	url = git@github.com:Chris00/beamer-umons

bac1/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

bac1/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")

bac1/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()

bac1/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 
+
+
+

bac1/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'))

bac1/q1/24nov/decalage.txt

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

bac1/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

bac1/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))
+
+

bac1/q1/24nov/substitution.txt

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

bac1/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()

bac1/q1/24nov/vigenere.txt

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

bac1/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))

bac1/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)

bac1/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)

bac1/q2/algo/.idea/.gitignore

@@ -0,0 +1,8 @@
+# Default ignored files
+/shelf/
+/workspace.xml
+# Editor-based HTTP Client requests
+/httpRequests/
+# Datasource local storage ignored files
+/dataSources/
+/dataSources.local.xml

bac1/q2/algo/.idea/algo.iml

@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="JAVA_MODULE" version="4">
+  <component name="NewModuleRootManager" inherit-compiler-output="true">
+    <exclude-output />
+    <content url="file://$MODULE_DIR$" />
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

bac1/q2/algo/.idea/misc.xml

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="MarkdownSettingsMigration">
+    <option name="stateVersion" value="1" />
+  </component>
+  <component name="ProjectRootManager" version="2" project-jdk-name="20" project-jdk-type="JavaSDK" />
+</project>

bac1/q2/algo/.idea/modules.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/algo.iml" filepath="$PROJECT_DIR$/.idea/algo.iml" />
+    </modules>
+  </component>
+</project>

bac1/q2/algo/.idea/vcs.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="$PROJECT_DIR$/../.." vcs="Git" />
+  </component>
+</project>

bac1/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;
+	}
+
+}

bac1/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);
+		
+	}
+}

bac1/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());
+	}
+}

bac1/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;
+	}
+}

bac1/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");
+
+		}
+	}
+
+
+}

bac1/q2/algo/cours6/TestsQuestionnaire.java

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

bac1/q2/algo/hashmap.java

@@ -0,0 +1,49 @@
+public class hashmap implements Map{
+
+	public static final TAB_SIZE = 1024;
+	LinkedList[] values = new Object[TAB_SIZE];
+	class HashEntry{ public Object key, values; 
+		public HashEntry(Object key, Object value){
+			this.key = key;
+			this.value = value;
+		}
+	
+	}
+
+	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<HashEntry> t){
+			t.add(new HashEntry(key, value));
+			return;
+		}
+		Object temp = values[pos];
+		values[pos] = new ArrayList<HashEntry>;
+		value[pos].add(temp);
+		value[pos].add(new HashEntry(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<HashEntry> t){
+			for (v : t) {
+				if (v.key.equals(key)){
+					return v.value
+				}
+			}
+		}
+		return null;
+
+	}
+
+	public static void main(String[] args) {
+		System.out.println("test");
+
+	}
+}

bac1/q2/algo/hashmap/.idea/.gitignore

@@ -0,0 +1,8 @@
+# Default ignored files
+/shelf/
+/workspace.xml
+# Editor-based HTTP Client requests
+/httpRequests/
+# Datasource local storage ignored files
+/dataSources/
+/dataSources.local.xml

bac1/q2/algo/hashmap/.idea/misc.xml

@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="MarkdownSettingsMigration">
+    <option name="stateVersion" value="1" />
+  </component>
+  <component name="ProjectRootManager" version="2" languageLevel="JDK_X" default="true" project-jdk-name="20" project-jdk-type="JavaSDK">
+    <output url="file://$PROJECT_DIR$/out" />
+  </component>
+</project>

bac1/q2/algo/hashmap/.idea/modules.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/hashmap.iml" filepath="$PROJECT_DIR$/hashmap.iml" />
+    </modules>
+  </component>
+</project>

bac1/q2/algo/hashmap/.idea/vcs.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="$PROJECT_DIR$/../../.." vcs="Git" />
+  </component>
+</project>

bac1/q2/algo/hashmap/HashMap.java

@@ -0,0 +1,36 @@
+import java.util.Iterator;
+import java.util.LinkedList;
+
+public class HashMap {
+    LinkedList<HashEntry>[] tab;
+    Iterator iter;
+
+    class HashEntry{
+        public Object key, value;
+    }
+
+    class MyHashMapIterator implements Iterator{
+        int i;
+
+        public MyHashMapIterator(){
+            while(i<tab.length){
+                if(tab[i] == null)
+                    continue;
+                return;
+            }
+        }
+
+        @Override
+        public boolean hasNext() {
+            if(i >= tab.length)
+                return false;
+        }
+
+        @Override
+        public Object next() {
+        }
+    }
+    public static void main(String[] args) {
+
+    }
+}