算法题记录

试写一个python程序，求平面直角坐标系中两点的距离：

class Coordinate:
    def __init__(self,x,y):
        self.x=x
        self.y=y
    def distance(self,other):
        x_diff_sq=(self.x-other.x)**2
        print(x_diff_sq)
        y_diff_sq=(self.y-other.y)**2
        print(y_diff_sq)
        return (x_diff_sq+y_diff_sq)**0.5
a=Coordinate(1,2)
b=Coordinate(4,6)
D=a.distance(b)
print('a和b之间的距离是：',D)


输出：
9
16
a和b之间的距离是： 5.0

 

水仙花数

class Solution:
    def findDoplicater():
        for i in range(1000, 10000):
            i1=i//100
            i2=i//100%10
            i3=i%10
            if i1**3+i2**3+i3**3==i:
                print(f"{i}是水仙花")


Solution.findDoplicater()

输出：
397是水仙花
713是水仙花

 

四叶玫瑰数

"四叶玫瑰数十4位数的自冥数。自冥数是指一个N位数，它的每个位数上的数字的n次冥之方和等于它本身"
"例如：当n为3时，有1^3+5^3+3^3=153，153是n为3时的一个自冥数，3位数是自冥数称为水仙花数"

class Solution:
    def findDoplicater():
        for i in range(1000,10000):
            i1=i//1000      #取千位数字  1234//1000=1
            i2=i//100%10    #取百位数字  1234//100=12 12%10=2
            i3=i//10%10     #取十位数字  1234//10=123 123%10=3
            i4=i%10         #取个位数字  1234%10=4
            # print(i1,i2,i3,i4)
            if i1**4+i2**4+i3**4+i4**4==i:
                print(f"{i}是四叶玫瑰数")

Solution.findDoplicater()


输出：
1634是四叶玫瑰数
8208是四叶玫瑰数
9474是四叶玫瑰数

 

逆序输出字符串

#逆序输出字符串
str=input("请输入：")
#切片方式
print(str[::-1])

#循环转换
list=[]
for x in range(len(str) -1,-1,-1):
    list.append(str[x])
print(''.join(list))


输入：abcd
输出：dcba

 

猜数字小游戏

#猜数字小游戏
#随机生成一个100以内的整数，共有10次机会开始游戏，输入猜测数字。
#猜大提示大，猜小提示小，猜对提示猜对游戏结束。
#十次机会用完还没猜对，提示游戏结束，没有猜到。

import random as rd
class aa(object):
    def bb(number):
        for i in range(10):
            choice = int(input("请输入数字："))
            if choice > number:
                print("你猜大了")
            elif choice <number:
                print("你猜小了")
            else:
                print("你猜对了，真棒！")
                print(f"你一共用了{i + 1}次机会")
                break
            print(f"还剩{9 - i}次机会")
        else:
            print("游戏结束，你没有猜到")
number1 = rd.randint(0, 100)
ss=aa
ss.bb(number1)


输出：
你猜大了
还剩2次机会
请输入数字：91
你猜对了，真棒！
你一共用了9次机会

 

百鸡百钱

#百鸡百钱
#需求分析：公鸡每只5元，母鸡每只3元，小鸡3只一元，现在拥有100元买100只鸡（三种类型鸡都要买），问公鸡、母鸡、小鸡各买多少？

#数学方程：
#设公鸡X只，母鸡Y只，小鸡Z只
#x+y+z=100
#5x+3y+z/3=100

#算法思路
#以公鸡为突破点公鸡5元一只，100元最多只能买20只
#由于三种鸡都要买，所有公鸡一定小于20只。
#母鸡每只3元，100全都要拿来买母鸡，也最多不能超过33只

class aa(object):
    def bb(count):
        for x in range(0,20):
            for y in range(0,33):
                z=100-x-y
                if z>0 and 5*x+3*y+z/3==100:
                    count+=1
                    print("=="*30)
                    print(f"第{count}种买法,公鸡买了{x}只，母鸡买了{y}只,小鸡买了{z}只")
number1=0
ss=aa
ss.bb(number1)


