Programa Python para imprimir palavras de uma frase com maior e menor valor ASCII de caracteres
ASCII (American Standard Code for Information Interchange), é um sistema de codificação de caracteres que representa cada caractere como um código binário exclusivo de 7 bits, ou seja, os valores ASCII são uma representação numérica de caracteres. Os valores ASCII são códigos binários de 7 bits que variam de 0 a 127. Por exemplo, o código ASCII para um caractere de espaço é 32, e para o dígito '1', o código ASCII é 49 e, da mesma forma, códigos ASCII são atribuídos a cada caractere que é representado em uma tabela ASCII.
Em Python, o código ASCII de um caractere pode ser calculado usando uma função predefinida ord(), que recebe um caractere como entrada e retorna o código ASCII desse caractere.
Por exemplo, ord('A') retorna 65.
Declaração do problema
Dada uma string S. Imprima as palavras que possuem a maior e a menor média dos valores ASCII de seus caracteres.
Amostra Exemplo 1
Entrada
S = “today is a sunny day”
Saída
Highest ASCII value = “sunny”
Lowest ASCII value = “a”
Explicação
Average of ASCII values:
today = (116 + 111 + 100 + 97 + 121) / 5 = 109
is = (105 + 115) / 2 = 110
a = 97 / 1 = 97
sunny = (115 + 117 + 110 + 110 + 121) / 5 = 114.6
day = (100 + 97 + 121) / 3 = 106
Thus, “sunny” has the highest average and “a” has the lowest average.
Amostra Exemplo 2
Entrada
S = “pink city”
Saída
Highest ASCII value = “city”
Lowest ASCII value = “pink”
Explicação
Explanation:
Average of ASCII values:
pink = (112 + 105 + 110 + 107) / 4 = 108.5
city = (99 + 105 + 116 + 121) / 4 = 110.25
Thus, “city” has the highest average and “pink” has the lowest average.
Abordagem 1: Abordagem de Força Bruta
A solução de força bruta para o problema é dividir a frase de entrada em palavras e então calcular a média dos valores ASCII de cada palavra para encontrar a média mais alta e mais baixa dos valores ASCII dos caracteres.
Para converter a string de entrada em uma lista de palavras, usamos a função split() integrada.
Pseudo-código
procedure ascii_avg (word)
sum = 0
For each character c in word
sum = sum + ord(c)
end for
avg = sum / length(word)
ans = avg
end procedure
procedure highLow (sentence)
words = split sentence by whitespace
high_word = words[0]
low_word = words[0]
high_avg = ascii_avg(words[0])
low_avg = ascii_avg(words[0])
for i = 1 to length(words) - 1
word = words[i]
avg = ascii_avg(word)
if avg > high_avg
high_word = word
high_avg = avg
else if avg < low_avg
low_word = word
low_avg = avg
end if
end for
print "Highest ASCII value:", high_word
print "Lowest ASCII value:", low_word
end procedure
Exemplo: Implementação Python
No programa a seguir, usamos uma função split para dividir frases em palavras.
def ascii_avg(word):
"""
Returns the average ASCII value of a word.
"""
return sum(ord(c) for c in word) / len(word)
def highLow (sentence):
"""
Prints the words with the highest and lowest average ASCII values in a sentence.
"""
words = sentence.split()
high_word, low_word = words[0], words[0]
high_avg, low_avg = ascii_avg(words[0]), ascii_avg(words[0])
for word in words[1:]:
avg = ascii_avg(word)
if avg > high_avg:
high_word, high_avg = word, avg
elif avg < low_avg:
low_word, low_avg = word , avg
print("Highest ASCII value:", high_word)
print("Lowest ASCII value:", low_word)
highLow("today is a sunny day")
Saída
Highest ASCII value: sunny
Lowest ASCII value: a
Abordagem 2: Usando um Heap
Outra abordagem para o problema pode ser manter um heap para manter os valores ASCII mais altos e mais baixos até o momento. Além disso, mantemos um dicionário para mapear palavras para seus valores ASCII e extrair o maior e o menor usando um heap.
Pseudo-código
procedure highLow(sentence)
words = split sentence by whitespace
word_avg = {}
for each word in words
avg = 0
for each character c in word
avg = avg + ord(c)
end for
avg = avg / length(word)
word_avg[word] = avg
end for
high_heap = []
low_heap = []
for word, avg IN word_avg.items()
heapq.heappush(high_heap, (-avg, word))
heapq.heappush(low_heap, (avg, word))
end for
high_word = heapq.heappop(high_heap)[1]
low_word = heapq.heappop(low_heap)[1]
print "Highest ASCII value:", high_word
print "Lowest ASCII value:", low_word
end procedure
Exemplo: Implementação Python
No programa a seguir, usamos um heap para controlar os valores ASCII mais altos e mais baixos e um dicionário para mapear os valores.
import heapq
def highLow(sentence):
"""
Prints the words with the highest and lowest average ASCII values in a sentence.
"""
words = sentence.split()
word_avg = {word: sum(ord(c) for c in word) / len(word) for word in words}
high_heap = [(-avg, word) for word, avg in word_avg.items()]
low_heap = [(avg, word) for word, avg in word_avg.items()]
heapq.heapify(high_heap)
heapq.heapify(low_heap)
high_word = heapq.heappop(high_heap)[1]
low_word = heapq.heappop(low_heap)[1]
print("Highest ASCII value:", high_word)
print("Lowest ASCII value:", low_word)
highLow("today is a sunny day")
Saída
Highest ASCII value: sunny
Lowest ASCII value: a
Abordagem 3: Usando funções integradas
Usando funções integradas como ord() que retorna o valor ASCII de um caractere, max() e min() para encontrar os valores máximo e mínimo, o problema pode ser resolvido.
Pseudo-código
procedure highLow(sentence)
words = split sentence by whitespace
high_word = max(words, key=lambda w: sum(ord(c) for c in w) / len(w))
low_word = min(words, key=lambda w: sum(ord(c) for c in w) / len(w))
print "Highest ASCII value:", high_word
print "Lowest ASCII value:", low_word
end procedure
Exemplo: Implementação Python
No programa a seguir, usamos a função Python integrada para encontrar as palavras com os valores ASCII mais altos e mais baixos.
def highLow(sentence):
"""
Prints the words with the highest and lowest average ASCII values in a sentence.
"""
words = sentence.split()
# min() and max() are built-in functions
high_word = max(words, key=lambda w: sum(ord(c) for c in w) / len(w))
low_word = min(words, key=lambda w: sum(ord(c) for c in w) / len(w))
print("Highest ASCII value:", high_word)
print("Lowest ASCII value:", low_word)
highLow("today is a sunny day")
Saída
Highest ASCII value: sunny
Lowest ASCII value: a
Complexidade de tempo - O (nlogn)
Complexidade Espacial - O (n)
Abordagem 4: classificando as palavras por seus valores ASCII médios
Ao classificar as palavras de acordo com a média das palavras ASCII, podemos encontrar o valor mais alto do último elemento e o valor mais baixo do primeiro elemento.
Pseudo-código
procedure highLow (sentence)
words = split sentence by whitespace
words_sorted = sort words by key=lambda w: sum(ord(c) for c in w) / len(w)
print "Highest ASCII value:", last word in words_sorted
print "Lowest ASCII value:", first word in words_sorted
end procedure
Exemplo: Implementação Python
No programa a seguir, classificamos as palavras com base em seus valores ASCII médios.
def highLow(sentence):
"""
Prints the words with the highest and lowest average ASCII values in a sentence.
"""
words = sentence.split()
# Sorts the words in ascending order
words_sorted = sorted(words, key=lambda w: sum(ord(c) for c in w) / len(w))
print("Highest ASCII value:", words_sorted[-1])
print("Lowest ASCII value:", words_sorted[0])
highLow("today is a sunny day")
Saída
Highest ASCII value: sunny
Lowest ASCII value: a
Complexidade de tempo - O (nlogn)
Complexidade Espacial - O (n)
Conclusão
Concluindo, para encontrar as palavras com os valores ASCII médios mais altos e mais baixos, podemos usar qualquer uma das abordagens acima, algumas das quais são fáceis de entender, mas têm uma alta complexidade de tempo de O (n ^2), mas usando funções integradas pode ser reduzido para O (nlogn).