text:
<file_sep>#Bài 94: Viết chương trình in ra tất cả các số lẻ nhỏ hơn 100 trừ các số 5, 7, 93

def odd_integer_less_than_100():
    list_odd_integer=[]
    for i in range(1,100,2):
        if i == 5 or i==7 or i==93:
            continue
        list_odd_integer.append(i)
    return list_odd_integer
if __name__ == '__main__':
    print(odd_integer_less_than_100())

<file_sep>#Bài 92: Tìm ước số chung lớn nhất của 2 số nguyên dương
def checkNumberInteger(Num):
    if Num.isdigit() == False or float(Num).is_integer() == False or int(Num) <= 0:
        return False
    else:
        return True
def greatestCommonDivisor(Num1 ,Num2):
    if Num1 > Num2:
        smallNumber = Num2
    else:
        smallNumber = Num1
    for i in range(smallNumber, 1, -1):
        if Num1 % i ==0 and Num2 % i ==0:
            return i
            break

if __name__ == '__main__':
    NumberFirst = (input("Nhập số thứ nhất "))
    while checkNumberInteger(NumberFirst) == False:
        NumberFirst = (input("Nhập lại số thứ nhất "))
    NumberSecond = (input("Nhập số thứ hai "))
    while checkNumberInteger(NumberFirst) == False:
        NumberFirst = (input("Nhập lại số thứ hai "))
    print("Ước chung lớn nhất của 2 số là " + str(greatestCommonDivisor(int(NumberFirst),int(NumberSecond))))

<file_sep>#Bài 93: Viết chương trình kiểm tra 1 số có phải là số nguyên tố hay không
def is_number(value):
    return value.isdigit() and float(value).is_integer() and int(value) > 0

def checkPrimeNumber(Number):
    if float(Number).is_integer() == False or int(Number) <= 0:
        return "Đây không phải là số nguyên tố"
    else:
        for i in range(2,Number):
            if Number % i == 0:
                return "Đây không phải là số nguyên tố"
        return "Đây là số nguyên tố"

if __name__ == '__main__':
    number = input("Nhập N ")

    while not is_number(number):
        number = input("Nhập lại N ")

    print(str(checkPrimeNumber(int(number))))<file_sep># Bài 479: Hãy khai báo kiểu dữ liệu biểu diễn khái niệm đơn thức P(x) = ax^n trong toán học và
# định nghĩa và định nghĩa hàm nhập, hàm xuất cho kiểu dữ liệu này

import mangsonguyen as sn

class monomial():
    def __init__(self,a,n):
        self.a = a
        self.n = n
    def set_a(self,a):
        self.a = a
    def set_n(self,n):
        self.n = n
    def get_a(self):
        return self.a
    def get_n(self):
        return self.n
    def __str__(self):
        return "{}x^{}".format(self.a,self.n)

# Bài 486: Tính tích 2 đơn thức
    def caculate_the_product_of_two_monomials(self,other):
        z = self.a * other.a
        x = self.n + other.n
        p = monomial(z,x)
        return p
# Bài 487: Tính đạo hàm cấp 1 đơn thức
    def calculate_the_derivative_of_the_unilateral_level(self):
        z = self.a * self.n
        x = self.n - 1
        p = monomial(z, x)
        return p
# Bài 488: Tính thương 2 đơn thức
    def calculate_the_quotient_of_two_monomials(self,other):
        z = self.a / other.a
        x = self.n - other.n
        p = monomial(z, x)
        return p
# Bài 489: Tính đạo hàm cấp k đơn thức
    def caculate_monomial_k_level_derivatives(self,k):
        p = monomial(self.a,self.n)
        while k > 0:
            p = p.calculate_the_derivative_of_the_unilateral_level()
            k -= 1
        return p
# Bài 490: Tính giá trị đơn thức tại vị trí x=x0
    def caculate_the_monomial_value_at_position_x(self,x):
        return self.a * (x ** self.n)
# Bài 491: Định nghĩa toán tử (operator *) cho 2 đơn thức
    def __mul__(self,other):
        z = self.a * other.a
        x = self.n + other.n
        p = monomial(z, x)
        return p
# Bài 492: Định nghĩa toán tử (operator /) cho 2 đơn thức
    def __truediv__(self,other):
        z = self.a / other.a
        x = self.n - other.n
        p = monomial(z, x)
        return p

#Hàm tạo đơn thức
def create_monomial():
    a = input("Nhập a")
    while sn.is_integer(a) == False:
        a = input("Nhập lại a")
    n = input("Nhập n")
    while sn.is_integer(n) == False:
        n = input("Nhập lại n")
    p = monomial(int(a),int(n))
    return p
def print_monomial(numerator,denominator):
    print("{}/{}".format(numerator,denominator))

a = create_monomial()
b = create_monomial()
print((a * b).__str__())

<file_sep>#Bài 478: Hãy khai báo kiểu dữ liệu biểu diễn khái niệm điểm trong không gian Oxyz và định nghĩa hàm nhập, hàm xuất cho kiểu dữ liệu này

import mangsothuc as st

class Coordinates():
    def __init__(self,x,y,z):
        self.x = x
        self.y = y
        self.z = z
    def set_x(self,x):
        self.x = x
    def set_y(self,y):
        self.y = y
    def set_z(self, z):
        self.z = z
    def get_x(self):
        return self.x
    def get_y(self):
        return self.y
    def get_z(self):
        return self.z
    def __str__(self):
        return "({},{},{})".format(self.x,self.y,self.z)

def create_coordinates():
    x = input("Nhập x")
    while st.is_float(x) == False:
        x = input("Nhập lại x")
    y = input("Nhập y")
    while st.is_float(y) == False :
        y = input("Nhập lại y")
    z = input("Nhập z")
    while st.is_float(z) == False:
        z = input("Nhập lại z")
    p = Coordinates(x,y,z)
    return p
def print_coordinates(x,y,z):
    print("({},{},{})".format(x,y,z))<file_sep>input = "D:\BaiTap\Bai.Tap\\7o7.py\nD:\BaiTap\iTap\\7i9.cpp\nC:\BaiTap\\78.qt\nD:\BaiTap\\69.bat"
print(input)

fileName = []   #List tên file sau khi tách

listPath = input.splitlines()    #Tách chuỗi ký tự từ \n
for i in listPath:
    indexLastDot = i.rfind('.')     #Tìm dấu chấm cuối cùng ở chuỗi
    indexLastBackSlash = i.rfind('\\') +1      #Tìm vị trí ký tự  sau dấu xẹt trái
    fileName.append(i[indexLastBackSlash:indexLastDot])        #Add Tên file vào List
print(fileName)

# for i in str:
#     if "." and "," in i:
#         num = i.split(".")
#         numfile.append(num[0])
# print(numfile)
<file_sep>#Bài 101: Viết chương trình nhập tháng, năm. Hãy cho biết tháng đó có bao nhiêu ngày

#Hàm kiểm tra tháng hợp lệ
def is_month(value):
    return value.isdigit() and 1<=int(value)<=12

#Hàm kiểm tra năm hợp lệ
def is_year(value):
    return  value.isdigit() and 1<= int(value)

def days_of_month(month,year):

    #Tháng 2 năm nhuận có 29 ngày
    if month==2 and year %4==0:
        return 29

    #Tháng 2 năm ko nhuận có 28 ngày
    elif month==2 and year %4 != 0:
        return 28

    #Tháng 4,6,9,11 có 30 ngày
    elif month==4 or month==6 or month==9 or month==11:
        return 30

    #Các tháng còn lại có 31 ngày
    else:
        return 31
if __name__ == '__main__':

    #Nhập tháng năm
    month = input("Nhập tháng ")
    while not is_month(month):
        month= input("Nhập lại tháng ")

    year = input("Nhập năm ")
    while not is_year(year):
        year = input("Nhập lại năm ")

    #Tìm kết quả
    result = days_of_month(int(month),int(year))
    print("Số ngày trong tháng đó là " + str(result))
<file_sep># Bài 483: Hãy khai báo kiểu dữ liệu biểu diễn khái niệm đường tròn trong mặt phẳng Oxy và
# định nghĩa hàm nhập, hàm xuất cho kiểu dữ liệu này
# Bài 484: Viết chương trình nhập tọa độ tâm và bán kính của 1 đường tròn trong mặt phẳng Oxy.
# Tính diện tích và chu vi của nó và xuất ra kết quả

import mangsothuc as st
class circle():
    def __init__(self,a,b,r):
        self.a = a
        self.b = b
        self.r = r

    def set_a(self, a):
        self.a = a

    def set_b(self, b):
        self.b = b

    def set_r(self, r):
        self.r = r

    def get_a(self):
        return self.a

    def get_b(self):
        return self.b

    def get_r(self):
        return self.r

    def __str__(self):
        return "(x - {})^2 + (y - {})^2 = {}^2".format(self.a, self.b, self.r)

    def calculate_the_area_of_the_circle(self):
        return self.r * self.r * 3.14

    def calculate_the_circumference_of_the_circle(self):
        return 2 * self.r * 3.14
def create_circle():
    a = input("Nhập a")
    while st.is_float(a) == False:
        a = input("Nhập lại a")
    b = input("Nhập b")
    while st.is_float(b) == False:
        b = input("Nhập lại b")
    r = input("Nhập bán kính")
    while st.is_float(r) == False or float(r) <=  0:
        r = input("Nhập lại bán kính")
    p = circle(a,b,r)
    return p

a= create_circle()
print(a.__str__())<file_sep>#Bài 102: Viết chương trình nhập vào 1 ngày ( ngày, tháng, năm). Tìm ngày kế ngày vừa nhập (ngày, tháng, năm)

#Kiểm tra ngày hợp lệ
def is_day_in_month(day, month, year):
    if month == 4 or month == 6 or month == 9 or month == 11:
        return day.isdigit() and 1 <= int(day) and  int(day)<= 30
    elif month == 2 and year % 4 == 0:
         return day.isdigit() and 1 <= int(day) and int(day) <= 29
    elif month == 2 and year % 4 != 0:
        return day.isdigit() and 1 <= int(day) and int(day) <= 28
    else:
        return day.isdigit() and 1 <= int(day) and int(day) <= 31

#Hàm kiểm tra tháng hợp lệ
def is_month(value):
    return value.isdigit() and 1 <= int(value) <= 12

#Hàm kiểm tra năm hợp lệ
def is_year(value):
    return  value.isdigit() and 1<= int(value)

#Hàm tính ngày kế tiếp của ngày vừa nhập
def find_next_day(day, month, year):

    if day == 30 and (month==4 or month==6 or month==9 or month==11):
        return "Ngày kế tiếp là ngày 1/"+ str(month+1) + "/" +str(year)

    elif day == 31 and month == 12:
        return "Ngày kế tiếp là ngày 1/1/"+ str(year+1)

    elif day == 29 and month==2 and year % 4 == 0:
        return "Ngày kế tiếp là ngày 1/3/" + str(year)

    elif day == 28 and month==2 and year % 4 != 0:
        return "Ngày kế tiếp là ngày 1/3/" + str(year)

    elif day==31 and (month==1 or month==3 or month==5 or month==7 or month==8 or month==10):
        return "Ngày kế tiếp là ngày 1/" + str(month + 1) + "/" + str(year)
    else:
        return "Ngày kế tiếp là ngày " + str(day+1)+"/" +str(month) + "/" +str(year)

if __name__ == '__main__':

    # Nhập ngày tháng năm
    day = input("Nhập ngày ")

    month = input("Nhập tháng ")
    while not is_month(month):
        month = input("Nhập lại tháng ")

    year = input("Nhập năm ")
    while not is_year(year):
        year = input("Nhập lại năm ")

    while not is_day_in_month(day, month, year):
        day = input("Nhập lại ngày hợp lệ")

    result = find_next_day(int(day), int(month),int(year))
    print(result)

<file_sep>#Bài 100: Viết chương trình giải phương trình bậc 2

import math

#Kiểm tra giá trị có phải là số thực hay ko
def is_real_number(value):
    return value.isalpha() == False

#Hàm giải phương trình bậc 2
def solve_quadratic_equations(a, b, c):

    # ax^2 + bx +c =0
    if a == 0:
        # bx+c=0
        if b != 0:
            return "Phương trình có 1 nghiệm là "+str(-c/b)
        else:
            #c=0
            if c != 0 :
                return "Phương trình vô nghiệm"
            else:
                return "Phương trình vô số nghiệm"
    else:
        #Tính delta
        delta = b ** 2 - 4*a*c

        # Nếu delta <0  thì vô nghiệm
        if delta < 0:
            return "Phương trình vô nghiệm"

        # Nếu delta = 0  thì nghiệm kép
        elif delta == 0:
            return "Phương trình có nghiệm kép là " + str(-b/2*a)

        # Nếu delta > 0  thì 2 nghiệm phân biệt
        else:
            return "Phương trình có 2 nghiệm phân biệt là "+ str(-b + math.sqrt(delta)/ 2*a)+"," +str((-b - math.sqrt(delta))/ 2*a)

if __name__ == '__main__':
    a = input("Nhập a ")
    while not is_real_number(a):
        a = input("Nhập lại a")

    b = input("Nhập b")
    while not is_real_number(b):
        b = input("Nhập lại b")

    c = input("Nhập c")
    while not is_real_number(c):
        c = input("Nhập lại c")

    #Tìm kết quả
    result =solve_quadratic_equations(float(a),float(b),float(c))
    print(result)

<file_sep># Bài 117: Viết chương trình nhập n và tính tổng S(n) = x + x^2 + x^3 + … + x^n

def is_number(value):
    return value.isdigit() and float(value).is_integer() and int(value) > 0

# Tính hàm S(n) = x + x^2 + x^3 + … + x^n
def caculate_sum( target_number , x):
    #Gắn tống bằng biến sum
    Sum = 0

    #Dùng vòng lặp để tính tổng
    for i in range(1,target_number+1):

        #Lần lượt lấy x^i để cộng vào tổng, i đi từ 1 đến n
        Sum = Sum + x**i

    #Trả vể tổng sau khi thực hiện xong vòng lặp
    return Sum

if __name__ == '__main__':

    #Nhập giá trị
    n = input("Nhập n ")
    while not is_number(n):
        n = input("Nhập lại n ")

    x = input("Nhập x ")
    while not is_number(x):
        x = input("Nhập lại x ")

    #Dùng hàm để tính tổng
    result = caculate_sum(int(n), int(x))
    print("Kết quả là " +str(result))<file_sep>n=int(input("Nhap N="))
list=[]
for i in range(2,n):
    if n%i == 0:
        list.append(i)
print(list)<file_sep>a=int(input("Nhap thang="))
while a>12:
    a= int(input("nhap lai thang hop le"))
if a==12 or a==9 or a==6 or a==3:
    quy=a//3
else:
    quy=a//3+1
print("Quy cua thang do la", quy)<file_sep>#Bài 103: Viết chương trình nhập vào 1 ngày ( ngày, tháng, năm). Tìm ngày trước ngày vừa nhập (ngày, tháng, năm)

#Kiểm tra ngày hợp lệ
def is_day_in_month(day, month, year):
    if month == 4 or month == 6 or month == 9 or month == 11:
        return day.isdigit() and 1 <= int(day) and  int(day)<= 30
    elif month == 2 and year % 4 == 0:
         return day.isdigit() and 1 <= int(day) and int(day) <= 29
    elif month == 2 and year % 4 != 0:
        return day.isdigit() and 1 <= int(day) and int(day) <= 28
    else:
        return day.isdigit() and 1 <= int(day) and int(day) <= 31

#Hàm kiểm tra tháng hợp lệ
def is_month(value):
    return value.isdigit() and 1 <= int(value) <= 12

#Hàm kiểm tra năm hợp lệ
def is_year(value):
    return  value.isdigit() and 1<= int(value)

#Hàm tính ngày kế tiếp của ngày vừa nhập
def find_day_before(day, month, year):

    if day == 1 and (month==5 or month==7 or month==10 or month==12):
        return "Ngày trước đó là ngày 31/"+ str(month - 1) + "/" +str(year)

    elif day == 1 and month == 1:
        return "Ngày trước đó là ngày 31/12/"+ str(year-1)

    elif day == 1 and month==3 and year % 4 == 0:
        return "Ngày trước đó là ngày 29/2/" + str(year)

    elif day == 1 and month==3 and year % 4 != 0:
        return "Ngày trước đó là ngày 28/2/" + str(year)

    elif day==1 and (month==2 or month==4 or month==6 or month==8 or month==9 or month==11):
        return "Ngày trước đó là ngày 31/" + str(month - 1) + "/" + str(year)
    else:
        return "Ngày trước đó là ngày " + str(day-1)+"/" +str(month) + "/" +str(year)

if __name__ == '__main__':

    # Nhập ngày tháng năm
    day = input("Nhập ngày ")

    month = input("Nhập tháng ")
    while not is_month(month):
        month = input("Nhập lại tháng ")

    year = input("Nhập năm ")
    while not is_year(year):
        year = input("Nhập lại năm ")

    while not is_day_in_month(day, month, year):
        day = input("Nhập lại ngày hợp lệ")

    result = find_day_before(int(day), int(month),int(year))
    print(result)<file_sep>a=float(input("nhap a="))
b=float(input("nhap b="))
if (a >=0 and b>=0) or (a<0 and b<0):
    print("cung dau")
else:
    print("khac dau")
<file_sep>#Bài 104: Viết chương trình nhập ngày, tháng, năm. Tính xem ngày đó là ngày thứ bao nhiêu trong năm

#Kiểm tra ngày hợp lệ
def is_day_in_month(day, month, year):
    if month == 4 or month == 6 or month == 9 or month == 11:
        return day.isdigit() and 1 <= int(day) and  int(day)<= 30
    elif month == 2 and year % 4 == 0:
         return day.isdigit() and 1 <= int(day) and int(day) <= 29
    elif month == 2 and year % 4 != 0:
        return day.isdigit() and 1 <= int(day) and int(day) <= 28
    else:
        return day.isdigit() and 1 <= int(day) and int(day) <= 31

#Hàm kiểm tra tháng hợp lệ
def is_month(value):
    return value.isdigit() and 1 <= int(value) <= 12

#Hàm kiểm tra năm hợp lệ
def is_year(value):
    return  value.isdigit() and 1<= int(value)

#Hàm đếm xem ngày đó là ngày bao nhiêu trong năm
def count_day_in_year(day, month, year):
    day_year = 0
    if year %4 == 0:
        day_year = 1
    if month == 1:
        day_year = day
    elif month == 2:
        day_year = 31 + day
    elif month == 3:
        day_year = day_year + 31 + 28 + day
    elif month == 4:
        day_year = day_year + 31 + 28 + 31 + day
    elif month == 5:
        day_year = day_year + 31 + 28 + 31 + 30 +day
    elif month == 6:
        day_year = day_year + 31 + 28 + 31 + 30 + 31 + day
    elif month == 7:
        day_year = day_year + 31 + 28 + 31 + 30 + 31 + 30 + day
    elif month == 8:
        day_year = day_year + 31 + 28 + 31 + 30 + 31 + 30 + 31 + day
    elif month == 9:
        day_year = day_year + 31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + day
    elif month == 10:
        day_year = day_year + 31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + 30 + day
    elif month == 11:
        day_year = day_year + 31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + 30 + 31 + day
    elif month == 12:
        day_year = day_year + 31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + 30 + 31 + 30 + day

    return day_year

