def breaking_records(n):
size = n
source_list = []
for elem in range(randint(21, 34)):
source_list.append(randint(0, 100))
print('^^^^^^^^^ START ^^^^^^^^^^')
print('The scores are: ' + str(source_list))
# test quantity of records
if 1 <= size <= pow(10, 3):
print('size ok')
if size < 2:
ans = 'Only one element in the records, max and min = {}'.format(
source_list[0])
print(ans)
return append_elements(source_list, ans)
else:
print('Continue process...')
else:
print('size -> [1, 10e3]')
print('****************** END *********************')
return False
# test magnitude of the record
if 0 <= len(source_list) <= pow(10, 8):
print('Magnitude ok')
else:
print('size -> [1, 10e8]')
return False
# if the constrains is ok, declaration of new variables
max_score = source_list[0]
min_score = source_list[0]
times_beat_max = 0
times_beat_min = 0
# brain
for elem in source_list:
if max_score < elem:
max_score = elem
times_beat_max += 1
elif min_score > elem:
min_score = elem
times_beat_min += 1
else:
print('Everthing stay the same, score: {}'.format(elem))
print('------------------------')
print('Score max : {}'.format(max_score))
print('Max score beated {} times!'.format(times_beat_max))
print('------------------------')
print('Score min: : {}'.format(min_score))
print('Min score beated {} times!'.format(times_beat_min))
print('#################### END #######################')
return append_elements(source_list, max_score, times_beat_max, min_score,
times_beat_min)
def exe_factorial():
list_elements = []
# random arr
for elem in range(21, randint(34, 55)):
list_elements.append(randint(-21, 21))
print('---------------------------------')
print('Numbers of elements source arr: ' + str(len(list_elements)))
print('Source arr: ' + str(list_elements))
print('---------------------------------')
ans_list = []
for el in list_elements:
if 2 <= el <= 12:
ans = str(el) + '! = ' + str(factorial(el))
ans_list.append(ans)
print(ans)
else:
ans = str(el) + ": element needs to be between [2,12]"
ans_list.append(ans)
print(ans)
return append_elements('factorial()', list_elements, ans_list)
def odd_even():
list_numbers = []
for elem in range(21, randint(34, 55)):
list_numbers.append(randint(-89, 89))
answer_list = []
print(list_numbers)
for elem in list_numbers:
if 0 <= elem <= 100:
if elem % 2 == 0:
if 2 <= elem <= 5:
txt_ans = 'Weird (even)'
elif 6 <= elem <= 20:
txt_ans = 'Not Bad (even)'
else:
txt_ans = 'ok (even)'
else:
txt_ans = '(odd)'
else:
txt_ans = 'input a valid number! [0,100]'
ans = str(elem) + ': ' + txt_ans
print(ans)
answer_list.append(ans)
return append_elements('odd_even()', list_numbers, answer_list)
def exe_wrap():
string, max_width = 'wisdom is clear and precise', randint(3, 5)
outcome = text_wrap(string, max_width)
print(outcome)
return append_elements('text_wrap()', outcome)
def use_kangaroo():
global collide
collide = 0
global never_meet
never_meet = 0
global out_constraint
out_constraint = 0
size = randint(500,800)
for i in range(0, size):
a, b = kangaroo()
if b == 1:
collide = collide + 1
elif b == 0:
never_meet = never_meet + 1
else:
out_constraint = out_constraint + 1
print(a)
print('------------------------------------------------')
print('Statistics of {} executions: '.format(size))
print('Collide: ' + str(collide))
print('Never meet: ' + str(never_meet))
print('Out of the constraints: ' + str(out_constraint))
print('------------------------------------------------')
return aidfunctions.append_elements('kangaroo()', collide, never_meet, out_constraint)
def is_leap():
size = randint(21, 89)
years_list = []
for i in range(0, size):
years_list.append(randint(1855, 2089))
answer_list = []
leap = False
for year in years_list:
if 1900 <= year <= pow(10, 5):
if year % 4 == 0:
if year % 100 == 0:
if year % 400 == 0:
leap = True
else:
leap = False
else:
leap = True
else:
leap = False
else:
print('y out of range')
print(year)
print(leap)
print('-------------------------------------------------')
ans = str(year) + ':' + str(leap)
answer_list.append(ans)
return aidfunctions.append_elements('is_leap()', answer_list)
def even_odd_string():
t = 1
even_list = []
odd_list = []
source_word = "wisdomisclearandprecise"
if 1 <= t <= 10:
while t > 0:
i = 0
for el in source_word:
if (i % 2) == 0:
even_list.append(el)
else:
odd_list.append(el)
i += 1
t -= 1
for el in even_list:
print(el, end='\n')
print('-----------------------------')
for el in odd_list:
print(el, end='\n')
print('-----------------------------')
ans = 'OK'
else:
ans = 't needs to be [1,10]'
print(ans)
return append_elements('even_odd_string()', source_word, even_list,
odd_list, ans)
def reverse_print():
source_arr = []
for elem in range(randint(21, 34)):
source_arr.append(randint(-500, 1200))
arr_reversed = []
tested_list = []
n = len(source_arr)
if 1 <= n <= 1000:
for el in source_arr:
if 1 <= el <= 10000:
ans = str(el) + ': Ok'
print(ans)
tested_list.append(el)
else:
ans = str(
el
) + ": The maximum value of element in source_arr is 10000 and the minimum 1."
print(ans)
arr_reversed = tested_list.copy()
arr_reversed.reverse()
print('-----------------------------')
print('source: ' + str(source_arr))
print('reverse: ' + str(arr_reversed))
else:
ans = "n needs to be between [1,1000]"
print(ans)
return append_elements('reverse_print()', source_arr, tested_list,
arr_reversed)
def merge_the_tools():
string_input = "AAB,CCA,ADD,DOM,JLN,SIN,TVS"
block = 3
n = len(string_input)
if 1 <= n <= 10000:
amount_block = n / block
n_block = amount_block
if 1 <= block <= n and n % block == 0:
ans = string_input.split(",", int(amount_block))
print(ans)
else:
ans = " Constraints -> block:[1,n] AND { n needs be a multiple of block } "
print(ans)
else:
ans = "input a valid source_text, size -> [1,10000]"
print(ans)
size_ans = len(ans)
random_elem = randint(0, size_ans)
print('The element of the position {}: '.format(random_elem) + ans[random_elem])
return aidfunctions.append_elements('merge_the_tools()', string_input, block, n, n_block, ans)
def diagonalDifference():
arr1 = [9, randint(1, 9), 1]
arr2 = [randint(1, 9), 4, 2]
arr3 = [7, 4, randint(1, 9)]
arr = [arr1, arr2, arr3]
n = len(arr)
primaryDiagonal = 0
secondaryDiagonal = 0
i = 0
while i < n:
primaryDiagonal += arr[i][i]
i += 1
j = 0
i = n - 1
while j < n:
secondaryDiagonal += arr[i][j]
j += 1
i -= 1
ans = abs(primaryDiagonal - secondaryDiagonal)
for elem in arr:
print(elem)
print('matrix : [3x3]')
print('Diagonal Difference = ' + str(ans))
return aidfunctions.append_elements('diagonalDifference()', arr, n, ans)
def gradingStudents():
final_grade = []
size_grade = randint(0, 55)
grades = []
for i in range(0, size_grade):
grades.append(round(uniform(0, 100), 2))
grades_count = len(grades)
if 1 <= grades_count <= 60:
i = 0
while i < grades_count:
if grades[i] < 38:
final_grade.append(grades[i])
elif grades[i] >= 38:
rest = grades[i] % 5
next_mult = (grades[i] - rest) + 5
dif = next_mult - grades[i]
if dif < 3:
final_grade.append(next_mult)
elif dif >= 3:
final_grade.append(grades[i])
i += 1
else:
print('Digite um valor valido')
for val in final_grade:
print(val)
print(grades)
print(final_grade)
return aidfunctions.append_elements('gradingStudents()', final_grade)
def drawDoor():
# n, m = map(int, input().split())
n, m = 8, 8
pattern = [('.|.' * (2 * i + 1)).center(m, '-') for i in range(n // 2)]
print('\n'.join(pattern + ['WELCOME'.center(m, '-')] + pattern[::-1]))
return aidfunctions.append_elements('drawDoor()', n, m, pattern)
def infinite_arguments(*args):
print(args)
for elem in args:
print(elem)
x = list(args)
return append_elements('infinite_arguments', args, x)
def seek_page():
source_book = []
i = 1
for _ in range(randint(-9, 90)):
source_book.append(i)
i += 1
print(source_book)
print('------------')
size_book = len(source_book)
wanted_page = randint(5, size_book)
print('size book: {}'.format(size_book))
print('wanted page: {}'.format(wanted_page))
if 1 <= size_book <= pow(10, 5):
print('Size book ok.')
else:
print('Size book NOT OK')
print('----------------')
return False
if 1 <= wanted_page <= size_book:
print('Page wanted ok.')
else:
print('Page wanted NOT OK')
print('-------------')
return False
half_book = size_book / 2
print('half book {}'.format(half_book))
if wanted_page < half_book:
i = 1
count_pass = 0
while wanted_page is not source_book[i] or source_book[i - 1]:
i += 2
count_pass += 1
else:
i = size_book - 1
count_pass = 0
while wanted_page is not source_book[i] or source_book[i - 1]:
i -= 2
count_pass += 1
print(count_pass)
# pivot = 0
# if half_book < wanted_page:
# i = len(source_book - 1)
# while wanted_page != pivot:
# pivot = source_book[i]
print('**************END***************')
return append_elements(source_book, size_book, half_book, count_pass)
def angleTriangle():
ab = randint(13, 34)
bc = randint(21, 55)
res = str(int(round(math.degrees(math.atan2(ab, bc)))))
print('AB: ' + str(ab))
print('BC: ' + str(bc))
print(res + '°')
return aidfunctions.append_elements('angleTriangle()', ab, bc, res)
def print_function():
n = randint(5, 21)
print_list = []
i = 1
while i <= n:
print(i, end='\n')
print_list.append(i)
i += 1
return append_elements('print_function()', print_list)
def gen_pdf():
weekdays_list = {
'Monday': '1',
'Tuesday': '1',
'Wednesday': '2',
'Thursday': '3',
'Friday': '5',
'Saturday': '8',
'Sunday': '13',
'Holiday': '21'
}
try:
file_name = input("Type the file name for your pdf archive: ")
pdf = canvas.Canvas('{}.pdf'.format(file_name))
x = 610
for day, fiboNum in weekdays_list.items():
x -= 21
pdf.drawString(233, x, '{} : {}'.format(day, fiboNum))
pdf.setTitle(file_name)
pdf.setFont("Helvetica-Oblique", 13)
pdf.drawString(233, 650, 'List day Fibonacci')
pdf.setFont("Helvetica-Bold", 13)
pdf.drawString(233, 630, 'Day : Fibo_Number')
pdf.drawString(233, 397, 'Holiday^2')
pdf.drawString(233, 377, str(datatypeconversion.datatype_conversion()))
pdf.save()
ans = '{}.pdf created !!!'.format(file_name)
print(ans)
return append_elements('gen_pdf', weekdays_list, ans)
except:
string_error = "Error to generate PDF"
print(string_error)
return append_elements('gen_pdf', string_error)
def nested_list():
list_sheet = []
i = 0
name_list = ['kira', 'nissa', 'triss', 'lilian']
for el in range(0, 4):
list_sheet.append([name_list[i], float(random.random() * 21)])
i += 1
second_highest = sorted(list(set([elem for name, elem in list_sheet])))[1]
print('Source List: ' + str(list_sheet))
print('\n'.join([a for a, b in sorted(list_sheet) if b == second_highest]))
return append_elements('nested_list()', list_sheet)
def swap_case():
s = "The future is Unpredictable"
ns = ""
for elem in s:
if elem.isupper():
ns += (elem.lower())
else:
ns += (elem.upper())
print(ns)
return append_elements('swap_case()', s, ns)
def stringValid():
s = 'Future is unpredictable'
string_list = []
# evaluates the parameters -> str.isalnum, str.isalpha, str.isdigit, str.islower, str.isupper
for method in [
str.isalnum, str.isalpha, str.isdigit, str.islower, str.isupper
]:
print(any(method(c) for c in s))
k = any(method(c) for c in s)
string_list.append(k)
return append_elements('stringValid()', s, string_list)
def simpleArraySum():
size_list = randint(1, 2000)
r_list = []
i = 0
while i < size_list:
r_list.append(randint(1, 500))
i += 1
sum = 0
for elem in r_list:
sum += elem
return aidfunctions.append_elements('simpleArraySum()', size_list, sum)
def multiples():
list_multiples = []
source_number = randint(5, 21)
if 2 <= source_number <= 20:
i = 1
while i <= 10:
k = str(i * source_number)
print(str(source_number) + " x " + str(i) + " = " + k)
list_multiples.append(k)
i += 1
print('Result: ')
print(source_number)
print(list_multiples)
return append_elements('multiples()', source_number, list_multiples)
else:
error_str = 'input a value between [2,20]'
print(error_str)
return append_elements('multiples()', error_str)
def div_sum_pairs():
# size array [2, 100]
size_array = 89
if 2 <= size_array <= 100:
print('size array ok.')
else:
return False
# element key divisible [1, 100]
key_divider = 3
if 1 <= key_divider <= 100:
print('key divider ok.')
else:
return False
source_array = []
# source_array[i] -> [1, 100]
for elem in range(size_array):
source_array.append(randint(1, 100))
# sum 2 elements of the source_array
sum_pair_array = []
for elem in source_array:
i = 1
while i < len(source_array):
sum_pair_array.append(elem * source_array[i])
i += 1
# verify if the element of the sum_pair_array is divider of key_divider
count_dividers = 0
not_divider = 0
for elem in sum_pair_array:
if elem % key_divider == 0:
count_dividers += 1
else:
not_divider += 1
print('------------------------------------')
print('Source list: {}'.format(source_array))
print('Key Divider: {}'.format(key_divider))
print('------------------------------------')
print('Sum pair list: {}'.format(source_array))
print(('Size of the sum_pair_list: {}'.format(len(sum_pair_array))))
print('Quantity of dividers: {}'.format(count_dividers))
print('------------------------------------')
return append_elements(source_array, sum_pair_array, count_dividers,
not_divider)
def exe_pow():
test_a = False
test_b = False
test_m = False
test_boolean = [test_a, test_b, test_m]
answer = 'earth'
print(test_boolean, answer)
print(bool(test_boolean))
# while test_boolean:
# print('blue')
# e, f, g = randint(1, 5), randint(5, 8), randint(-3, 5)
# test_a, test_b, test_m, answer = pow_function(e, f, g)
return append_elements('pow_function()', [test_a, test_b, test_m], answer)
def list_dictionary_tuple():
# LIST ----------------------------
source_list = [1, 2, 3, 4, 5]
lista = source_list.copy()
lista.extend([6, 7, 8, 9])
del (lista[0])
print('---------------------------------')
print('SOURCE LIST : {}'.format(str(source_list)))
print(lista)
# DICTIONARY --------------------------------
# consult item
d = {'nome': 'Jadson'}
print(d.items())
print('---------------------------------')
print('SOURCE DICTIONARY : {}'.format(str(d)))
# printing item in a arr
for k, v in d.items():
print(k, v)
# delete element in a dictionary
del (d['nome'])
print(d)
# TUPLE ------------------------------
t = (1, 1, 2, 3, 5, 8, 13, 21)
print('---------------------------------')
print('SOURCE TUPLE : {}'.format(str(t)))
print(t.index(5))
print(t[4])
print(t[t.index(5)])
# Random list and check the element
print('------------------------------')
print('CHECK ELEMENT OF LIST: ')
random_list = []
for el in range(randint(21, 34)):
random_list.append(randint(-144, 144))
index_to_check = randint(0, (len(random_list) - 1))
print('Source list: ' + str(random_list))
print('Index to check: ' + str(index_to_check))
ans_check = check_index(random_list, index_to_check)
return append_elements('list_dictionary_tuple()', lista, d, t, index_to_check, ans_check)
def list_positions():
source_list = []
for el in range(0, randint(5, 8)):
source_list.append(randint(0, 55))
list_log = []
print('Souce List' + str(source_list))
print(source_list[::2], source_list[1::2])
print(source_list[::-1], source_list[1::-1])
list_log.append(source_list)
list_log.append(source_list[::-1])
list_log.append(source_list[1::-1])
list_log.append(source_list[::2])
list_log.append(source_list[1::2])
return append_elements('list_positions()', list_log)
def convertTime():
day_night = ['AM', 'PM']
hours = randint(0, 12)
minutes = randint(0, 60)
seconds = randint(0, 60)
# source = '07:05:45PM'
source = str(hours) + ':' + str(minutes) + ':' + str(seconds) + str(
day_night[randint(0, 1)])
print(source)
converted = timeConversion(source)
print(converted)
return aidfunctions.append_elements('timeConversion(s)', 'convertTime()',
source, converted)
def dynamic_descompression():
# dynamic decompression
a = [5, 6, 9]
ans = 'Elements example 1 :' + ' {} {} {}'
print(ans.format(*a))
# example 2
size = randint(5, 21)
source_list = []
# create a random list
for i in range(0, size):
source_list.append(randint(55, 89))
ans_2 = 'Elements example 2: ' + size * ' {} '
print(ans_2.format(*source_list))
return append_elements('dynamic_descompression()', ans, ans_2)
def writeArchive():
# overwrite data
arq = open('arq_demo.txt', mode='w') # sobrescreve / overwrite
arq.write('salvando source_text...\n')
arq.close()
# open and add data / append
arq = open('arq_demo.txt', mode='a')
arq.write('adicionando conteudo ...\n')
arq.close()
# open and read
arq = open('arq_demo.txt', mode='r')
conteudo_arquivo = arq.read()
arq.close()
a = 'source_text'
try:
# uso de with
arq = open('arq_demo.txt', mode='a')
a = 'Testa se esta escrevendo! / try write test'
arq.write(a + '\n')
arq.close()
except IOError:
a = 'arquivo nao encontrado / archive not found'
print(a)
except ValueError:
a = 'Erro de valor / value error'
print(a)
except:
a = 'Erro desconhecido / coringa / unknown errors'
print(a)
finally:
b = 'Cleanup'
print(b)
print('Fim.')
return aidfunctions.append_elements('writeArchive()', a, b)
def jump_cloud():
# create a souce list of clouds
clouds = [0]
for elem in range(randint(55, 89)):
clouds.append(randint(0, 1))
# cloud origin need to be 0
if clouds[0] == 0:
print('First cloud ok.')
else:
print('First element not ok.')
size_sky = len(clouds)
# number of clouds -> integer [2, 100]
if 2 <= size_sky <= 100:
print('Numbers of clouds ok.')
else:
return False
# elements of sky_list -> integer [0,1]
for elem in clouds:
if 0 <= elem <= 1:
print('cloud {} ok.'.format(elem))
else:
return False
# the navigator need to jump the ones[1] cloud
jumps = 0
i = 1
while i < size_sky:
if clouds[i] == 0:
print('jump: cloud {} -> cloud {}'.format(jumps, i))
jumps = i
else:
print('Not jump to {}'.format(i))
i += 1
print('-------------------------------')
print('Quantity of clouds {}'.format(size_sky))
print('Quantity of jumps {}'.format(jumps))
return append_elements('jumpingclouds.py', clouds, size_sky, jumps)
