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)