if __name__ == '__main__':

    # Nhập ngày tháng năm
    day = input("Nhập ngày ")

    month = input("Nhập tháng ")
    while not is_month(month):
        month = input("Nhập lại tháng ")

    year = input("Nhập năm ")
    while not is_year(year):
        year = input("Nhập lại năm ")

    while not is_day_in_month(day, month, year):
        day = input("Nhập lại ngày hợp lệ")

    result = count_day_in_year(int(day), int(month),int(year))
    print("Đây là ngày thứ "+str(result)+" trong năm")

<file_sep>#Bài 123: Viết hàm tìm 1 vị trí mà giá trị tại vị trí đó là giá trị nhỏ nhất trong mảng 1 chiều các số nguyên

#HÀm kiểm tra đây có phải là số nguyên
def is_integer(value):
    try:
        int(value)
        return True
    except ValueError:
        return False

#Hàm lấy ra giá trị nhỏ nhất trong mảng
def smallest_number_in_list(list):

    #Gắn số nhỏ nhất cho giá trị đầu trong mảng
    smallest_number = list[0]

    #Kiểm tra lần lượt các giá trị trong mảng
    for i in list:

        #Nếu giá trị nào nhỏ hơn giá trí đang đc gán hiện tại
        #Thì chuyển qua gán giá trị đó là giá trị nhỏ nhất
        if i <smallest_number:
            smallest_number = i

    return smallest_number

if __name__ == '__main__':

    list_integet_number = []

    n = input("Tổng số giá trị muốn nhập là ")
    while not is_integer(n):
        print("Lỗi")
        n = input("Tổng số giá trị muốn nhập là ")

    #Dùng vòng lặp để nhập đối tượng vào mảng
    for i in range(int(n)):

        integer_number = input("Nhập phần tử số nguyên thứ "+str(i+1)+" là ")
        #Nếu ko phải là số nguyên thì nhập lại
        while not is_integer(integer_number):
            integer_number = input("Nhập lại phần tử số nguyên thứ " + str(i + 1) + " là ")
        list_integet_number.append(integer_number)

    #Lấy ra kết quả và in ra màn hình
    result = smallest_number_in_list(list_integet_number)
    print("Giá trị nhỏ nhất trong mảng là "+str(result))<file_sep>#Bài 481: Hãy khai báo kiểu dữ liệu biểu diễn ngày trong thế giới thực và
# định nghĩa hàm nhập, hàm xuất cho kiểu dữ liệu này

import mangsonguyen as sn
def is_month(month):
    if 1 <= month <= 12:
        return True
    else:
        return False
def is_day_in_month(day,month,year):
    if year % 4 == 0 and month == 2:
        if 0 <= day <= 29:
            return True
        else:
            return False
    elif year % 4 != 0 and month == 2:
        if 0 <= day <= 28:
            return True
        else:
            return False
    elif month in [1,3,5,7,8,10,12]:
        if 0 <= day <= 31:
            return True
        else:
            return False
    else:
        if 0 <= day <= 30:
            return True
        else:
            return False

class Date():
    def __init__(self,day,month,year):
        self.day = day
        self.month = month
        self.year = year

    def set_day(self,day):
        self.day = day
    def set_month(self,month):
        self.month = month
    def set_year(self,year):
        self.year = year
    def get_day(self):
        return self.day
    def get_month(self):
        return self.month
    def get_year(self):
        return self.year
    def __str__(self):
        return "Ngày {} Tháng {} Năm {}".format(self.day,self.month,self.year)

def input_date():
    day = input("Nhập vào ngày")
    month = input("Nhập vào tháng")
    while sn.is_integer(month) == False or is_month(int(month)) == False:
        day = input("Nhập lại tháng")
    year = input("Nhập vào năm")
    while sn.is_integer(year) == False or int(year) < 0:
        year = input("Nhập lại năm")
    while is_day_in_month(int(day), int(month), int(year)) == False or sn.is_integer(day) == False:
        day = input("Nhập lại ngày")
    p = Date(day,month,year)
    return p
a = input_date()
print(a.__str__())<file_sep>sum=0
for i in range(1,10000):
    sum=sum+i
    if sum>10000:
        print(i)
        break
<file_sep>#Bài 128 + 130: Viết hàm nhập, xuất mảng 1 chiều các số thực

#Hàm kiểm tra đây có phải là số thực
def is_float(value):
    try:
        float(value)
        return True
    except ValueError:
        return False
#Hàm kiểm tra đây có phải là số nguyên
def is_option(value):
    return value.isdigit() and float(value).is_integer() and int(value) >= 0

#Hàm nhập mảng số nguyên
def enter_array_of_real_numbers():

    list_float_numbers = []

    n = input("Tổng số giá trị muốn nhập là ")
    while not is_option(n):
        print("Lỗi")
        n = input("Tổng số giá trị muốn nhập là ")

    #Dùng vòng lặp để nhập đối tượng vào mảng số thực
    for i in range(int(n)):

        real_number = input("Nhập phần tử số thực thứ "+str(i+1)+" là ")
        #Nếu ko phải là số thực thì nhập lại
        while not is_float(real_number):
            real_number = input("Nhập lại phần tử số thực thứ " + str(i + 1) + " là ")
        list_float_numbers.append(float(real_number))

    return list_float_numbers

#Hàm in ra mảng số thực
def print_array_of_real_numbers(list):
    print()
    #Biến đếm thứ tự
    ordinal =1

    for i in list:
        print("Phần tử số thực thứ " + str(ordinal) + " trong mảng là " + str(i))
        ordinal+=1

# Bài 133: Viết hàm liệt kê các vị trí mà giá trị tại đó là giá trị âm trong mảng 1 chiều các số thực
def find_locate_negative_number(list):
    # Biến đếm thứ tự
    ordinal = 0

    list_locate=[]

    for i in list:

        if i < 0:
            #Nếu phần tự nhỏ hơn 0 thì cho vị trí vào list
            list_locate.append(ordinal)
        ordinal += 1

    return list_locate

#Bài 134: Viết hàm tìm giá trị lớn nhất trong mảng 1 chiều các số thực
def find_biggest_real_number(list):
    biggest_number = list[0]

    for i in list:
        if biggest_number<i:
            biggest_number=i
    return biggest_number

#Bài 135: Viết hàm tìm giá trị dương đầu tiên trong mảng 1 chiều các số thực. Nếu mảng không có giá trị dương thì trả về -1
def find_first_positive_numbers_in_list_real_number(list):

    for i in list:
        if i > 0:
            return i
    return -1

#Bài 137: Tìm 1 vị trí mà giá trị tại vị trí đó là giá trị nhỏ nhất trong mảng 1 chiều các số thực
def find_locate_smallest_numbers_in_list_real_number(list):
    i = 1

    ordinal = 0
    smallest_number= list[0]

    while i < len(list) :
        if float(list[i]) < smallest_number:
            smallest_number = float(list[i])
            ordinal = i
        i = i+1
    return ordinal

#Bài 140: Hãy tìm giá trị dương nhỏ nhất trong mảng 1 chiều các số thực. Nếu mảng không có giá trị dương thì sẽ trả về -1
def find_smallest_positive_numbers_in_list_real_number(list):
    smallest_positive_number = -1

    for i in list:
        if (i > 0 and smallest_positive_number <0) or (i < smallest_positive_number and i >0):
            smallest_positive_number=i

    return smallest_positive_number

#Bài 141: Hãy tìm vị trí giá trị dương nhỏ nhất trong mảng 1 chiều các số thực. Nếu mảng không có giá trị dương thì trả về  -1
def find_locate_smallest_positive_numbers_in_list_real_number(list):

    ordinal = -1
    smallest_positive_number = -1
    for i in range(0,len(list)):
        if (list[i] > 0 and smallest_positive_number <0) or (list[i] < smallest_positive_number and list[i] > 0):
            smallest_positive_number = list[i]
            ordinal =i

    return ordinal

#Bài 142: Tìm giá trị nhỏ nhất trong mảng 1 chiều số thực
def find_smallest_numbers_in_list_real_number(list):
    i = 1

    smallest_number= list[0]

    while i < len(list) :
        if list[i] < smallest_number:
            smallest_number = list[i]

        i = i+1
    return smallest_number

#Bài 146: Tìm giá trị âm đầu tiên trong mảng 1 chiều các số thực. Nếu mảng không có giá trị âm thì trả về -1
def find_first_negative_number_in_list_real_number(list):
    i = 0
    while i < len(list) -1 :
        if list[i]<0:
            return list[i]
        i = i + 1
    return -1

#Bài 147: Tìm số dương cuối cùng trong mảng số thực. Nếu mảng không có giá trị dương thì trả về  -1

def find_last_positive_number_in_list_real_number(list):
    i = len(list)-1
    while i >0:
        if list[i] >0:
            return i
        i = i-1
    return -1

#Bài 150: Hãy tìm giá trị âm lớn nhất trong mảng 1 chiều các số thực. Nếu mảng không có giá trị âm thì trả về  -1

def find_smallest_negative_numbers_in_list_real_number(list):
    smallest_negative_numbers = 1
    for i in list:
        if (i < 0 and smallest_negative_numbers> 0) or (i > smallest_negative_numbers and i < 0):
            smallest_negative_numbers = i

    if smallest_negative_numbers == 1:
        smallest_negative_numbers= -1
    return smallest_negative_numbers
#Bài 154: Hãy tìm vị trí giá trị âm nhỏ nhất trong mảng các số thực. Nếu mảng không có số âm thì trả về -1

def find_locate_smallest_negative_numbers_in_list_real_number(list):
    locate = 1
    i = 0
    while i < len(list) - 1:
        if (list[i] < 0 and locate > 0) or (list[i] < smallest_negative_numbers and list[i] < 0):
            smallest_negative_numbers=list[i]
            locate = i
        i = i + 1
    if locate == 1:
        locate = -1
    return locate

#Bài 155: Hãy tìm giá trị trong mảng các số thực xa giá trị x nhất

def find_farthest_real_number(x, list):

    #Biến khoảng cách xa nhất
    farthest_range = 0

    #Gắn giá trị đầu tiên trong mảng là giá trị xa nhất
    real_number_farthest = list[0]

    for i in list:
        # Tính khoảng cách
        range_x_vs_element = abs(x-i)
        if range_x_vs_element > farthest_range or farthest_range == 0:
            farthest_range = range_x_vs_element
            real_number_farthest = i

    return real_number_farthest

#Bài 156: Hãy tìm giá trị trong mảng các số thực gần giá trị x nhất

def find_nearest_real_number(x, list):

    #Biến khoảng cách xa nhất
    nearest_range = 0

    #Gắn giá trị đầu tiên trong mảng là giá trị xa nhất
    real_number_nearest = list[0]

    for i in list:
        range_x_vs_element = abs(i - x)

        #So sánh khoảng cách vừa đo với khoảng cách hiện tại
        if range_x_vs_element < nearest_range or nearest_range == 0:
            nearest_range = range_x_vs_element
            real_number_nearest = i

    return real_number_nearest

#Bài 157: Cho mảng 1 chiều các số thực, hãy tìm đoạn [a, b] sao cho đoạn này chứa tất cả các giá trị trong mảng

def find_range_min_real_number_max_real_number(list):
    min_number = list[0]
    max_number = list[0]
    for i in list:
        if min_number > i:
            min_number = i
        if max_number <i :
            max_number = i

    return "["+str(min_number)+","+str(max_number)+"]"

#Bài 158: Cho mảng 1 chiều các số thực, hãy tìm giá trị x sao cho đoạn [-x, x] chứa tất cả các giá trị trong mảng

def find_space_contain_all_value_in_list(list):

    highest_number = abs(list[0])

    for i in list:
        if abs(i) > highest_number:
            highest_number = abs(i)

    return "[-" + str(highest_number) + "," + str(highest_number) + "]"

#Bài 159: Cho mảng 1 chiều các số thực, hãy tìm giá trị đầu tiên lớn hơn giá trị 2003. Nếu mảng không có giá trị thỏa điều kiện trên thì trả về  -1

def find_first_real_number_bigger_2003(list):
    for i in list:
        if i >2003:
            return i
    return -1

#Bài 160: Cho mảng 1 chiều các số thực, hãy tìm giá trị âm cuối cùng lớn hơn giá trị -1. Nếu mảng không có giá trị thỏa điều kiện trên thì trả về -1

def find_last_real_number_smaller(list):

    for i in range(len(list)-1,-1,-1):
        if list[i] < 0 and list[i] > -1:
            return list[i]
    return -1

#Bài 162: Cho mảng 1 chiều các số thực. Hãy viết hàm tìm một vị trí trong mảng thỏa 2 điều kiện: có 2 giá trị lân cận và giá trị tại đó bằng tích 2 giá trị lân cận.
# Nếu mảng không tồn tại giá trị như vậy thì trả về giá trị -1

def find_real_number_by_product(list):

    for i in range(1, len(list)-1):
        if list[i] == (list[i - 1] * list[i + 1]):
            return list[i]
    return -1

#Bài 174 (*): Cho mảng số thực có nhiều hơn 2 giá trị và các giá trị trong mảng khác nhau từng đôi một.
# Hãy viết hàm liệt kê tất cả các cặp giá trị (a, b) trong mảng thỏa điều kiện a <= b

def finds_all_pairs_of_values_in_list(list):
    for i in list:
        for t in list:
            if i <= t:
                print("["+str(i)+","+str(t)+"]")

#Bài 175 (*): Cho mảng số thực có nhiều hơn 2 giá trị và các giá trị trong mảng khác nhau từng đôi một. Hãy viết hàm tìm 2 giá trị gần nhau nhất trong mảng
# (Lưu ý: Mảng có các giá trị khác nhau từng đôi một còn có tên là mảng phân biệt)

def find_space_shortest_in_list_real_number(list):
    space_shortest = 0
    location_space_shortest_first = list[0]
    location_space_shortest_second = list[1]
    for x in list:
        for i in list:
            if x == i:
                continue
            range_x_vs_i = abs(i - x)

            # So sánh khoảng cách vừa đo với khoảng cách hiện tại
            if range_x_vs_i < space_shortest or space_shortest == 0:
                space_shortest = range_x_vs_i
                location_space_shortest_first = i
                location_space_shortest_second = x
                if i > x:
                    location_space_shortest_first = x
                    location_space_shortest_second = i

    return "Khoảng cách ngắn nhất là ["+str(location_space_shortest_first)+","+str(location_space_shortest_second)+"]"

#Bài 176: Hãy liệt kê các số âm trong mảng 1 chiều các số thực

def find_all_odd_number_in_list_real_number(list):
    list_odd_number = []
    for i in list:
        if i < 0:
            list_odd_number.append(i)
    return list_odd_number

#Bài 177: Hãy liệt kê các số trong mảng 1 chiều các số thực thuộc đoạn [x, y] cho trước

def find_all_number_in_space_in_list_real_number(x, y,list):
    list_number = []
    for i in list:
        if i <= y and i >= x:
            list_number.append(i)
    return list_number

#Bài 182: Cho mảng 1 chiều các số thực. Hãy viếth hàm liệt kê tất cả các giá trị trong mảng có ít nhất 1 lận cận trái dấu với nó
    number_list = []
    for i in range(1, len(list) - 1):
        if (list[i] >= 0 and (list[i - 1] < 0 or list[i + 1] < 0)) or (list[i] < 0 and (list[i - 1] >= 0 or list[i + 1] >= 0)):
            number_list.append(list[i])
    return number_list

#Bài 182: Cho mảng 1 chiều các số thực. Hãy viết hàm liệt kê tất cả các giá trị trong mảng có ít nhất 1 lận cận trái dấu với nó

def find_all_real_number_at_least_one_diacritic_with_it(list):

    number_list = []
    for i in range(1, len(list) - 1):
        if (list[i] >= 0 and (list[i - 1] < 0 or list[i + 1] < 0)) or (list[i] < 0 and (list[i - 1] >= 0 or list[i + 1] >= 0)):
            number_list.append(list[i])
    return number_list

#Bài 183: Hãy liệt kê các vị trí mà giá trị tại đó là giá trị tại đó là giá trị lớn nhất trong mảng 1 chiều các số thực

def def_all_locate_biggest_real_number_in_real_number_list(list):
    locate_number_list = []

    for i in range(0, len(list)):
        if list[i] > find_biggest_real_number():
            locate_max = i
            locate_number_list.append(i)
    return locate_number_list
#Bài 186: Hãy liệt kê các vị trí trong mảng 1 chiều các số thực mà giá trị tại đó bằng giá trị âm đầu tiên trong mảng

def def_all_locate_negative_real_number_in_real_number_list(list):
    locate_number_list = []

    for i in range(0, len(list)):

        if list[i] == find_first_negative_number_in_list_real_number(list):
            locate_number_list.append(i)

    return locate_number_list

#Bài 187: Hãy liệt kê các vị trí mà giá trị tại các vị trí đó bằng giá trị dương nhỏ nhất trong mảng 1 chiều các số thực
def find_all_locate_smallest_positive_in_list(list):
    locate_number_list = []

    for i in range(0, len(list)):

        if list[i] == find_smallest_positive_numbers_in_list_real_number(list):
            locate_number_list.append(i)

    return locate_number_list

#Bài 191: Hãy liệt kê các giá trị cực đại trong mảng 1 chiều các số thực. Một phần tử được gọi là cực đại khi lớn hơn các phần tử lân cận

def find_all_maximum_values_in_real_number_array(list):
    number_list = []
    for i in range(1, len(list) - 1):
        if list[i - 1] < list[i] and list[i + 1] < list[i]:
            number_list.append(list[i])
    return number_list

#Bài 198: Hãy liệt kê các vị trí mà giá trị tại đó là giá trị lớn nhất trong mảng 1 chiều các số thực

def find_positions_where_the_value_is_the_maximum(list):
    list_locate_maximum_number = []
    for i in range(0,len(list)):
        if find_biggest_real_number(list) == list[i]:
            list_locate_maximum_number.append(list[i])

    return list_locate_maximum_number

#Bài 201: Tính tổng các giá trị dương trong mảng 1 chiều các số thực

def caculate_sum_positive_number_in_list(list):
    sum_list = 0
    for i in list:
        if i >= 0:
            sum += i
    return sum_list

#Bài 204: Tính tổng các giá trị lớn hơn giá trị đứng liền trước nó trong mảng 1 chiều các số thực

def caculate_sum_number_greater_value_that_precedes_it(list):
    sum_list = 0
    for i in range(1, len(list)):
        if list[i - 1] < list[i] :
            sum_list += list[i]
    return sum_list

#Bài 205: Tính tổng các giá trị lớn hơn trị tuyệt đối của giá trị đứng liền sau nó trong mảng 1 chiều các số thực