输出：
============================================================
第1种买法,公鸡买了0只，母鸡买了25只,小鸡买了75只
============================================================
第2种买法,公鸡买了4只，母鸡买了18只,小鸡买了78只
============================================================
第3种买法,公鸡买了8只，母鸡买了11只,小鸡买了81只
============================================================
第4种买法,公鸡买了12只，母鸡买了4只,小鸡买了84只

 

 润年问题

#润年问题
#输入年月日，输出该日期是否是润年，并且输出该日期是次年的多少天
#能被4整除，并且不能被100整除。能被400整除。两个条件满足一个就是润年


class aa(object):
    def bb(data_list):
        year=int(input("请输入年份："))
        mouth=int(input("请输入月份："))
        day=int(input("请输入日期："))
        count_day=day
        if year%4==0 and year%100!=0 or year%400==0:
            print(f"{year}是润年")
            data_list[1]=29
        else:
            print(f"{year}是平年")
            data_list[1]=28
        for i in range(mouth-1):
            count_day+=data_list[i]

        print(f"{year}年{mouth}月{day}日是当年的第{count_day}天")

data_list1=[31,29,31,30,31,30,31,31,30,31,30,31]
ss=aa
ss.bb(data_list1)


输出：
请输入年份：2024
请输入月份：2
请输入日期：21
2024是润年
2024年2月21日是当年的第52天

 

猴子吃桃问题

#猴子吃桃问题
#需求分析
#猴子第一天摘下若干桃子，当即吃了一半，不过瘾，又多吃了一个。
#猴子第二天又将剩下的桃子吃掉一半，由多吃了一个。
#以后每天吃前一天剩余的一半零一个，第10天早上剩余一个桃子
#求原来一共有多少桃子


class aa:
    def bb(p):
        print(f'第10天还剩{p}个桃子')
        for i in range(9,0,-1):
            p=(p+1)*2
            print(f"第{i}天还剩{p}个桃子")
        print(f"第一天一共摘了{p}个桃子")

p1=1
ss=aa
ss.bb(p1)


输出：
第10天还剩1个桃子
第9天还剩4个桃子
第8天还剩10个桃子
第7天还剩22个桃子
第6天还剩46个桃子
第5天还剩94个桃子
第4天还剩190个桃子
第3天还剩382个桃子
第2天还剩766个桃子
第1天还剩1534个桃子
第一天一共摘了1534个桃子

 

冒泡排序

#冒泡排序
import numpy as np

pop_list=np.random.randint(100,size=6)  #随机生成6位属性的列表

# print(pop_list)
count=len(pop_list)
print('没排序之前的序列',pop_list)

for i in range(count-1):
    for j in range(count-i-1):
        if pop_list[j]>pop_list[j+1]:
            pop_list[j],pop_list[j+1]=pop_list[j+1],pop_list[j]
print('排序好的序列',pop_list)


输出：
没排序之前的序列 [35 25 19 83 34 69]
排序好的序列 [19 25 34 35 69 83]

 

二分查找

#二分查找

arr_list=[1,3,5,7,11,22,27,33,39,52,59]

def binary_search(number,left,right):
    if left <=right:
        middle=(left+right)//2
        if number<arr_list[middle]:
            right=middle-1
        elif number>arr_list[middle]:
            left=middle+1
        else:
            return middle
        return binary_search(number,left,right)
    else:
        return -1
a=22
b=0
c=len(arr_list)-1
print(binary_search(a,b,c))

输出：
5

 

选择排序

import random as rd

sec_licst=[rd.randint(1,100) for i in range(5)]
length=len(sec_licst)
print(f'未排序的列表为：{sec_licst}')

for i in range(length-1):
    min_index=i
    for j in range(i+1,length):
        if sec_licst[min_index]>sec_licst[j]:
            min_index=j
    sec_licst[min_index],sec_licst[i]=sec_licst[i],sec_licst[min_index]
    print(f"第{i+1}轮排好序是：{sec_licst}")
print(f'最终排好序的列表为：{sec_licst}')


输出：
未排序的列表为：[84, 46, 62, 50, 27]
第1轮排好序是：[27, 46, 62, 50, 84]
第2轮排好序是：[27, 46, 62, 50, 84]
第3轮排好序是：[27, 46, 50, 62, 84]
第4轮排好序是：[27, 46, 50, 62, 84]
最终排好序的列表为：[27, 46, 50, 62, 84]

 

