MIT 6.00.1x: набор задач 1

Допустим, я хочу создать программу, которая распечатывает, есть ли мороженое в магазине.

Сначала мы определяем переменную iceCreamAvailable и устанавливаем для нее значение True.

iceCreamAvailable = True

Одна интересная особенность Python заключается в том, что вам не нужно указывать тип данных перед объявлением переменной. Независимо от того, устанавливаем ли мы для нашей переменной логическое значение, целое число, число с плавающей запятой или строку, нам просто нужно изменить значение справа от знака равенства. С другой стороны, некоторые языки программирования, такие как C, даже не имеют встроенного логического типа данных (C по-прежнему великолепен).

Следующая часть нашей программы настраивает наше выражение if-else для запуска в зависимости от того, равно ли iceCreamAvailable истинному или ложному.

if iceCreamAvailable == True:
    # print statement 1
else:
    # print statement 2

Если значение iceCreamAvailable здесь равно true, мы затем напечатаем оператор 1. Если iceCreamAvailable оценивается как любое другое значение, он напечатает оператор 2. Если бы я хотел быть более конкретным для оператора 2, я мог бы использовать elif, например:

elif iceCreamAvailable == False:
   # print statement 2

Однако из-за того, что тип данных Boolean может оценивать только два значения, elif не нужен. Фактически, здесь я мог бы даже удалить двойной знак равенства, поскольку операторы if автоматически оценивают любые ненулевые и ненулевые значения как True.

if iceCreamAvailable: 
   # print statement 1

Это просто делает наш код более лаконичным и более удобным для чтения. Мне это нравится.

Наконец, для нашего небольшого примера программы мы хотим распечатать наши операторы. Для этого воспользуемся встроенной функцией print. Если вы полный новичок, вы, вероятно, еще не знаете, что такое функция. Если вы не спали в старших классах по алгебре, вы, вероятно, имеете смутное представление о том, что это такое. В основном print просто принимает аргумент и печатает или выводит его в оболочку. Это наше первое знакомство с концепцией ввода и вывода, или, как ее называют ботаники, ввода-вывода.

Например:

print("Hello doggo")

Распечатал бы в оболочку:

Hello doggo

Итак, теперь вся наша программа IceCream будет выглядеть примерно так:

iceCreamAvailable = True
if iceCreamAvailable:
    print("Come get some ice cream!"
else:
    print("We're all out!")

Итак, вернемся к нашей первой проблеме. На самом деле он не сильно отличается от нашего примера программы, который мы только что создали. Единственная разница в том, что здесь мы собираемся использовать цикл for, чтобы повторять наши условные операторы определенное количество раз. Давайте сначала настроим переменную vowelCount и установим ее в ноль, чтобы отслеживать количество гласных в строке.

vowelCount = 0

Затем нам нужно настроить цикл for. Есть несколько способов сделать это. Вот два из них.

for index in range(len(string)):

Сначала выполняется итерация в диапазоне от 0 до длины строки. Это означает, что index здесь будет равняться целому числу на каждой итерации цикла.

Давайте попробуем сначала посчитать только гласную «а».

for index in range(len(string)):
   if string[index] == 'a':
      # increment vowelCount

Здесь мы получаем доступ к каждому символу строки через его индекс, а затем проверяем, соответствует ли он «a». Если символ соответствует «a», мы переносим все, что находится внутри нашего блока if.

Более простой и понятный способ написать этот код - получить доступ к символам напрямую, а не просматривать индекс строки.

for letter in string:

Я знаю. Довольно красиво выглядит, правда? Он читается как английский, и вам не нужно использовать функции range или len.

Наконец, мы хотим увеличить количество переменных VowelCount на единицу внутри наших условных операторов. Мы можем сделать это еще раз двумя способами.

vowelCount = vowelCount + 1

or

vowelCount += 1

В дальнейшем я воспользуюсь вторым.

Хорошо, теперь, когда мы разобрались со всеми мелкими кусочками этой проблемы, давайте соберем все вместе.

# variable s is predefined
# define and set variable vowelCount to 0
vowelCount = 0
# create a for loop to iterate through each character of s
for letter in s:
    # if letter in s equal to each vowel, increment vowelCount by 1
    if letter == "a":
        vowelCount += 1
    elif letter == "e":
        vowelCount += 1
    elif letter == "i":
        vowelCount += 1
    elif letter == "o":
        vowelCount += 1
    elif letter == "u":
        vowelCount += 1
# print the concatenated first string and vowelCount
print("Number of vowels: " + str(vowelCount))

Бум. Первая проблема устранена. Совсем не так уж плохо, правда?

Проблема 2

Предположим, что s - это строка символов нижнего регистра.

Напишите программу, которая печатает, сколько раз строка 'bob' встречается в s. Например, если s = 'azcbobobegghakl', ваша программа должна печатать

Количество повторений боба: 2

Хорошо, это немного сложнее, но это не так уж сложно, если вы разберетесь с концепцией доступа к подстрокам через индекс строки. Что, черт возьми, я имею в виду? Вот небольшой пример:

name = "cyberdoggo"
lastName = name[5:]

Если мы напечатаем lastName, мы получим:

doggo

Здесь нам нужно выполнить итерацию по строке, обращаясь к подстрокам s [i: i + 3), пока мы не найдем подстроку, которая соответствует «bob»

Я покажу, что вы подразумеваете под этим, если это все еще звучит как тарабарщина.

Сначала давайте определим и установим для переменной bobCount значение 0. Эта переменная будет иметь то же назначение, что и переменная vowelCount в первой программе.

bobCount = 0

Вот где это немного усложняется. Сначала создадим цикл for:

for i in range(len(s)):

Это еще раз просто итерация диапазона от 0 до длины s.

Затем нам нужно создать условный оператор, чтобы подстрока соответствовала «bob»:

if (s[i:i+3] == 'bob'):
    # a statement

Это проверяет, равна ли подстрока, созданная из s [i: i + 3], «bob», так как имя bob имеет длину три символа и, следовательно, требует, чтобы длина подстроки была равна трем. Итак, если s = 'azcbobobegghakl', первая подстрока s [0: 3] будет равна 'azc'. Поскольку 'azc' действительно равно 'bob', оператор в выражении if не будет выполнен.

Хорошо, самая сложная часть здесь сделана. Теперь нам просто нужно увеличить bobCount на единицу в инструкции if.

bobCount += 1

А теперь давайте все вместе:

# s is a predefined string
# define and set bobCount to 0
bobCount = 0
# iterate through the range from 0 to the length of s
for i in range(len(s)):
  # check to see if the substring accessed is equal to 'bob'
  if (s[i:i+3] == 'bob'):
      bobCount += 1
print("Number of times bob occurs is: " + str(bobCount))

Между прочим, создание комментариев - отличная привычка, которую нужно освоить с самого начала. Если вы в конечном итоге работаете с другими людьми, комментарии невероятно важны для того, чтобы ваши коллеги могли легко понять ваш код. Не будь «тем парнем» или «той девушкой».

Иди перекуси, и тогда мы сможем перейти к последней задаче.

Проблема 3

Предположим, что s - это строка символов нижнего регистра.

Напишите программу, которая печатает самую длинную подстроку s, в которой буквы встречаются в алфавитном порядке. Например, если s = 'azcbobobegghakl', ваша программа должна печатать

Самая длинная подстрока в алфавитном порядке: begingh

В случае ничьей выведите первую подстроку. Например, если s = 'abcbcd', ваша программа должна печатать

Самая длинная подстрока в алфавитном порядке: abc

Эта проблема - отстой, пока вы ее не получите. Тогда все не так уж и плохо. Что я имею в виду под «получить»? Я покажу тебе.

Сначала давайте настроим небольшой пример:

letters = "abc"
print(letters[1] > letters[0])

Если мы запустим эту программу, мы получим:

True

Я знаю, о чем ты думаешь. "Почему это сработало?" Что ж, давай попробуем что-нибудь еще. Введите этот оператор в оболочку Python.

print(ord(‘a’))

Вы должны получить число 97. То, что делает ord (), преобразует символ а в соответствующее ему числовое значение ASCII. ASCII - это просто стандарт кодировки символов. Я не буду вдаваться в подробности, так как мне пришлось бы написать что-нибудь размером со статью в Википедии, чтобы полностью это объяснить. К счастью, кое-кто уже написал там отличную статью. Ничего страшного, если не получишь много. Я понимаю только около четверти этого.

Итак, теперь, когда мы знаем, что можем сравнивать персонажей друг с другом, эта проблема должна стать намного проще для понимания.

Сначала давайте определим две переменные called и longest. Вы можете просто установить их на пустые строки. Я объясню это позже, не волнуйтесь.

current = ''
longest = ''

Теперь давайте настроим цикл for, чтобы перебирать строку как обычно:

for i in range(len(s)):

Вот где бывает весело:

if (s[i] >= s[i-1]):
    current += s[i]
else:
    current = s[i]

Наш оператор if проверяет, больше ли текущий символ s [i] предыдущего символа s [i-1] в строке. Поэтому, если s [i] больше или равно s [i-1], он добавляется к строке current, поскольку s [i] опережает s [i-1] в алфавите. . Однако, если s [i] стоит перед s [i-1] в алфавите, нам нужно сбросить строку current и установить для нее значение s [i].

Проблема, однако, сейчас в том, что мы не находим самую длинную алфавитную подстроку в s, мы просто находим последнюю алфавитную подстроку в s. Здесь вступает в игру переменная самая длинная, которую мы определили ранее. Под нашим блоком if-else нам нужно создать еще один оператор if, который устанавливает longest в строку current, если длина current больше чем самый длинный. Давайте воспользуемся той функцией len (), которую мы использовали ранее в наших циклах for.

if len(current) > len(longest):
    longest = current

Вот и все. А теперь давайте в последний раз соберем все вместе:

# s is predefined variable set to a string value
current = ''
longest = ''
for i in range(len(s)):
 if (s[i] >= s[i-1]):
  current += s[i]
 else:
  current = s[i]
 if len(current) > len(longest):
  longest = current
print("Longest substring in alphabetical order is: " + longest)

В целом, это было неплохо. Теперь вы можете сказать, что выполнили набор задач MIT! Следует отметить, что, хотя мои программы прошли все тесты, которые MIT поместил в свою платформу оценивания, они не идеальны. При написании кода вы всегда должны стараться сделать свои программы как можно более модульными. Всегда старайтесь искать новые пути, по которым ваша программа может дать сбой. Если вы можете это сделать, то официально вы больше хакер, чем кто-либо в CSI: GreenTerminals.

Увидимся в следующий раз.