def caculate_sum_values_greater_abs_of_value_after_it(list):
    sum_list = 0
    for i in range(0, len(list) - 1):
        if abs(list[i + 1]) < list[i]:
            sum_list += list[i]
    return sum_list

#Bài 206: Tính tổng các giá trị lớn hơn các giá trị xung quanh trong mảng 1 chiều các số thực
# Lưu ý: Một giá trị trong mảng có tối đa 2 giá trị xung quang

def caculate_sum_values_greater_than_the_surrounding_values_in_real_number_array(list):
    sum_list = 0
    for i in range(1, len(list) - 1):
        if list[i - 1] < list[i] and list[i + 1] < list[i]:
            sum_list += list[i]
        return sum_list

#Bài 207: Tính tổng các phần tử “cực trị” trong mảng. Một phần tử được gọi là cực trị khi
# nó lớn hơn hoặc nhỏ hơn các phần tử xung quanh nó

def sum_the_extreme_elements_in_list(list):
    sum_list = 0
    for i in range(1, len(list) - 1):
        if (list[i - 1] < list[i] and list[i + 1] < list[i]) or (list[i - 1] > list[i] and list[i + 1] > list[i]):
            sum_list += list[i]
        return sum_list

#Bài 212: Tính trung bình cộng các số dương trong mảng 1 chiều các số thực

def average_the_positive_numbers_in_list(list):
    sum_positive_numbers = 0
    count_positive_numbers = 0
    for i in list:
        if i > 0:
            sum_positive_numbers += i
            count_positive_numbers += 1

    if sum_positive_numbers == 0:
        return 0
    return sum_positive_numbers / count_positive_numbers

#Bài 213: Tính trung bình cộng các giá trị lớn hơn giá trị x trong mảng 1 chiều các số thực

def average_values_greater_than_x_in_list(x, list):
    sum_numbers_greater_than_x = 0
    count_numbers_greater_than_x = 0

    for i in list:
        if i > x:
            sum_numbers_greater_than_x += i
            count_numbers_greater_than_x += 1
    if count_numbers_greater_than_x == 0:
        return 0

    return sum_numbers_greater_than_x / count_numbers_greater_than_x

#Bài 214: Tính trung bình nhân các giá trị dương có trong mảng 1 chiều các số thực

def average_multiplies_positive_values(list):
    multiplies_positive_values = 1
    count_positive_values = 0
    for i in list:
        if i > 0:
            multiplies_positive_values = multiplies_positive_values * i
            count_positive_values += 1
    if count_positive_values == 0:
        return 0

    return multiplies_positive_values**(1/count_positive_values)

#Bài 215 (*): Tính khoảng các trung bình giữa các giá trị trong mảng

def calculate_the_average_distance_between_the_values(list):
    sum_the_average_distance_between_the_values = 0
    count_the_average_distance__between_the_values = 0
    for i in range(0,len(list)):
        for t in range(0,len(list)):
            if i != t :
                sum_the_average_distance_between_the_values += abs(list[i] - list[t])
                count_the_average_distance__between_the_values += 1
    if count_the_average_distance__between_the_values == 0:
        return 0
    print(count_the_average_distance__between_the_values)
    print(sum_the_average_distance_between_the_values)
    return sum_the_average_distance_between_the_values / count_the_average_distance__between_the_values

#Bài 272: Hãy xóa tất cả số lớn nhất trong mảng các số thực
def delete_eletments_with_list_index(list_index, list):
    for i in list_index:
        list.pop(i)
    return list

def delete_all_the_largest_numbers_in_the_array_of_real_numbers(list):
    a = len(list)
    i = 0
    while i <= a:

        if list[i] == find_biggest_real_number(list):
            list.pop(i)
            a -= 1
        i += 1

    return list

#Bài 292: Biến đổi mảng số thực bằng cách thay tất cả phần tử trong mảng bằng số nguyên gần nó nhất (giống làm tròn)

def rounds_the_elements_in_the_array_of_real_numbers(list):

    for i in range(0, len(list)):
        list[i] = int(list[i])

    return list

#
if __name__ == '__main__':

    #Dùng hàm nhập
    result = enter_array_of_real_numbers()
    a = calculate_the_average_distance_between_the_values(result)

    print(a)

<file_sep>#Bài 109: Viết chương trình in bảng cửu chương ra màn hình

#Hàm in ra bảng cửu chương
def multiplication_table():
    for i in range(1,10):
        for t in range(1,10):
            print(str(i) +" * "+str(t)+" = " +str(i*t))
        print("")

if __name__ == '__main__':

    #in ra bảng cửu chương
    multiplication_table()<file_sep>n=int(input("Nhap N="))
a=1
sumN=0
while n>0:

    if n // a == 0:
        break
    sumN = sumN + 1
    a=a*10
print(sumN)<file_sep>#Bài 111: Viết chương trình in ra tam giác cân có độ cao h

#Kiểm tra lựa chọn
def is_option(value):
    return value.isdigit() and float(value).is_integer() and 1 <= int(value) <= 4

#Kiểm tra chiều cao
def is_height(value):
    return value.isdigit() and float(value).is_integer() and 1<= int(value)

#Hàm vẽ tam giác cân đặc
def triangle_solid(height):

    #Tạo chiều cao của tam giác
    for row in  range(0, height):

        # Tạo khoảng trống ở trước nếu số đầu tiên có height - row - 2 ô trống
        # Nếu row càng nhiều thì sẽ có ít " "
        # - 2 để chỗ cho dòng "*" và " "
        for i in range(0,height - row - 1):
            print(end=" ")

        #In ra số * bằng đúng với row đang nhận ở từng dòng
        # Nếu row bằng 1 thì in ra 1 ngôi sao, nếu == 2 thì in ra 2 ngôi sao
        for i in range(0, row +1 ):
            print("*" ,end=" ")

        #Xuống dòng
        print()

#Hàm vẽ tam giác cân rỗng
def triangle_hollow(height):

    #Tạo chiều cao của tam giác
    for row in  range(1, height+1):

        # Tạo khoảng trống ở trước nếu số đầu tiên có height - row - 2 ô trống
        # Nếu row càng nhiều thì sẽ có ít " "
        # - 2 để chỗ cho dòng "*" và " "
        for i in range(1,height*2):

            # 3 điều kiển để in ra "*"
            # 1. Luôn Luôn in ra ngôi sao ở dòng cuối cùng(Cạnh đáy)
            # 2. Tổng dòng và cột để in ra "*"  luôn bằng tổng số hàng cộng với 1(Cạnh trước)
            # Ví dụ nếu có 4 hàng thì vị trí in đầu tiên sẽ là vị trí 4 và dòng đâu tiên
            # còn dòng thứ 2 sẽ là vị trí thứ 3
            # 3. Đây là điều kiện để vẽ cạnh đối diện (cạnh sau)
            # Cạnh sau có vị trí đối diện cạnh trước
            # nên vị cạnh sau trừ cho dòng hiện tại sẽ luôn bằng tổng số dòng trừ đi một
            # bởi đỉnh ko có cạnh đối diện
            if row == height or row + i == height + 1 or i - row == height -1:
                print( "*",end="")
            else:
                print(end=" ")

        #Xuống dòng
        print()

#Hàm vẽ tam giác vuông cân rỗng
def triangle_right_angle_hollow(height):

    #Xác định số ra dòng
    for row in range(height):
        # in ra độ dài cạnh dưới bằng cạnh ngang
        for col in range(height):

            # Luôn in ra ngôi sao ở hàng đầu tiên
            # Luôn in ra ở hàng cuối cùng
            # Cạnh cuối luôn có vị trí cột và hàng bằng nha
            if col == 0 or row == (height - 1) or row == col:
                print("*", end="  ")

            #Nếu ko thì in ra khoảng trắng
            else:
                print(end="   ")

        #Xuống dòng
        print()

#Hàm vẽ tam giác vuông cân đặc
def triangle_right_angle_solid(height):

    # Xác định số dòng
    for row in range(height):

        #Xác định sô cột bằng dòng để vuông cân tam giác
        for col in range(row):

            #Dòng thứ bao nhiêu thì in ra bấy nhiêu ngôi sao
            print("* ",end= " ")
        print()

if __name__ == '__main__':
    print("1. Vẽ hình tam giác cân đặc\n"
          "2. Vẽ hình tam giác cân rỗng\n"
          "3. Vẽ Tam giác  vuông cân đặc\n"
          "4. Vẽ Tam giác  vuông cân rỗng")

    option = input("Nhập lựa chọn")

    while not is_option(option):
        option = input("Nhập lựa chọn hợp lệ: ")

    height = input("Nhập chiều cao")

    while not is_height(height):
        height = input("Nhập lại chiều cao: ")
    if int(option) == 1:
        triangle_solid(int(height))
    elif int(option) == 2:
        triangle_hollow(int(height))
    elif int(option) == 3:
        triangle_right_angle_solid(int(height))
    else:
        triangle_right_angle_hollow(int(height))<file_sep>#Bài 91: In tất cả các số nguyên dương lẻ nhỏ hơn 100

def ListOddPositiveIntegers():
    OddPositiveIntegers = []
    for i in range(1,100,2):
        OddPositiveIntegers.append(i)
    return OddPositiveIntegers

if __name__ == '__main__':

    print("Các số nguyên lẻ nhỏ hơn 100 là " + str(ListOddPositiveIntegers()))

<file_sep>#Bài 90: Viết chương trình tìm số nguyên dương m lớn nhất sao cho 1 + 2 + … + m < N

def FindLargestInteger(Number):
    Sum = 0
    integerNumber = 0

    while Sum<Number:
        integerNumber = integerNumber + 1
        Sum = Sum + integerNumber
    return integerNumber

if __name__ == '__main__':
    n = input("Nhập N ")

    while n.isdigit() == False or float(n).is_integer() == False or int(n) <=0:
        n = input("Nhập lại N ")

    print("Số nguyên dương lớn nhất trong tổng các số nhỏ hơn N là " + str(FindLargestInteger(int(n))))<file_sep>#Bài 95: Viết chương trình nhập 3 số thực. Hãy thay tất cả các số âm bằng trị tuyệt đối của nó

#Kiểm tra xem đây là số thực hay ko
def is_real_number(value):
    return value.isalpha() == False

#Kiểm tra xem số này có phải là số âm
def is_negative_number(target_number):
    return target_number < 0

def absolute_value_number(target_number):

    # Hàm trả abs trả về giá trị tuyệt đố của một số
    return abs(target_number)

if __name__ == '__main__':
    list_real_number= []

    #Nhập vào một số thực nếu giá trị nhập vào ko phải là số thì nhập lại
    first_number = input("Nhập số thực đầu tiên")
    while not is_real_number(first_number):
        first_number = input("Nhập lại số thực đầu tiên")

    second_number = input("Nhập số thực thứ 2")
    while not is_real_number(second_number):
        second_number = input("Nhập lại số thực thứ 2")

    third_number = input("Nhập số thực thứ 3")
    while not is_real_number(third_number):
        third_number = input("Nhập lại số thực thứ 3")

    #Gom các số thực vào một mảng
    list_real_number.append(float(first_number))
    list_real_number.append(float(second_number))
    list_real_number.append(float(third_number))

    for i in range(0,len(list_real_number)):

        # Nếu giá trị của phần tử trong mảng nhỏ hơn 0 thì chuyển đổi giá trị đó thành giá trị tuyệt đối
        if is_negative_number(list_real_number[i]):
             list_real_number[i] = absolute_value_number(list_real_number[i])

    print(list_real_number)

<file_sep>a=float(input("Nhap a"))
b=float(input("Nhap b"))
c=float(input("Nhap c"))
if a>=b:
    if a>=c:
        print(a)
    else:
        print(c)
elif b>=a:
    if b>=c:
        print(b)
    else:
        print(c)

<file_sep>#Bài 124: Viết hàm kiểm tra trong mảng các số nguyên có tồn tại giá trị chẵn nhỏ hơn 2004 hay không

#HÀm kiểm tra đây có phải là số nguyên
def is_integer(value):
    try:
        int(value)
        return True
    except ValueError:
        return False

#Hàm tìm số chẵn nhỏ hơn 2004 trong mảng
def find_even_number_smaller_2004_in_list(list):

    count_even_number_smaller_2004 =0
    #Kiểm tra lần lượt các giá trị trong mảng
    for i in list:

        #Nếu giá trị chẵn nào nhỏ hơn 2004  thì số lần tăng thêm 1
        if int(i) < 2004 and int(i) % 2 ==0:
            count_even_number_smaller_2004 += 1

    return count_even_number_smaller_2004

if __name__ == '__main__':

    list_integet_number = []

    n = input("Tổng số giá trị muốn nhập là ")
    while not is_integer(n) and int(n) <=0 :
        print("Lỗi")
        n = input("Tổng số giá trị muốn nhập là ")

    #Dùng vòng lặp để nhập đối tượng vào mảng
    for i in range(int(n)):

        integer_number = input("Nhập phần tử số nguyên thứ "+str(i+1)+" là ")
        #Nếu ko phải là số nguyên thì nhập lại
        while not is_integer(integer_number):
            integer_number = input("Nhập lại phần tử số nguyên thứ " + str(i + 1) + " là ")
        list_integet_number.append(integer_number)

    #Lấy ra kết quả và in ra màn hình
    result = find_even_number_smaller_2004_in_list(list_integet_number)
    print("Tổng số giá trị chẵn nhỏ hơn 2004 trong mảng là "+str(result))<file_sep>#Bài 113: Lập chương trình tính sin(x) với độ chính xác 0.00001 theo công thức:
# Sin(x) = x – x^3/3! + x^5/5! + … + (-1)^n . x^2n + 1/(2n + 1)!

#Hàm kiểm tra giá trị có phải là số hay ko
def is_number(value):
    return value.isdigit()  and float(value).is_integer() and int(value) >= 0

# Giải hàm số Sin(x) = x – x^3/3! + x^5/5! + … + (-1)^n . x^2n + 1/(2n + 1)!
def solve_functions_sinx(x , n):
   result = x
   if n != 0:

       #giải lần lượt từ 1 - n
       for i in range(1,n + 1):
            giaithua = 1

            # Tính giai thừ
            for t in range(1,2*i+2):
                giaithua = giaithua * t

            #Giải hàm số (-1)^n . x^(2n + 1)/(2n + 1)!
            result = result + (((-1) ** i ) * (x **(2*i +1)) / int(giaithua))
   return result

if __name__ == '__main__':
    x = input("Nhập x = ")
    while not is_number(x):
        width  = input("Nhập lại x = ")

    n = input("Nhập n = ")
    while not is_number(n):
        n = input("Nhập lại n = ")

    result = solve_functions_sinx(int(x), int(n))
    print("Kết quả là " + str(result))<file_sep>list=[a,b,c,d,e,f,g,h,i,k,j,l,m,n,o,p,q,r,s,t,u,v,x,w,z]
for i in list:
    print(str(i))<file_sep>#Bài 485: Viết chương trình nhập tọa độ 3 đỉnh của 1 tam giác trong mặt phẳng Oxy.
# Tính diện tích, chu vi và tọa độ trọng tâm của tam giác và xuất ra kết quả
import math
import mangsothuc as st

def distance_calculation( xa, ya, xb, yb):
    return math.sqrt((xa - xb) ** 2 + (ya - yb) ** 2)
class triangle():
    def __init__(self,xa,ya,xb,yb,xc,yc):
        self.xa = xa
        self.ya = ya
        self.xb = xb
        self.yb = yb
        self.xc = xc
        self.yc = yc

    def set_xa(self, xa):
        self.xa = xa

    def set_xb(self, xb):
        self.xb = xb

    def set_xc(self, xc):
        self.xc = xc

    def set_ya(self, ya):
        self.ya = ya

    def set_yb(self, yb):
        self.yb = yb

    def set_yc(self, yc):
        self.yc = yc

    def get_xa(self):
        return self.xa

    def get_xb(self):
        return self.xb

    def get_xc(self):
        return self.xc

    def get_ya(self):
        return self.ya

    def get_yb(self):
        return self.yb

    def get_yc(self):
        return self.yc

    def __str__(self):
        return "(({},{}),({},{}),({},{}))".format(self.xa,self.ya,self.xb,self.yb,self.xc,self.yc)

    def calculate_the_area_of_the_triangle(self):
        return 1/2*abs((self.xb-self.xa)*(self.yc -self.ya) - (self.xc - self.xa) *(self.yb -self.ya))

    def calculate_the_circumference_of_the_triangle(self):
        return distance_calculation(self.xa,self.ya,self.xb,self.yb) + distance_calculation(self.xc,self.yc,self.xb,self.yb) + distance_calculation(self.xa,self.ya,self.xc,self.yc)

    def find_the_coordinates_of_the_center_of_the_triangle(self):
        return "({},{})".format((self.xa+self.xb+self.xc)/3, (self.ya+self.yb+self.yc)/3)

def create_triangle_in_plane_Oxy():
    x1 = input("Nhập tọa độ xA")
    while st.is_float(x1) == False:
        x1 = input("Nhập lại tọa độ xA")

    y1 = input("Nhập tọa độ yA")
    while st.is_float(y1) == False:
        y1 = input("Nhập lại tọa độ yA")

    x2 = input("Nhập tọa độ xB")
    while st.is_float(x2) == False:
        x2 = input("Nhập lại tọa độ xB")

    y2 = input("Nhập tọa độ yB")
    while st.is_float(y2) == False:
        y2 = input("Nhập lại tọa độ yB")

    x3 = input("Nhập tọa độ xC")
    while st.is_float(x3) == False:
        x3 = input("Nhập lại tọa độ xC")

    y3 = input("Nhập tọa độ yC")
    while st.is_float(y3) == False:
        y3 = input("Nhập lại tọa độ yC")

    p = triangle(x1,y1,x2,y2,x3,y3)
    return p

a = create_triangle_in_plane_Oxy()
print(a.__str__())<file_sep>#Bài 97: Viết chương trình nhập 3 cạnh của 1 tam giác, cho biết đó là tam giác gì

# Kiểm tra xem đây có phải là số nguyên dương hay ko
def is_number(value):
    return value.isdigit() and float(value).is_integer() and int(value) > 0

# Hàm kiểm tra tam giác
def identify_triangle(first_edge,second_edge,third_edge):

    #Điều kiện tam giác đều
    if first_edge == second_edge and second_edge == third_edge:
        return "Đây là tam giác đều"
    #Điều kiện tam giác cân
    elif first_edge == second_edge or first_edge == third_edge or second_edge == third_edge:
        return "Đây là tam giác cân"
    #Điều kiện tam giác vuông
    elif first_edge**2 == (second_edge **2 +third_edge**2) or second_edge**2 == (first_edge**2+third_edge**2) or third_edge**2 == (first_edge**2+second_edge**2):
        return "Đây là tam giác vuông"
    #Điều kiện tam giác vuông cân
    elif (first_edge**2 == (second_edge **2 +third_edge**2) and second_edge==third_edge) or (second_edge**2 == (first_edge**2+third_edge**2) and first_edge==third_edge) or (third_edge**2 == (first_edge**2+second_edge**2) and first_edge==second_edge):
        return "Đây là tam giác vuông cân"
    else:
        return "Đây là tam giác thường"