剪刀、石头、布

#剪刀、石头、布
#1剪刀、2石头、3布
#游戏初始用户和电脑都有100分，赢加10分，输减10分
#当用户为0时，游戏结束提示游戏输
#当用户为200时，游戏也结束，提示用户赢。每轮比赛都输出当前的分数

import random as rd

game_info={1:'剪刀',2:'石头',3:'布'}
score=100

while True:
    robots_choic=rd.randint(1,3)
    user_choice=input("请出拳")
    if user_choice not in '123':
        print('出拳错误，请重新出拳')
        continue
    user_choice=int(user_choice)
    print('#'*20)
    print(f'电脑出{game_info[robots_choic]}')
    print(f'你出{game_info[user_choice]}')
    print('*'*20)
    if user_choice==1 and robots_choic==3 or user_choice==2 and robots_choic==1 or user_choice==3 and robots_choic==2:
        score+=10
        print(f"你赢了比赛，当前得分为{score}")
    elif user_choice==robots_choic:
        print(f'平局，当前分数为：{score}')
    else:
        score-=10
        print(f'你输了比赛，当前分数：{score}')
    if score>=200:
        print('游戏结束，你赢了')
        break
    elif score<=0:
        print('游戏结束，你输了')
        break


输出：
请出拳3
####################
电脑出剪刀
你出布
********************
你输了比赛，当前分数：90

 

快乐数

# 比如：19，该数字的所有位数平方和，得到新的平方和，重复 最终结果是1
#第一轮：1*1+9*9=1+81=82
#第二轮：8*8+2*2=64+4=68
#第三轮：6*6+8*8=36+64=100
#第四轮：1*1+0*0+0*0=1


def sum_square(n):
    sum=0
    for i in str(n):
        sum+=int(i)**2
    return sum

list1=[]
n=int(input('请输入数字：'))
while sum_square(n) not in list1:
    n=sum_square(n)
    list1.append(n)

if n==1:
    print('是快乐数')
else:
    print('不是快乐数')


请输入数字：82
是快乐数

 

猜年龄

#猜年龄
#小冥两个妹妹，年龄之乘积是年龄之和的6倍，她们不是双胞胎，年龄差不超过8岁,求较小妹妹的年龄


for i in range(100):
    for j in range(1,i):
        if i*j==(i+j)*6 and i-j<8 and i>j:

            print(i,j)


输出：
15 10

 

猜年龄二

#猜年龄二
#年龄的立方是4位数，年龄的4次方是6位数。这10个数字正好包含了数字0到9，切都出现一次。


for i in  range(10,30):
    i3=str(i**3)
    i4=str(i**4)
    if len(i3)==4 and len(i4)==6:
        if len(set(i3+i4))==10:
            print(i)
            print(i3)
            print(i4)
            print(i3+i4)


输出：
18
5832
104976
5832104976

 

 

 

 

 

 

 

 

常数时间插入、删除、获取随机元素

"常数时间插入、删除、获取随机元素"
"insert(val):当元素val不存在时，向集合中插入该项"
"remove(val)元素val存在时，从集合中删除该项"
"getRandom:随机返回现有集合中的一项。每个元素应该有相同的概率被返回"


import random

class RandomizedSet:
    def __init__(self):
        self.data = [1,2]
        self.values=[2,3,5,8,9,1,7,'a']
        self.index={'a':1,'b':2,'c':3,1:2}
    def insert(self, val):
        if val in self.index:
            return False
        self.values.append(val)
        self.index[val] = len(self.values) - 1
        return True
    def remove(self, val):
        if val not in self.index:
            return False
        self.index[self.values[-1]] = self.index[val]
        self.values[-1], self.values[self.index[val]] = self.values[self.index[val]], self.values[-1]
        self.values.pop()
        self.index.pop(val)
        return True
    def getRandom(self):
        # return self.data
        return self.values[random.randint(0,len(self.values)-1)]

x="122"
x = RandomizedSet()
print(x.remove(1))
print(x.getRandom())


输出：
True
8