Py HelloKitty

a = input("Enter your first name: ")

b = input("Enter your surname: ")

print(f"Hi {a.lower()} {b.upper()}, how are you?")

 def get_min_abs_distance(a_list):

    min_distance = abs(a_list[0]-a_list[1])

    for i in range(1, len(a_list)-1):

        current_distance = abs(a_list[i] - a_list[i+1])

        if current_distance < min_distance:

            min_distance = current_distance

    return min_distance

 def modify_list(words_list):

    for i in range(len(words_list)):

        words_list[i] = words_list[i][i+1: len(words_list[i])]

 def get_first_mid_last(words_list):
    lst = []
    for word in words_list:
        if len(word) < 3:
            pass
        else:
            a = word[0] + word[len(word)//2] + word[-1]
            lst.append(a.lower())
    return lst

 def generate_words(filename):

    try:

        if filename == "":

            raise NameError("ERROR: Invalid filename!")

        else:

            content = open(filename, "r")

    except NameError as e:

        return e

    except FileNotFoundError:

        return f"ERROR: The file '{filename}' does not exist."

    else:

        words_list = content.read().split()

        words_list = [word.lower() for word in words_list]

        new_lst= []

        for word in words_list:

            if word not in new_lst:

                new_lst.append(word)

        content.close()

        lst = []

        for word in new_lst:

            if len(word) < 3:

                pass

            else:

                a = word[0] + word[len(word)//2] + word[-1]

                lst.append(a.lower())

        return lst

 class City:

    def __init__(self, name, population=1, area=1):

        self.__name = name

        self.__population = population

        self.__area = area

 

    def get_name(self):

        return self.__name

 

    def get_population(self):

        return self.__population

 

    def get_area(self):

        return self.__area

 

    def set_name(self, name):

        self.__name = name

 

    def set_population(self, population):

        if population > 0:

            self.__population = population

 

    def set_area(self, area):

        if area > 0:

            self.__area = round(area, 1)

 

    def get_population_density(self):

        return self.__population / self.__area

 

    def __str__(self):

        return f"{self.__name}({self.get_population_density():.2f})"

 class Country:

    def __init__(self, name):

        self.__name = name

        self.__cities_list = []

 

    def get_name(self):

        return self.__name

 

    def add_city(self, name, population, area):

        city = City(name, population, area)

        self.__cities_list.append(city)

 

    def get_total_population(self):

        total = 0

        for city in self.__cities_list:

            total += city.get_population()

        return total

 

    def get_total_area(self):

        total = 0

        for city in self.__cities_list:

            total += city.get_area()

        return total

 

    def get_population_density(self):

        return self.get_total_population() / self.get_total_area()

 

    def get_city(self, index):

        return self.__cities_list[index]

 

    def __str__(self):

        msg = self.__name + ":" + "\n"

        msg += "\n".join(str(city) for city in self.__cities_list)

        msg += f"\nPopulation density = {self.get_population_density():.2f}"

        return msg

 import random

 

def bogo_sort(data):

    c = 2

    is_sorted = False

    while not is_sorted:

        c += 6

        i = 0

        while i < len(data) - 1:

            c += 4

            j = random.randrange(i, len(data))

            data[i], data[j] = data[j], data[i]

            i += 1

        is_sorted = True

        i = 0

        while i < len(data) - 1:

            c += 3

            is_sorted = is_sorted and not data[i] > data[i + 1]

            i += 1

    print(f"Number of operations: {c}")

 stop = False

compare_total = 0

original_lst = []

while not stop:

    result_lst = []

    num = int(input("Enter a number: "))

    if num == 99999:

        stop = True

        print(f"Total comparisons: {compare_total}")

        print(original_lst)

    else:

        if not original_lst:

            original_lst.append(num)

            print(f"Comparisons: 0")

            print(original_lst)

        else:

            i = len(original_lst) - 1

            while i >= 0 and original_lst[i] > num:

                i -= 1

            if i == -1:

                result_lst.append(num)

                for item in original_lst:

                    result_lst.append(item)

                compare = len(original_lst)

                compare_total += compare

            else:

                for i in range(0, i + 1):

                    result_lst.append(original_lst[i])

                result_lst.append(num)

                for j in range(i + 1, len(original_lst)):

                    result_lst.append(original_lst[j])

                compare = len(original_lst) - 1 - i + 1

                compare_total += compare

            original_lst = result_lst

            print(f"Comparisons: {compare}")

            print(result_lst)

 def weighted_binary_search(data, value):

    low = 0

    high = len(data) - 1

    while low <= high:

        low_value = data[low]

        high_value = data[high]

        approx_mid = int(((value - low_value) / (high_value - low_value)) * (high - low)) + low

        print(f'Searching mid index: {approx_mid}')

        if not 0 <= approx_mid < len(data) or approx_mid < low or approx_mid > high:

            return -1

        if data[approx_mid] == value:

            return approx_mid

        elif data[approx_mid] < value:

            low = approx_mid + 1

        else:

            high = approx_mid - 1

    return -1

 num = int(input("Enter a number: "))

digit = num % 10

print("The least significant digit of {} is {}.".format(num, digit))

 def get_sum_of_neighbours(a_list):

    result = [a_list[1]]

    for index in range(1, len(a_list)-1):

        total = a_list[index-1] + a_list[index+1]

        result.append(total)

    result.append(a_list[-2])

    return result

 def index_of_closest(a_list, number):

    new = [abs(num - number) for num in a_list]

    a = min(new)

    return new.index(a)

 def create_username_dictionary(names_list):

    dict = {}

    for i in names_list:

        if i[1] not in dict:

            dict[i[1]] = i[0]

        else:

            print(f"ERROR: {i[1]} is already in the dictionary.")

    return dict

 def count_words_of_length(filename, n): 

    try:

        if len(filename)<=0:

            raise ValueError

        input_file = open(filename, "r")

        words = input_file.read().split()

        temp = [len(word) for word in words]

        return temp.count(n)

    except ValueError:

        return 'ERROR: Invalid filename!'

    except FileNotFoundError:

        return("ERROR: The file '{}' does not exist.".format(filename))

    else:

        input_file.close()

 def rate(n):

    total = 0

    i = 0

    count = 3

    while i<10:

        count +=3

        total += i

        i += 1

    i = 0

    count += 2

    while i < n:

        count += 4

        j = n

        while j > 0:

            count += 3

            total += 1

            j -= 2

        i += 2

    count +=1

    print('Number of operations: {}'.format(count))   

    return total 

 def selection_sort(data):

    swaps = 0

    for pass_num in range(len(data) - 1, 0, -1):

        position_largest = 0

        for i in range(1, pass_num+1):

            if data[i] > data[position_largest]:

                position_largest = i

        if position_largest != i:

            data[position_largest], data[i] = data[i], data[position_largest]

            swaps += 1

    return swaps 

 def get_study_guide(filename, keyword):
    dictionary = {}
    input_file = open(filename, "r")
    list_of_word_pairs = input_file.readlines()
    input_file.close()
    for word_pair in list_of_word_pairs:
        word_pair = word_pair.strip()
        word_pair_split = word_pair.split(":")
        dictionary[word_pair_split[0]] = word_pair_split[1]
    try:
        if len(keyword) == 0:
            raise ValueError
        value = dictionary[keyword]
        return value
    except KeyError:
        return("ERROR: {} is not available.".format(keyword))
    except TypeError:
        return("ERROR: Invalid input!")
    except ValueError:
        return("ERROR: Invalid keyword!")

 class Student:

    def __init__(self, surname, firstname, student_id):

        self.__surname = surname

        self.__firstname = firstname

        self.__student_id = student_id

        self.__project_scores = []

 

    def add_project_score(self, score):

        if 0 <= score <= 10:

            self.__project_scores.append(score)

 

    def get_names(self):

        return f"{self.__surname} {self.__firstname}"

 

    def get_student_id(self):

        return self.__student_id

 

    def get_project_scores(self):

        return self.__project_scores

 

    def get_average(self):

        sum = 0

        if len(self.__project_scores) != 0:

            for i in self.__project_scores:

                sum += i

            return round(sum / (len(self.__project_scores)), 1)

        else:

            return 0

 

    def __str__(self):

        return f"{self.__surname} {self.__firstname}({self.__student_id}), average score = {self.get_average()}"

 class Project:

    def __init__(self, id, title):

        self.__project_id = id

        self.__title = title

        self.__students = []

    def get_project_id(self):

        return self.__project_id

    def get_title(self):

        return self.__title

    def add_student(self, s):

        self.__students.append(s)

    def set_score(self, score):

        for s in self.__students:

            s.add_project_score(score)

    def get_number_of_students(self):

        return len(self.__students)

    def get_students(self):

        result = [s.get_names() for s in self.__students]    

        return ','.join(result)

    def __str__(self):

        return 'ID={},({}):{}'.format(self.__project_id, self.__title, self.get_students())

 def get_missing_items_list(my_list):

    missing_items = []

    if len(my_list) > 1:

        index = 0

        while (index < len(my_list)-1):

            current_item = my_list[index]

            next_item = my_list[index + 1]

            curent_plus_one = current_item + 1

            while curent_plus_one < next_item:

                missing_items.append(curent_plus_one)

                curent_plus_one = curent_plus_one + 1

            index = index + 1  

    return missing_items