if __name__ == '__main__':

    #Nhập giá trị 3 cạnh
    first_edge = input("Nhập độ dài cạnh đầu tiên")
    while not is_number(first_edge):
        first_edge = input("Nhập lại độ dài cạnh đầu tiên")

    second_edge = input("Nhập độ dài cạnh thứ hai")
    while not is_number(second_edge):
        second_edge = input("Nhập độ dài cạnh thứ hai")

    third_edge = input("Nhập độ dài cạnh thứ ba")
    while not is_number(third_edge):
        third_edge = input("Nhập độ dài cạnh thứ ba")

    result = identify_triangle(int(first_edge),int(second_edge),int(third_edge))

    print(result)
<file_sep>#Bài 122: Viết hàm tìm giá trị lớn nhất trong mảng 1 chiều các số thực

#Hàm kiểm tra đây có phải là số thực
def is_float(value):
    try:
        float(value)
        return True
    except ValueError:
        return False
#Hàm kiểm tra đây có phải là số nguyên
def is_option(value):
    try:
        int(value)
        return True
    except ValueError:
        return False

#Hàm lấy ra số lớn nhất trong mảng
def biggest_number_in_list(list):

    #Gắn số lớn nhất cho giá trị đầu trong mảng
    biggest_number = list[0]

    #Kiểm tra lần lượt các giá trị trong mảng
    for i in list:

        #Nếu giá trị nào lớn hơn giá trí đang đc gán hiện tại
        #Thì chuyển qua gán giá trị đó là giá trị lớn nhất
        if i >biggest_number:
            biggest_number = i

    return biggest_number

if __name__ == '__main__':

    list_float_numbers = []

    n = input("Tổng số giá trị muốn nhập là ")
    while not is_option(n):
        print("Lỗi")
        n = input("Tổng số giá trị muốn nhập là ")

    #Dùng vòng lặp để nhập đối tượng vào mảng số thực
    for i in range(int(n)):

        real_number = input("Nhập phần tử số thực thứ "+str(i+1)+" là ")
        #Nếu ko phải là số thực thì nhập lại
        while not is_float(real_number):
            real_number = input("Nhập lại phần tử số thực thứ " + str(i + 1) + " là ")
        list_float_numbers.append(real_number)

    #Lấy ra kết quả và in ra màn hình
    result = biggest_number_in_list(list_float_numbers)
    print("Giá trị lớn nhất trong mảng là "+str(result))

<file_sep># Bài 116: Viết chương trình nhập n và tính tổng S = 1 + 2 + 3 + … + n

#Kiểm tra giá trị nhập vào có phải là số nguyên dương
def is_number(value):
    return value.isdigit() and float(value).is_integer() and int(value) > 0

# Hàm tính tổng S = 1 + 2 + 3 + … + n
def caculate_sum( target_number):
    #Gắn tống bằng biến sum
    Sum = 0

    #Dùng vòng lặp để tính tổng
    for i in range(1,target_number+1):
        Sum = Sum + i

    #Trả vể tổng sau khi thực hiện xong vòng lặp
    return Sum

if __name__ == '__main__':

    #Nhập giá trị
    n = input("Nhập n ")
    while not is_number(n):
        n = input("Nhập lại n ")

    #Dùng hàm để tính tổng
    result = caculate_sum(int(n))
    print("Kết quả là " +str(result))
<file_sep>#Bài 128 + 130: Viết hàm nhập, xuất mảng 1 chiều các số thực

#Hàm kiểm tra đây có phải là số thực
def is_float(value):
    try:
        float(value)
        return True
    except ValueError:
        return False
#Hàm kiểm tra đây có phải là số nguyên
def is_option(value):
    return value.isdigit() and float(value).is_integer() and int(value) >= 0

#Hàm nhập mảng số nguyên
def enter_array_of_integer_numbers():

    list_integer_numbers = []

    n = input("Tổng số giá trị muốn nhập là ")
    while not is_option(n):
        print("Lỗi")
        n = input("Tổng số giá trị muốn nhập là ")

    #Dùng vòng lặp để nhập đối tượng vào mảng số nguyên
    for i in range(int(n)):

        integer_number = input("Nhập phần tử số nguyên thứ "+str(i+1)+" là ")
        #Nếu ko phải là số thực thì nhập lại
        while not is_float(integer_number):
            integer_number = input("Nhập lại phần tử số nguyên thứ " + str(i + 1) + " là ")
        list_integer_numbers.append(int(integer_number))

    return list_integer_numbers

#Hàm in ra mảng số nguyên
def print_array_of_integer_numbers(list):
    print()
    #Biến đếm thứ tự
    ordinal =1

    for i in list:
        print("Phần tử số nguyên thứ " + str(ordinal) + " trong mảng là " + str(i))
        ordinal+=1

if __name__ == '__main__':

    #Dùng hàm nhập
    result = enter_array_of_integer_numbers()

    #Dùng hàm xuất
    print_array_of_integer_numbers(result)
<file_sep>import math
n=int(input("Nhap N="))
tong=0
for i in range(1,n+1):
    tong= tong+math.pow(i,3)
print(tong)<file_sep>#Bài 126: Viết hàm tính tổng các giá trị âm trong mảng 1 chiều các số thực

#Hàm kiểm tra đây có phải là số thực
def is_float(value):
    try:
        float(value)
        return True
    except ValueError:
        return False
#Hàm kiểm tra đây có phải là số nguyên
def is_option(value):
    try:
        int(value)
        return True
    except ValueError:
        return False

#Hàm sắp xếp lại giá trị tăng dần trong mảng
def sort_real_number_in_list(list):

    # .sort() là hàm sắp xếp mảng , reverse=False tăng dần ,reverse là giảm dần
    list.sort(reverse=False)

    return list

if __name__ == '__main__':

    list_float_numbers = []

    n = input("Tổng số giá trị muốn nhập là ")
    while not is_option(n):
        print("Lỗi")
        n = input("Tổng số giá trị muốn nhập là ")

    #Dùng vòng lặp để nhập đối tượng vào mảng số thực
    for i in range(int(n)):

        real_number = input("Nhập phần tử số thực thứ "+str(i+1)+" là ")
        #Nếu ko phải là số thực thì nhập lại
        while not is_float(real_number):
            real_number = input("Nhập lại phần tử số thực thứ " + str(i + 1) + " là ")
        list_float_numbers.append(float(real_number))

    #Lấy ra kết quả và in ra màn hình
    result = sort_real_number_in_list(list_float_numbers)
    print("Các giá trị tăng dần lân lượt trong mảng là "+str(result))<file_sep>#Bài 107: Viết hàm tính S = CanBacN(x)

#Kiểm tra xem giá trị đó có phải số nguyên
def is_number(value):
    return value.isdigit() and  float(value).is_integer()

#HÀm tính căn mũ N
def square_root_n(x,n):
    return float(x ** (1/n))

if __name__ == '__main__':

    # Nhập số mũ
    n = input("Nhập số mũ N ")
    while not is_number(n):
        n = input("Nhập lại số mũ")

    #Nhập x
    x = input("Nhập x ")
    while not is_number(x):
        x = input("Nhập lại x")

    result = square_root_n(int(x), int(n))
    print("Kết quả hàm căn x mũ n là " +str(result))

<file_sep>#Bài 480: Hãy khai báo kiểu dữ liệu để biểu diễn khái niệm đa thức 1 biến trong toán học:
#P(x) = a.n.X^n + a.n-1.X^n-1 + … + a.1.X + a.0 và định nghĩa hàm nhập và hàm xuất cho kiểu dữ liệu này
import mangsonguyen as sn

class polynomial():

    def __init__(self, coefficient, index_number):
        self.coefficient = coefficient
        self.index_number = index_number

    def set_coefficient(self, coefficient):
        self.coefficient = coefficient

    def set_index_number(self, index_number):
        self.index_number = index_number

    def get_coefficient(self):
        return self.coefficient

    def get_index_number(self):
        return self.index_number

    def __str__(self):
        p = ""
        for i in range(self.index_number, -1, -1):
            if self.coefficient[i] != 0:
                if self.coefficient[i] > 0:
                    if i == self.index_number:
                        p += "{}*X^{}".format(self.coefficient[i], i)
                    elif i == 0:
                        p += " + {}".format(self.coefficient[i])
                    elif i == 1:
                        p += " + {}*X".format(self.coefficient[i])
                    else:
                        p += " + {}*X^{}".format(self.coefficient[i], i)
                else:
                    if i == self.index_number:
                        p += "(-{})*X^{}".format(abs(self.coefficient[i]), i)
                    elif i == 0:
                        p += " - {}".format(abs(self.coefficient[i]))
                    elif i == 1:
                        p += " - {}*X".format(abs(self.coefficient[i]))
                    else:
                        p += " - {}*X^{}".format(abs(self.coefficient[i]), i)
        return p

# Bài 493: Tính hiệu 2 đa thức
    def subtract_two_polynomials(self, other):
        if self.index_number > other.index_number:
            index = self.index_number
            temp = self.coefficient
            n = other.index_number
        else:
            index = other.index_number
            temp = other.coefficient
            n = self.index_number
        for i in range(n + 1):
            if self.index_number >= other.index_number:
                temp[i] = self.coefficient[i] - other.coefficient[i]
            else:
                temp[i] = other.coefficient[i] - self.coefficient[i]
        p = polynomial(temp, index)
        return p
# Bài 494: Tính tổng 2 đa thức
    def sum_two_polynomials(self,other):
        if self.index_number > other.index_number:
            index = self.index_number
            temp = self.coefficient
            n = other.index_number
        else:
            index = other.index_number
            temp = other.coefficient
            n = self.index_number
        for i in range(n + 1):
            temp[i] = other.coefficient[i] + self.coefficient[i]
        p = polynomial(temp, index)
        return p
# Bài 495: Tính tích 2 đa thức
    def product_two_polynomials(self,other):
        temp = self.coefficient + other.coefficient
        index = self.index_number + other.index_number
        for i in range(self.index_number + 1):
            for j in range(other.index_number + 1):
                temp[i + j] = self.coefficient[i] + other.coefficient[j]
        p = polynomial(temp, index)
        return p

# Bài 496: Tính thương 2 đa thức
#     def quotient_two_polynomials(self,other):
#         temp = self.coefficient + other.coefficient
#         index = self.index_number + other.index_number
#         for i in range(self.index_number + 1):
#             for j in range(other.index_number + 1):
#                 temp[i + j] = self.coefficient[i] + other.coefficient[j]
#         p = polynomial(temp, index)
#         return p
# Bài 497: Tính đa thức dư của phép chia đa thức thứ nhất cho đa thức thứ hai
# Bài 498: Tính đạo hàm cấp 1 của đa thức
    def calculate_the_primary_derivative_of_the_polynomial(self):
        index = self.index_number - 1
        temp = self.coefficient
        for i in range(len(temp) - 1, 0, -1):
            temp[i - 1] = self.coefficient[i] * i
        temp[0] += self.coefficient[0]
        temp.pop(len(temp) - 1)
        p = polynomial(temp, index)
        return p

# Bài 499: Tính đạo hàm cấp k của đa thức
    def calculate_the_derivative_k_level_of_the_polynomial(self, k):
        if k >= self.index_number:
            print("Cấp k không thể lớn hơn số mũ")
        else:
            a = polynomial(self.coefficient,self.index_number)
            for i in range(0,k):
                a = a.calculate_the_primary_derivative_of_the_polynomial()
            return a
# Bài 500: Tính giá trị của đa thức tại vị trí x = x0
    def calculate_the_value_of_the_polynomial_at_a_value_of_x(self,x):
        sum = 0
        for i in range(self.index_number, -1, -1):
            sum += self.coefficient[i]*(x**i)
        return sum

# Bài 501: Định nghĩa toán tử cộng (operator +) cho hai đa thức
    def __add__(self, other):
        if self.index_number > other.index_number:
            index = self.index_number
            temp = self.coefficient
            n = other.index_number
        else:
            index = other.index_number
            temp = other.coefficient
            n = self.index_number
        for i in range(n + 1):
            temp[i] = other.coefficient[i] + self.coefficient[i]
        p = polynomial(temp, index)
        return p

# Bài 502: Định nghĩa toán tử trừ (operator -) cho hai đa thức
    def __sub__(self, other):
        if self.index_number > other.index_number:
            index = self.index_number
            temp = self.coefficient
            n = other.index_number
        else:
            index = other.index_number
            temp = other.coefficient
            n = self.index_number
        for i in range(n + 1):
            if self.index_number >= other.index_number:
                temp[i] = self.coefficient[i] - other.coefficient[i]
            else:
                temp[i] = other.coefficient[i] - self.coefficient[i]
        p = polynomial(temp, index)
        return p
# Bài 503: Định nghĩa toán tử nhân (operator *) cho hai đa thức
    def __mul__(self,other):
        temp = self.coefficient + other.coefficient
        index = self.index_number + other.index_number
        for i in range(self.index_number + 1):
            for j in range(other.index_number + 1):
                temp[i + j] = self.coefficient[i] + other.coefficient[j]
        p = polynomial(temp, index)
        return p
# Bài 505: Tìm nghiệm của đa thức trong đoạn [a, b] cho trước
    def find_the_solution_of_the_polynomial_in_the_given_interval_a_to_b(self, a, b):
        if self.calculate_the_value_of_the_polynomial_at_a_value_of_x(
                a) * self.calculate_the_value_of_the_polynomial_at_a_value_of_x(b) > 0:
            print("Error")
            return
        c = a
        while (b - a) >= 0.01:
            c = (a + b) / 2
            if self.calculate_the_value_of_the_polynomial_at_a_value_of_x(c) == 0:
                break
            if self.calculate_the_value_of_the_polynomial_at_a_value_of_x(
                    c) * self.calculate_the_value_of_the_polynomial_at_a_value_of_x(a) < 0:
                b = c
            else:
                a = c
        return "Nghiệm của đa thức là {}".format(c)

def create_polynomial():
    index_number = input("Nhập số mũ")
    while sn.is_integer(index_number) == False or int(index_number) < 1:
        index_number = input("Nhập lại số mũ")
    coefficient = []
    for i in range(0,int(index_number) + 1):
        a = input("Nhập hệ số vị trí mũ {}".format(i))
        while sn.is_integer(a) == False:
            a = input("Nhập hệ số vị trí mũ {}".format(i))
        coefficient.append(int(a))
    p = polynomial(coefficient, int(index_number))
    return p

a = create_polynomial()
# p = create_polynomial()
print((a.find_the_solution_of_the_polynomial_in_the_given_interval_a_to_b(-300,200)).__str__())

# Bài 504: Định nghĩa toán tử thương (operator /) cho hai đa thức

<file_sep>import math
n=int(input("Nhap N"))
m=int(input("Nhap X"))
sum=0
for i in range(1,n+1):
    sum = sum + math.pow(m, i)
    if i > 1:
        for t in range(2, i + 1):
            sum = sum + t
print(sum)<file_sep>#Bài 108:  Viết hàm tính S = x^y

def is_number(value):
    return value.isdigit() and float(value).is_integer()

#Hàm x^y
def function_solving(x,y):
    return x ** y

if __name__ == '__main__':

    #Nhập vào x và y
    x= input("Nhập x ")
    while not is_number(x):
        x = input("Nhập x ")

    y = input("Nhập y ")
    while not is_number(y):
        y = input("Nhập y ")

    #Giải Hàm và đưa ra kết quả
    result = function_solving(int(x),int(y))

    print("Kết quả của hàm số " +str(x)+"^"+str(y) +" là " +str(result))<file_sep>#Bài 124: Viết hàm kiểm tra trong mảng các số nguyên có tồn tại giá trị chẵn nhỏ hơn 2004 hay không

#HÀm kiểm tra đây có phải là số nguyên
def is_integer(value):
    try:
        int(value)
        return True
    except ValueError:
        return False

#Hàm tìm số nguyên tố
def is_prime_number(target_number):

    # 1, 2, 3 luôn là số nguyên tố
    if target_number== 1 or target_number== 2 or target_number== 3:
        return True
    else:
        for i in range(2,target_number,1):
            if target_number % i == 0:
                return False
        return True

#Hàm lấy ra giá trị nhỏ nhất trong mảng
def count_prime_number_in_list(list):

    #Biến đếm số nguyên tố
    count_prime_number = 0

    #Kiểm tra lần lượt các giá trị trong mảng
    for i in list:
        if int(i) <= 0:
            continue
        else:
            if is_prime_number(int(i))!=False:
                count_prime_number+=1
    return count_prime_number

if __name__ == '__main__':

    list_integet_number = []

    n = input("Tổng số giá trị muốn nhập là ")
    while not is_integer(n) and int(n) <=0 :
        print("Lỗi")
        n = input("Tổng số giá trị muốn nhập là ")

    #Dùng vòng lặp để nhập đối tượng vào mảng
    for i in range(int(n)):

        integer_number = input("Nhập phần tử số nguyên thứ "+str(i+1)+" là ")
        #Nếu ko phải là số nguyên thì nhập lại
        while not is_integer(integer_number):
            integer_number = input("Nhập lại phần tử số nguyên thứ " + str(i + 1) + " là ")
        list_integet_number.append(integer_number)

    #Lấy ra kết quả và in ra màn hình
    result = count_prime_number_in_list(list_integet_number)
    print("Tổng số giá trị là số nguyên tố  trong mảng là "+str(result))<file_sep>a= int(input("Nhap a="))
b= int(input("Nhap b="))
if a==0:
    print("vo nghiem")
else:
    print("x=", -b/a)<file_sep>

#Kiểm tra giá tị nhập vào có phải là số nguyên dương
def is_number(value):
    return value.isalpha() == False

#Hàm kiểm tra số chính phương
def is_square_number(target_number):

    if target_number < 0:
        return False

    else:
        for i in range(1, target_number):
            if i * i == target_number:
                return True

        return False

if __name__ == '__main__':

    # Nhập giá trị
    n = input("Nhập n ")
    while not is_number(n):
        n = input("Nhập lại n ")

    list_square_number =[]
    for i in range(1,int(n)):

        if is_square_number(i) == True:
            list_square_number.append((i))

    print("Kết quả các số chính phương nhỏ hơn n là " +str(list_square_number))
<file_sep>#Bài 126: Viết hàm tính tổng các giá trị âm trong mảng 1 chiều các số thực

#Hàm kiểm tra đây có phải là số thực
def is_float(value):
    try:
        float(value)
        return True
    except ValueError:
        return False
#Hàm kiểm tra đây có phải là số nguyên
def is_option(value):
    try:
        int(value)
        return True
    except ValueError:
        return False

#Hàm tính tổng giá trị âm trong mảng
def caculate_sum_negative_number_in_list(list):

    #Gắn tổng các giá trị âm bằng 1 biến
    sum_negative_number = 0

    #Kiểm tra lần lượt các giá trị trong mảng
    for i in list:

        #Nếu giá trị nào nhỏ hơn 0 thì cộng nó với biến tổng
        if float(i) < 0:
            sum_negative_number = sum_negative_number + float(i)

    return sum_negative_number

