Можете ли вы объяснить мне код алгоритма RLE в python?
Я, наконец, нашел, как создать алгоритм RLE, посмотрев учебник, но этот учебник не объяснил что-то в этом коде, я не понял, почему мы пишем j = i вместо j = 0 (зная, что я = 0) это же нет?
Я тоже не понял, почему i = j + 1. Почему i = j + 1 В конце функции? Почему бы не просто i += 1, но если мы хотим повторить цикл в цикле, мы делаем j + 1?
Должен ли первый цикл while повторять второй цикл while до тех пор, пока строка не будет завершена?
И, наконец, почему encoded_message повторяется два раза? вместо одного. Мы возвращаем encoded_message, вот и все? Мы можем просто выполнить print(encode(text)) вместо "print('Закодированное сообщение является выходом',encoded_message)" (когда мы помещаем encode(text) в encoded_message)
Я знаю, что задаю много вопросов, но я просто не могу запомнить код, не понимая его, это было бы совершенно бесполезно и непродуктивно.
def encode(message):
encoded_message = ""
i = 0
while(i<len(message)):
count = 1
ch = message[i]
j = i # ???
while(j<len(message)-1): # GET IT -----------------------------------------------------------
if message[j] == message[j+1]: # if the previous and next characters are the same
count = count + 1 # we increase count variable
j += 1 # we increase j position
# GET IT ----------------------------------------------------------------------------
else:
break
encoded_message = encoded_message + str(count) + ch # "" + count converted to string + character (ch)
i = j + 1 # ???
return encoded_message
text = input('enter your charcter chain...')
encoded_message = encode(text)
print('The encoded message is the output ',encoded_message)
Когда я заменил j = i на j = 0, в терминале ничего не отображается
см.: безрезультатно
Ответы 1
Есть внешняя петля и внутренняя петля. Внешний цикл с переменной i начинает перебирать сообщение. Внутренний цикл использует переменную j и начинается с текущей позиции i.
То есть: когда i=0, то j=0. Но когда i=5 (например) то j=5 тоже.
Задача внутренних циклов — проверить, следуют ли друг за другом 2 или более одинаковых символа. Если да, то i соответственно увеличивается в конце внутреннего цикла. Так что каждая буква сообщения просматривается только один раз.
Вот почему j не следует устанавливать на постоянное значение. Установка его на j=0 приведет к тому, что внутренний цикл будет начинаться с начала сообщения на каждой итерации.
Я добавил два простых оператора print() в ваш код, чтобы уточнить:
def encode(message):
encoded_message = ""
i = 0
while(i<len(message)):
print(f'outer loop: i = {i}')
count = 1
ch = message[i]
j = i
while(j<len(message)-1):
print(f'\tinner loop: j = {j}')
if message[j] == message[j+1]: # if the previous and next characters are the same
count = count + 1 # we increase count variable
j += 1 # we increase j position
else:
break
encoded_message = encoded_message + str(count) + ch # "" + count converted to string + character (ch)
i = j + 1
return encoded_message
text = 'Hello World'
encoded_message = encode(text)
print('The encoded message is the output ', encoded_message)
(Обратите внимание: я не знаю алгоритм RLE, но только что посмотрел ваш код.)
Да, это правильно.
Но мы могли бы написать i += 1 вместо no ?
Использование i+=1 допустимо, если входное слово не содержит одинаковых последовательных букв. Но опять же внутренний цикл вообще не нужен... так как его единственная задача состоит в том, чтобы суммировать эти одинаковые последовательные буквы. Просто используйте `aaa` в качестве входных данных и проверьте, что происходит при использовании i=j+1 по сравнению с i+=1.
Хорошо, спасибо за объяснение, у меня только два последних вопроса. Вы не возражаете?
Каково на самом деле реальное значение i = j + 1, это похоже на то, что i увеличивается, когда внутренний цикл увеличивается на 1 элемент вместо увеличения внешнего цикла на 1 (i = i + 1). И последнее, как символ, например, с «aaa ' почему в результате мы получили 3а вместо 1а2а3а ?
Обратите внимание, что я правильно понимаю вопросы. Но я попробую: (1/2) Алгоритм RLE сжимает входные данные, заменяя каждую последовательность идентичных символов длиной последовательности и самим символом. Таким образом, aaa становится 3a, aabccc становится 2a1b3c и т. д. Использование i = j + 1 гарантирует, что алгоритм «перепрыгивает» через символы, которые уже были оценены.
(2/2) Возьмем, к примеру, строку aabccc. Начиная с i=0 и ch=a. Внутренний цикл проверяет, есть ли более одного a. И да, действительно: есть 2 as. Итак, aa в исходной строке заменяется на 2a. Теперь, когда первые два символа исходной строки обработаны, вы переходите к 3-й букве, которой в примере является b. И так далее...
Хорошо, теперь это более ясно, но для i = j + 1 для i соответственно увеличивается в конце внутреннего цикла, верно?