response
stringlengths 1
33.1k
| instruction
stringlengths 22
582k
|
|---|---|
Test for 'y' | def test_y():
"""Test for 'y'"""
rv, out = getstatusoutput(f'{prg} Y')
assert rv == 0
expected = 'Y is for Yorick whose head was bashed in.'
assert out.strip() == expected |
Test for 'o' from 'alternate.txt' | def test_o_alternate():
""" Test for 'o' from 'alternate.txt' """
rv, out = getstatusoutput(f'{prg} o P q -f alternate.txt')
assert rv == 0
expected = ('O is for Orville, who fell in a canyon.\n'
'P is for Paul, strangled by his banyan.\n'
'Q is for Quintanna, flayed in the night.')
assert out.strip() == expected |
Test for bad input | def test_bad_letter():
"""Test for bad input"""
rv, out = getstatusoutput(f'{prg} 5 CH')
assert rv == 0
expected = ('I do not know "5".\n' 'I do not know "CH".')
assert out.strip() == expected |
generate a random string | def random_string():
"""generate a random string"""
k = random.randint(5, 10)
return ''.join(random.choices(string.ascii_letters + string.digits, k=k)) |
get command-line arguments | def get_args():
"""get command-line arguments"""
parser = argparse.ArgumentParser(
description='Apples and bananas',
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument('text', metavar='text', help='Input text or file')
parser.add_argument('-v',
'--vowel',
help='The vowel to substitute',
metavar='vowel',
type=str,
default='a',
choices=list('aeiou'))
args = parser.parse_args()
if os.path.isfile(args.text):
args.text = open(args.text).read().rstrip()
return args |
Make a jazz noise here | def main():
"""Make a jazz noise here"""
args = get_args()
text = args.text
vowel = args.vowel
new_text = []
for char in text:
if char in 'aeiou':
new_text.append(vowel)
elif char in 'AEIOU':
new_text.append(vowel.upper())
else:
new_text.append(char)
print(''.join(new_text)) |
get command-line arguments | def get_args():
"""get command-line arguments"""
parser = argparse.ArgumentParser(
description='Apples and bananas',
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument('text', metavar='text', help='Input text or file')
parser.add_argument('-v',
'--vowel',
help='The vowel to substitute',
metavar='vowel',
type=str,
default='a',
choices=list('aeiou'))
args = parser.parse_args()
if os.path.isfile(args.text):
args.text = open(args.text).read().rstrip()
return args |
Make a jazz noise here | def main():
"""Make a jazz noise here"""
args = get_args()
text = args.text
vowel = args.vowel
for v in 'aeiou':
text = text.replace(v, vowel).replace(v.upper(), vowel.upper())
print(text) |
get command-line arguments | def get_args():
"""get command-line arguments"""
parser = argparse.ArgumentParser(
description='Apples and bananas',
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument('text', metavar='text', help='Input text or file')
parser.add_argument('-v',
'--vowel',
help='The vowel to substitute',
metavar='vowel',
type=str,
default='a',
choices=list('aeiou'))
args = parser.parse_args()
if os.path.isfile(args.text):
args.text = open(args.text).read().rstrip()
return args |
Make a jazz noise here | def main():
"""Make a jazz noise here"""
args = get_args()
vowel = args.vowel
trans = str.maketrans('aeiouAEIOU', vowel * 5 + vowel.upper() * 5)
text = args.text.translate(trans)
print(text) |
get command-line arguments | def get_args():
"""get command-line arguments"""
parser = argparse.ArgumentParser(
description='Apples and bananas',
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument('text', metavar='text', help='Input text or file')
parser.add_argument('-v',
'--vowel',
help='The vowel to substitute',
metavar='vowel',
type=str,
default='a',
choices=list('aeiou'))
args = parser.parse_args()
if os.path.isfile(args.text):
args.text = open(args.text).read().rstrip()
return args |
Make a jazz noise here | def main():
"""Make a jazz noise here"""
args = get_args()
vowel = args.vowel
text = [
vowel if c in 'aeiou' else vowel.upper() if c in 'AEIOU' else c
for c in args.text
]
print(''.join(text)) |
get command-line arguments | def get_args():
"""get command-line arguments"""
parser = argparse.ArgumentParser(
description='Apples and bananas',
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument('text', metavar='text', help='Input text or file')
parser.add_argument('-v',
'--vowel',
help='The vowel to substitute',
metavar='vowel',
type=str,
default='a',
choices=list('aeiou'))
args = parser.parse_args()
if os.path.isfile(args.text):
args.text = open(args.text).read().rstrip()
return args |
Make a jazz noise here | def main():
"""Make a jazz noise here"""
args = get_args()
print(''.join([new_char(c, args.vowel) for c in args.text])) |
Return the given vowel if a char is a vowel else the char | def new_char(char, vowel):
"""Return the given vowel if a char is a vowel else the char"""
return vowel if char in 'aeiou' else \
vowel.upper() if char in 'AEIOU' else char |
get command-line arguments | def get_args():
"""get command-line arguments"""
parser = argparse.ArgumentParser(
description='Apples and bananas',
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument('text', metavar='text', help='Input text or file')
parser.add_argument('-v',
'--vowel',
help='The vowel to substitute',
metavar='vowel',
type=str,
default='a',
choices=list('aeiou'))
args = parser.parse_args()
if os.path.isfile(args.text):
args.text = open(args.text).read().rstrip()
return args |
Make a jazz noise here | def main():
"""Make a jazz noise here"""
args = get_args()
vowel = args.vowel
def new_char(c):
return vowel if c in 'aeiou' else vowel.upper() if c in 'AEIOU' else c
print(''.join([new_char(c) for c in args.text])) |
get command-line arguments | def get_args():
"""get command-line arguments"""
parser = argparse.ArgumentParser(
description='Apples and bananas',
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument('text', metavar='text', help='Input text or file')
parser.add_argument('-v',
'--vowel',
help='The vowel to substitute',
metavar='vowel',
type=str,
default='a',
choices=list('aeiou'))
args = parser.parse_args()
if os.path.isfile(args.text):
args.text = open(args.text).read().rstrip()
return args |
Make a jazz noise here | def main():
"""Make a jazz noise here"""
args = get_args()
vowel = args.vowel
text = map(
lambda c: vowel if c in 'aeiou' else vowel.upper()
if c in 'AEIOU' else c, args.text)
print(''.join(text)) |
get command-line arguments | def get_args():
"""get command-line arguments"""
parser = argparse.ArgumentParser(
description='Apples and bananas',
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument('text', metavar='text', help='Input text or file')
parser.add_argument('-v',
'--vowel',
help='The vowel to substitute',
metavar='vowel',
type=str,
default='a',
choices=list('aeiou'))
args = parser.parse_args()
if os.path.isfile(args.text):
args.text = open(args.text).read().rstrip()
return args |
Make a jazz noise here | def main():
"""Make a jazz noise here"""
args = get_args()
vowel = args.vowel
def new_char(c):
return vowel if c in 'aeiou' else vowel.upper() if c in 'AEIOU' else c
print(''.join(map(new_char, args.text))) |
get command-line arguments | def get_args():
"""get command-line arguments"""
parser = argparse.ArgumentParser(
description='Apples and bananas',
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument('text', metavar='text', help='Input text or file')
parser.add_argument('-v',
'--vowel',
help='The vowel to substitute',
metavar='vowel',
type=str,
default='a',
choices=list('aeiou'))
args = parser.parse_args()
if os.path.isfile(args.text):
args.text = open(args.text).read().rstrip()
return args |
Make a jazz noise here | def main():
"""Make a jazz noise here"""
args = get_args()
text = args.text
vowel = args.vowel
text = re.sub('[aeiou]', vowel, text)
text = re.sub('[AEIOU]', vowel.upper(), text)
print(text) |
exists | def test_exists():
"""exists"""
assert os.path.isfile(prg) |
usage | def test_usage():
"""usage"""
for flag in ['-h', '--help']:
rv, out = getstatusoutput(f'{prg} {flag}')
assert rv == 0
assert re.match("usage", out, re.IGNORECASE) |
Should fail on a bad vowel | def test_bad_vowel():
"""Should fail on a bad vowel"""
rv, out = getstatusoutput(f'{prg} -v x foo')
assert rv != 0
assert re.match("usage", out, re.IGNORECASE) |
foo -> faa | def test_command_line():
""" foo -> faa """
out = getoutput(f'{prg} foo')
assert out.strip() == 'faa' |
foo -> fii | def test_command_line_with_vowel():
""" foo -> fii """
out = getoutput(f'{prg} -v i foo')
assert out.strip() == 'fii' |
foo -> fii | def test_command_line_with_vowel_preserve_case():
""" foo -> fii """
out = getoutput(f'{prg} "APPLES AND BANANAS" --vowel i')
assert out.strip() == 'IPPLIS IND BININIS' |
fox.txt | def test_file():
""" fox.txt """
out = getoutput(f'{prg} {fox}')
assert out.strip() == 'Tha qaack brawn fax jamps avar tha lazy dag.' |
fox.txt | def test_file_with_vowel():
""" fox.txt """
out = getoutput(f'{prg} --vowel o {fox}')
assert out.strip() == 'Tho qoock brown fox jomps ovor tho lozy dog.' |
Get command-line arguments | def get_args():
"""Get command-line arguments"""
parser = argparse.ArgumentParser(
description='Heap abuse',
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument('-a',
'--adjectives',
help='Number of adjectives',
metavar='adjectives',
type=int,
default=2)
parser.add_argument('-n',
'--number',
help='Number of insults',
metavar='insults',
type=int,
default=3)
parser.add_argument('-s',
'--seed',
help='Random seed',
metavar='seed',
type=int,
default=None)
args = parser.parse_args()
if args.adjectives < 1:
parser.error(f'--adjectives "{args.adjectives}" must be > 0')
if args.number < 1:
parser.error(f'--number "{args.number}" must be > 0')
return args |
Make a jazz noise here | def main():
"""Make a jazz noise here"""
args = get_args()
random.seed(args.seed)
adjectives = """
bankrupt base caterwauling corrupt cullionly detestable dishonest false
filthsome filthy foolish foul gross heedless indistinguishable infected
insatiate irksome lascivious lecherous loathsome lubbery old peevish
rascaly rotten ruinous scurilous scurvy slanderous sodden-witted
thin-faced toad-spotted unmannered vile wall-eyed
""".strip().split()
nouns = """
Judas Satan ape ass barbermonger beggar block boy braggart butt
carbuncle coward coxcomb cur dandy degenerate fiend fishmonger fool
gull harpy jack jolthead knave liar lunatic maw milksop minion
ratcatcher recreant rogue scold slave swine traitor varlet villain worm
""".strip().split()
for _ in range(args.number):
adjs = ', '.join(random.sample(adjectives, k=args.adjectives))
print(f'You {adjs} {random.choice(nouns)}!') |
exists | def test_exists():
"""exists"""
assert os.path.isfile(prg) |
usage | def test_usage():
"""usage"""
for flag in ['-h', '--help']:
rv, out = getstatusoutput(f'{prg} {flag}')
assert rv == 0
assert re.match("usage", out, re.IGNORECASE) |
bad_adjectives | def test_bad_adjective_str():
"""bad_adjectives"""
bad = random_string()
rv, out = getstatusoutput(f'{prg} -a {bad}')
assert rv != 0
assert re.search(f"invalid int value: '{bad}'", out) |
bad_adjectives | def test_bad_adjective_num():
"""bad_adjectives"""
n = random.choice(range(-10, 0))
rv, out = getstatusoutput(f'{prg} -a {n}')
print(out)
assert rv != 0
assert re.search(f'--adjectives "{n}" must be > 0', out) |
bad_number | def test_bad_number_str():
"""bad_number"""
bad = random_string()
rv, out = getstatusoutput(f'{prg} -n {bad}')
assert rv != 0
assert re.search(f"invalid int value: '{bad}'", out) |
bad_number | def test_bad_number_int():
"""bad_number"""
n = random.choice(range(-10, 0))
rv, out = getstatusoutput(f'{prg} -n {n}')
assert rv != 0
assert re.search(f'--number "{n}" must be > 0', out) |
bad seed | def test_bad_seed():
"""bad seed"""
bad = random_string()
rv, out = getstatusoutput(f'{prg} -s {bad}')
assert rv != 0
assert re.search(f"invalid int value: '{bad}'", out) |
test | def test_01():
"""test"""
out = getoutput(f'{prg} -s 1 -n 1')
assert out.strip() == 'You filthsome, cullionly fiend!' |
test | def test_02():
"""test"""
out = getoutput(f'{prg} --seed 2')
expected = """
You corrupt, detestable beggar!
You peevish, foolish gull!
You insatiate, heedless worm!
""".strip()
assert out.strip() == expected |
test | def test_03():
"""test"""
out = getoutput(f'{prg} -s 3 -n 5 -a 1')
expected = """
You infected villain!
You vile braggart!
You peevish worm!
You sodden-witted villain!
You cullionly worm!
""".strip()
assert out.strip() == expected |
test | def test_04():
"""test"""
out = getoutput(f'{prg} --seed 4 --number 2 --adjectives 4')
expected = """
You infected, lecherous, dishonest, rotten recreant!
You filthy, detestable, cullionly, base lunatic!
""".strip()
assert out.strip() == expected |
generate a random filename | def random_string():
"""generate a random filename"""
return ''.join(random.choices(string.ascii_lowercase + string.digits, k=5)) |
Get command-line arguments | def get_args():
"""Get command-line arguments"""
parser = argparse.ArgumentParser(
description='Telephone',
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument('text', metavar='text', help='Input text or file')
parser.add_argument('-s',
'--seed',
help='Random seed',
metavar='seed',
type=int,
default=None)
parser.add_argument('-m',
'--mutations',
help='Percent mutations',
metavar='mutations',
type=float,
default=0.1)
args = parser.parse_args()
if not 0 <= args.mutations <= 1:
parser.error(f'--mutations "{args.mutations}" must be between 0 and 1')
if os.path.isfile(args.text):
args.text = open(args.text).read().rstrip()
return args |
Make a jazz noise here | def main():
"""Make a jazz noise here"""
args = get_args()
text = args.text
random.seed(args.seed)
alpha = ''.join(sorted(string.ascii_letters + string.punctuation))
len_text = len(text)
num_mutations = round(args.mutations * len_text)
new_text = text
for i in random.sample(range(len_text), num_mutations):
new_char = random.choice(alpha.replace(new_text[i], ''))
new_text = new_text[:i] + new_char + new_text[i + 1:]
print(f'You said: "{text}"\nI heard : "{new_text}"') |
Get command-line arguments | def get_args():
"""Get command-line arguments"""
parser = argparse.ArgumentParser(
description='Telephone',
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument('text', metavar='text', help='Input text or file')
parser.add_argument('-s',
'--seed',
help='Random seed',
metavar='seed',
type=int,
default=None)
parser.add_argument('-m',
'--mutations',
help='Percent mutations',
metavar='mutations',
type=float,
default=0.1)
args = parser.parse_args()
if not 0 <= args.mutations <= 1:
parser.error(f'--mutations "{args.mutations}" must be between 0 and 1')
if os.path.isfile(args.text):
args.text = open(args.text).read().rstrip()
return args |
Make a jazz noise here | def main():
"""Make a jazz noise here"""
args = get_args()
text = args.text
random.seed(args.seed)
alpha = ''.join(sorted(string.ascii_letters + string.punctuation))
len_text = len(text)
num_mutations = round(args.mutations * len_text)
new_text = list(text)
for i in random.sample(range(len_text), num_mutations):
new_text[i] = random.choice(alpha.replace(new_text[i], ''))
print('You said: "{}"\nI heard : "{}"'.format(text, ''.join(new_text))) |
exists | def test_exists():
"""exists"""
assert os.path.isfile(prg) |
usage | def test_usage():
"""usage"""
for flag in ['', '-h', '--help']:
out = getoutput(f'{prg} {flag}')
assert re.match('usage', out, re.IGNORECASE) |
bad seed str value | def test_bad_seed_str():
"""bad seed str value"""
bad = random_string()
rv, out = getstatusoutput(f'{prg} -s {bad} {fox}')
assert rv > 0
assert re.search(f"invalid int value: '{bad}'", out) |
bad mutation str value | def test_bad_mutation_str():
"""bad mutation str value"""
bad = random_string()
rv, out = getstatusoutput(f'{prg} -m {bad} {fox}')
assert rv > 0
assert re.search(f"invalid float value: '{bad}'", out) |
bad mutation values | def test_bad_mutation():
"""bad mutation values"""
for val in ['-1.0', '10.0']:
rv, out = getstatusoutput(f'{prg} -m {val} {fox}')
assert rv > 0
assert re.search(f'--mutations "{val}" must be between 0 and 1', out) |
test | def test_for_echo():
"""test"""
txt = open(now).read().rstrip()
rv, out = getstatusoutput(f'{prg} -m 0 "{txt}"')
assert rv == 0
assert out.rstrip() == f'You said: "{txt}"\nI heard : "{txt}"' |
test | def test_now_cmd_s1():
"""test"""
txt = open(now).read().rstrip()
rv, out = getstatusoutput(f'{prg} -s 1 "{txt}"')
assert rv == 0
expected = """
Now is Ege time [dr all good me- to come to the jid of the party.
""".strip()
assert out.rstrip() == f'You said: "{txt}"\nI heard : "{expected}"' |
test | def test_now_cmd_s2_m4():
"""test"""
txt = open(now).read().rstrip()
rv, out = getstatusoutput(f'{prg} -s 2 -m .4 "{txt}"')
assert rv == 0
expected = """
No$ i% khefMiIe sor@all$glo<BmenYts cAAeltaTtheSaid[HYnthe Aalty.
""".strip()
assert out.rstrip() == f'You said: "{txt}"\nI heard : "{expected}"' |
test | def test_fox_file_s1():
"""test"""
rv, out = getstatusoutput(f'{prg} --seed 1 {fox}')
assert rv == 0
txt = open(fox).read().rstrip()
expected = "The duic: brown hox jumps over the lkzy dog."
assert out.rstrip() == f'You said: "{txt}"\nI heard : "{expected}"' |
test | def test_fox_file_s2_m6():
"""test"""
rv, out = getstatusoutput(f'{prg} --seed 2 --mutations .6 {fox}')
assert rv == 0
txt = open(fox).read().rstrip()
expected = "ZoA@qric` HwdTB Alx$jumIslolXs th^Yl?dy<YoA."
assert out.rstrip() == f'You said: "{txt}"\nI heard : "{expected}"' |
generate a random filename | def random_string():
"""generate a random filename"""
return ''.join(random.choices(string.ascii_lowercase + string.digits, k=5)) |
Get command-line arguments | def get_args():
"""Get command-line arguments"""
parser = argparse.ArgumentParser(
description='Bottles of beer song',
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument('-n',
'--num',
metavar='number',
type=int,
default=10,
help='How many bottles')
args = parser.parse_args()
if args.num < 1:
parser.error(f'--num "{args.num}" must be greater than 0')
return args |
Make a jazz noise here | def main():
"""Make a jazz noise here"""
args = get_args()
print('\n\n'.join(map(verse, range(args.num, 0, -1)))) |
Sing a verse | def verse(bottle):
"""Sing a verse"""
next_bottle = bottle - 1
s1 = '' if bottle == 1 else 's'
s2 = '' if next_bottle == 1 else 's'
num_next = 'No more' if next_bottle == 0 else next_bottle
return '\n'.join([
f'{bottle} bottle{s1} of beer on the wall,',
f'{bottle} bottle{s1} of beer,',
f'Take one down, pass it around,',
f'{num_next} bottle{s2} of beer on the wall!',
]) |
Test verse | def test_verse():
"""Test verse"""
last_verse = verse(1)
assert last_verse == '\n'.join([
'1 bottle of beer on the wall,', '1 bottle of beer,',
'Take one down, pass it around,',
'No more bottles of beer on the wall!'
])
two_bottles = verse(2)
assert two_bottles == '\n'.join([
'2 bottles of beer on the wall,', '2 bottles of beer,',
'Take one down, pass it around,', '1 bottle of beer on the wall!'
]) |
exists | def test_exists():
"""exists"""
assert os.path.isfile(prg) |
usage | def test_usage():
"""usage"""
for flag in ['-h', '--help']:
rv, out = getstatusoutput(f'{prg} {flag}')
assert rv == 0
assert re.match("usage", out, re.IGNORECASE) |
Bad integer value | def test_bad_int():
"""Bad integer value"""
bad = random.randint(-10, 0)
rv, out = getstatusoutput(f'{prg} -n {bad}')
assert rv != 0
assert re.search(f'--num "{bad}" must be greater than 0', out) |
float value | def test_float():
"""float value"""
bad = round(random.random() * 10, 2)
rv, out = getstatusoutput(f'{prg} --num {bad}')
assert rv != 0
assert re.search(f"invalid int value: '{bad}'", out) |
str value | def test_str():
"""str value"""
bad = random_string()
rv, out = getstatusoutput(f'{prg} -n {bad}')
assert rv != 0
assert re.search(f"invalid int value: '{bad}'", out) |
One bottle of beer | def test_one():
"""One bottle of beer"""
expected = ('1 bottle of beer on the wall,\n'
'1 bottle of beer,\n'
'Take one down, pass it around,\n'
'No more bottles of beer on the wall!')
rv, out = getstatusoutput(f'{prg} --num 1')
assert rv == 0
assert out == expected |
Two bottles of beer | def test_two():
"""Two bottles of beer"""
expected = ('2 bottles of beer on the wall,\n'
'2 bottles of beer,\n'
'Take one down, pass it around,\n'
'1 bottle of beer on the wall!\n\n'
'1 bottle of beer on the wall,\n'
'1 bottle of beer,\n'
'Take one down, pass it around,\n'
'No more bottles of beer on the wall!')
rv, out = getstatusoutput(f'{prg} -n 2')
assert rv == 0
assert out == expected |
Random number | def test_random():
"""Random number"""
sums = dict(
map(lambda x: x.split('\t'),
open('sums.txt').read().splitlines()))
for n in random.choices(list(sums.keys()), k=10):
flag = '-n' if random.choice([0, 1]) == 1 else '--num'
rv, out = getstatusoutput(f'{prg} {flag} {n}')
out += '\n' # because the last newline is removed
assert rv == 0
assert hashlib.md5(out.encode('utf-8')).hexdigest() == sums[n] |
generate a random string | def random_string():
"""generate a random string"""
k = random.randint(5, 10)
return ''.join(random.choices(string.ascii_letters + string.digits, k=k)) |
Get command-line arguments | def get_args():
"""Get command-line arguments"""
parser = argparse.ArgumentParser(
description='Ransom Note',
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument('text', metavar='text', help='Input text or file')
parser.add_argument('-s',
'--seed',
help='Random seed',
metavar='int',
type=int,
default=None)
args = parser.parse_args()
if os.path.isfile(args.text):
args.text = open(args.text).read().rstrip()
return args |
Make a jazz noise here | def main():
"""Make a jazz noise here"""
args = get_args()
random.seed(args.seed)
# Method 1: Iterate each character, add to list
ransom = []
for char in args.text:
ransom.append(choose(char))
print(''.join(ransom)) |
Randomly choose an upper or lowercase letter to return | def choose(char):
"""Randomly choose an upper or lowercase letter to return"""
return char.upper() if random.choice([0, 1]) else char.lower() |
Test choose | def test_choose():
"""Test choose"""
state = random.getstate()
random.seed(1)
assert choose('a') == 'a'
assert choose('b') == 'b'
assert choose('c') == 'C'
assert choose('d') == 'd'
random.setstate(state) |
Get command-line arguments | def get_args():
"""Get command-line arguments"""
parser = argparse.ArgumentParser(
description='Ransom Note',
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument('text', metavar='text', help='Input text or file')
parser.add_argument('-s',
'--seed',
help='Random seed',
metavar='int',
type=int,
default=None)
args = parser.parse_args()
if os.path.isfile(args.text):
args.text = open(args.text).read().rstrip()
return args |
Make a jazz noise here | def main():
"""Make a jazz noise here"""
args = get_args()
random.seed(args.seed)
# Method 2: Iterate each character, add to a list
ransom = []
for char in args.text:
ransom += choose(char)
print(''.join(ransom)) |
Randomly choose an upper or lowercase letter to return | def choose(char):
"""Randomly choose an upper or lowercase letter to return"""
return char.upper() if random.choice([0, 1]) else char.lower() |
Test choose | def test_choose():
"""Test choose"""
state = random.getstate()
random.seed(1)
assert choose('a') == 'a'
assert choose('b') == 'b'
assert choose('c') == 'C'
assert choose('d') == 'd'
random.setstate(state) |
Get command-line arguments | def get_args():
"""Get command-line arguments"""
parser = argparse.ArgumentParser(
description='Ransom Note',
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument('text', metavar='text', help='Input text or file')
parser.add_argument('-s',
'--seed',
help='Random seed',
metavar='int',
type=int,
default=None)
args = parser.parse_args()
if os.path.isfile(args.text):
args.text = open(args.text).read().rstrip()
return args |
Make a jazz noise here | def main():
"""Make a jazz noise here"""
args = get_args()
random.seed(args.seed)
# Method 3: Iterate each character, add to a str
ransom = ''
for char in args.text:
ransom += choose(char)
print(''.join(ransom)) |
Randomly choose an upper or lowercase letter to return | def choose(char):
"""Randomly choose an upper or lowercase letter to return"""
return char.upper() if random.choice([0, 1]) else char.lower() |
Test choose | def test_choose():
"""Test choose"""
state = random.getstate()
random.seed(1)
assert choose('a') == 'a'
assert choose('b') == 'b'
assert choose('c') == 'C'
assert choose('d') == 'd'
random.setstate(state) |
Get command-line arguments | def get_args():
"""Get command-line arguments"""
parser = argparse.ArgumentParser(
description='Ransom Note',
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument('text', metavar='text', help='Input text or file')
parser.add_argument('-s',
'--seed',
help='Random seed',
metavar='int',
type=int,
default=None)
args = parser.parse_args()
if os.path.isfile(args.text):
args.text = open(args.text).read().rstrip()
return args |
Make a jazz noise here | def main():
"""Make a jazz noise here"""
args = get_args()
random.seed(args.seed)
# Method 4: List comprehension
ransom = [choose(char) for char in args.text]
print(''.join(ransom)) |
Randomly choose an upper or lowercase letter to return | def choose(char):
"""Randomly choose an upper or lowercase letter to return"""
return char.upper() if random.choice([0, 1]) else char.lower() |
Test choose | def test_choose():
"""Test choose"""
state = random.getstate()
random.seed(1)
assert choose('a') == 'a'
assert choose('b') == 'b'
assert choose('c') == 'C'
assert choose('d') == 'd'
random.setstate(state) |
Get command-line arguments | def get_args():
"""Get command-line arguments"""
parser = argparse.ArgumentParser(
description='Ransom Note',
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument('text', metavar='text', help='Input text or file')
parser.add_argument('-s',
'--seed',
help='Random seed',
metavar='int',
type=int,
default=None)
args = parser.parse_args()
if os.path.isfile(args.text):
args.text = open(args.text).read().rstrip()
return args |
Make a jazz noise here | def main():
"""Make a jazz noise here"""
args = get_args()
random.seed(args.seed)
# Method 5: List comprehension
print(''.join([choose(char) for char in args.text])) |
Randomly choose an upper or lowercase letter to return | def choose(char):
"""Randomly choose an upper or lowercase letter to return"""
return char.upper() if random.choice([0, 1]) else char.lower() |
Test choose | def test_choose():
"""Test choose"""
state = random.getstate()
random.seed(1)
assert choose('a') == 'a'
assert choose('b') == 'b'
assert choose('c') == 'C'
assert choose('d') == 'd'
random.setstate(state) |
Get command-line arguments | def get_args():
"""Get command-line arguments"""
parser = argparse.ArgumentParser(
description='Ransom Note',
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument('text', metavar='text', help='Input text or file')
parser.add_argument('-s',
'--seed',
help='Random seed',
metavar='int',
type=int,
default=None)
args = parser.parse_args()
if os.path.isfile(args.text):
args.text = open(args.text).read().rstrip()
return args |
Make a jazz noise here | def main():
"""Make a jazz noise here"""
args = get_args()
random.seed(args.seed)
# Method 6: map
ransom = map(choose, args.text)
print(''.join(ransom)) |
Randomly choose an upper or lowercase letter to return | def choose(char):
"""Randomly choose an upper or lowercase letter to return"""
return char.upper() if random.choice([0, 1]) else char.lower() |
Test choose | def test_choose():
"""Test choose"""
state = random.getstate()
random.seed(1)
assert choose('a') == 'a'
assert choose('b') == 'b'
assert choose('c') == 'C'
assert choose('d') == 'd'
random.setstate(state) |
Get command-line arguments | def get_args():
"""Get command-line arguments"""
parser = argparse.ArgumentParser(
description='Ransom Note',
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument('text', metavar='text', help='Input text or file')
parser.add_argument('-s',
'--seed',
help='Random seed',
metavar='int',
type=int,
default=None)
args = parser.parse_args()
if os.path.isfile(args.text):
args.text = open(args.text).read().rstrip()
return args |
Make a jazz noise here | def main():
"""Make a jazz noise here"""
args = get_args()
random.seed(args.seed)
# Method 7: map
print(''.join(map(choose, args.text))) |
Randomly choose an upper or lowercase letter to return | def choose(char):
"""Randomly choose an upper or lowercase letter to return"""
return char.upper() if random.choice([0, 1]) else char.lower() |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.