if __name__ == '__main__':

    list_float_numbers = []

    n = input("Tổng số giá trị muốn nhập là ")
    while not is_option(n):
        print("Lỗi")
        n = input("Tổng số giá trị muốn nhập là ")

    #Dùng vòng lặp để nhập đối tượng vào mảng số thực
    for i in range(int(n)):

        real_number = input("Nhập phần tử số thực thứ "+str(i+1)+" là ")
        #Nếu ko phải là số thực thì nhập lại
        while not is_float(real_number):
            real_number = input("Nhập lại phần tử số thực thứ " + str(i + 1) + " là ")
        list_float_numbers.append(real_number)

    #Lấy ra kết quả và in ra màn hình
    result = caculate_sum_negative_number_in_list(list_float_numbers)
    print("Tổng các giá trị âm trong mảng là "+str(result))<file_sep>#Bài 110: Cần có tổng 200000 đồng từ 3 loại giấy bạc 1000 đồng, 2000 đồng, 5000 đồng. Lập chương trình để tìm ra tất cả các phương án có thể

def find_way_to_get_200000():

    #Tổng số cách
    total_way = 0

    # Tổng số tờ 1000 có thể lấy để đủ 200000 là 200 tờ nên giới hạn lấy ra tối đa là 200
    for i in  range(1,201):

        # Tổng số tờ 2000 có thể lấy để đủ 200000 là 100 tờ nên giới hạn lấy ra tối đa là 100
        for t in range(1,101):

            # Tổng số tờ 5000 có thể lấy để đủ 200000 là 40 tờ nên giới hạn lấy ra tối đa là 40
            for v in range(1,40):

                #Nếu tổng tiền của các tờ cộng lại với nhau mà bằng 200000 đồng thì in ra kết qua
                if (i * 1000) + (t * 2000) + (v * 5000) == 200000:
                    print( str(i) + " tờ 1000 đồng + " + str(t) +" tờ 2000 đồng + " + str(v) + " tờ 5000 đồng = 200000 đồng")
                    total_way = total_way +1

    print("Tổng số cách để lấy ra 200000 đồng từ 1000,2000,5000 là " + str(total_way) + " cách")

if __name__ == '__main__':

    #Chạy chương trình
    find_way_to_get_200000()<file_sep>#Bài 476: Hãy khai báo kiểu dữ liệu biểu diễn khái niệm hỗn số trong toán học và
# định nghĩa hàm nhập, hàm xuất cho kiểu dữ liệu này
import mangsonguyen as sn

class mixedNumbers():
    def __init__(self,integer,numerator,denominator):
        self.integer = integer
        self.numerator = numerator
        self.denominator = denominator
    def set_integer(self,integer):
        self.integer = integer
    def set_numerator(self,numerator):
        self.numerator = numerator
    def set_denominator(self,denominator):
        self.denominator = denominator
    def get_integer(self):
        return self.integer
    def get_numerator(self):
        return self.numerator
    def get_denominator(self):
        return self.denominator
    def __str__(self):
        return "{}({}/{})".format(self.integer,self.numerator,self.denominator)

def create_mixed_numbers():
    integer = input("Nhập phần nguyên")
    while sn.is_integer(integer) == False:
        integer = input("Nhập lại phần nguyên")
    numerator = input("Nhập tử số")
    while sn.is_integer(numerator):
        numerator = input("Nhập lại tử số")
    denominator = input("Nhập mẫu số")
    while sn.is_integer(denominator) == False or denominator == 0:
        denominator = input("Nhập lại mẫu số")
    p = mixedNumbers(integer,numerator,denominator)
    return p
def print_mixed_numbers(integer,numerator,denominator):
    print("{}({}/{})".format(integer,numerator,denominator))<file_sep>#Bài 105: Viết chương trình nhập 1 số nguyên có 2 chữ số.  Hãy in ra cách đọc của số nguyên này

#Hàm kiểm tra giá trị nhập vào có phải là số có 2 chữ sô
def is_number(value):
    return value.isdigit() and float(value).is_integer() and 99 >= int(value) >= 10

def read_number(target_number):
    name_number= ""
    dozens_of_numbers = target_number//10
    un_of_numbers = target_number % 10

    #Cách đọc hàng chục
    if dozens_of_numbers == 1:
        name_number = name_number + "Mười"
    elif dozens_of_numbers == 2:
        name_number = name_number + "<NAME>"
    elif dozens_of_numbers == 3:
        name_number = name_number + "<NAME>"
    elif dozens_of_numbers == 4:
        name_number = name_number + "<NAME>"
    elif dozens_of_numbers == 5:
        name_number = name_number + "<NAME>"
    elif dozens_of_numbers == 6:
        name_number = name_number + "<NAME>"
    elif dozens_of_numbers == 7:
        name_number = name_number + "<NAME>"
    elif dozens_of_numbers == 8:
        name_number = name_number + "<NAME>"
    elif dozens_of_numbers == 9:
        name_number = name_number + "<NAME>"

    #Cách đọc hàng đơn vị
    if un_of_numbers == 1:
        name_number = name_number + "Mốt"
    elif un_of_numbers == 2:
        name_number = name_number + "Hai"
    elif un_of_numbers == 3:
        name_number = name_number + "Ba"
    elif un_of_numbers == 4:
        name_number = name_number + "Bốn"
    elif un_of_numbers == 5:
        name_number = name_number + "Năm"
    elif un_of_numbers == 6:
        name_number = name_number + "Sáu"
    elif un_of_numbers == 7:
        name_number = name_number + "Bảy"
    elif un_of_numbers == 8:
        name_number = name_number + "Tám"
    elif un_of_numbers == 9:
        name_number = name_number + "Chín"
    return name_number

if __name__ == '__main__':

    two_digit_number = input("Nhập số có 2 chữ số")

    while not is_number(two_digit_number):
        two_digit_number = input("Nhập lại số có 2 chữ số")

    result = read_number(int(two_digit_number))
    print("Cách đọc của số này là " +str(result))
<file_sep># Bài 115: Viết chương trình nhập họ tên, điểm toán, điểm văn của 1 học sinh. Tính điểm trung bình và xuất ra kết quả

#Hàm kiểm tra điểm nhập vào
def is_score(value):
    return value.isdigit() and float(value).is_integer() and 10 >= int(value) >= 0

#Hàm tính điểm trung bình của 2 môn
def average_two_score(name, first_score, second_score):

    return "Điểm trung bình của " +str(name) +" là "+str((first_score + second_score)/2)

if __name__ == '__main__':

    #Nhập thông tin
    name = input("Nhập <NAME>")

    #Nhập điểm Toán
    math_score = input("Nhập điểm Toán ")
    while not is_score(math_score):
        math_score = input("Nhập lại điểm Toán ")

    #Nhập điểm văn
    literature_score = input("Nhập điểm văn ")
    while not is_score(literature_score):
        literature_score= input("Nhập lại điểm Văn ")

    result = average_two_score(name , int(math_score),int(literature_score))
    print(result)

<file_sep>#Bài 128 + 130: Viết hàm nhập, xuất mảng 1 chiều các số thực

import math
from termcolor import colored

#Hàm kiểm tra đây có phải là số thực
def is_float(value):
    try:
        float(value)
        return True
    except ValueError:
        return False
#Hàm kiểm tra đây có phải là số nguyên
def is_option(value):
    return value.isdigit() and float(value).is_integer() and int(value) >= 0

#Hàm nhập mảng số nguyên
def enter_array_of_integer_numbers():

    list_integer_numbers = []

    n = input("Tổng số giá trị muốn nhập là ")
    while not is_option(n):
        print("Lỗi")
        n = input("Tổng số giá trị muốn nhập là ")

    #Dùng vòng lặp để nhập đối tượng vào mảng số nguyên
    for i in range(int(n)):

        integer_number = input("Nhập phần tử số nguyên thứ "+str(i+1)+" là ")
        #Nếu ko phải là số thực thì nhập lại
        while not is_float(integer_number):
            integer_number = input("Nhập lại phần tử số nguyên thứ " + str(i + 1) + " là ")
        list_integer_numbers.append(int(integer_number))

    return list_integer_numbers

#Hàm in ra mảng số nguyên
def print_array_of_integer_numbers(list):
    print()
    #Biến đếm thứ tự
    ordinal =1

    for i in list:
        print("Phần tử số nguyên thứ " + str(ordinal) + " trong mảng là " + str(i))
        ordinal+=1

#Bài 132: Viết hàm liệt kê các giá trị chẵn trong mảng 1 chiều các số nguyên\
def find_integer_even_numbers(list):
    #Biến đếm thứ tự

    list_even_number= []

    for i in list:
        if i % 2 ==0:
            list_even_number.append(i)
    return list_even_number

#Bài 136: Tìm số chẵn cuối cùng trong mảng 1 chiều các số nguyên. Nếu mảng không có giá trị chẵn thì trả về -1
def find_last_integer_even_numbers_in_list(list):
    i = len(list) - 1
    while i > 0 :
        if int(list[i]) % 2 == 0:
            return i
        i = i -1
    return -1

#Bài 138: Tìm vị trí của giá trị chẵn đầu tiên trong mảng 1 chiều các số nguyên. Nếu mảng không có giá trị chẵn thì sẽ trả về -1

def find_first_integer_even_numbers_in_list(list):
    i = 0
    while i < len(list):
        if int(list[i]) % 2 == 0:
            return i
        i = i + 1
    return -1

#Bài 139: Tìm vị trí số hoàn thiện cuối cùng trong mảng 1 chiều các số nguyên. Nếu mảng không có số hoàn thiện thì trả về giá trị  -1

def is_perfect_number(target_number):
    Sum = 0
    for i in range(1,target_number):
        if target_number % i == 0:
            Sum = Sum + i
    if Sum == target_number:
        return True
    else:
        return False
def find_last_perfect_number_in_list(list):
    i = len(list)-1
    while i >0:
        if is_perfect_number(int(list[i])) == True:
            return i
    return -1

#Bài 143: Viết hàm tìm số chẵn đầu tiên trong mảng các số nguyên. Nếu mảng không có giá trị chẵn thì trả về  -1
def find_first_integer_even_numbers_in_list(list):
    i = 0
    while i < len(list) -1 :
        if int(list[i]) % 2 == 0:
            return i
        i = i + 1
    return -1

#Bài 144: Tìm số nguyên tố đầu tiên trong mảng 1 chiều các số nguyên. Nếu mảng không có số nguyên tố thì trả về  – 1

#Hàm tìm số nguyên tố
def is_prime_number(target_number):

    # 1, 2, 3 luôn là số nguyên tố
    if target_number== 1 or target_number== 2 or target_number== 3:
        return True
    else:
        for i in range(2,target_number,1):
            if target_number % i == 0:
                return False
        return True

def find_first_prime_number_in_list(list):
    i = 0
    while i < len(list) -1 :
        if is_prime_number(list[i]) == True:
            return list[i]
        i = i + 1
    return -1

#Bài 145: Tìm số hoàn thiện đầu tiên trong mảng 1 chiều số nguyên. Nếu mảng không có số hoàn thiện thì trả về  -1

def find_first_perfect_number_in_list(list):
    i = 0
    while i < len(list) -1 :
        if is_perfect_number(list[i]) == True:
            return list[i]
        i = i + 1
    return -1

#Bài 148: Tìm số nguyên tố cuối cùng trong mảng 1 chiều các số nguyên. Nếu mảng không có số nguyên tố thì trả về  -1

def find_last_prime_number_in_list(list):
    i = len(list) -1

    while i > 0 :
        if is_prime_number(list[i]) == True:
            return list[i]
        i = i -1
    return -1

#Bài 149: Tìm số hoàn thiện cuối cùng trong mảng 1 chiều các số nguyên. Nếu mảng không có số hoàn thiện thì trả về  -1

def find_last_perfect_number_in_list(list):

    i = len(list) -1

    while i > 0 :
        if is_perfect_number(list[i]) == True:
            return list[i]
        i = i -1
    return -1

#Bài 151: Hãy tìm số nguyên tố lớn nhất trong mảng 1 chiều các số nguyên. Nếu mảng không có số nguyên tố thì trả về -1

def find_biggest_prime_number_in_list(list):
    biggest_prime_number = -1

    for i in list:
        if is_prime_number(i) == True and biggest_prime_number < i:
            biggest_prime_number=i

    return biggest_prime_number

#Bài 152: Hãy tìm số hoàn thiện nhỏ nhất trong mảng 1 chiều các số nguyên. Nếu mảng không có số hoàn thiện thì trả về -1

def find_smallest_perfect_number_in_list(list):
    smallest_perfect_number = -1

    for i in list:
        if (is_perfect_number(i) == True and smallest_perfect_number<0) or smallest_perfect_number > i:
            smallest_perfect_number=i

    return smallest_perfect_number

#Bài 153: Hãy tìm giá trị chẵn nhỏ nhất trong mảng 1 chiều các số nguyên. Nếu mảng không có số chẵn thì trả về -1
def find_smallest_even_number_in_list(list):
    smallest_even_number = -1

    for i in list:
        if (i % 2 == 0 and smallest_even_number == -1) or (smallest_even_number > i and  i % 2 == 0):
            smallest_even_number = i

    return smallest_even_number

#Bài 161: Cho mảng 1 chiều các số nguyên, hãy tìm giá trị đầu tiên nằm trong khoảng [x, y] cho trước. Nếu mảng không có giá trị thỏa điều kiện trên thì trả về -1

def find_real_number_in_range(x,y,list):

    for i in list:
        if x > y:
            if i >=y and i <= x:
                return i
        else:
            if i <=y and i >= x:
                return i
    return -1

#Bài 163: Tìm số chính phương đầu tiên trong mảng 1 chiều các số nguyên

#Hàm kiểm tra số chính phương
def is_square_number(target_number):

    if target_number < 0:
        return False

    else:
        for i in range(1, target_number):
            if i * i == target_number:
                return True

        return False

def find_square_number_in_list_integer_number(list):
    for i in list:
        if is_square_number(i)== True:
            return i
    return -1
#Bài 164: Cho mảng 1 chiều các số nguyên. Hãy tìm giá trị đầu tiên thỏa mãn tính chất số gánh

#Hàm xác định số đảo ngược
def is_reversible_number(target_number):
    #Biến số thành chuôi
    str1 = str(target_number)
    #Đảo ngược chuôi
    str2 = str1[::-1]
    if (str1 == str2):
        return True
    else:
        return False

def find_first_reversible_number_in_list(list):
    for i in list:
        if is_reversible_number(i) == True:
            return i
    return  -1

#Bài 165: Cho mảng 1 chiều các số nguyên. Hãy tìm giá trị đầu tiên có chữ số đầu tiên là chữ số lẻ

def find_first_odd_number_in_list_integer_number(list):
    for i in list:
        if i % 2 != 0:
            return  i
    return  -1

#Bài 166: Cho mảng 1 chiều các số nguyên. Hãy viết hàm tìm giá trị đầu tiên trong mảng có dạng 2^k. Nếu mảng không có giá trị dạng 2k thì hàm sẽ trả về 0

def find_first_square_root_number_in_list_integer_number(list):
    for i in list:
        if math.sqrt(i).is_integer() == True:
            return i
    return 0

#Bài 167: Hãy tìm giá trị thỏa điều kiện toàn chữ số lẻ và là giá trị lớn nhất thỏa điều kiện ấy trong mảng 1 chiều các số nguyên.
# Nếu mảng không có giá trị thỏa điều kiện trên thì trả về 0

def is_is_number_by_all_negative(number):

    str_number = str(number)

    for i in range(0,len(str_number) ):
        if str_number[i] == "-" and i == 0:
            continue
        if int(str_number[i]) % 2 == 0:
            return False
    return True

def find_number_with_all_negative_number_in_list(list):

    target_number = 0
    for i in list:
        if (is_is_number_by_all_negative(i) == True and target_number ==0 ) or (is_is_number_by_all_negative(i) == True and i >target_number):
            target_number = i
    return target_number

#Bài 168: Cho mảng 1 chiều các số nguyên. Hãy viết hàm tìm giá trị lớn nhất trong mảng có dạng 5^k. Nếu mảng khong tồn tại giá trị 5^k thì hàm sẽ trả về 0

def is_number_square_root_of_five(number):
    while number != 1 :
        if number % 5 != 0:
            return False
        number = number// 5
    return True

def find_number_square_root_of_five_number_in_list_integer_number(list):

    biggeset_number_square_root_of_five = 0

    for i in list:
        if (is_number_square_root_of_five(i) == True and biggeset_number_square_root_of_five==0) or (is_number_square_root_of_five(i) == True and biggeset_number_square_root_of_five < i):
            biggeset_number_square_root_of_five = i
    return biggeset_number_square_root_of_five

#Bài 169 (*): Cho mảng 1 chiều các số nguyên. Hãy viết hàm tìm số chẵn nhỏ nhất lớn hơn mọi giá trị có trong mảng

def find_smallest_even_number_bigger_sum_numbers_in_list(list):
    sum_list = 0
    for i in list:
        sum_list = sum_list + i

    while sum_list != 0.1:
        sum_list = sum_list + 1
        if sum_list % 2 == 0:
           return sum_list

#Bài 170: Cho mảng 1 chiều các số nguyên. Hãy viết hàm tìm số nguyên tố nhỏ nhất lớn hơn mọi giá trị có trong mảng

def find_smallest_prime_number_bigger_sum_numbers_in_list(list):
    sum_list = 0
    for i in list:
        sum_list = sum_list + i

    while sum_list!=0.1:
        sum_list = sum_list + 1
        if is_prime_number(sum_list)==True:

           return sum_list

#Bài 171: Cho mảng 1 chiều các số nguyên. Hãy viết hàm tìm ước chung lớn nhất của tất cả các phần tử trong mảng

def is_number_common_divisor_in_list(x , list):
    for t in range(0, len(list)):
        if list[t] % x != 0:
            return False
    return True

def find_greatest_common_divisor_in_list(list):
    smallest_number = list[0]
    for i in list:
        if i <= 0:
            return -1
        if i < smallest_number and i >0:
            smallest_number = i
    for i in range(smallest_number, 0 , -1):
        if is_number_common_divisor_in_list(i,list) == True:
            return i

    return -1

#Bài 172: Cho mảng 1 chiều các số nguyên. Hãy viết hàm tìm bội chung nhỏ nhất của tất cả các phần tử trong mảng

def is_common_multiple_in_list(x, list):
    for i in  list:
        if x % i != 0:
            return False
    return True

def find_the_smallest_common_multiple_in_list(list):
    biggest_number = list[0]
    product_of_numbers = 1
    for i in list:
        if i <= 0:
            return -1
        else:
            product_of_numbers = product_of_numbers * i
            if i > biggest_number:
                biggest_number = i
    for i in range(biggest_number, product_of_numbers , 1):
        if is_common_multiple_in_list(i,list) == True:
            return i

    return -1

