moving files
This commit is contained in:
81 files changed
+126
No files matched your search
@@ -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
|
||||
Executable
+90
@@ -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")
|
||||
@@ -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()
|
||||
Binary file not shown.
@@ -0,0 +1 @@
|
||||
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 1 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 2 3 4 5 0 1 35 2 3 4 5 6 7 8 9 10 11 12 13 36 15 1 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 37 38 39 40 41 42 43 44 45 10 11 12 46 15 1 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 60 70 57 71 72 73 64 74 75 53 76 77 78 79 80 81 82 83 70 84 85 86 87 24 88 89 90 51 91 51 92 93 51 94 95 96 97 51 98 99 100 101 102 103 20 88 104 70 105 106 107 108 102 109 110 111 53 112 70 113 114 115 4 116 117 118 119 120 121 51 52 122 123 124 125 126 127 128 129 102 130 131 51 132 133 93 102 134 135 136 88 74 137 138 93 139 140 141 51 142 20 88 143 67 144 145 146 147 148 149 150 151 152 128 153 154 155 10 11 12 156 157 158 159 20 160 20 161 162 163 164 165 166 167 168 20 88 169 93 4 170 171 172 173 174 175 93 176 51 88 177 152 178 179 180 93 181 182 183 184 185 186 4 166 187 128 188 93 189 178 190 191 192 193 185 194 137 195 20 196 197 198 199 200 201 202 93 111 203 70 49 204 205 53 206 207 125 181 208 209 210 211 20 212 93 213 214 215 216 93 217 218 139 219 220 221 181 222 181 223 51 224 225 226 227 228 229 230 231 181 178 232 233 234 64 235 236 20 237 51 238 239 53 240 20 69 241 139 53 242 102 243 149 244 181 245 126 246 247 248 249 244 250 251 139 248 252 253 254 236 230 255 178 256 257 93 258 181 259 260 20 225 261 102 262 263 67 264 53 109 234 53 265 20 266 93 267 236 268 230 53 269 270 271 272 236 70 273 274 187 178 275 126 276 277 51 278 279 67 280 51 281 53 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 48 297 298 102 299 300 301 69 302 303 128 304 305 306 307 308 309 20 310 311 20 312 313 314 315 93 316 230 317 318 319 149 320 321 226 322 323 324 325 326 20 53 327 152 64 143 328 329 330 49 181 331 332 93 258 181 333 334 335 336 337 338 149 185 339 123 226 340 341 342 271 343 344 270 185 285 345 346 4 347 15 1 348 349 93 350 307 351 102 352 51 353 354 20 355 51 53 356 51 53 357 149 358 51 288 359 360 361 362 363 20 64 364 93 20 365 366 67 100 367 368 369 93 370 20 371 372 93 185 373 287 70 374 375 20 376 377 378 379 380 381 382 69 383 236 93 384 385 236 152 181 174 20 386 93 20 387 388 389 137 390 391 51 392 20 69 393 389 144 394 395 93 258 396 397 398 399 400 93 401 70 402 403 404 389 405 187 128 406 288 169 407 408 53 409 410 2 411 412 413 414 178 415 178 416 93 178 417 4 418 332 93 419 51 420 421 236 93 422 423 93 137 424 51 425 426 64 427 428 171 51 429 128 430 20 431 432 128 433 51 88 434 435 436 93 437 438 139 439 440 198 288 441 146 442 93 220 443 444 445 53 446 447 448 449 288 450 451 51 452 236 453 454 455 456 24 69 457 236 458 459 460 181 461 70 462 187 128 463 93 464 2 465 466 88 467 67 468 4 469 93 470 51 88 471 472 48 137 473 474 270 475 287 167 476 67 477 288 478 479 480 181 481 482 483 288 481 484 485 51 285 287 357 20 486 93 258 51 285 487 357 4 488 489 20 88 149 490 491 362 126 53 492 493 494 215 495 51 496 20 497 187 53 498 51 499 500 501 322 502 285 100 287 347 51 189 503 403 504 505 506 507 508 10 11 12 156 157 509 510 51 511 93 512 513 200 514 365 515 516 388 185 285 517 518 53 519 93 285 520 521 522 523 230 70 524 525 93 526 20 527 146 528 291 529 230 530 20 531 469 532 49 533 534 328 83 93 535 380 536 230 537 61 487 51 249 123 538 539 102 540 67 541 70 542 20 543 544 545 546 67 137 547 548 549 20 137 550 51 365 515 93 185 137 551 552 67 553 554 20 555 556 557 554 558 51 559 560 561 144 562 563 69 564 565 566 567 53 568 569 67 570 521 53 571 572 53 573 215 169 574 572 20 88 575 67 576 577 578 214 20 579 580 225 88 581 582 583 220 88 584 102 585 200 234 88 586 93 587 588 589 187 88 590 51 181 591 592 234 593 185 594 20 69 595 2 596 318 597 598 181 599 600 601 93 602 152 479 149 603 604 171 20 605 606 93 607 51 178 260 608 217 609 20 610 93 418 611 612 613 67 137 614 615 258 288 616 181 617 93 288 618 67 285 619 287 620 621 368 622 623 328 624 20 625 626 24 53 113 627 628 186 288 629 630 612 631 93 632 181 633 634 612 635 149 288 636 637 178 638 20 639 362 88 640 641 93 642 20 643 644 645 646 88 647 20 627 455 3 4 648 93 128 649 20 650 20 651 652 646 653 128 654 200 649 20 328 655 656 657 658 659 15 1 660 661 93 217 662 663 288 664 665 93 666 667 53 668 185 669 288 670 671 93 672 673 674 93 675 53 676 51 677 678 88 679 455 680 681 93 682 683 684 181 685 686 178 687 688 207 178 689 20 450 690 181 691 20 692 51 693 694 93 695 70 449 20 696 697 93 698 215 699 236 125 700 691 701 185 702 703 236 704 276 705 612 126 53 617 706 146 215 707 93 708 24 709 710 181 711 288 712 20 713 714 295 715 126 53 716 717 67 718 719 53 720 721 722 93 581 139 86 320 64 723 724 67 137 725 726 727 149 53 728 53 146 729 93 730 53 146 728 362 93 137 731 187 732 149 733 729 24 734 226 735 736 737 738 20 69 149 739 362 740 93 741 67 144 119 742 185 144 743 288 744 368 745 20 88 746 344 185 747 521 119 748 67 61 88 749 70 750 236 751 752 93 753 93 347 53 754 328 755 293 287 756 187 318 757 758 139 759 149 760 102 761 362 580 187 762 149 285 487 763 704 320 181 332 764 49 577 765 20 766 226 3Line truncated
|
||||
@@ -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
|
||||
|
||||
|
||||
|
||||
Binary file not shown.
|
After Width: | Height: | Size: 256 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 321 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 261 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 790 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 727 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 161 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 186 KiB |
@@ -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')
|
||||
Binary file not shown.
|
After Width: | Height: | Size: 173 KiB |
Binary file not shown.
@@ -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
|
||||
@@ -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()
|
||||
@@ -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()
|
||||
@@ -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()
|
||||
@@ -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()
|
||||
@@ -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()
|
||||
@@ -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()
|
||||
@@ -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
|
||||
Binary file not shown.
@@ -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()
|
||||
|
||||
@@ -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))
|
||||
|
||||
@@ -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("")
|
||||
Binary file not shown.
@@ -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")
|
||||
+113810
File diff suppressed because it is too large.
Load diff
@@ -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'))
|
||||
Binary file not shown.
@@ -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.")
|
||||
@@ -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()
|
||||
|
||||
Binary file not shown.
@@ -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)
|
||||
@@ -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
|
||||
|
||||
@@ -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)
|
||||
Binary file not shown.
Executable
+38
@@ -0,0 +1,38 @@
|
||||
#!/usr/bin/env python
|
||||
|
||||
from math import pi
|
||||
|
||||
def volume_sphere(rayon):
|
||||
return (4/3)*pi*rayon**3
|
||||
|
||||
def prix_livre(nbr, prix):
|
||||
return ((prix*nbr) - (prix*nbr*(40/100)) + (3 + 0.75*(prix - 1)))
|
||||
|
||||
def time_per_miles(km, h, m, s):
|
||||
mi = km / 1.61 # km to mi
|
||||
total_sec = h *60 + m * 60 + s
|
||||
return mi / total_sec
|
||||
|
||||
def time_per_miles(km, h, m, s):
|
||||
mi = km / 1.61 # km to mi
|
||||
total_sec = h *60 + m * 60 + s
|
||||
return mi / total_sec
|
||||
|
||||
def mi_per_h(km, h, m, s):
|
||||
mi = km / 1.61
|
||||
total_h = h + m / 60 + s /3600
|
||||
return mi / total_h
|
||||
|
||||
if __name__ == "__main__":
|
||||
vol = volume_sphere(5)
|
||||
print(vol)
|
||||
|
||||
nbre_livre = prix_livre(60, 24.95)
|
||||
print(nbre_livre)
|
||||
|
||||
time = time_per_miles(10, 0, 43, 30)
|
||||
print(time)
|
||||
|
||||
speed = mi_per_h(10, 0, 43, 30)
|
||||
print(speed)
|
||||
|
||||
Binary file not shown.
@@ -0,0 +1 @@
|
||||
orjzkniugrmfyyhgoyxkiurjyxuwgrerghwryjgrzrmfygywsjrmfyygrjxfhgnryowkjwynjujgoygnurgyiyjgufgkiugrmfyxyorjzkniugrkjlunxyhiuwsrjyhgyooyhmfywuowfougyfnhbhgiyyivunmfknxrjugyfnwkjhkoyxyqyfcerxknkvkgufgkiugyygwoygyniyrjzkniugrmfyeryjgxyhxyfcikghrjzkniugrkjygufgkiugrmfyroxhrtjyoknrtrjyoyjhyivoyxyhuwgrerghoryhouwkjwylgrkjygoyilokrxyhknxrjugyfnhxfjlkrjgxyefylnrjwrluoyiyjggywsjrmfyxujhoyekwuvfournyfjreynhrgurnyuinrwurjroxhrtjyhfngkfgorjzkniugrmfygsknrmfyfjyjhyivoyxyhwryjwyhzkniyooyhmfrkjglkfnkvqygxgfxyoujkgrkjxrjzkniugrkjygxyhlnkwxhxygnurgyiyjgufgkiugrmfyxywyooywrouotknrgsirmfylunzkrhufhhroygnurgyiyjgxfhrtjuoouwuowfouvrorgkfougsknryxyorjzkniugrkjoufgnyhyjhxfikgwkjwylgrkjxlokryiyjgygfhutyyjyjgnylnrhyyhgxhrtjhkfhoyjkixyxugulnkwyhhrjtoufgkiugrhugrkjxfgnurgyiyjgxyorjzkniugrkjyhgvryjlofhujwryjjymfyorjeyjgrkjxyoknxrjugyfnoyhlnyirnyhiuwsrjyhiwujrmfyhxygnurgyiyjgufgkiugrhubujggwkjhgnfrgyhufcerryhrwoyouhwryjwyrjzkniugrmfyjyhgluhlofhouhwryjwyxyhknxrjugyfnhmfyouhgnkjkiryjyhgwyooyxyhgoyhwklyhyxhtynxrqphgnuullunfxujhoyhujjyhoyhywgyfnxuwgrergxyhgywsjkoktryhxyorjzkniugrkjygxyouwkiifjrwugrkjyhgorouzkrhorjzkniugrmfyooywgnkjrmfyygougowkiifjrwugrkjoyhuwgrerghhkjgoulnkxfwgrkjxyiugnryorjzkniugrmfyiuwsrjyhyglrwyhxguwsyhygxyoktrwryohlnkwxhxygnurgyiyjgmfrhkjgxyhgrjhouwmfrhrgrkjufhgkwputyougnujhzkniugrkjougnujhirhhrkjygounyhgrgfgrkjufgkiugrmfyxrjzkniugrkjhoyhywgyfnzkfnjrgtuoyiyjgxyjkivnyfchynerwyhorhofgrorhugrkjxyhyhlnkxfrghyjhyrtjyiyjguhhrhgujwyhfneyrooujwyygyjgnygryjgbikoktryyjujtourhoygyniywkilfgynhwryjwyyhgfgrorhouzkrhlkfnouhwryjwyzkjxuiyjguoyrjzkniugrmfyygouhwryjwyullormfyurjhrmfyogfxyxyhuirhyyjfenylunkllkhrgrkjrjzkniugrkjgywsjkoktbufgnyzkrhxugulnkwyhhrjtmfrnytnkflygkfgyhoyhgywsjrmfyhlyniyggujgxygnurgynoyhrjzkniugrkjhyxhtynxrqphgnuiygyjtunxywkjgnyfjtorhhyiyjgxyhyjhiuoeyjflkfnofrorjzkniugrmfyjyhgluhlofhogfxyxyoknxrjugyfnmfyouhgnkjkiryjyhgogfxyxfgoyhwklyoygyniyrjzkniugrmfyyhgfgrorhlkfnoulnyirnyzkrhyjznujwyyjiunhlunlsrorllyxnybzfhujwryjxrnywgyfnxfwyjgnyjugrkjuoxywuowfooywgnkjrmfyxyvfooxujhoyhujjyhlkfnhkjyjgnylnrhyhkwrgxrjzkniugrmfyullormfyhrulungrnxyhikghrjzkniugrkjygufgkiugrmfylyjxujgoyiiyikrhxyiunhduogynzvufynrjuftfnuouhkwrguinrwurjyrjzkniugrwhrjwmfrxlkhuhkjjkiyglkfnhfrerggkfgyhoyhfjreynhrghmfrfgrorhnyjgwyikglkfnxwnrnyoujkfeyooyxrhwrlorjyoyhzknujghynuvuggnyhfnwkilfgynhwryjwyvryjmfyoyhxrloihmfyooyhzkniuryjgzfhhyjglkfnouloflungxyhlnugrwryjhxyorjzkniugrmfylofggmfyxyhhwryjgrzrmfyhufhyjhlnklnyouhhkwrugrkjzknwkilfgrjtiuwsrjynboulofhtnujxyuhhkwrugrkjxrjzkniugrwryjhufikjxyullnkwsuiiyrjzkniugrwhrjwuzrjxylkfekrnfgrorhynoyikgrjzkniugrwhlkfnnyilouwynoyclnyhhrkjwkilfgyniuwsrjynbiurhoyjgnylnrhyxworjuoulnklkhrgrkjouhkwrgrjzkniugrwhrjwwyhhuhyhuwgrerghyjuwsygylunhgynorjthkzgdunynzjwyhhurnyyjznujwyofhutykzzrwryoxfikgugwkjhuwnlunouwuxiryznujurhyyjlkfnxhrtjynouhwryjwyxfgnurgyiyjgxyorjzkniugrkjygountyiyjguxklgxhwyggylkmfyxujhoulnyhhyorjxfhgnryygoyiroryffjreynhrgurnyoygyniyuooyiujxrjzkniugrpyhgwnyjlunpunohgyrjvfwsmfrulfvorfjyhhurrjgrgforjzkniugrpufgkiugrhwsyrjzkniugrkjheynunvyrgfjtrjzkniugrmfygnurgyiyjgufgkiugrmfyxyorjzkniugrkjyjqfrooygoyirjrhgnyzxnuoxyounywsynwsyhwryjgrzrmfyxuooyiutjytynsunxhgkogyjvyntlnkjkjuoyikgrjzkniugrpoknhxfjxrhwkfnhkzzrwryoufhfqygxyoujwyhhrgxyjhyrtjynwyggyjkfeyooyxrhwrlorjyxujhoyhfjreynhrghxyhkjlubhkjyilokbuwyiiygyniylkfnjkiiynwyngurjhwkfnhxujhoyhfjreynhrghuooyiujxyhnzjwyhhurnyoyikgrjzkniugrwuzrguoknhhkjullunrgrkjyjrguoryygyjyhlutjyxyiiymfrjzkniugrwhufnkbufiyfjroyikgrjzkniugrmfyuyjhfrgygnylnrhlunouwkilutjrytjnuoyxrjzkniugrmfywtrwnyyjekofgrkjhiujgrmfyxujhhkjfhutywkjgyilknurjoyikgrjzkniugrmfymfrxhrtjyrjrgruoyiyjgouhwryjwyxfwuowfougyfnyhgfjikglkobhirmfymfrxhrtjyufgujgoyxkiurjyrjxfhgnryoyjnullkngueywoywuowfougyfnmfyouhwryjwyxfwuowfougyfnoyhlnkxfrghxfxkiurjyrjxfhgnryoygouiujrlfougrkjxywyhlnkxfrghvynjunxoujtzurgfjyujuoktryufxkiurjyxyoufgkikvroyxujhoymfyojfojywkjzkjxougsynikxbjuirmfyougywsjrmfyxyhikgyfnhyclokhrkjygoyikxyxyilokrxfjesrwfoyufgkikvroyhrwoyhikghhwryjwyrjzkniugrmfyrjzkniugrmfyzkjxuiyjguoykfrjzkniugrmfygsknrmfyhkjgfgrorhhlkfnxhrtjynhujhuivrtfgouhwryjwygujxrhmfygywsjkoktryhxyorjzkniugrkjkfgywsjkoktryhxyorjzkniugrkjygxyouwkiifjrwugrkjxhrtjyoyhywgyfnrjxfhgnryoyghyhlnkxfrghouiujrlfougrkjxyhullunyrohyhglunzkrhuhhriroyxyouwkjxfrgyufgkikvroywkiiyxujhouyfnklyujwkilfgynxnrerjtorwyjhygnuxfwgrkjorggnuoylynirhxywkjxfrnyfjknxrjugyfnorjzkniugrmfyikxynjyonyxyorjzkniugrmfyikxynjywkiiyjuulnhouhywkjxytfynnyikjxruoyueyworjeyjgrkjxfgnujhrhgknlfrhxfwrnwfrgrjgtnmfyomfyhujjyhlofhgunxofgrorhugrkjxywyhwkilkhujghoywgnkjrmfyhoulouwyxyhnyourhoywgnkiwujrmfyhygxygfvyherxykjglynirhxynyjxnyoyhullunyrohouzkrhlofhlygrghlofhwkiloycyhlofhwkjkirmfyhyglofhzruvoyhufiiyikiyjgoyiugsiugrwryjuoujgfnrjtgsknrhyoylnyirynwymfyhgfjknxrjugyfnueywhkjwkjwylgxyiuwsrjyfjreynhyooyxygfnrjtoyxkiurjyxyorjzkniugrmfyyhgxkjwfjxkiurjynwyjgvuhhfnxyhhwryjwyhknrtrjurnyhxyoujgrmfrgouwnblgktnulsryygxyhyclnryjwyhiyjyhufcerryhrwoywkiiylunycyiloyouiuwsrjywuowfoynxyvourhyluhwuowyjyhgmfouzrjxyouhywkjxytfynnyikjxruoymfyorjzkniugrmfyugnywkjjfywkiiyfjxkiurjyhwryjgrzrmfyyggywsjkoktrmfylungyjgrnyouhnryxyoreLine truncated
|
||||
@@ -0,0 +1 @@
|
||||
xzujwrtsnruqjrjsyfyntsjxyhtwwjhyjojujzcrfnsyjsfsyufxxjwfqjcjwhnhjxznafsy
|
||||
@@ -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
|
||||
@@ -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))
|
||||
|
||||
|
||||
Binary file not shown.
@@ -0,0 +1 @@
|
||||
zbdpduookbrmbldtdiduszmkjkbsallkidusjambymaujbklrbkokbusymk
|
||||
@@ -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()
|
||||
@@ -0,0 +1 @@
|
||||
yzadgqxqmmtpxazvblxitapsgmnedinexsikallqotgvrp
|
||||
@@ -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))
|
||||
@@ -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))
|
||||
@@ -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))
|
||||
@@ -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))
|
||||
Binary file not shown.
@@ -0,0 +1,32 @@
|
||||
def rendreMonnaie(prix, monnaie):
|
||||
x1, x2, x3, x4, x5 = monnaie # Chaques billets en entree (20, 10, 5, 2, 1)
|
||||
|
||||
given = (x1*20) + (x2*10) + (x3*5) + (x4*2) + (x5*1)
|
||||
|
||||
rest = given - prix
|
||||
if rest < 0:
|
||||
return f"vous n'avez pas assez d'argent. Il manque : {-rest}"
|
||||
|
||||
o1 = rest // 20
|
||||
rest = rest % 20
|
||||
|
||||
o2 = rest // 10
|
||||
rest = rest % 10
|
||||
|
||||
o3 = rest // 5
|
||||
rest = rest % 5
|
||||
|
||||
o4 = rest // 2
|
||||
rest = rest % 2
|
||||
|
||||
o5 = rest // 1
|
||||
rest = rest % 1
|
||||
|
||||
return o1, o2, o3, o4, o5
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
prix = int(input("quel est le prix :"))
|
||||
print("entrez maintenant les billets")
|
||||
mon = (int(input("20e:")),int(input("10e:")),int(input("5e:")),int(input("2e:")),int(input("1e:")))
|
||||
print(rendreMonnaie(prix, mon))
|
||||
@@ -0,0 +1,124 @@
|
||||
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
|
||||
:p2: tuple du point 2
|
||||
:returns: 3-uple (a,b,c) tq ax+by=c
|
||||
|
||||
"""
|
||||
x1, y1 = p1
|
||||
x2, y2 = p2
|
||||
if p1 == p2:
|
||||
return
|
||||
if x2-x1 == 0:
|
||||
return 1, 0, 0
|
||||
a = -(y2-y1)/(x2-x1)
|
||||
c = a*x1
|
||||
b = (-a*x2 + c) / y2
|
||||
return a, b, c
|
||||
|
||||
|
||||
def appartient(d, p):
|
||||
"""
|
||||
:d: equation d'une droite
|
||||
:p: point
|
||||
:returns: true si point est dans droite
|
||||
|
||||
"""
|
||||
a, b, c = d
|
||||
x, y = p
|
||||
return a*x + b*y == c
|
||||
|
||||
|
||||
def paralleles(d1, d2):
|
||||
"""
|
||||
:d1: droite 1
|
||||
:d2: droite 2
|
||||
:returns: true si d1 et d2 sont paralleles sinon false
|
||||
|
||||
"""
|
||||
a1, b1, c1 = d1
|
||||
a2, b2, c2 = d2
|
||||
|
||||
return a1/b1 == a2/b2
|
||||
|
||||
|
||||
def intersection(d1, d2):
|
||||
"""Trouve le point d'intersection
|
||||
|
||||
:d1: droite 1
|
||||
:d2: droite 2
|
||||
:returns: retourne le point d'intersection sinon None
|
||||
|
||||
"""
|
||||
a1, b1, c1 = d1
|
||||
a2, b2, c2 = d2
|
||||
|
||||
if paralleles(d1, d2):
|
||||
return # paralleles donc pas d'intersection
|
||||
|
||||
y = (c2*a1 - a2*c1) / (-a2*b1 + b2*a1)
|
||||
x = (c1 - b1*y)/ a1
|
||||
|
||||
return x, y
|
||||
|
||||
|
||||
def droite_normale(d, p):
|
||||
"""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):
|
||||
""" retourne la symétrie orthogonale par le point p de la droite d
|
||||
:returns: symétrie orthogonale
|
||||
|
||||
"""
|
||||
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):
|
||||
""" donne la distance entre une droite et un point
|
||||
:returns: distance la plus courte entre le point et la droite
|
||||
|
||||
"""
|
||||
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)
|
||||
|
||||
@@ -0,0 +1,38 @@
|
||||
from droite import *
|
||||
|
||||
def test(function, p1, p2, exp_result):
|
||||
fun_result = function(p1, p2)
|
||||
if fun_result == exp_result:
|
||||
print(f"{function.__name__}({p1}, {p2}) == {exp_result} --- SUCCESS!")
|
||||
else:
|
||||
print(f"{function.__name__}({p1}, {p2}) == {exp_result} --- ERROR! (result was:{fun_result})")
|
||||
|
||||
|
||||
def tests():
|
||||
test(droite, (-2, 0), (1, 1.5), (-0.5, 1, 1.0))
|
||||
test(droite, (0, -3), (0, 5), (1, 0, 0))
|
||||
test(droite, (0, -1), (0, -1), None)
|
||||
|
||||
test(appartient, (-0.5, 1, 1.0), (-2, 0), True)
|
||||
test(appartient, (-0.5, 1, 1.0), (1, 1.5), True)
|
||||
test(appartient, (-0.5, 1, 1.0), (0, -1), False)
|
||||
|
||||
test(paralleles, (0, 1, 1), (0, 2, 3), True)
|
||||
test(paralleles, (-0.5, 1, 1.0), (0, 2, 3), False)
|
||||
|
||||
test(intersection, (-0.5, 1, 1.0), (0, 2, 3), (1.0, 1.5))
|
||||
test(intersection, (0, 1, 1), (0, 2, 3), None)
|
||||
|
||||
test(droite_normale, (-0.5, 1, 1.0), (-2, 0), (2.0, 1, -4.0))
|
||||
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), (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)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
tests()
|
||||
|
||||
@@ -0,0 +1,75 @@
|
||||
#!/usr/bin/env python3
|
||||
|
||||
import matplotlib.pyplot as plt
|
||||
import numpy as np
|
||||
|
||||
|
||||
class Plot(object):
|
||||
"""Show graphical drawing of lines from their equation."""
|
||||
|
||||
def __init__(self):
|
||||
self.setXAxis()
|
||||
self.functs = []
|
||||
self.verts = []
|
||||
|
||||
def prepare(self, line):
|
||||
"""Add the given line to the plot.
|
||||
The line is not shown until the method show is called.
|
||||
|
||||
Args:
|
||||
line: a triplet `(a, b, c)` representing the coefficients of the
|
||||
line of equation `ax + bx + c = 0`.
|
||||
"""
|
||||
a, b, c = line
|
||||
if b == 0:
|
||||
if a == 0:
|
||||
raise ValueError('Not a line.')
|
||||
else:
|
||||
self.verts.append(line)
|
||||
else:
|
||||
self.functs.append(line)
|
||||
|
||||
def setXAxis(self, xmin=-10, xmax=10):
|
||||
self.xmin = xmin
|
||||
self.xmax = xmax
|
||||
|
||||
def reset(self):
|
||||
self.setXAxis()
|
||||
self.functs = []
|
||||
self.verts = []
|
||||
|
||||
def plot(self, t, y, line):
|
||||
a, b, c = line
|
||||
plt.plot(t, y, label='%.4g*x + %.4g*y = %.4g' % (a, b, c))
|
||||
|
||||
def draw(self):
|
||||
for a, b, c in self.functs:
|
||||
t = np.array([self.xmin, self.xmax])
|
||||
y = (-a * 1.0 / b) * t + (c * 1.0 / b)
|
||||
self.plot(t, y, (a, b, c))
|
||||
for a, b, c in self.verts:
|
||||
x = c / a
|
||||
self.plot([x, x], plt.ylim(), (a, b, c))
|
||||
plt.axis('tight')
|
||||
plt.legend()
|
||||
plt.title('Exercices sur les droites')
|
||||
plt.xlabel('x')
|
||||
plt.ylabel('y')
|
||||
plt.grid(True)
|
||||
|
||||
def save(self, filename):
|
||||
self.draw()
|
||||
plt.savefig(filename)
|
||||
|
||||
def show(self):
|
||||
self.draw()
|
||||
plt.show()
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
p = Plot()
|
||||
p.prepare((1, 1, 3))
|
||||
p.prepare((-2, 1, -1))
|
||||
p.prepare((1, 0, -5))
|
||||
p.show()
|
||||
input()
|
||||
Binary file not shown.
@@ -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
|
||||
@@ -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;
|
||||
}
|
||||
Executable
BIN
Binary file not shown.
@@ -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);
|
||||
}
|
||||
@@ -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 */
|
||||
Binary file not shown.
@@ -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")
|
||||
@@ -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())
|
||||
@@ -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'))
|
||||
@@ -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')
|
||||
|
||||
@@ -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))
|
||||
Binary file not shown.
@@ -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)
|
||||
@@ -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)
|
||||
@@ -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))
|
||||
@@ -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()
|
||||
@@ -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]
|
||||
Binary file not shown.
@@ -0,0 +1,149 @@
|
||||
Séance de renforcement
|
||||
CPUMons
|
||||
25 octobre 2022
|
||||
|
||||
Ce document comporte plusieurs exercices dont la di culté 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 di culté :
|
||||
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 di cile.
|
||||
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 con e 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 a n 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 a cher 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" a n de bien véri er si vous n'avez pas de problèmes avec les entrées et
|
||||
sorties; puis, de passer aux faciles et, rapidement, aux moyens (les di ciles portant très bien leur
|
||||
nom).
|
||||
|
||||
5
|
||||
|
||||
|
||||
@@ -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()
|
||||
|
||||
Reference in new issue
Block a user