Olá a todos, o editor está aqui para responder às seguintes perguntas para vocês, banco de perguntas de programação em python e análise de respostas, perguntas e respostas de programação clássica em python, vamos dar uma olhada agora!
Tópico 1: Número de narcisos
O número narcisista também é conhecido como invariante digital mais-perfeito (PPDI), número narcisista, número de auto-exponencialização, número de Armstrong ou número de Armstrong.
O número narciso é um número de 3 dígitos em que a soma das terceiras potências dos dígitos de cada dígito é igual a si mesmo. Por exemplo: 1^3 + 5^3+ 3^3 = 153 Como instalar bibliotecas de terceiros em Python e como instalar o módulo PIL em Python .
for i in range(100, 1000):
i1 = i // 100 # 取百位数字 123//100=1
i2 = i // 10 % 10 # 取十位数字 123//10=12 12%10=2
i3 = i % 10 # 取个位数字 123%10=3
if i1 ** 3 + i2 ** 3 + i3 ** 3 == i:
print(f"{i}是水仙花数")
# 153 是水仙花数
# 370 是水仙花数
# 371 是水仙花数
# 407 是水仙花数
Tópico 2: Número de rosas de quatro folhas
O número da rosa de quatro folhas é um número de potência de 4 dígitos. Um número autoexponencial é um número de n dígitos em que a soma das enésimas potências dos dígitos em cada dígito é igual a si mesmo.
(Por exemplo: quando n é 3, há 1 ^ 3 + 5 ^ 3 + 3 ^ 3 = 153. 153 é um número autoexponencial quando n é 3. O número autoexponencial de 3 dígitos é chamado de número narciso.).
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(i,i1,i2,i3,i4)
if i1 ** 4 + i2 ** 4 + i3 ** 4 + i4 ** 4 == i:
print(f'{i}是四叶玫瑰数')
# 1634 是四叶玫瑰数
# 8208 是四叶玫瑰数
# 9474 是四叶玫瑰数
Pergunta 3: Strings de saída na ordem inversa
- Método de escrita 1: método de fatiamento
str = input("请输入字符串")
print(str[::-1])
- Método de escrita 2: conversão de loop
str = input("请输入字符串")
list = []
for x in range(len(str) -1,-1,-1):
list.append(str[x])
print(''.join(list))
Tópico 4: Jogo de adivinhação de números
análise de demanda:
Gere aleatoriamente um número inteiro dentro de 100. Existem 10 chances de iniciar o jogo e inserir o número adivinhado.
-
Se a estimativa for muito pequena, o prompt será: A estimativa é muito pequena.
-
Se a estimativa for muito alta, será solicitado: A estimativa é muito grande.
-
Se você adivinhar corretamente, será solicitado: Adivinhe corretamente e o jogo terminará.
-
Se você não adivinhou corretamente após 10 chances, diga: Fim de jogo, sem palpite.
import random as rd
number = rd.randint(0,100)
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('游戏结束，你没有猜到')
Tópico 5: Cem galinhas e cem moedas
análise de demanda:
Galos custam 5 yuans cada, galinhas 3 yuans cada e 3 pintinhos custam 1 yuan. Agora você deve comprar 100 galinhas (três tipos de galinhas) com 100 yuans. Pergunte quantos galos, galinhas e pintinhos você deseja comprar. Apenas?
Equação matemática:
-
Suponha que você compre um número x de galos, um número y de galinhas e um número z de pintinhos.
-
x+y+z= 100
-
5x+3y+z/3 = 100
Ideias de algoritmo
-
Tomando o galo como ponto de avanço, um galo custa 5 yuans e você só pode comprar 20 no máximo por 100 yuans.
-
Como é necessário comprar três tipos de frangos, o número de galos deve ser inferior a 20.
-
As galinhas custam 3 yuans cada. Use todos os 100 para comprar galinhas. O número máximo não pode exceder 33.
-
Seja o número de galos x, o número de galinhas y e o número de galinhas z
-
Contanto que 5x+3y+z/3=100 e x+y+z==100 sejam satisfeitos, o resultado desta combinação pode ser gerado.
count = 0
for x in range(1,20):
for y in range(1,33):
z = 100 - x -y
if z > 0 and 5 * x + 3 * y + z / 3 == 100:
count += 1
print("="*60)
print(f'第{count}种买法，公鸡买了{x}只，母鸡买了{y}只，小鸡买了{z}只')
# == == == == == == == == == == == == == == == == == == == == == == == == == == == == == ==
# 第1种买法，公鸡买了4只，母鸡买了18只，小鸡买了78只
# == == == == == == == == == == == == == == == == == == == == == == == == == == == == == ==
# 第2种买法，公鸡买了8只，母鸡买了11只，小鸡买了81只
# == == == == == == == == == == == == == == == == == == == == == == == == == == == == == ==
# 第3种买法，公鸡买了12只，母鸡买了4只，小鸡买了84只
Tópico 6: Versão atualizada do problema do ano bissexto
Insira o ano, mês e dia, informe se a data é um ano bissexto e informe o dia do ano em que a data é.
Condições de julgamento do ano bissexto:
-
Divisível por 4 e não divisível por 100
-
Divisível por 400
-
Se qualquer uma das duas condições for atendida, trata-se de um ano bissexto.
Ideia de algoritmo:
-
Receba o ano, mês e dia inseridos pelo usuário e crie uma lista que salva os dias de 12 meses
-
Determine se é um ano bissexto com base no ano. Se for, defina fevereiro para 29 dias, caso contrário, defina fevereiro para 28 dias.
-
De acordo com o mês e a data, é o dia do ano
year = int(input("请输入年份"))
month = int(input("请输入月份"))
day = int(input("请输入日期"))
date_list = [31,29,31,30,31,30,31,31,30,31,30,31]
count_day = day
if year % 4 == 0 and year % 100 !=0 or year % 400 == 0:
print(f'{year}年是闰年')
date_list[1]=29
else:
print(f'{year}年是平年')
date_list[1]=28
for i in range(month-1):
count_day += date_list[i]
print(f'{year}年{month}月{day}日是当年的第{count_day}天')
Tópico 7: Problema de macaco comendo pêssego
análise de demanda:
-
O macaco colheu alguns pêssegos no primeiro dia e comeu metade imediatamente, quando não ficou satisfeito comeu mais um.
-
Na manhã seguinte comi metade dos pêssegos restantes e mais um.
-
A partir daí, todas as manhãs comi metade e uma das sobras do dia anterior. Quando quis comer de novo na manhã do 10º dia, vi que só restava um pêssego.
-
Descubra quantos pêssegos ele colheu no total.
Esta questão pode ser resolvida de trás para frente usando o pensamento recursivo.
-
No 10º dia sobrou apenas um antes de comer, o que significa que no 9º dia comeu metade da comida e comeu outra, e ainda sobrou uma.
-
Suponha que haja p pêssegos antes de comer no 9º dia
-
Pode-se obter: p/2 - 1 = 1, e o número de pêssegos no nono dia é p=4.
-
Por analogia, você pode calcular quantos pêssegos foram colhidos no primeiro dia.
Ideia de algoritmo:
-
O número de pêssegos antes de comer no 10º dia é inicializado para p=1
-
Faça um loop de 9 a 1 9 vezes. De acordo com a fórmula acima, faça backup como p=(p+1)*2 para obter o número de pêssegos antes de comer no primeiro dia.
p = 1
print(f'第10天还剩下{p}个桃子')
for i in range(9,0,-1):
p = (p + 1) * 2
print(f'第{i}天还剩下{p}个桃子')
print(f'第一天一共摘了{p}个桃子')
# 第10天还剩下1个桃子
# 第9天还剩下4个桃子
# 第8天还剩下10个桃子
# 第7天还剩下22个桃子
# 第6天还剩下46个桃子
# 第5天还剩下94个桃子
# 第4天还剩下190个桃子
# 第3天还剩下382个桃子
# 第2天还剩下766个桃子
# 第1天还剩下1534个桃子
# 第一天一共摘了1534个桃子
Tópico 8: Classificação por bolhas
A origem do algoritmo de classificação por bolhas: O nome deste algoritmo vem do fato de que elementos menores irão lentamente "flutuar" até o topo da matriz por meio de troca (em ordem crescente ou decrescente), assim como as bolhas de dióxido de carbono em bebidas carbonatadas. eventualmente flutuará para o topo. , daí o nome "classificação por bolha"
De frente para trás (ou seja, partindo do elemento com o subscrito menor), os valores dos elementos adjacentes são comparados em sequência. Se for constatado que o valor é maior que o anterior, as posições são trocadas, então que o elemento com o valor maior se mova gradualmente da frente para trás.
Suponha que haja uma lista [29,12,19,37,14] que você deseja classificar em ordem crescente
Rodada 1: A lista inicial é [29,12,19,37,14]
-
Compare 29> 12 posições de troca: [12,29,19,37,14]
-
Compare 29> 19 posições de troca: [12,19,29,37,14]
-
Compare 29 > 37 não maior que, sem troca: a lista permanece a mesma acima
-
Compare 37> 14 posições de troca: [12,19,29,14,37]
Segunda rodada: A lista herda da rodada anterior como [12,19,29,14,37]
-
Compare 12 > 19 não maior que, sem troca: a lista permanece a mesma acima
-
Compare 19 > 29 não maior que, sem troca: a lista permanece a mesma acima
-
Compare 29> 14 posições de troca: [12,19,14,29,37]
A terceira rodada: A lista herda a rodada anterior como [12,19,14,29,37]
-
Compare 12 > 19 não maior que, sem troca: a lista permanece a mesma acima
-
Compare 19> 14 posições de troca: [12,14,19,29,37]
Rodada 4: a herança da lista da rodada anterior é [12,14,19,29,37]
-
Compare 12 > 14 não maior que, sem troca: a lista permanece a mesma acima
-
Classificação da lista concluída: [12,14,19,29,37]
import numpy as np
pop_list = np.random.randint(100,size=6)
# pop_list = [82,15,15,41,37,31]
# pop_list = [29,12,19,37,14]
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)
# 排好序的列表为 [15, 15, 31, 37, 41, 82]
# 排好序的列表为 [12, 14, 19, 29, 37]
Pergunta 9: Método de pesquisa binária
O método da dicotomia é um método de pesquisa relativamente eficiente
Lembre-se do jogo de adivinhação de números que joguei antes. Um número inteiro positivo x menor que 100 é fornecido antecipadamente para você adivinhar. Durante o processo de adivinhação, você receberá dicas para avaliar o tamanho. Como você pode adivinhar rapidamente? O jogo que fizemos antes deu 10 chances. Se aprendermos o método de busca binária, não importa qual seja o número, leva apenas 7 vezes no máximo para adivinhar o número.
- método de pesquisa binária
Primeiro adivinhe 50, se a estimativa estiver correta, termine; se a estimativa for maior, adivinhe na direção menor, e então adivinhe 25; se a estimativa for menor, adivinhe na direção maior, e então adivinhe 75;...remover metade de cada número adivinhado, para que possamos nos aproximar gradativamente do número pré-dado. Essa ideia é o método da dicotomia.
Aplicação da dicotomia
-
Deve ser uma sequência ordenada.
-
Existem requisitos para a quantidade de dados.
-
A quantidade de dados é muito pequena para ser adequada para pesquisa binária e a melhoria da eficiência não é óbvia em comparação com o percurso direto.
-
Não é adequado usar a pesquisa binária se a quantidade de dados for muito grande, porque a matriz requer espaço de armazenamento contínuo. Se a quantidade de dados for muito grande, muitas vezes é impossível encontrar espaço de memória contínuo para armazenar esses dados em grande escala .
Ideia de algoritmo:
Suponha que haja uma lista ordenada: [5,7,11,22,27,33,39,52,58]
O número 11 está nesta lista e, em caso afirmativo, qual é o seu valor de índice?
-
Primeiro, comparamos as posições intermediárias 27 e 11 da lista ordenada e descobrimos que 11 é menor que 27.
-
Portanto, excluímos os números à direita de 27 e a lista restante é: [5,7,11,22]
-
Então pegamos 7 e 11 no meio de [5,7,11,22] e comparamos e descobrimos que 11 é maior que 7, então excluímos os números à esquerda de 7 e a lista retida é: [11 ,22]
-
Finalmente, tomamos a posição intermediária entre 11 e 22
-
Acabou de chegar a 11. Neste momento, pode ser retornado o valor do índice 11. Se não for encontrado, avisará que não existe.
A primeira abordagem puramente algorítmica
arr_list = [5,7,11,22,27,33,39,52,58]
number = 11
count = 0
left = 0
right = len(arr_list)-1
while left<=right:
middle = (left+right)//2
count += 1
if number > arr_list[middle]:
left = middle +1
elif number < arr_list[middle]:
right = middle - 1
else:
print(f'数字{number}已找到，索引值为{middle}')
break
else:
print(f'数字{number}没有找到')
print(f'一共用了{count}次查找')
# 数字11已找到，索引值为2， 一共用了3次查找
O segundo método de função recursiva
arr_list = [5,7,11,22,27,33,39,52,58]
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
print(binary_search(11,0,len(arr_list)-1))
Tópico 10: Classificação de seleção
Idéia básica: Encontre o menor elemento da sequência não classificada e coloque-o na primeira posição, depois encontre o menor elemento da sequência não classificada restante e coloque-o na segunda posição, e assim por diante até que todos os elementos sejam classificados.
-
Se a lista for [6, 8, 3, 5, 9, 10, 7, 2, 4, 1], primeiro encontre 1 e troque-o no mínimo para a 1ª posição
-
Obtenha a lista [1, 8, 3, 5, 9, 10, 7, 2, 4, 6], seguida de 2 transposições mínimas para a 2ª posição
-
Obtenha a lista [1, 2, 3, 5, 9, 10, 7, 8, 4, 6], seguida de 3, a posição mínima permanece inalterada
-
Obtenha a lista [1, 2, 3, 5, 9, 10, 7, 8, 4, 6], seguida de 4 transposições mínimas para a 4ª posição
-
Obtenha a lista [1, 2, 3, 4, 9, 10, 7, 8, 5, 6], seguida de 5 transposições mínimas para a 5ª posição
-
Obtenha a lista [1, 2, 3, 4, 5, 10, 7, 8, 9, 6], seguida de 6 transposições mínimas para a 6ª posição
-
Obtenha a lista [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], seguida de 7, a posição mínima permanece inalterada
-
Obtenha a lista [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], seguida de 8, a posição mínima permanece inalterada
-
Obtenha a lista [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], seguida de 9, a posição mínima permanece inalterada
-
Obtenha a lista [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], seguida de 10. A posição mínima permanece inalterada e a classificação é concluída.
import random as rd
sec_list = [rd.randint(1,100) for i in range(8)]
# sec_list = [91,30,93,98,26,98,20,90]
length = len(sec_list)
print(f'未排序的列表为：{sec_list}')
for i in range(length -1):
min_index = i
for j in range(i + 1,length):
if sec_list[min_index] > sec_list[j]:
min_index = j
sec_list[min_index],sec_list[i] = sec_list[i],sec_list[min_index]
print(f'第{i+1}轮排好序是：{sec_list}')
print(f'最终排好序的列表为：{sec_list}')
# 未排序的列表为：[91, 30, 93, 98, 26, 98, 20, 90]
# 第1轮排好序是：[20, 30, 93, 98, 26, 98, 91, 90]
# 第2轮排好序是：[20, 26, 93, 98, 30, 98, 91, 90]
# 第3轮排好序是：[20, 26, 30, 98, 93, 98, 91, 90]
# 第4轮排好序是：[20, 26, 30, 90, 93, 98, 91, 98]
# 第5轮排好序是：[20, 26, 30, 90, 91, 98, 93, 98]
# 第6轮排好序是：[20, 26, 30, 90, 91, 93, 98, 98]
# 第7轮排好序是：[20, 26, 30, 90, 91, 93, 98, 98]
# 最终排好序的列表为：[20, 26, 30, 90, 91, 93, 98, 98]
Tópico 11: Pedra, Papel, Tesoura
-
Quando o jogo começa, tanto o usuário quanto o computador possuem 100 pontos no estado inicial. Uma vitória equivale a +10 pontos e uma derrota equivale a -10 pontos.
-
Quando o usuário marca 0 pontos, o jogo termina, informando que o jogo termina e o jogo está perdido.
-
Quando o usuário atinge 200 pontos, o jogo termina, fazendo com que o jogo termine, vencendo o jogo e exibindo a pontuação atual em cada rodada.
-
1 representa tesoura 2 representa pedra 3 representa papel
import random as rd
print('=' * 60)
print(' ' * 20, '剪刀石头布游戏')
print('1代表剪刀 2代表石头 3代表布')
game_info = {1: "剪刀", 2: "石头", 3: "布"}
score = 100
while True:
robots_choice = rd.randint(1, 3)
user_choice = input("请出拳")
if user_choice not in '123':
print('出拳错误，请重新出拳')
continue
user_choice = int(user_choice)
print('*' * 60)
print(f'电脑出{game_info[robots_choice]}')
print(f'你出{game_info[user_choice]}')
print('*' * 60)
if user_choice == 1 and robots_choice == 3 or user_choice == 2 \
and robots_choice == 1 or user_choice == 3 and robots_choice == 2:
score += 10
print(f'你赢得本轮游戏，当前分数为{score}')
elif user_choice == robots_choice:
print(f'本轮游戏平局，当前分数为{score}')
else:
score -= 10
print(f'你输了本轮游戏，当前分数{score}')
if score >= 200:
print('游戏结束，你赢得比赛')
break
elif score <= 0:
print('游戏结束，你输了')
break
Tópico 12: Números Felizes
Sob um determinado número, calcula-se a soma dos quadrados de todos os dígitos do número. O novo número obtido é novamente a soma dos quadrados de todos os dígitos. Repita este processo e o resultado final deve ser 1.
Por exemplo, o número: 19
-
Rodada 1: (1_1)+(9_9) =1 + 81 = 82
-
Rodada 2: (8_8)+(2_2) =64 + 4 = 68
-
Rodada 3: (6_6)+ (8_8) =36 + 64 = 100
-
Rodada 4: (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('不是快乐数')
Tópico 13: Adivinhe a idade (1)
Xiao Ming levou suas duas irmãs mais novas para participar do Festival das Lanternas Festival das Lanternas. Quando alguém lhes perguntou quantos anos tinham, eles disseram, brincando: "O produto das nossas idades é 6 vezes a soma das nossas idades." Xiao Ming acrescentou: “Eles não são gêmeos e a diferença de idade não deve ser superior a 8 anos.” Por favor, anote a idade da irmã mais nova de Xiao Ming.
for i in range(1,100):
for j in range(1,i):
if i*j == 6*(i+j) and i-j<8:
print(i,j)
# 15 10
Pergunta 14: Adivinhe a idade (2)
O matemático americano N. Wiener era mentalmente precoce e ingressou na faculdade aos 11 anos. Ele foi convidado para dar palestras na Universidade Tsinghua, na China, de 1935 a 1936.
Certa vez, ele compareceu a uma reunião importante e seu rosto jovem chamou a atenção.
Então alguém lhe perguntou a idade e ele respondeu:
"O cubo da minha idade é um número de 4 dígitos. A 4ª potência da minha idade é um número de 6 dígitos. Esses 10 números contêm exatamente 10 números de 0 a 9, cada um ocorrendo exatamente uma vez."
Você pode estimar quão jovem ele era naquela época?
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 + i4)
# 18
# 5832104976 舍去
Tópico 15: Implementação do algoritmo de divisão
split é um método muito útil incorporado em strings python
-
Ele pode cortar uma string na lista que queremos por delimitador
-
Por exemplo, agora temos a string life-is-short-you-need-python. Cada palavra é separada pelo delimitador "-"
-
Quando chamamos o método de divisão de string e passamos nosso delimitador "-", obteremos uma lista na qual cada elemento é na verdade uma substring cortada pelo delimitador.
-
Então, como implementar esse algoritmo? O método split integrado do Python é implementado na linguagem C. Hoje vamos escrever uma função para obter a mesma função que split.
-
Vamos primeiro falar sobre como implementar o algoritmo. Este algoritmo exige que iteremos a string. Primeiro definimos um ponteiro de inicialização, porque quando fatiamos, precisamos começar de onde fatiar.
-
Portanto, primeiro precisamos inicializar um ponteiro. Podemos definir uma variável de ponteiro com um valor padrão de 0. Em seguida, começamos a iterar sobre a string.
-
Quando encontrarmos o primeiro delimitador, obteremos o índice do delimitador atual?Neste momento, fatiaremos a string do ponteiro inicial até o final do delimitador.
-
Porque nossas strings são fechadas à esquerda e abertas à direita, e seu índice final é o índice do delimitador, então ele só ganhará vida e nós o adicionaremos à lista.
-
Imediatamente após adicioná-lo, precisamos modificar a posição do ponteiro inicializado. Onde devemos modificá-lo? Modifique para a próxima posição do separador que encontramos pela primeira vez, que é i, e então continue a iterar
-
Após a iteração, o segundo delimitador é encontrado. Existe outro índice do delimitador? Neste momento, continuamos a fatiar a string. A posição inicial da fatia é o ponteiro da sua posição i, e a posição final é a segunda - O ponteiro segue as regras de fechamento à esquerda e abertura à direita, portanto nossa palavra também pode ser adicionada à lista
-
Isso vai até o fim. Quando iteramos até o último caractere n, descobrimos que não há nenhuma barra horizontal separadora atrás dele. Neste momento, precisamos processá-lo e julgá-lo. Se o caractere para o qual iteramos for O último caractere , então, quando cortarmos, de onde devemos cortá-lo?
-
Começando em p, se cortarmos para n, só podemos obter python, e cortar um n a menos, então para a posição de n + 1, bem, se conhecermos esse processo, podemos usar o código para implementar esse algoritmo.
def split_s(string, sep="", num=0):
split_words = []
last_index = 0
count = 0
for index, char in enumerate(string):
if count == num and num > 0:
split_words.append(string[last_index:len(string)])
break
if char == sep:
split_words.append(string[last_index:index])
last_index = index + 1
count += 1
elif index + 1 == len(string):
split_words.append(string[last_index:index + 1])
return split_words
print(split_s("life-is-short-you-need-python",'-'))
# ['life', 'is', 'short', 'you', 'need', 'python']
print(split_s("life-is-short-you-need-python",'-',2))
# ['life', 'is', 'short-you-need-python']
Tópico 16: Sequência Dayan
Na literatura chinesa antiga, foi registrada a "Sequência Dayan", que é usada principalmente para explicar o princípio de derivação do Tai Chi na cultura tradicional chinesa. Seus primeiros são: 0, 2, 4, 8, 12, 18, 24, 32 , 40 , 50... A regra é: os itens pares são o quadrado do número de série dividido por 2, e os itens ímpares são o número de série ao quadrado menos 1 e dividido por 2. Imprima os primeiros 100 termos da Sequência Dayan
for x in range(1,101):
if x % 2 == 0: # 偶数
a = int((x ** 2) / 2)
else: # 奇数
a = int((x ** 2 - 1) / 2)
print(a)
# 0
# 2
# 4
# 8
# 12
# 18
# 24
# 32
# 40
# 50
Tópico 17: Análise de palavras
Xiaolan está aprendendo uma língua mágica. As palavras nesta língua são todas compostas por letras minúsculas do inglês. Algumas palavras são muito longas, excedendo em muito o comprimento das palavras normais do inglês. Xiao Lan não conseguia se lembrar de algumas palavras depois de aprendê-las por muito tempo. Ele planejava não memorizá-las completamente, mas distinguir as palavras de acordo com as letras que apareciam com mais frequência nas palavras.
Agora, por favor, ajude Xiao Lan. Depois de dar uma palavra a ele, ajude-o a encontrar a letra que mais aparece e o número de vezes que essa letra aparece. Na verdade, significa que depois de inserir uma string, você poderá obter a letra que aparece o máximo e o número de vezes que aparece na string atual.
输入：HelloWorld
输出：
l # 小写字母 l
3 # 小写字母 l,出现了3次，出现次数最多
-
Podemos fazer um loop e iterar a string atual e, em seguida, usar cada caractere atual da string como um valor-chave e armazená-lo no dicionário. Se a chave atual estiver no dicionário, adicionaremos um a ela.
-
Se não estiver lá, inicializaremos seu número como 1 e, finalmente, encontraremos o valor-chave e o valor mais frequente do dicionário.
def analyse_words(words):
word_dict = {}
for i in words:
if i in word_dict:
word_dict[i] += 1
else:
word_dict[i] = 1
max_key = max(word_dict,key=word_dict.get)
print(max_key)
print(word_dict[max_key])
# l
# 3
analyse_words('helloworld')
Pergunta 18: Use pilha para imprimir formato de diamante
Insira o comprimento do lado n e imprima o losango correspondente ao comprimento do lado.
analisar:
-
imprima algumas linhas
-
Imprima vários espaços e estrelas por linha
-
As primeiras linhas são adicionadas à pilha antes da impressão, e as próximas linhas são impressas usando o princípio último a entrar, primeiro a sair da pilha.
def diamond(n):
stack = []
for i in range(1, 2 * n):
if i <= n:
p_str = ' ' * (n - i) + '*' * (2 * i - 1)
if i != n:
stack.append(p_str)
print(p_str)
else:
print(stack.pop())
diamond(5)
# 为了区分我把空格换成了点
# ....*
# ...***
# ..*****
# .*******
# *********
# .*******
# ..*****
# ...***
# ....*
Pergunta 19: Compreensão aprofundada das funções recursivas
-
O que é uma função recursiva? Uma função recursiva é uma função que chama a si mesma dentro do corpo da função. A execução de uma função recursiva chamará a si mesma repetidamente, entrando em um novo nível a cada vez.
-
Nota: Funções recursivas devem ter uma condição final.
Três elementos para projetar uma função recursiva:
-
Deixe claro o que sua função deseja fazer
-
Encontre a condição final da recursão
-
Encontre a relação de equivalência de uma função
def p(n):
if n == 0:
return
print('递归前->',n)
p(n-1)
print('递归后->',n)
p(5)
# 递归前-> 5
# 递归前-> 4
# 递归前-> 3
# 递归前-> 2
# 递归前-> 1
# 递归后-> 1
# 递归后-> 2
# 递归后-> 3
# 递归后-> 4
# 递归后-> 5
Tópico 20: Função recursiva de Fibonacci
A sequência de Fibonacci, também conhecida como sequência da seção áurea, foi introduzida pelo matemático Leonardo Fibonacci usando a reprodução do coelho como exemplo, por isso também é chamada de “sequência do coelho”. , 8, 13, 21, 34,…
Nesta sequência, os dois primeiros itens são ambos números 1. A partir do terceiro item, cada número é a soma dos dois números anteriores.
Expressão matemática: f(n) = f(n-1)+f(n-2)
def fib(n):
if n<=2:
return 1
return fib(n-1)+fib(n-2)
print(fib(10)) # 55
print(fib(2)) # 1
A relação entre recursão e pilha. O princípio da função recursiva: cada chamada empurrará a chamada atual para a pilha. Finalmente, de acordo com o princípio do último a entrar, primeiro a sair, ela continuará retornando ao processo de execução do programa recursivo. Sabemos que a chamada do programa recursivo é Camadas para baixo, e o processo de retorno é exatamente o oposto, para cima camada por camada.
Em outras palavras: a primeira chamada de função retorna por último e a última chamada de função retorna primeiro. É o mesmo que a ordem "último a entrar, primeiro a sair" da pilha. Portanto, ao implementar chamadas recursivas, a pilha geralmente é usada para salvar os dados locais de cada chamada:
Quando uma função é chamada, o sistema envia os dados locais no momento da chamada para a pilha de chamadas do sistema.Os dados locais colocados na pilha são chamados de quadro de pilha. Quando a função retorna, o endereço de retorno deve ser obtido do topo da pilha de chamadas, a cena deve ser restaurada, o quadro da pilha deve ser removido e o endereço deve ser retornado.
Pergunta 21: Encontre o máximo de três números
Sabe-se que os números a, b e c são respectivamente 10, 6 e 18. Encontre o maior número entre a, b e c (sem usar funções, listas, etc.). Sabemos que a função max pode obter diretamente o valor máximo, ou o número pode ser adicionado à lista também pode obter o número máximo por meio de classificação. Simplesmente usamos o ramo if para conseguir isso.
a, b, c = 10, 6, 18
if a > b:
max_num = a
else:
max_num = b
if max_num < c:
max_num = c
print(max_num) # 18
Tópico 22: A soma dos fatores "número completo"
-
O que é um fator? Fatores são todos os números que podem dividir o número, incluindo 1, mas não o número em si. Por exemplo, os fatores de 8 são 1, 2 e 4
-
O que é um número perfeito? Se um número for exatamente igual à soma de seus fatores, o número é chamado de "número perfeito". Imprima um número perfeito dentro de 1000, por exemplo, 6=1+2+3, 6 é um "número perfeito"
def factor_sum(n):
s_sum = 0
for i in range(1, n):
if n % i == 0:
s_sum += i
return s_sum
for j in range(1, 1000):
if j == factor_sum(j):
print(j)
# 6
# 28
# 496
Questão 23: Soma fatorial recursiva
O fatorial de um número inteiro positivo é o produto de todos os números inteiros positivos menores ou iguais a esse número, e o fatorial de 0 é 1
Por exemplo, 5!=1_2_3_4_5 calcula 1!+2!+3!+4!+5!+…+10!Expressão matemática: f(n) = n*f(n-1):
def factor(n):
if n < 2:
return 1
return n * factor(n - 1)
s_sum = 0
for i in range(1, 11):
s_sum += factor(i)
print(s_sum) # 4037913
Pergunta 24: Parênteses válidos
Dada uma string que inclui apenas '(', ')', '{', '}', '[', ']', determine se a string é válida.
Uma string válida deve satisfazer:
-
O colchete de abertura deve ser fechado por um colchete de fechamento do mesmo tipo
-
Os colchetes de abertura devem ser fechados na ordem correta
-
A string vazia é considerada uma string válida
-
Exemplo 1:
digitar:"()"
Saída: Verdadeiro
- Exemplo 2:
digitar:"()[]{}"
Saída: Verdadeiro
- Exemplo 3:
digitar:"(]"
Saída: Falso
- Exemplo 4:
digitar:"([)]"
Saída: Falso
- Solução 1: método de substituição de string: encontre pares de (), [], {} na string. Depois de encontrá-los, substitua-os por pares vazios. Use um loop while para determinar continuamente se há pares de parênteses, colchetes e colchetes . Se existirem, basta usar replace para substituí-lo por nada até que não possa mais ser substituído e então avaliar se a string atual está vazia. Se estiver vazio, significa que a string é válida. Se não estiver vazio, é significa que a string é inválida.
def valid_str(string):
if len(string) % 2 == 1:
return False
while '()' in string or '[]' in string or '{}' in string:
string = string.replace('()', '')
string = string.replace('[]', '')
string = string.replace('{}', '')
return string == ''
print(valid_str('()')) # True
print(valid_str('()[]{}')) # True
print(valid_str('()[]{[()]}')) # True
print(valid_str('()[]{[(}]}')) # False
- Solução 2: Use o princípio último a entrar, primeiro a sair da pilha para primeiro definir uma pilha vazia e percorrer a pilha atual. Quando encontramos um colchete esquerdo, adicionamos o colchete esquerdo atual à pilha. Quando encontramos um colchete esquerdo colchete direito, nós o adicionamos ao topo da pilha. Os elementos são comparados para ver se eles são parênteses emparelhados. Nesse caso, o elemento atual é retirado da pilha até que o percurso da string seja concluído. Vamos ver se a string está vazia . Se estiver vazio, a string será válida. Se não estiver vazia, a string será inválida.
def valid_str(string):
if len(string) % 2 == 1:
return False
stack = []
char_dict = {
')': '(',
'}': '{',
']': '['
}
for char in string:
if char in char_dict:
# 右括号
if not stack or char_dict[char] != stack.pop():
return False
else:
# 左括号
stack.append(char)
return not stack
print(valid_str('(){}[({[]})]')) # True
print(valid_str('(){}[({[)})]')) # False
print(valid_str('')) # True
Pergunta 25: Duas soluções para números palíndromos
Os números do palíndromo são inteiros iguais na ordem direta (da esquerda para a direita) e na ordem inversa (da direita para a esquerda). Por exemplo, 1221 é um palíndromo, mas 1222 não é.
- Solução 1: compare invertendo as strings
def is_palindrome(x):
if x < 0 or x > 0 and x % 10 == 0:
return False
str_x = str(x)
return str_x == str_x[::-1]
print(is_palindrome(121)) # True
print(is_palindrome(120)) # False
- Solução 2: inverta a metade do número e compare-a com a primeira metade do número
processo
-
Para um inteiro x, inverta a segunda metade e salve-o na variável revertida
-
Cada vez que o loop x%10 obtém o último número
-
Então x/10 remove o número no final
-
Condição final do loop x<=revertida
-
Comprimento do número (número ímpar) 12321
-
Comprimento do número (número par) 1221
def is_palindrome(x):
if x < 0 or x > 0 and x % 10 == 0:
return False
reverted = 0
while x > reverted:
# 我们看下 1221
# 第一次循环我们需要把末尾数字1取出来 第二次取末尾数字2 我们需要把21变成12
reverted = reverted * 10 + x % 10
# 把x的末尾数字删除掉
x //= 10
return x == reverted or x == reverted // 10
print(is_palindrome(1221)) # True
print(is_palindrome(1223)) # False
print(is_palindrome(123321)) # True