#Bài 173 (*): Cho mảng 1 chiều các số nguyên. Hãy  viết hàm tìm chữ số xuất hiện ít nhất trong mảng

def find_number_appears_least(list):
    count_number_appears_least = 0
    number_appears_least = [0]
    for i in range(1,10):
        count_number_appears = 0
        for t in list:
            count_number_appears = count_number_appears + int(str(t).count(str(i)))
        if count_number_appears < count_number_appears_least or count_number_appears_least==0:
            count_number_appears_least = count_number_appears
            number_appears_least = i
    return number_appears_least

#Bài 178: Hãy liệt kê các số chẵn trong mảng 1 chiều các số nguyên thuộc đoạn [x, y] cho trước (x, y là các số nguyên)

def find_all_number_in_space_in_list_number(x, y,list):
    list_number = []
    for i in list:
        if i <= y and i >= x and i % 2 == 0:
            list_number.append(i)
    return list_number

#Bài 179: Hãy liệt kê các giá trị trong mảng mà thỏa điều kiện lớn hơn giá trị tuyệt đối của giá trị đứng liền sau nó

def find_number_bigger_next_number_in_list(list):
    list_number =[]
    for i in range(1,len(list)-1):
        if list[i] > abs(list[i+1]):
            list_number.append(list[i])
    return list_number

#Bài 180: Hãy liệt kê các giá trị trong mảng mà thỏa điều kiện nhỏ hơn trị tuyệt đối của giá trị đứng liền sau nó
# và lớn hơn trị tuyệt đối của giá trị đứng liền trước nó

def find_number_bigger_previous_number_and_smaller_next_number_in_list(list):
    list_number =[]
    for i in range(1,len(list)-1):
        if list[i] < abs(list[i+1]) and list[i] > abs(list[i-1]) :
            list_number.append(list[i])
    return list_number

# Bài 181: Cho mảng 1 chiều các số nguyên. Hãy viết hàm liệt kê các giá trị chẵn có ít nhất 1 lân cận cũng là giá trị chẵn
def find_all_even_number_nearly_even_number(list):
    number_list = []
    for i in range(1, len(list) - 1):
        if list[i] % 2 == 0 and (list[i - 1] % 2 == 0 or list[i + 1] % 2 == 0):
            number_list.append(list[i])
    return number_list

# Bài 184: Hãy liệt kê các vị trí mà giá trị tại đó là số nguyên tố trong mảng 1 chiều các số nguyên
def find_all_locate_prime_number_in_list(list):
    locate_number_list = []

    for i in range(0, len(list)):

        if is_prime_number(list[i]) == True:
            locate_number_list.append(i)

    return locate_number_list
#Bài 185: Hãy liệt kê các vị trí mà giá trị tại đó là số chính phương trong mảng 1 chiều các số nguyên

    locate_number_list = []

    for i in range(0, len(list)):

        if is_square_number(list[i]) == True:
            locate_number_list.append(i)

    return locate_number_list

#Bài 188: Hãy liệt kê các vị trí chẵn lớn nhất trong mảng 1 chiều các số nguyên

def find_biggest_even_number_in_list(list):
    max_even_number = 0
    for i in list:
        if (max_even_number == 0 and  i % 2==0) or (max_even_number< i and max_even_number != 0) :
            max_even_number= i
    return  i

def find_all_locate_biggest_even_number_in_list(list):
    locate_number_list = []
    for i in range(0, len(list)):

        if list[i] == find_biggest_even_number_in_list(list):
            locate_number_list.append(i)

    return locate_number_list

#Bài 189: Hãy liệt kê các giá trị trong mảng 1 chiều các số nguyên có chữ số đầu tiên là chữ số lẻ

def find_all_integers_whose_first_digit_is_an_odd_number(list):
    number_list = []
    for i in list:
        text_i = str(i)
        if text_i[0] == '-':
            if  int(text_i[1]) % 2 != 0:
                number_list.append(i)
        else:
            if int(text_i[0]) % 2 != 0:
                number_list.append(i)
    return  number_list

#Bài 190: Hãy liệt kê các giá trị có toàn chữ số lẻ trong mảng 1 chiều các số nguyên
def find_all_integers_whose_all_digit_is_an_odd_number(list):
    number_list = []
    for i in list:
        if is_is_number_by_all_negative(i) == True:
            number_list.append(i)
    return number_list

#Bài 192: Hãy liệt kê các  giá trị trong mảng 1 chiều các số nguyên có chữ số đầu tiên là số chẵn

def find_all_integers_whose_first_digit_is_an_even_number(list):

    number_list = []
    for i in list:
        text_i = str(i)
        if text_i[0] == '-':
            if  int(text_i[1]) % 2 == 0:
                number_list.append(i)
        else:
            if int(text_i[0]) % 2 == 0:
                number_list.append(i)
    return  number_list

#Bài 193: Cho mảng 1 chiều các số nguyên. Hãy viết hàm liệt kê các giá trị trong mảng có dạng 3^k. Nếu mảng không có giá trị đó thì trả về 0

def is_number_square_root_of_three(number):
    while number != 1 :
        if number % 3 != 0:
            return False
        number = number// 5
    return True

def find_number_square_root_of_three_number_in_list_of_integer_number(list):

    list_of_number = []

    for i in list:
        if is_number_square_root_of_three(i) == True :
            list_of_number.append(i)
    if list_of_number == []:
        return 0
    else:
        return list_of_number

#Bài 194: Cho mảng 1 chiều các số nguyên có nhiều hơn 2 giá trị. Hãy viết hàm liệt kê các cặp giá trị gần nhau nhất

def find_closest_distance_between_two_values(list):
    closest_distance = 0

    for i in range(0,len(list)-1):
        if closest_distance > abs(list[i] -list[i+1]) or closest_distance == 0:
            closest_distance = abs(list[i] -list[i+1])

    return closest_distance

def find_lists_the_closest_pairs_of_values_in_list(list):
    list_of_value_pairs = []
    for i in range(0,len(list)-1):
        if abs(list[i] -list[i +1]) == find_closest_distance_between_two_values(list):
            if list[i] >list[i+1]:
                list_of_value_pairs.append("[" + str(list[i + 1]) + "," + str(list[i]) + "]")
            else:
                list_of_value_pairs.append("["+str(list[i])+","+str(list[i+1])+"]")

    return list_of_value_pairs

#Bài 196: Liệt kê các số âm trong mảng 1 chiều các số nguyên

def find_list_negative_numbers_in_array(list):
    list_negative_numbers = []
    for i in list:
        if i < 0:
            list_negative_numbers.append(i)
    return list_negative_numbers

#Bài 197: Hãy liệt kê các giá trị trong mảng các số nguyên có chữ số đầu tiên là chữ số lẻ

def is_number_whose_first_digit_is_an_odd_number(number):
    text_number = str(number)
    if text_number[0] == '-':
        if int(text_number[1]) % 2 != 0:
            return True
    else:
        if int(text_number[0]) % 2 != 0:
            return True
    return False

def find_all_integers_whose_first_digit_is_an_odd_number(list):
    number_list = []
    for i in list:
        text_i = str(i)
        if text_i[0] == '-':
            if  int(text_i[1]) % 2 != 0:
                number_list.append(i)
        else:
            if int(text_i[0]) % 2 != 0:
                number_list.append(i)
    return  number_list

#Bài 199: Hãy liệt kê các vị trí mà giá trị tại đó là số nguyên tố trong mảng 1 chiều các số nguyên

def find_all_locate_prime_number_in_list(list):
    locate_number_list = []

    for i in range(0, len(list)):

        if is_prime_number(list[i]) == True:
            locate_number_list.append(i)

    return locate_number_list

#Bài 200: Tính tổng các phần tử trong mảng

def caculate_sum_in_list(list):
    sum_list = 0
    for i in list:
        sum += i
    return sum_list

#Bài 202: Tính tổng các giá trị có chữ số đầu tiên là chữ số lẻ trong mảng 1 chiều các số nguyên

def caculate_sum_number_whose_first_digit_is_an_odd_number_in_list(list):
    sum_list = 0
    for i in list:
        if is_number_whose_first_digit_is_an_odd_number(i) == True:
            sum += i
    return sum_list

#Bài 203: Tinh tổng các chữ số có chữ số hàng chục là 5 trong mảng 1 chiều các số nguyên
def caculate_sum_number_whose_tens_digit_is_five_in_list(list):
    sum_list = 0
    for i in  list:
        if i >= 10:
            if i %100 //10  == 5:
                sum_list += i
    return sum_list

#Bài 208: Tính tổng các giá trị chính phương trong mảng 1 chiều các số nguyên

def sum_the_square_values_in_the_array(list):
    sum_list = 0
    for i in list:
        if is_square_number(i) == True:
            sum_list += i
    return sum_list

#Bài 209: Tính tổng các giá trị đối xứng trong mảng các số nguyên
def sum_the_reversible_numbers_in_the_array(list):
    sum_list = 0
    for i in list:
        if is_reversible_number(i) == True:
            sum_list += i
    return sum_list

#Bài 210: Tính tổng các giá trị có chữ số đầu tiên là chữ số chẵn trong mảng các số nguyên
def sum_values_with_an_even_number_first_digit(list):
    sum_list = 0
    for i in list:
        if is_number_whose_first_digit_is_an_odd_number(i) ==False:
            sum_list += i
    return sum_list

#Bài 211: Tính trung bình cộng các số nguyên tố trong mảng 1 chiều các số nguyên
def calculate_the_average_prime_numbers(list):
    sum_list_of_prime_number = 0
    count_prime_number = 0
    for i in list:
        if is_prime_number(i) == True:
            sum_list_of_prime_number += i
            count_prime_number += 1
    return sum_list_of_prime_number / count_prime_number

#Bài 216: Đếm số lượng số chẵn trong mảng

def count_the_even_numbers_in_list(list):
    total_even_numbers = 0

    for i in list:
        if i % 2 == 0:
            total_even_numbers += 1

    return total_even_numbers

#Bài 217: Đếm số dương chia hết cho 7 trong mảng

def counts_positive_numbers_divisible_by_seven_in_list(list):
    total_positive_numbers = 0

    for i in list:
        if i % 7 == 0 and i > 0:
            total_positive_numbers += 1

    return total_positive_numbers

#Bài 218: Đếm số đối xứng trong mảng

def counts_reversible_numbers_in_list(list):
    total_reversible_numbers = 0

    for i in list:
        if is_reversible_number(i) == True:
            total_reversible_numbers += 1

    return total_reversible_numbers

#Bài 219: Đếm số lần xuất hiện của giá trị x trong mảng
def counts_the_number_of_occurrences_of_x_value(x, list):
    total_the_number_of_occurrences_of_x_value = 0

    for i in list:
        if i == x:
            total_the_number_of_occurrences_of_x_value += 1

    return total_the_number_of_occurrences_of_x_value

#Bài 220: Đếm số lượng giá trị tận cùng bằng 5 trong mảng

def is_number_with_a_final_value_of_five(target_number):
    str_target_number = str(target_number)
    if str_target_number[len(str_target_number) -1] == "5":
        return True
    return False

def counts_the_number_with_a_final_value_of_five( list):
    total_the_number_with_a_final_value_of_five = 0

    for i in list:
        if is_number_with_a_final_value_of_five(i):

            total_the_number_with_a_final_value_of_five += 1

    return total_the_number_with_a_final_value_of_five

# Bài 221: Cho biết sự tương quan giữa số lượng chẵn và lẻ trong mảng
# Hàm trả về 1 trong 3 giá trị -1, 0, 1
# Giá trị -1 là chẵn nhiều hơn lẻ
# Giá trị 0 là chẵn bằng lẻ
# Giá trị 1 là chẵn ít hơn lẻ

def find_correlation_between_even_and_odd_numbers_in_list(list):
    count_even_numbers = 0
    count_odd_numbers = 0

    for i in list:
        if i % 2 == 0:
            count_even_numbers += 1
        else:
            count_odd_numbers += 1

    # Giá trị 1 là chẵn ít hơn lẻ
    if count_odd_numbers > count_even_numbers :
        return 1

    # Giá trị 0 là chẵn bằng lẻ
    elif count_odd_numbers == count_even_numbers :
        return 0

    else:
        return -1

#Bài 222: Đếm phần tử lớn hơn hay nhỏ hơn phần tử xung quanh mảng

def Counts_elements_larger_or_smaller_than_surrounding_elements(list):

    total_elements_larger_surrounding_elements = 0
    total_elements_smaller_surrounding_elements = 0

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

        if list[i -1] > list[i] and list[i+1] >list[i]:
            total_elements_smaller_surrounding_elements += 1

        elif list[i - 1] < list[i] and list[i+1] <list[i]:
            total_elements_larger_surrounding_elements += 1
    return total_elements_larger_surrounding_elements+ total_elements_smaller_surrounding_elements

#Bài 223: Đếm số nguyên tố trong mảng

def count_prime_number_in_list(list):
    total_prime_number = 0
    for i in list:

        if is_prime_number(i) == True:

            total_prime_number += 1

    return total_prime_number

#Bài 224: Đếm số hoàn thiện trong mảng

def count_perfect_number_in_list(list):
    total_perfect_number = 0
    for i in list:

       if is_perfect_number(i) == True:

            total_perfect_number += 1

    return total_perfect_number

#Bài 225: Đếm số lượng giá trị lớn nhất có trong mảng
def find_maximum_number(list):
    maximum_number = list[0]

    for i in list:
        if maximum_number<i:
            maximum_number=i

    return maximum_number

def count_the_maximum_number_of_values_in_list(list):
    total_maximum_number = 0

    for i in list:
        if i == find_maximum_number(list):
            total_maximum_number += 1

    return total_maximum_number

#Bài 226: Hãy xác định số lượng phần tử kề nhau mà cả 2 đều chẵn

def counts_total_adjacent_elements_that_are_both_even(list):
    total_adjacent_elements_that_are_both_even = 0

    for i in range(0 ,len(list)-1):
        if list[i] % 2 == 0 and list[i+1] % 2 == 0:
            total_adjacent_elements_that_are_both_even += 1

    return total_adjacent_elements_that_are_both_even

#Bài 227: Hãy xác định số lượng phần tử kề nhau mà cả 2 trái dấu

def is_opposite_signs(x , y):

    return x * y < 0

def counts_total_adjacent_elements_that_are_both_even(list):
    total_adjacent_elements_that_are_both_even = 0

    for i in range(0 ,len(list)-1):
        if is_opposite_signs(list[i],list[i+1]):
            total_adjacent_elements_that_are_both_even += 1

    return total_adjacent_elements_that_are_both_even

#Bài 228: Hãy xác định số lượng phần tử kề nhau mà số đứng sau cùng dấu số đứng trước và có giá trị tuyệt đối lớn hơn

def count_elements_with_the_same_sign_as_the_number_and_the_absolute_value_is_greater_before_them(list):
    total_adjacent_elements_the_same_sign = 0

    for i in range(1, len(list) ):
        if is_opposite_signs(list[i], list[i - 1]) == False and abs(list[i]) > abs(list[i-1]):

            total_adjacent_elements_the_same_sign += 1

    return total_adjacent_elements_the_same_sign

#Bài 229: Đếm số lượng các giá trị phân biệt có trong mảng

def counts_the_number_of_distinct_values(list):
    count = 0
    for i in range(0, len(list)):
        a = 0
        for t in range(0, len(list)):
            if i != t :
                if list[i] == list[t]:
                    a = 1

        if a == 0:
            count += 1
    return count

#Bài 230: Liệt kê tần suất xuất hiện các giá trị trong mảng (mỗi giá trị liệt kê 1 lần)

def list_how_often_values_are_present(list):
    list_has_appeared = []
    for i in range(0 ,len(list)):

        if list[i] in list_has_appeared:
            continue

        count = 1
        list_has_appeared.append(list[i])

        for t in range(0, len(list)):

            if i != t :
                if list[i] == list[t]:
                    count += 1

        print("Giá trị {} được xuất hiên {} lần".format(list[i],count))

#Bài 231: Hãy liệt kê các giá trị xuất hiện trong mảng 1 chiều các số nguyên đúng 1 lần

def list_values_appears_once(list):
    list_has_appeared = []

    for i in range(0, len(list)):

        if list[i] in list_has_appeared:
            continue

        a = 0
        list_has_appeared.append(list[i])

        for t in range(0, len(list)):
            if i != t:
                if list[i] == list[t]:
                    a = 1

        if a == 0:
            print("Giá trị {} được xuất hiên 1 lần duy nhất".format(list[i]))

#Bài 232: Hãy liệt kê các giá trị xuất hiện trong dãy quá 1 lần. Lưu ý: mỗi giá trị liệt kê 1 lần

def list_values_appears_more_than_once(list):
    list_has_appeared = []
    for i in range(0 ,len(list)):

        if list[i] in list_has_appeared:
            continue

        count = 1
        list_has_appeared.append(list[i])

        for t in range(0, len(list)):

            if i != t :
                if list[i] == list[t]:
                    count += 1
        if count> 1:
            print("Giá trị {} được xuất hiên quá 1 lần".format(list[i],count))

#Bài 233: Hãy liệt kê tần suất của các giá trị xuất hiện trong dãy. Lưu ý: mỗi giá trị liệt kêt tần suất 1 lần

def list_values_appears_more_than_once_in_str(number):
    number_str = str(number)
    list_has_appeared = []
    for i in range(0 ,len(number_str)):

        if number_str[i] in list_has_appeared:
            continue

        count = 1
        list_has_appeared.append(number_str[i])

        for t in range(0, len(number_str)):

            if i != t :
                if number_str[i] == number_str[t]:
                    count += 1
        if count> 1:
            print("Giá trị {} được xuất hiên quá 1 lần".format(number_str[i],count))

#Bài 234: Cho 2 mảng a, b. Đếm số lượng giá trị chỉ xuất hiện 1 trong 2 mảng:

def counts_the_number_of_values_that_appear_only_in_one_of_the_two_arrays(list1, list2) -> object:
    list_values_has_appeared = []
    count_values = 0
    for i in list1:
        if i in list_values_has_appeared:
            continue
        list_values_has_appeared.append(i)

        count_appear = 0
        for t in list2:
            if i == t:
                count_appear = 1
        if count_appear == 0:
            count_values += 1

    for i in list2:
        if i in list_values_has_appeared:
            continue
        list_values_has_appeared.append(i)

        count_appear = 0
        for t in list1:
            if i == t:
                count_appear = 1
        if count_appear == 0:
            count_values += 1
    return count_values
#Bài 235: Cho 2 mảng a, b. Liệt kê các giá trị chỉ xuất hiện 1 trong 2 mảng

def List_values_that_appear_only_in_one_of_the_two_arrays(list1, list2):
    list_values_has_appeared = []
    for i in list1:
        if i in list_values_has_appeared:
            continue
        list_values_has_appeared.append(i)

        count_appear = 0
        for t in list2:
            if i == t:
                count_appear = 1
        if count_appear == 0:
            print("Giá trị {} chỉ xuất hiện trong mảng 1 trong hai mảng".format(i))

    for i in list2:
        if i in list_values_has_appeared:
            continue
        list_values_has_appeared.append(i)

        count_appear = 0
        for t in list1:
            if i == t:
                count_appear = 1
        if count_appear == 0:
            print("Giá trị {} chỉ xuất hiện trong 1 trong hai mảng".format(i))

# Bài 236(*): Cho 2 mảng a, b. Hãy cho biết số lần xuất hiện của mảng a trong mảng b

def the_number_of_occurrences_of_array_a_in_array_b(list1, list2):
    #Biến đếm số lần xuất hiện của mảng 1 trong mảng hai
    count_list1_appear_list2 = 0
    for i in range(0,len(list2)):

        #Nếu tìm thấy vị trị đầu tiên của mảng 1 trong mảng 2 và độ dài của mảng hai
        # tính từ i vẫn lớn hơn đồ dài mảng một thì bắt đầu vòng lặp
        if list2[i] == list1[0] and len(list2) - i >= len(list1):

            #Biến để kiểm tra đúng sai
            a = 0

            #Điểm bắt đầu
            start = i
            for t in list1:

                #Kiểm tra từ kí tự tiếp theo trong văn bản nếu sai thì trả về a = 1 và dừng vòng lặp
                if t != (list2[start]):
                    a = 1
                    break

                start = start + 1

            #Nếu sau khi chạy xong vòng lặp mà a vẫn bằng 0
            #thì đương nhiên mảng 2 có chứa mảng 1
            if a == 0:
                count_list1_appear_list2 += 1

    return count_list1_appear_list2

#Bài 237 + 238(*): Hãy liệt kê các giá trị có số lần xuất hiện nhiều nhất trong mảng

def count_number_of_occurrences_in_the_array(list):
    list_has_appeared = []
    maximum_appear = 0
    for i in range(0, len(list)):

        if list[i] in list_has_appeared:
            continue

        count = 1
        list_has_appeared.append(list[i])

        for t in range(0, len(list)):

            if i != t:
                if list[i] == list[t]:
                    count += 1
        if count > maximum_appear:
            maximum_appear = count

    return maximum_appear

def list_the_values_with_the_most_occurrences_in_the_array(list):
    list_has_appeared = []
    list_values_maximum_appear = []
    for i in range(0, len(list)):

        if list[i] in list_has_appeared:
            continue

        count = 1
        list_has_appeared.append(list[i])

        for t in range(0, len(list)):

            if i != t:
                if list[i] == list[t]:
                    count += 1
        if count == count_number_of_occurrences_in_the_array(list):
            list_values_maximum_appear.append(list[i])

    return list_values_maximum_appear

#Bài 239: Hãy đếm số lượng số nguyên tố phân biệt trong mảng

def count_the_number_of_distinct_primes_in_the_array(list):
    list_has_appeared = []
    count = 0
    for i in range(0, len(list)):
        if list[i] in list_has_appeared:
            continue

        list_has_appeared.append(list[i])
        flag = 0

        for t in range(0 , len(list)):
            if t != i and list[i] == list[t]:
                flag =1
                break

        if flag == 0 and is_prime_number(list[i]):
            count += 1

    return count

#Bài 240: Kiểm tra mảng có giá trị 0 hay không? Có trả về 1, không có trả về 0

def is_a_list_0_in_list(list):

    for i in list:

        if i == 0:
            return 1

    return 0

#Bài 241: Kiểm tra mảng có 2 giá trị 0 liên tiếp hay không? Có trả về 1, không có trả về 0

def do_an_array_has_two_consecutive_values_equal_to_zero(list):
    for i in range(0, len(list)-1):

        if list[i]==0 and list[i+1] ==0:
            return 1

    return 0

#Bài 242: Kiểm tra mảng có số chẵn hay không? Có trả về 1, không có trả về 0

def do_a_list_has_even_number(list):
    for i in list:
        if i % 2 == 0:
            return  1

    return  0

#Bài 243: Kiểm tra mảng có số nguyên tố hay không? Có trả về 1, không có trả về 0

def do_a_list_has_prime_number(list):
    for i in list:
        if is_prime_number(i) == True:
            return 1

    return  0

#Bài 244: Kiểm tra mảng thỏa tính chất: mảng không có số hoàn thiện lớn hơn 256. Có trả về 1, không có trả về 0
def do_a_list_has_perfect_number_smaller_256(list):
    for i in list:
        if is_perfect_number(i) == True and i >256:
            return 1

    return 0

#Bài 245: Kiểm tra mảng có toàn số chẵn không? Có trả về 1, không có trả về 0

def is_list_of_even_number(list):
    for i in list:
        if i % 2 != 0:
            return 0

    return 1

#Bài 246: Kiểm tra mảng có đối xứng không? Có trả về 1, không có trả về 0

def is_the_array_symmetrical(list):

    #Mảng đảo ngược
    list1 = []

    #Dùng vòng lặp để add phần tử vào mảng
    for i in range(len(list)-1,-1,-1):
        list1.append(list[i])

    #So sánh 2 mảng
    if list == list1:
        return True

    return False

#Bài 247: Ta định nghĩa 1 mảng có tính chất lẻ, khi tổng của 2 phần tử liên tiếp luôn là lẻ. Kiểm tra mảng có tính chất lẻ hay không

def is_an_array_with_the_sum_of_two_consecutive_elements_is_always_odd(list):
    for i in range(0, len(list)-1):
        if (list[i] + list[i+1]) % 2 != 0:
            return False
    return True

#Bài 248: Kiểm tra mảng có tăng dần hay không

def is_this_array_with_ascending(list):
    for i in range(0,len(list) - 1):
        if list[i] > list[i+1]:
            return False
    return True

#Bài 249: Kiểm tra mảng có giảm dần hay không

def is_this_array_with_descending(list):
    for i in range(0, len(list) - 1):
        if list[i] < list[i + 1]:
            return False
    return True

#Bài 250: Hảy cho biết các phần tử trong mảng có lập thành cấp số cộng hay không? Nếu có chỉ ra công sai d

def do_an_array_has_elements_set_to_add(list):

    if len(list) >2:
        arithmetic_progression = list[1] - list[0]

        for i in range(1, len(list) - 1):
            if (list[i+1] - list[i]) != arithmetic_progression:
                return False

        return arithmetic_progression
    else:
        return False

#Bài 251: Hãy cho biết các phần tử trong mảng có bằng nhau không

def are_the_elements_in_the_array_equal(list):
    for i in range(0, len(list) -1):
        if list[i] != list[i+1]:
            return False
    return True

#Bài 252: Ta định nghĩa 1 mảng được gọi là dạng song, khi phần tử có trị số I lớn hơn hoặc nhỏ hơn 2 phần tử xung quanh. Hãy viết hàm kiểm tra mảng có dạng sóng không

def is_this_array_waveform(list):
    for i in range(0,len(list)-1):
        if (list[i] < list[i -1] and list[i] > list[i + 1]) or (list[i] > list[i -1] and list[i] < list[i + 1]):
            return False
    return  True

#Bài 253: Hãy cho biết tất cả các phần tử trong mảng a có nằm trong mảng b không

def are_all_elements_in_array_a_in_array_b(lista,listb):
    for i in lista:
        if i not in listb:
            return False
    return True

#Bài 254: Hãy đếm giá trị trong mảng thỏa: lớn hơn tất cả các giá trị đứng đằng trước nó

def counts_values_greater_than_all_values_preceding_it(list):
    count = 0
    for i in range(0,len(list)):
        if i != 0:
            flag = 1
            for t in range(0,i):
                if list[i] < list[t]:
                    flag = 0
            if flag == 1:
                count +=1
    return  count

#Bài 255: Sắp xếp mảng tăng dần
def sort_arrays_in_ascending_order(list):
    list.sort(reverse = False)

    return  list

#Bài 256: Sắp xếp mảng giảm dần
def sort_arrays_in_descending_order(list):
    list.sort(reverse = True)

    return  list

#Bài 257: Sắp xếp lẻ tăng dần nhưng giá trị khác giữ nguyên vị trí

def odd_sort_odd_numbers_but_other_values_stay_the_same(list):

    for i in range(0,len(list)):
        if list[i] % 2 != 0:
            for t in range(i + 1,len(list)):
                if list[t] % 2 != 0 and list[t] < list[i]:

                    temp = list[i]
                    list[i] = list[t]
                    list[t] = temp
    return list

#Bài 258: Sắp xếp số nguyên tố tăng dần nhưng giá trị khác giữ nguyên vị trí

def odd_sort_prime_numbers_but_other_values_stay_the_same(list):
    for i in range(0,len(list)):
        if is_prime_number(list[i]) == True:
            for t in range(i + 1,len(list)):
                if is_prime_number(list[t]) == True and list[t] < list[i]:

                    temp = list[i]
                    list[i] = list[t]
                    list[t] = temp
    return list

#Bài 259: Sắp xếp số hoàn thiện giảm dần nhưng giá trị khác giữ nguyên vị trí

def odd_sort_perfect_numbers_but_other_values_stay_the_same(list):
    for i in range(len(list) -1 , -1 ,-1):
        if is_perfect_number(list[i]) == True:
            for t in range(i -1,-1 ,-1 ):
                if is_perfect_number(list[t]) == True and list[t] < list[i]:

                    temp = list[i]
                    list[i] = list[t]
                    list[t] = temp
    return list

#Bài 260: Cho 2 mảng a, b. Hãy cho biết mảng b có phải là hoán vị của mảng a không

def Is_array_b_a_permutation_of_array_a(list_a , list_b):
    list_a.sort(reverse = True)
    list_b.sort(reverse = True)
    for i in range(len(list_a)):
        if list_a[i] != list_b[i]:
            return False
    return True

#Bài 261: Sắp xếp số dương tăng dần, các số âm giữ nguyên vị trí

def sort_in_ascending_positive_numbers_while_the_positions_keep_the_same_number(list):
    for i in range(0, len(list)):
        if list[i] >= 0:
            for t in range(i + 1, len(list)):
                if list[i] >= 0 and list[t] < list[i]:
                    temp = list[i]
                    list[i] = list[t]
                    list[t] = temp
    return list

#Bài 262: Sắp xếp chẵn, lẻ tăng dần nhưng vị trí tương đối giữa các số không thay đổi

def sort_even_and_odd_numbers_incrementally(list):
    for i in range(len(list)):
        if list[i] > 0:
            for t in range(i + 1 ,len(list)):
                if (list[i] % 2 != 0 and list[t] % 2 != 0 and list[t] < list[i]) or (list[i] % 2 == 0 and list[t] % 2 == 0 and list[t] < list[i]):

                    temp = list[i]
                    list[i] = list[t]
                    list[t] = temp
    return list

#Bài 263: Sắp xếp số dương tăng dần, âm giảm dần. Vị trí tương đối không thay đổi

def sort_positive_numbers_in_ascending_negative_numbers_descending_and_the_relative_position_does_not_change(list):
    for i in range(len(list)):
        if list[i] > 0:
            for t in range(i + 1, len(list)):
                if (list[i] > 0 and list[t] > 0 and list[t] < list[i]) or (list[i] % 2 < 0 and list[t] % 2 < 0 and list[t] > list[i]):
                    temp = list[i]
                    list[i] = list[t]
                    list[t] = temp
    return list

#Thêm gạch chân dưới chuỗi
def add_underlined_string(a) :
    list = a.split(" ")
    b =  "_".join(list)
    return b

#Bài 264: Trộn 2 mảng đã tăng thành 1 mảng được sắp xếp tăng

def merges_two_incremented_arrays_into_one_increment_sorted_array(list_a ,list_b):
    #Sắp sếp 2 mảng tăng
    list_a.sort(reverse = False)
    list_b.sort(reverse = False)

    #add list b vào list a
    list_a.extend(list_b)

    #Sắp xếp lại list chứa a và b
    list_a.sort(reverse = False)

    #Trả vê kế quả
    return list_a

#Bài 265: Cho 2 mảng tăng. Hãy trộn thành 1 mảng giảm dần

#Sắp sếp 2 mảng tăng
def merges_two_incremented_arrays_into_one_descending_sorted_array(list_a, list_b):

    list_a.sort(reverse = False)
    list_b.sort(reverse = False)

    #add list b vào list a
    list_a.extend(list_b)

    #Sắp xếp lại list chứa a và b
    list_a.sort(reverse = True)

    #Trả vê kế quả
    return list_a

# Bài 266: Thêm 1 phần tử x vào mảng tại vị trí k

def adds_an_element_to_the_array_at_the_given_position(x , index,list):
    list.insert(x,index)
    return list

#Bài 267: Viết hàm nhập mảng sao cho khi nhập xong thì giá trị trong mảng sắp xếp giảm dần
def import_the_array_so_that_when_the_import_is_complete_the_values_in_the_sort_array_decrease():

    list_integer_numbers = []

    n = input("Tổng số giá trị muốn nhập là ")
    while not is_option(n):
        print("Lỗi")
        n = input("Tổng số giá trị muốn nhập là ")

    #Dùng vòng lặp để nhập đối tượng vào mảng số nguyên
    for i in range(int(n)):

        integer_number = input("Nhập phần tử số nguyên thứ "+str(i+1)+" là ")
        #Nếu ko phải là số thực thì nhập lại
        while not is_float(integer_number):
            integer_number = input("Nhập lại phần tử số nguyên thứ " + str(i + 1) + " là ")
        list_integer_numbers.append(int(integer_number))
    list_integer_numbers.sort(reverse=True)
    return list_integer_numbers

#Bài 268: Hãy tạo mảng b từ mảng a các giá trị 0, 1 để mảng có tính chẵn lẻ

def create_array_b_from_array_a_so_array_b_has_parity(list):

    list_new = []
    for i in list:
        if list_new == []:
            list_new.append(i)
        if list_new[0] % 2 == 0 and i % 2 != 0:
            list_new.append(i)
            break
        elif list_new[0] % 2 != 0 and i % 2 == 0:
            list_new.append(i)
            break
    return list_new

#Bài 269: Thêm x vào trong mảng tăng nhưng vẫn giữ nguyên tính tăng của mảng

def adds_x_to_the_array_increment_but_keeps_the_array_increment(x, list):
    list.append(x)
    list.sort(reverse = False)
    return list

#Bài 270: Nhập mảng sau khi nhập xong đã tự sắp xếp tăng dần
def after_importing_the_array_has_been_sorted_in_ascending_order():
    list_integer_numbers = []

    n = input("Tổng số giá trị muốn nhập là ")
    while not is_option(n):
        print("Lỗi")
        n = input("Tổng số giá trị muốn nhập là ")

    # Dùng vòng lặp để nhập đối tượng vào mảng số nguyên
    for i in range(int(n)):

        integer_number = input("Nhập phần tử số nguyên thứ " + str(i + 1) + " là ")
        # Nếu ko phải là số thực thì nhập lại
        while not is_float(integer_number):
            integer_number = input("Nhập lại phần tử số nguyên thứ " + str(i + 1) + " là ")
        list_integer_numbers.append(int(integer_number))
    list_integer_numbers.sort(reverse=False)
    return list_integer_numbers

#Bài 271: Xóa các phần tử có chỉ số k trong mảng

def delete_eletments_with_list_index(list_index, list):
    for i in list_index:
        list.pop(i)
    return list
def delete_elements_with_index_k_in_the_array(k, list):
    list_index = []
    for i in range(len(list) -1 ,-1,-1):
        if list[i] == k:
            list_index.append(i)
    delete_eletments_with_list_index(list_index,list)
    return list

#Bài 273: Xóa tất cả các số âm trong mảng

def delete_all_negative_numbers_in_the_array(list):
    list_index = []
    for i in range(len(list) - 1, -1, -1):
        if list[i] < 0:
            list_index.append(i)
    delete_eletments_with_list_index(list_index, list)
    return list

#Bài 274: Xóa tất cả các số chẵn trong mảng

def delete_all_even_numbers_in_the_array(list):
    list_index = []
    for i in range(len(list) - 1, -1, -1):
        if list[i] % 2 == 0:
            list_index.append(i)
    delete_eletments_with_list_index(list_index, list)
    return list

#Bài 275: Xóa tất cả các số chính phương trong mảng
def delete_all_square_number_in_the_array(list):
    list_index = []
    for i in range(len(list) - 1, -1, -1):
        if is_square_number(list[i]) == 0:
            list_index.append(i)
    delete_eletments_with_list_index(list_index, list)
    return list

#Bài 276: Xóa tất cả các phần tử trùng với x

def delete_all_elements_that_match_x(x,list):
    list_index = []
    for i in range(len(list) - 1, -1, -1):
        if list[i] == x:
            list_index.append(i)
    delete_eletments_with_list_index(list_index, list)
    return list

# Bài 277: Xóa tất cả các số nguyên tố trong mảng
def delete_all_prime_number_in_the_array(list):
    list_index = []
    for i in range(len(list) - 1, -1, -1):
        if is_prime_number(list[i]) == 0:
            list_index.append(i)
    delete_eletments_with_list_index(list_index, list)
    return list

#Bài 278: Xóa tất cả các phần tử trùng nhau trong mảng và chỉ giữ lại duy nhất 1 phần tử
def delete_all_duplicate_elements_in_the_array_and_keep_only_1_element(list):
    a = len(list)
    i = 0
    while a > i:
        list_delete =[]
        for t in range(0,len(list)):
            if t == i:
                continue
            if list[i] == list[t]:
                list_delete.append(t)
                a = a - 1
        delete_eletments_with_list_index(list_delete,list)
        i += 1
    return list

#Bài 279: Xóa tất cả các phần tử xuất hiện nhiều hơn 1 lần trong mảng

def delete_all_elements_that_appear_more_than_once_in_the_array(list):
    a = len(list)
    i = 0
    while a > i:
        flag = 0
        list_delete =[]
        for t in range(0,len(list)):
            if t == i:
                continue
            if list[i] == list[t]:
                list_delete.append(t)
                flag = 1
                a = a - 1
        if flag == 1:
            list_delete.append(i)
            delete_eletments_with_list_index(list_delete,list)
            a = a -1
        else:
            i += 1
    return list
#Bài 280: Hãy đưa số 1 về đầu mảng

def change_the_specified_position_to_the_top(index , list):
    for i in range(index, -1 ,-1):

        #Gắn giá trị sau làm giá trị trước nó
        list[i] = list[i -1]
    #Gắn giá trị đầu bằng 0
    list[0] = 1
    return list

def return_number_one_to_the_beginning_of_the_array(list):

    for i in range(0 ,len(list)):
        #Nếu tìm được giá trị = 1
        if list[i] == 1:

            #Sử dụng hàm để đẩy một lên đầu mảng
            change_the_specified_position_to_the_top(i, list)
            return list

#Bài 281: Hãy đưa chẵn về đầu, lẻ về cuối, phần tử 0 nằm giữa mảng

#Đưa số chẵn vào đầu
def put_numbers_at_the_top_of_the_list(index, list):

    #Tạm lưu số đưa lên đầu để đưa lên đầu
    temp = list[index]

    #Chuyển giá trị sau làm giá trị trước
    for i in range(index, -1, -1):
        list[i] = list[i - 1]

    list[0] = temp

    return list

def put_zero_in_the_middle_of_the_list(index, index_last, list):

    for i in range(index,index_last+1):

        #Gắn giá trị trước bằng giá trị sau để điểm cuối cùng  = 0
        list[i] = list[i+1]

    #Gắn điểm cuối cùng  =0
    list[index_last] = 0

    return list

def put_even_to_beginning_and_odd_to_end_and_zero_in_the_middle_of_array(list):

    index_last_even_number = 0

    #Đẩy  số chẵn về đầu hàng
    for i in range(0 , len(list)):
        if list[i] % 2 == 0:
            put_numbers_at_the_top_of_the_list(i, list)

    #Tìm số chẵn cuối cùng
    for i in range(len(list)-1 ,-1 ,-1):
        if (list[i] % 2 == 0):
            index_last_even_number = i
            break

    #Tìm  0 trong chuỗi số chẵn
    for i in range(0, index_last_even_number):
        if list[i] == 0:
            put_zero_in_the_middle_of_the_list(i , index_last_even_number,list)
    return list

#Bài 282: Đưa các số chia hết cho 3 về đầu mảng

def returns_the_numbers_divisible_by_3_to_the_beginning_of_the_list(list):
    for i in range(0,len(list)):
        if list[i] % 3 == 0:
            put_numbers_at_the_top_of_the_list(i ,list)
    return list

#Bài 283: Đảo ngược mảng ban đầu
def reverse_the_original_array(list):
    #Xác định điểm đầu và điểm cuối
    first_point = 0
    last_point = len(list) -1

    while last_point > first_point:

        #Hoán đổi giá trị đầu thành giá trị cuối và ngược lại
        temp = list[first_point]
        list[first_point] =list[last_point]
        list[last_point] = temp

        first_point += 1
        last_point -= 1

    return list

#Bài 284: Đảo ngược thứ tự các số chẵn trong mảng

def reverse_the_order_of_even_numbers_in_array(list):
    for i in range(0, len(list)):
        if list[i] % 2 == 0:
            for t in range(i+1 , len(list)):
                if list[t] % 2 == 0:
                    temp = list[i]
                    list[i] = list[t]
                    list[t] =temp
    return list

#Bài 285: Đảo ngược thứ tự số dương trong mảng

def reverses_the_order_of_positive_numbers_in_the_array(list):
    for i in range(0, len(list)):
        if list[i] >  0:
            for t in range(i+1 , len(list)):
                if list[t] % 2 > 0:
                    temp = list[i]
                    list[i] = list[t]
                    list[t] = temp
    return list

#Bài 286: Dịch trái xoay vòng k phần tử trong mảng

def move_to_the_left_and_then_rotate_the_element_in_the_array_k_times(k,list):
    for i in range(k):
        temp  = list[0]
        for i in range(0, len(list) -1):
            list[i] = list[i + 1]
        list[len(list) - 1] = temp
    return list

#Bài 287: Dịch phải xoay vòng k phần tử trong mảng

def move_to_the_right_and_then_rotate_the_element_in_the_array_k_times(k,list):
    for i in range(k):
        temp  = list[0]
        for i in range(0, len(list) -1):
            list[i] = list[i + 1]
        list[len(list) - 1] = temp
    return list

#Bài 288: Hãy xuất phần tử trong mảng theo yêu cầu: chẵn vàng, lẻ trắng

def export_elements_in_the_array_as_required_even_yellow_and_odd_white(list):
    for i in list:
        if i % 2 == 0:
            print(colored('{}'.format(i), 'yellow'))
        else:
            print(colored('{}'.format(i), 'white'))

#Bài 289: Xuất mảng: chẵn nằm trên 1 mảng, lẻ nằm trên hàng tiếp theo
def print_even_is_on_an_array_and_odd_is_on_the_next_row(list):
    for i in list:
        if i % 2 == 0:
            print("{}".format(i) ,end=" ")
    print()
    for i in list:
        if i % 2 != 0:
            print("{}".format(i), end=" ")

#Bài 290: Đảo ngược thứ tự số chẵn và lẻ trong mảng nhưng giữ vị trí tương đối

def reverse_the_order_of_even_and_odd_numbers_in_array_but_keep_relative_position(list):
    for i in range(0, len(list)):
        if list[i] >= 0:
            for t in range(i+1, len(list)):
                if list[t] >= 0 and t != i:
                    if (list[t] % 2 == 0 and list[t] % 2 == 0) or (list[t] % 2 != 0 and list[t] % 2 != 0):
                        temp = list[i]
                        list[i] = list[t]
                        list[t] =temp
    return list

#Bài 291: Biến đổi mảng bằng cách thay giá trị max = giá trị min và ngược lại

def find_biggest_number_in_list(list):
    target_number = list[0]
    for i in range(1 , len(list)):
        if list[i] > target_number:
            target_number = list[i]

    return target_number

def find_smallest_number_in_list(list):
    target_number = list[0]
    for i in range(1, len(list)):
        if list[i] < target_number:
            target_number = list[i]

    return target_number

def replace_maximum_value_with_minimum_value_and_vice_versa(list):
    for i in range(0, len(list)):
        for t in range(i+1 ,len(list)):
            if (find_smallest_number_in_list(list) == list[i] and find_biggest_number_in_list(list) == list[t]) or (find_smallest_number_in_list(list) == list[t] and find_biggest_number_in_list(list) == list[i]):
                temp = list[i]
                list[i] = list[t]
                list[t] = temp

    return list

#Bài 293: Liệt kê tất cả các mảng con
def list_all_sub_arrays(list):
    #Tạo Mảng con

    #mảng chứa các mảng con
    lists = []

    for i in range(len(list)):
        t = lists[:]
        new = list[i]

        for j in range(len(lists)):
            lists[j] = lists[j] + [new]
        lists = t + lists

    return lists

if __name__ == '__main__':

    #Dùng hàm nhập
    result = enter_array_of_integer_numbers()
    # result2 = enter_array_of_integer_numbers()

    a = a(result)

    print(a)

<file_sep>#Bài 482: Hãy khai báo kiểu dữ liệu biểu diễn khái niệm đường thẳng ax + by + c = 0 trong mặt phẳng Oxy
# và định nghĩa hàm nhập, hàm xuất cho kiểu dữ liệu này
import mangsothuc as st

class straightLine():
    def __init__(self, a, b, c):
        self.a = a
        self.b = b
        self.c = c
    def set_a(self, a):
        self.a = a

    def set_b(self, b):
        self.b = b

    def set_c(self, c):
        self.c = c

    def get_a(self):
        return self.a

    def get_b(self):
        return self.b

    def get_c(self):
        return self.c

    def __str__(self):
        return "{}x + {}y + {} = 0".format(self.a, self.b, self.c)

def create_straight_line():
    a = input("Nhập a")
    while st.is_float(a) == False:
        a = input("Nhập lại a")
    b = input("Nhập b")
    while st.is_float(b) == False:
        b = input("Nhập lại b")
    c = input("Nhập c")
    while st.is_float(c) == False:
        c = input("Nhập lại c")
    p = straightLine(a,b,c)
    return p
a = create_straight_line()
print(a.__str__())<file_sep>#Bài 96: Viết chương trình nhập giá trị x sau tính giá trị của hàm số
# f(x) = 2x^2 + 5x + 9 khi x >= 5, f(x) = -2x^2 + 4x – 9 khi x < 5
import math

#Hàm kiểm tra giá trị có phải là số hay ko
def is_number(value):
    return value.isalpha()== False
#Hàm giải hàm số
def solve_number_funtion(x, a, b ,c ):
    if a != 0:
        if b!=0:
            # ax^2+ bx +c
            Sum = a * math.pow(x,2) + x * b +c
        else:
            # ax^2+ c
            Sum = a * math.pow(x, 2) + c
    else:
        if b != 0:
            # bx +c
            Sum = x * b +c
        else:
            # c
            Sum = c
    return Sum

if __name__ == '__main__':

    x = input("Nhập x = ")
    while not is_number(x):
        x = input("Nhập lại x = ")

        # Xét điều kiện
    if float(x) >=5 :
        #f(x) = 2x^2 + 5x + 9
        result = solve_number_funtion(float(x), 2, 5, 9)
    else:
        #f(x) = -2x^2 + 4x – 9
        result = solve_number_funtion(float(x), -2, 4, -9)

    print("Kết quả là" , result)<file_sep>#Bài 111: Viết chương trình in ra tam giác cân có độ cao h

#Kiểm tra lựa chọn
def is_option(value):
    return value.isdigit() and float(value).is_integer() and 1 <= int(value) <= 2

#Kiểm tra cạnh
def is_edge(value):
    return value.isdigit() and float(value).is_integer() and 1<= int(value)

#Hình chữ nhật đặc
def solid_rectangle(width, length):

    for row in range(width):
        for col in range(length):
            print("*", end= " ")

        #Xuống dòng
        print()

#hình chữ nhật rỗng
def hollow_rectangle(width, length):
    #Thiết kế chiều rộng
    for row in range(width):
        #thiết kế chiều cao
        for col in range(length):

            #In ngôi sao ở hàng đầu tiên, hàng cuối cùng , dòng dầu tiên và dòng cuối cùng
            if col == 0 or col == length-1 or row==0 or row == width -1:
                print("*", end=" ")
            else:
                print(end= "  ")
        #Xuống dòng
        print()

if __name__ == '__main__':
    print("1.  Hình chữ nhật đặc\n"
          "2. Hình chữ nhật rỗng")
    option = input("Nhập lựa chọn")

    while not is_option(option):
        option = input("Nhập lựa chọn hợp lệ: ")

    width = input("Nhập chiều rộng: ")

    while not is_edge(width):
        width  = input("Nhập lại chiều rộng: ")

    length = input("Nhập chiều dài: ")
    while not is_edge(length):
        length = input("Nhập lại chiều dài: ")

    if int(option) == 1:
        solid_rectangle(int(width),int(length))
    else:
        hollow_rectangle(int(width),int(length))<file_sep>n=int(input("Nhap N="))
sum=0
for i in range(1,n+1):
    sum=sum+i
print(sum)

<file_sep>#Bài 475: Hãy khai báo kiểu dữ liệu biểu diễn khái niệm phân số trong toán học và
# định nghĩa hàm nhập, hàm xuất cho kiểu dữ liệu này

import mangsonguyen as sn

def find_the_greatest_common_divisor_of_two_numbers(a, b):
    if sn.is_integer(a) == False or sn.is_integer(b) == False:
        print("Lỗi")
        return
    target_number = abs(a)
    if a > b:
        target_number = abs(b)
    for i in range(target_number, 0,-1):
        if a % i == 0 and b % i == 0:
            return i
def find_the_least_common_multiple_of_two_numberss(a, b):
    if sn.is_integer(a) == False or sn.is_integer(b) == False or a <=0 or b <= 0:
        print("Lỗi")
        return
    target_number = b
    if a > b:
        target_number = a
    for i in range(target_number, a * b +1):
        if i % a == 0 and i % b == 0:
            return i
class Fraction():
    def __init__(self,numerator,denominator):
        self.numerator = numerator
        self.denominator = denominator
    def set_numerator(self,numerator):
        self.numerator = numerator
    def set_denominator(self,denominator):
        self.denominator = denominator
    def get_numerator(self):
        return self.numerator
    def get_denominator(self):
        return self.denominator
    def __str__(self):
        return "{}/{}".format(self.numerator, self.denominator)

    # Bài 506: rút gọn phân số
    def fraction_reduction(self):
        temp = find_the_greatest_common_divisor_of_two_numbers(self.numerator, self.denominator)
        self.denominator = self.denominator // temp
        self.numerator = self.numerator // temp
        p = Fraction(self.numerator, self.denominator)
        return p
    # Bài 507: Tính tổng 2 phân số
    def sum_two_fractions(self,other):
        numerator = self.numerator * other.denominator + self.denominator * other.numerator
        denominator = self.denominator * other.denominator
        a = Fraction(numerator,denominator)
        a.fraction_reduction()
        return a
    # Bài 508: Tính hiệu 2 phân số
    def subtract_two_fractions(self,other):
        numerator = self.numerator * other.denominator - self.denominator * other.numerator
        denominator = self.denominator * other.denominator
        a = Fraction(numerator,denominator)
        a.fraction_reduction()
        return a
    # Bài 509: Tính tích 2 phân số
    def divisor_two_fractions(self,other):
        numerator = self.numerator * other.numerator
        denominator = self.denominator * other.denominator
        a = Fraction(numerator, denominator)
        a.fraction_reduction()
        return a
    # Bài 510: Tính thương 2 phân số
    def divisor_two_fractions(self,other):
        numerator = self.numerator * other.denominator
        denominator = self.denominator * other.numerator
        a = Fraction(numerator, denominator)
        a.fraction_reduction()
        return a
    # Bài 511: Kiểm tra phân số tối giản
    def simple_fraction_test(self):
        if find_the_greatest_common_divisor_of_two_numbers(self.numerator,self.denominator) == 1:
            print("Phân  số đã tối giản")
        else:
            print("Phân số chưa tối giản")
    # Bài 512: Qui đồng phân số
    def the_least_common_multiple_of_the_denominators(self,other):
        temp = find_the_least_common_multiple_of_two_numberss(self.denominator,other.denominator)
        self.numerator = (temp // self.denominator) * self.numerator
        other.numerator = (temp // other.denominator) * other.numerator
        self.denominator = temp
        other.denominator = temp
        print("Hai phân số sau khi quy đồng là\n"
              "{}/{} và {}/{}".format(self.numerator,self.denominator,other.numerator,other.denominator))
    # Bài 513: Kiểm tra phân số dương
    def is_a_positive_fraction(self):
        if self.numerator / self.denominator >= 0:
            print("Đây là phân số dương")
        else:
            print("Đây không phải là phân số dương")

    # Bài 514: Kiểm tra phân số âm
    def is_a_negative_fraction(self):
        if self.numerator / self.denominator < 0:
            print("Đây là phân số âm")
        else:
            print("Đây không phải là phân số âm")

    # Bài 515: So sánh 2 phân số: hàm trả về 1 trong 3 giá trị: 0,-1,1
    def compare_two_fractions(self,other):
        if self.is_a_positive_fraction() and other.is_a_negative_fraction():
            return 1
        elif other.is_a_positive_fraction() and self.is_a_negative_fraction():
            return -1
        else:
            if self.is_a_positive_fraction():
                a = self.numerator * other.denominator
                b = self.denominator * other.numerator
                if a > b:
                    return 1
                elif a == b:
                    return 0
                else:
                    return -1
            else:
                a = self.numerator * other.denominator
                b = self.denominator * other.numerator
                if a > b:
                    return -1
                elif a == b:
                    return 0
                else:
                    return 1

    # Bài 516: Định nghĩa toán tử operator + cho 2 phân số
    def __add__(self, other):
        numerator = self.numerator * other.denominator + self.denominator * other.numerator
        denominator = self.denominator * other.denominator
        a = Fraction(numerator, denominator)
        a.fraction_reduction()
        return a
    # Bài 517: Định nghĩa toán tử operator – cho 2 phân số
    def __sub__(self, other):
        numerator = self.numerator * other.denominator - self.denominator * other.numerator
        denominator = self.denominator * other.denominator
        a = Fraction(numerator, denominator)
        a.fraction_reduction()
        return a
    # Bài 518: Định nghĩa toán tử operator * cho 2 phân số
    def __mul__(self, other):
        numerator = self.numerator * other.numerator
        denominator = self.denominator * other.denominator
        a = Fraction(numerator, denominator)
        a.fraction_reduction()
        return a
    # Bài 519: Định nghĩa toán tử operator / cho 2 phân số
    def __truediv__(self, other):
        numerator = self.numerator * other.denominator
        denominator = self.denominator * other.numerator
        a = Fraction(numerator, denominator)
        a.fraction_reduction()
        return a

    # Bài 520: Định nghĩa toán tử operator ++ cho 2 phân số

    # Bài 521: Định nghĩa toán tử operator —- cho 2 phân số
def create_fraction():
    numerator = input("Nhập tử số")
    while sn.is_integer(numerator) == False:
        numerator = input("Nhập lại tử số")
    denominator = input("Nhập mẫu số")
    while sn.is_integer(denominator) == False or denominator ==0:
        denominator = input("Nhập lại mẫu số")
    p = Fraction(int(numerator),int(denominator))
    return p
a = create_fraction()
b = create_fraction()
print((a.the_least_common_multiple_of_the_denominators(b)))

<file_sep>#Bài 99: Viết chương trình nhập vào 3 số thực. Hãy in 3 số ấy ra màn hình theo thứ tự tang dần mà chỉ dùng tối đa 1 biến phụ

#Kiểm tra giá trị có phải là số thực hay ko
def is_real_number(value):
    return value.isalpha() == False

if __name__ == '__main__':
    list_float_number = []

    #Nhập 3 số thực
    first_number = input("Nhập số thực đầu tiên")
    while not is_real_number(first_number):
        first_number = input("Nhập lại số thực đầu tiên")

    second_number = input("Nhập số thực thứ hai")
    while not  is_real_number(second_number):
        second_number = input("Nhập lại số thực thứ hai")

    third_number = input("Nhập số thực thứ ba")
    while not  is_real_number(third_number):
        third_number = input("Nhập lại số thực thứ ba")

    #Add 3 số thực vaò mảng
    list_float_number.append(float(first_number))
    list_float_number.append(float(second_number))
    list_float_number.append(float(third_number))

    #Sắp xếp lại mảng theo thứ tự tăng dần
    result = list_float_number.sort(reverse=False)

    print(result)<file_sep>#Bài 119: Liệt kê tất cả các số nguyên tố nhỏ hơn n

#Kiểm tra giá tị nhập vào có phải là số nguyên dương
def is_number(value):
    return value.isdigit() and float(value).is_integer() and int(value) > 0

#Hàm tìm số nguyên tố
def is_prime_number(target_number):

    if target_number== 1 or target_number== 2 or target_number== 3:
        return True
    else:
        for i in range(2,target_number,1):
            if target_number % i == 0:
                return False

if __name__ == '__main__':

    # Nhập giá trị
    n = input("Nhập n ")
    while not is_number(n):
        n = input("Nhập lại n ")

    #Mảng chứ số nguyên tố
    list_prime_number = []

    for i in range(1,int(n)):
        if is_prime_number(i) != False :
            list_prime_number.append(i)

    print("Các số nguyên tố nhỏ hơn n lần lượt là " + str(list_prime_number))
<file_sep>#Bài 89: Viết chương trình tính tổng các giá trị lẻ nguyên dương nhỏ hơn N
def SumOldIntegers(Num):
    Sum = 0
    for i in range(1,Num,2):
        Sum += i
    return Sum
if __name__ == '__main__':
    n = input("Nhập N ")
    print(float(n).is_integer())
    while n.isdigit() == False or float(n).is_integer() == False or int(n) < 0:
        n = input("Nhập lại N ")

    print("Tổng các số lẻ nguyên dương nhỏ hơn N là " + str(SumOldIntegers(int(n))))

repo_language: Python