ака: как без необходимости усложнить простую лыжную прогулку, внедрив цифровую запутанную демократию.
Бен Начлас
Загорелся
Я сижу здесь, предвкушая предстоящую прогулку на лыжах по бэккантри с друзьями, и я думаю, «какими способами я могу намеренно привнести ненужные слои усилий и сложности в то, что якобы должно быть простой и несложной лыжной экскурсией». ?»
Как поборник краткости и руководитель поездки в этом конкретном случае, мне нужно было собрать воедино несколько ключевых элементов для безопасной и успешной экскурсии. Главным среди них является очень важное и часто горячо оспариваемое задание по питанию.
Из-за спорного характера обязанностей по приготовлению пищи я не хотел играть в фаворитов или навязывать какие-либо личные предпочтения при разработке расписания, для кого и когда готовить, поэтому я решил создать скрипт на Python, чтобы добиться этого с объективной случайностью.
Но в этом и заключается загвоздка: с моим текущим набором навыков работы с Python в автономном режиме мне потребовалось бы несколько дней, чтобы создать это. Я хотел закончить до того, как допью вторую чашку кофе.
Войдите в магию ChatGPT.
Как вы, наверное, слышали, ChatGPT ворвался в космос с впечатляющим набором возможностей. По сути (можете ли вы сказать то же самое об ИИ?), это генеративная большая языковая модель, обученная на более чем 173 миллиардах точек данных, что дает ей иногда сверхъестественную способность выполнять широкий спектр задач и производить выходные данные, аналогичные тем, которые мог бы сделать человек. create — все из простой текстовой подсказки, созданной пользователем в качестве ввода.
Возможно, одним из самых мощных вариантов использования этого инструмента является его способность быстро и [относительно] точно генерировать код на большинстве языков. Для этого упражнения я хотел написать на python. Для этого я начал представлять, чего я хочу добиться от своей функции, и соответствующим образом подсказал ИИ. Но для наилучшего достижения желаемых результатов в первую очередь необходимо иметь общее представление о том, как работает ChatGPT.
Перейти в
ChatGPT — это предиктивная текстовая модель, которая, проще говоря, означает, что ее задача — анализировать вводимый вами текст и генерировать стохастический результат с наивысшей вероятностью точности на основе огромного массива обучающих данных.
А??
По сути, он пытается понять, что вы пишете, и угадать наиболее вероятный правильный ответ. С точки зрения человека. Как компьютер. Сумасшедший, верно?
Верно. Но чтобы дать ChatGPT наилучшие шансы на создание качественной реализации кода, потребуется подробная и структурированная подсказка. Сначала мне нужно было обдумать, чего я пытаюсь достичь. Каков мой желаемый результат? Какая информация будет предопределена? Какие факторы являются переменными, а какие постоянными?
После некоторого тщательного рассмотрения и планирования я создал следующую подсказку и создал экземпляр чата. За этим следует иллюстрация того, как развивалось мое взаимодействие с ChatGPT и как я, как инженер-подсказчик, итеративно корректировал модель в соответствии с моей первоначальной целью и в конечном итоге пришел к желаемому результату.
Мои текстовые подсказки/ответы отображаются как
кавычки
и результаты ChatGPT, а также их ВЫВОДЫ при запуске в среде IDE показаны на
code blocks.
(примечание редактора: если программирование на самом деле вам не по душе, вам следует просто рассматривать блоки кода как цифровое волшебство и, как правило, сразу же застеклять. Это не должно быть сложно.)
Имея это в виду, давайте посмотрим, что он может сделать!
Приступаем к делу
В этом чате вы поможете с генерацией кода. У вас есть возможность программировать как человек, писать элегантный, но мощный код, который хорошо продуман и выполняется без ошибок.
Поскольку мы будем писать код, очень важно, чтобы формат всего кода, который вы генерируете, выводился в поле фрагмента кода с возможностью копирования/вставки.
После того, как вы сгенерируете блок кода, выведите ожидаемый результат с учетом входных данных примера.
Не предоставляйте никаких объяснений или дополнительного контекста, если я не попрошу вас сделать это.
Сегодня мы будем писать на Python.
Пожалуйста, напишите код Python для достижения следующего:
Мы хотим написать код, который случайным образом распределяет людей по группам приготовления различных блюд (например, завтрака, обеда, ужина).
На основе предварительно определенного размера группы повара будут случайным образом распределены в группу. Чтобы сбалансировать рабочую нагрузку для всех людей, это гарантирует, что все будут готовить одинаковое количество раз (или, если это невозможно сделать одинаково, почти одинаково). Поскольку каждая группа поваров генерируется случайным образом, никакие две группы не будут одинаковыми. Каждая группа поваров ВСЕГДА будет содержать ТОЧНО указанное количество поваров в группе, даже если это означает, что повара должны будут идти снова.
Для этого произойдет следующее:
Пользователь определит список строк, называемых «имена», который будет содержать список имен различных поваров. Список «имена» может иметь много значений и быть переменным, поэтому код должен обрабатывать это.
Пользователь определит переменные, называемые «завтрак», «обед» и «ужин», каждая из которых содержит целое число, представляющее количество приемов пищи на завтрак/обед/ужин соответственно. Значение этих переменных может варьироваться от 0 до 100, поэтому учитывайте нулевые и ненулевые случаи.
Пользователь определит переменную с именем «group_size», которая содержит ненулевое положительное целое число. «group_size» относится к количеству поваров в каждой группе. Всегда должно быть точное значение «group_size» количества поваров, назначенных каждой группе. Кроме того, каждый человек должен быть случайным образом распределен по группам примерно столько же раз, сколько и любой другой повар.
Вы сгенерируете код, который принимает вышеуказанные условия и реализует решение. Чтобы помочь с этим, я теперь предоставлю примеры входных данных и связанных с ними ожидаемых результатов.
Вот некоторые примеры входных данных:
имена = ["Стив", "Ли", "Джейсон", "Линн", "Тедди", "Кэти", "Мэтти", "Начо"]
размер_группы = 3
завтрак = 3
обед = 1
ужин = 3
И вот ожидаемый результат:
Группы завтраков:
Прием пищи 1: [Кэти, Линн, Тедди]
Еда 2: [Мэтти, Ли, Джейсон]
Прием пищи 3: [«Стив», «Начо», «Кэти»]
Обеденные группы:
Прием пищи 1: [Мэтти, Линн, Стив]
Обеденные группы:
Прием пищи 1: [«Тедди», «Кэти», «Начо»]
Прием пищи 2: ['Линн', 'Мэтти', 'Ли']
Прием пищи 3: [«Джейсон», «Стив», «Начо»]
Сгенерируйте блок кода ниже:
import random
def assign_cook_groups(names, group_size, breakfasts, lunch, dinner):
all_meals = [("breakfast", breakfasts), ("lunch", lunch), ("dinner", dinner)]
for meal_type, num_meals in all_meals:
print(f"{meal_type.capitalize()} groups:")
for i in range(num_meals):
random.shuffle(names)
num_cooks = len(names)
num_groups = num_cooks // group_size
if num_cooks % group_size != 0:
num_groups += 1
for j in range(num_groups):
group = names[j*group_size:(j+1)*group_size]
print(f"Meal {i+1}: {group}")
names = ["Steve", "Leigh", "Jason", "Lynn", "Teddy", "Katie", "Matty", "Nacho"]
group_size = 3
breakfasts = 3
lunch = 1
dinner = 3
assign_cook_groups(names, group_size, breakfasts, lunch, dinner)
OUTPUT
Breakfast groups:
Meal 1: ['Teddy', 'Lynn', 'Leigh']
Meal 1: ['Steve', 'Nacho', 'Matty']
Meal 1: ['Jason', 'Katie']
Meal 2: ['Nacho', 'Steve', 'Teddy']
Meal 2: ['Jason', 'Leigh', 'Katie']
Meal 2: ['Lynn', 'Matty']
Meal 3: ['Matty', 'Lynn', 'Teddy']
Meal 3: ['Jason', 'Leigh', 'Steve']
Meal 3: ['Katie', 'Nacho']
Lunch groups:
Meal 1: ['Matty', 'Leigh', 'Steve']
Meal 1: ['Katie', 'Teddy', 'Jason']
Meal 1: ['Lynn', 'Nacho']
Dinner groups:
Meal 1: ['Katie', 'Lynn', 'Nacho']
Meal 1: ['Steve', 'Jason', 'Teddy']
Meal 1: ['Matty', 'Leigh']
Meal 2: ['Steve', 'Jason', 'Katie']
Meal 2: ['Leigh', 'Teddy', 'Matty']
Meal 2: ['Lynn', 'Nacho']
Meal 3: ['Lynn', 'Steve', 'Matty']
Meal 3: ['Teddy', 'Jason', 'Leigh']
Meal 3: ['Katie', 'Nacho']
Чертовски хороший первый выстрел!
Неплохо, но результаты не совпали с ожидаемыми.
Как видите, назначено слишком много приемов пищи (должно быть 3 завтрака, а есть 9)
Кроме того, никогда не должно быть группы поваров, состоящей только из людей group_size-1. Каждая группа ДОЛЖНА состоять из людей ровно group_size.
import random
names = ["Steve", "Leigh", "Jason", "Lynn", "Teddy", "Katie", "Matty", "Nacho"]
group_size = 3
breakfast = 3
lunch = 1
dinner = 3
# Initialize meals dictionary
meals = {"breakfast": breakfast, "lunch": lunch, "dinner": dinner}
# Initialize groups dictionary
groups = {}
for name in names:
groups[name] = {"breakfast": 0, "lunch": 0, "dinner": 0}
# Assign meals to groups
for meal in meals:
meal_count = meals[meal]
print(meal.title() + " groups:")
for i in range(1, meal_count + 1):
group_list = []
while len(group_list) < group_size:
group = random.sample(names, group_size - len(group_list))
group_list.extend(group)
for name in group_list:
groups[name][meal] += 1
print("Meal {}: {}".format(i, group_list))
OUTPUT
Breakfast groups:
Meal 1: ['Teddy', 'Nacho', 'Jason']
Meal 2: ['Leigh', 'Matty', 'Lynn']
Meal 3: ['Lynn', 'Katie', 'Steve']
Lunch groups:
Meal 1: ['Steve', 'Lynn', 'Matty']
Dinner groups:
Meal 1: ['Lynn', 'Jason', 'Katie']
Meal 2: ['Jason', 'Lynn', 'Leigh']
Meal 3: ['Matty', 'Steve', 'Leigh']
Отлично, вроде сработало.
Давайте теперь создадим блок кода, который подсчитывает, сколько раз каждому повару было назначено блюдо, и выводит результаты. Напишите блок кода ниже.
import numpy as np
names = ["Steve", "Leigh", "Jason", "Lynn", "Teddy", "Katie", "Matty", "Nacho"]
group_size = 3
breakfasts = 3
lunch = 1
dinner = 3
meals = [("breakfast", breakfasts), ("lunch", lunch), ("dinner", dinner)]
# Create a dictionary to keep track of how many times each cook has cooked
cook_count = {name: 0 for name in names}
# Loop through each meal and assign the cooks to groups
for meal, num_meals in meals:
print(meal.capitalize(), "groups:")
for i in range(1, num_meals + 1):
# Randomly shuffle the list of names to assign random groups
np.random.shuffle(names)
# Split the list of names into groups of group_size
groups = [names[i:i+group_size] for i in range(0, len(names), group_size)]
# If the last group has less than group_size people, add people from the first group to it
if len(groups[-1]) < group_size:
diff = group_size - len(groups[-1])
groups[-1].extend(groups[0][:diff])
groups[0] = groups[0][diff:]
# Print out the groups for this meal
for j, group in enumerate(groups):
print("Meal", i, "Group", j+1, ":", group)
for name in group:
cook_count[name] += 1
# Print out the cook counts
print("Cook counts:")
for name, count in cook_count.items():
print(name, ":", count)
OUTPUT
Breakfast groups:
Meal 1 Group 1 : ['Lynn', 'Leigh']
Meal 1 Group 2 : ['Jason', 'Matty', 'Steve']
Meal 1 Group 3 : ['Katie', 'Nacho', 'Teddy']
Meal 2 Group 1 : ['Lynn', 'Nacho']
Meal 2 Group 2 : ['Matty', 'Katie', 'Teddy']
Meal 2 Group 3 : ['Jason', 'Steve', 'Leigh']
Meal 3 Group 1 : ['Steve', 'Teddy']
Meal 3 Group 2 : ['Leigh', 'Katie', 'Lynn']
Meal 3 Group 3 : ['Nacho', 'Matty', 'Jason']
Lunch groups:
Meal 1 Group 1 : ['Nacho', 'Jason']
Meal 1 Group 2 : ['Leigh', 'Lynn', 'Steve']
Meal 1 Group 3 : ['Teddy', 'Katie', 'Matty']
Dinner groups:
Meal 1 Group 1 : ['Teddy', 'Lynn']
Meal 1 Group 2 : ['Steve', 'Jason', 'Matty']
Meal 1 Group 3 : ['Nacho', 'Leigh', 'Katie']
Meal 2 Group 1 : ['Teddy', 'Katie']
Meal 2 Group 2 : ['Nacho', 'Steve', 'Matty']
Meal 2 Group 3 : ['Jason', 'Lynn', 'Leigh']
Meal 3 Group 1 : ['Lynn', 'Leigh']
Meal 3 Group 2 : ['Teddy', 'Nacho', 'Matty']
Meal 3 Group 3 : ['Jason', 'Katie', 'Steve']
Cook counts:
Steve : 7
Leigh : 7
Jason : 7
Lynn : 7
Teddy : 7
Katie : 7
Matty : 7
Nacho : 7
Неа.
Это не сработало. Вывод должен быть следующим:
Breakfast groups: Meal 1: ['Nacho', 'Matty', 'Teddy'] Meal 2: ['Katie', 'Steve', 'Leigh'] Meal 3: ['Lynn', 'Jason', 'Teddy'] Lunch groups: Meal 1: ['Steve', 'Nacho', 'Katie'] Dinner groups: Meal 1: ['Leigh', 'Matty', 'Lynn'] Meal 2: ['Jason', 'Katie', 'Teddy'] Meal 3: ['Leigh', 'Nacho', 'Steve'] Cook Counts: Steve: # Leigh: # Lynn: # Jason: # Teddy: # Katie: # Matty: # Nacho: #
Где # заменяется количеством приготовлений каждого человека.
Пожалуйста, просмотрите код и измените его просто, чтобы добавить количество раз, когда каждый человек готовил под группами.
Пожалуйста, напишите исправленный блок кода ниже.
import random
names = ["Steve", "Leigh", "Jason", "Lynn", "Teddy", "Katie", "Matty", "Nacho"]
group_size = 3
breakfast = 3
lunch = 1
dinner = 3
# Initialize meals dictionary
meals = {"breakfast": breakfast, "lunch": lunch, "dinner": dinner}
# Initialize groups and cook_counts dictionaries
groups = {}
cook_counts = {}
for name in names:
groups[name] = {"breakfast": 0, "lunch": 0, "dinner": 0}
cook_counts[name] = 0
# Assign meals to groups
for meal in meals:
meal_count = meals[meal]
print(meal.title() + " groups:")
for i in range(1, meal_count + 1):
group_list = []
while len(group_list) < group_size:
group = random.sample(names, group_size - len(group_list))
group_list.extend(group)
for name in group_list:
groups[name][meal] += 1
cook_counts[name] += 1
print("Meal {}: {}".format(i, group_list))
# Print cook counts
print("\nCook Counts:\n")
for name in names:
print("{}: {}".format(name, cook_counts[name]))
OUTPUT
Breakfast groups:
Meal 1: ['Leigh', 'Katie', 'Lynn']
Meal 2: ['Teddy', 'Matty', 'Lynn']
Meal 3: ['Jason', 'Matty', 'Leigh']
Lunch groups:
Meal 1: ['Jason', 'Matty', 'Nacho']
Dinner groups:
Meal 1: ['Lynn', 'Jason', 'Matty']
Meal 2: ['Katie', 'Teddy', 'Lynn']
Meal 3: ['Nacho', 'Leigh', 'Jason']
Cook Counts:
Steve: 0
Leigh: 3
Jason: 4
Lynn: 4
Teddy: 2
Katie: 2
Matty: 4
Nacho: 2
Спасибо. Хотя результаты теперь включают счетчик, вы можете видеть, что некоторые люди готовят больше, чем другие.
Пожалуйста, измените, чтобы все готовили одинаковое или почти одинаковое количество раз.
(в этом примере каждый человек должен готовить 2 или 3 раза)
import random
names = ["Steve", "Leigh", "Jason", "Lynn", "Teddy", "Katie", "Matty", "Nacho"]
group_size = 3
breakfast = 3
lunch = 1
dinner = 3
# Initialize meals dictionary
meals = {"breakfast": breakfast, "lunch": lunch, "dinner": dinner}
# Initialize groups dictionary
groups = {}
for name in names:
groups[name] = {"breakfast": 0, "lunch": 0, "dinner": 0}
# Shuffle names list to randomize the order
random.shuffle(names)
# Assign meals to groups
for meal in meals:
meal_count = meals[meal]
print(meal.title() + " groups:")
assigned_names = names[:group_size * meal_count]
names = names[group_size * meal_count:]
for i in range(1, meal_count + 1):
group_list = assigned_names[group_size * (i-1):group_size * i]
for name in group_list:
groups[name][meal] += 1
print("Meal {}: {}".format(i, group_list))
# Count the number of times each person cooked
cook_counts = {}
for name in names:
cook_counts[name] = sum(groups[name].values())
print("\nCook Counts:\n")
for name, count in cook_counts.items():
print("{}: {}".format(name, count))
OUTPUT
Breakfast groups:
Meal 1: ['Jason', 'Steve', 'Lynn']
Meal 2: ['Teddy', 'Katie', 'Nacho']
Meal 3: ['Matty', 'Leigh']
Lunch groups:
Meal 1: []
Dinner groups:
Meal 1: []
Meal 2: []
Meal 3: []
Cook Counts:
Уф.
Измените приведенный выше код, чтобы он соответствовал следующему ожидаемому результату:
Breakfast groups:
Meal 1: ['Steve', 'Matty', 'Lynn']
Meal 2: ['Nacho', 'Jason', 'Leigh']
Meal 3: ['Teddy', 'Katie', 'Steve']
Lunch groups:
Meal 1: ['Nacho', 'Leigh', 'Matty']
Dinner groups:
Meal 1: ['Katie', 'Teddy', 'Jason']
Meal 2: ['Leigh', 'Lynn', 'Matty']
Meal 3: ['Katie', 'Nacho', 'Steve']
Cook Counts:
Steve: 3
Leigh: 3
Jason: 2
Lynn: 2
Teddy: 2
Katie: 3
Matty: 3
Nacho: 2
import random
names = ["Steve", "Leigh", "Jason", "Lynn", "Teddy", "Katie", "Matty", "Nacho"]
group_size = 3
breakfast = 3
lunch = 1
dinner = 3
# Calculate number of meals each person should cook
num_meals = len(names) * (breakfast + lunch + dinner) // group_size
cook_counts = {name: 0 for name in names}
# Initialize meals dictionary
meals = {"breakfast": breakfast, "lunch": lunch, "dinner": dinner}
# Initialize groups dictionary
groups = {name: {meal: 0 for meal in meals} for name in names}
# Assign meals to groups
for meal in meals:
meal_count = meals[meal]
print(meal.title() + " groups:")
for i in range(1, meal_count + 1):
group_list = []
while len(group_list) < group_size:
# Sort names by cook counts in ascending order
sorted_names = sorted(names, key=lambda x: cook_counts[x])
group = sorted_names[:group_size - len(group_list)]
group_list.extend(group)
for name in group:
cook_counts[name] += 1
for name in group_list:
groups[name][meal] += 1
print("Meal {}: {}".format(i, group_list))
# Print cook counts
print("\nCook Counts:")
for name in sorted(cook_counts, key=lambda x: cook_counts[x]):
print("{}: {}".format(name, cook_counts[name]))
OUTPUT
Breakfast groups:
Meal 1: ['Steve', 'Leigh', 'Jason']
Meal 2: ['Lynn', 'Teddy', 'Katie']
Meal 3: ['Matty', 'Nacho', 'Steve']
Lunch groups:
Meal 1: ['Leigh', 'Jason', 'Lynn']
Dinner groups:
Meal 1: ['Teddy', 'Katie', 'Matty']
Meal 2: ['Nacho', 'Steve', 'Leigh']
Meal 3: ['Jason', 'Lynn', 'Teddy']
Cook Counts:
Katie: 2
Matty: 2
Nacho: 2
Steve: 3
Leigh: 3
Jason: 3
Lynn: 3
Teddy: 3
Выглядеть лучше! Но когда я запускал последовательно, я продолжал получать точно такой же план.
Ваш код выполняется правильно, но результат каждый раз один и тот же и не меняется. Код должен производить новый вывод каждый раз при запуске, поскольку код каждый раз включает случайность. Как написано, ваш код сгенерировал только один вывод. Пожалуйста, перепишите ниже, чтобы включить случайность.
import random
# Set random seed
# Editor's Note! When ChatGPT generated this originally, it included a default value for random.seed() of '42'. Since this would produce the same output every time, which was not the intended effect, I manually deleted the number which enabled the function to run as expected.
random.seed()
names = ["Steve", "Leigh", "Jason", "Lynn", "Teddy", "Katie", "Matty", "Nacho"]
group_size = 3
breakfast = 3
lunch = 1
dinner = 3
# Shuffle names list to assign groups randomly
random.shuffle(names)
# Calculate number of meals each person should cook
num_meals = len(names) * (breakfast + lunch + dinner) // group_size
cook_counts = {name: 0 for name in names}
# Initialize meals dictionary
meals = {"breakfast": breakfast, "lunch": lunch, "dinner": dinner}
# Initialize groups dictionary
groups = {name: {meal: 0 for meal in meals} for name in names}
# Assign meals to groups
for meal in meals:
meal_count = meals[meal]
print(meal.title() + " groups:")
for i in range(1, meal_count + 1):
group_list = []
while len(group_list) < group_size:
# Sort names by cook counts in ascending order
sorted_names = sorted(names, key=lambda x: cook_counts[x])
group = sorted_names[:group_size - len(group_list)]
group_list.extend(group)
for name in group:
cook_counts[name] += 1
for name in group_list:
groups[name][meal] += 1
print("Meal {}: {}".format(i, group_list))
# Print cook counts
print("\nCook Counts:")
for name in sorted(cook_counts, key=lambda x: cook_counts[x]):
print("{}: {}".format(name, cook_counts[name]))
OUTPUT
Breakfast groups:
Meal 1: ['Matty', 'Nacho', 'Leigh']
Meal 2: ['Teddy', 'Katie', 'Steve']
Meal 3: ['Jason', 'Lynn', 'Matty']
Lunch groups:
Meal 1: ['Nacho', 'Leigh', 'Teddy']
Dinner groups:
Meal 1: ['Katie', 'Steve', 'Jason']
Meal 2: ['Lynn', 'Matty', 'Nacho']
Meal 3: ['Leigh', 'Teddy', 'Katie']
Cook Counts:
Steve: 2
Jason: 2
Lynn: 2
Matty: 3
Nacho: 3
Leigh: 3
Teddy: 3
Katie: 3
Попасть туда! Каждый раз, когда мы запускаем функцию, у нас есть рандомизированная группировка в соответствии с заданными входными данными. Нагрузка кажется сбалансированной. Однако, если вы внимательно присмотритесь, вы увидите небольшое повторение в общей структуре плана.
На данный момент все работает хорошо, давайте пока придерживаться этого подхода к коду.
Однако, как вы видите в выводе, имена следуют одному и тому же шаблону во всем списке групп блюд. Каждая группа должна быть полностью рандомизирована каждый раз, но при этом поддерживать баланс количества приготовлений.
Рассматривая только что сгенерированный вывод, вы увидите, что шаблон имен выглядит следующим образом:
Мэтти › Начо › Ли › Тедди › Кэти › Стив › Джейсон › Линн
(а потом повторяется)
Пожалуйста, перепишите ниже, чтобы каждый раз перемешивать, сохраняя при этом сбалансированное количество приготовлений.
import random
names = ["Steve", "Leigh", "Jason", "Lynn", "Teddy", "Katie", "Matty", "Nacho"]
group_size = 3
breakfast = 3
lunch = 1
dinner = 3
# Calculate number of meals each person should cook
num_meals = len(names) * (breakfast + lunch + dinner) // group_size
cook_counts = {name: 0 for name in names}
# Initialize meals dictionary
meals = {"breakfast": breakfast, "lunch": lunch, "dinner": dinner}
# Initialize groups dictionary
groups = {name: {meal: 0 for meal in meals} for name in names}
# Shuffle names
random.shuffle(names)
# Assign meals to groups
for meal in meals:
meal_count = meals[meal]
print(meal.title() + " groups:")
for i in range(1, meal_count + 1):
group_list = random.sample(names, group_size)
for name in group_list:
groups[name][meal] += 1
cook_counts[name] += 1
print("Meal {}: {}".format(i, group_list))
# Print cook counts
print("\nCook Counts:")
for name in sorted(cook_counts, key=lambda x: cook_counts[x]):
print("{}: {}".format(name, cook_counts[name]))
OUTPUT
Breakfast groups:
Meal 1: ['Matty', 'Katie', 'Jason']
Meal 2: ['Nacho', 'Leigh', 'Teddy']
Meal 3: ['Steve', 'Teddy', 'Katie']
Lunch groups:
Meal 1: ['Katie', 'Nacho', 'Steve']
Dinner groups:
Meal 1: ['Lynn', 'Katie', 'Jason']
Meal 2: ['Teddy', 'Leigh', 'Steve']
Meal 3: ['Nacho', 'Steve', 'Leigh']
Cook Counts:
Lynn: 1
Matty: 1
Jason: 2
Leigh: 3
Teddy: 3
Nacho: 3
Steve: 4
Katie: 4
Часто это два шага вперед, один шаг назад.
Теперь случайность работает лучше, но мы потеряли сбалансированное количество поваров. Рассмотрим вывод кода, который вы только что предоставили.
Видите, как все готовят разное количество раз? С нашими примерами входных данных каждый человек должен готовить 2 или 3 раза. Пожалуйста исправьте.
import random
names = ["Steve", "Leigh", "Jason", "Lynn", "Teddy", "Katie", "Matty", "Nacho"]
group_size = 3
breakfast = 3
lunch = 1
dinner = 3
# Calculate number of meals each person should cook
num_meals = len(names) * (breakfast + lunch + dinner) // group_size
cook_counts = {name: 0 for name in names}
# Initialize meals dictionary
meals = {"breakfast": breakfast, "lunch": lunch, "dinner": dinner}
# Initialize groups dictionary
groups = {name: {meal: 0 for meal in meals} for name in names}
# Assign meals to groups
for meal in meals:
meal_count = meals[meal]
print(meal.title() + " groups:")
for i in range(1, meal_count + 1):
group_list = []
while len(group_list) < group_size:
# Shuffle names
random.shuffle(names)
# Sort shuffled names by cook counts in ascending order
sorted_names = sorted(names, key=lambda x: cook_counts[x])
group = sorted_names[:group_size - len(group_list)]
group_list.extend(group)
for name in group:
cook_counts[name] += 1
for name in group_list:
groups[name][meal] += 1
print("Meal {}: {}".format(i, group_list))
# Print cook counts
print("\nCook Counts:")
for name in sorted(cook_counts, key=lambda x: cook_counts[x]):
print("{}: {}".format(name, cook_counts[name]))
OUTPUT
Breakfast groups:
Meal 1: ['Matty', 'Steve', 'Katie']
Meal 2: ['Leigh', 'Lynn', 'Teddy']
Meal 3: ['Jason', 'Nacho', 'Lynn']
Lunch groups:
Meal 1: ['Matty', 'Katie', 'Teddy']
Dinner groups:
Meal 1: ['Nacho', 'Steve', 'Leigh']
Meal 2: ['Jason', 'Leigh', 'Matty']
Meal 3: ['Jason', 'Teddy', 'Lynn']
Cook Counts:
Steve: 2
Katie: 2
Nacho: 2
Leigh: 3
Jason: 3
Lynn: 3
Teddy: 3
Matty: 3
Бум!
Красиво сделано, это было прекрасно.
Теперь, придерживаясь этого кода, мы хотим убедиться, что каждый человек готовит одинаковое или примерно одинаковое количество видов еды (т. е. каждый должен готовить примерно одинаковое количество завтраков, обедов и ужинов). Чтобы подтвердить это, мы добавим новый счетчик под названием количество приемов пищи, в котором указано, сколько раз человек готовил каждый прием пищи.
import random
names = ["Steve", "Leigh", "Jason", "Lynn", "Teddy", "Katie", "Matty", "Nacho"]
group_size = 3
breakfast = 3
lunch = 1
dinner = 3
# Calculate number of meals each person should cook
num_meals = len(names) * (breakfast + lunch + dinner) // group_size
cook_counts = {name: 0 for name in names}
# Initialize meals dictionary
meals = {"breakfast": breakfast, "lunch": lunch, "dinner": dinner}
# Initialize groups dictionary
groups = {name: {meal: 0 for meal in meals} for name in names}
# Assign meals to groups
for meal in meals:
meal_count = meals[meal]
print(meal.title() + " groups:")
for i in range(1, meal_count + 1):
group_list = []
while len(group_list) < group_size:
# Sort names by cook counts in ascending order
sorted_names = sorted(names, key=lambda x: cook_counts[x])
group = sorted_names[:group_size - len(group_list)]
group_list.extend(group)
for name in group:
cook_counts[name] += 1
for name in group_list:
groups[name][meal] += 1
print("Meal {}: {}".format(i, group_list))
# Calculate meal counts for each person
meal_count = {name: {"breakfast": 0, "lunch": 0, "dinner": 0} for name in names}
for name in names:
for meal in meals:
for group in groups.values():
if group[meal] > 0 and name in group:
meal_count[name][meal] += 1
# Print cook counts and meal counts for each person
print("\nCook Counts:")
for name in sorted(cook_counts, key=lambda x: cook_counts[x]):
print("{}: {}".format(name, cook_counts[name]))
print("\nMeal Counts:")
for name in sorted(meal_count, key=lambda x: meal_count[x]):
print("{}: {}".format(name, meal_count[name]))
OUTPUT
Breakfast groups:
Meal 1: ['Steve', 'Leigh', 'Jason']
Meal 2: ['Lynn', 'Teddy', 'Katie']
Meal 3: ['Matty', 'Nacho', 'Steve']
Lunch groups:
Meal 1: ['Leigh', 'Jason', 'Lynn']
Dinner groups:
Meal 1: ['Teddy', 'Katie', 'Matty']
Meal 2: ['Nacho', 'Steve', 'Leigh']
Meal 3: ['Jason', 'Lynn', 'Teddy']
Cook Counts:
Katie: 2
Matty: 2
Nacho: 2
Steve: 3
Leigh: 3
Jason: 3
Lynn: 3
Teddy: 3
Meal Counts:
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
Cell In[1], line 49
47 print("{}: {}".format(name, cook_counts[name]))
48 print("\nMeal Counts:")
---> 49 for name in sorted(meal_count, key=lambda x: meal_count[x]):
50 print("{}: {}".format(name, meal_count[name]))
TypeError: '<' not supported between instances of 'dict' and 'dict'
Ой! Похоже, что код ChatGPT, сгенерированный из последней подсказки, выдал ошибку TypeError при запуске. Не бойтесь, ChatGPT уже здесь! Я вставил ошибку дословно в качестве следующего запроса, чтобы посмотреть, может ли он выполнить самостоятельную отладку.
Спойлер: так и было.
import random
# define people and meal groups
people = ['Katie', 'Matty', 'Nacho', 'Steve', 'Leigh', 'Jason', 'Lynn', 'Teddy']
meals = ['Breakfast', 'Lunch', 'Dinner']
# create empty dictionaries to store counts
cook_counts = {name: 0 for name in people}
meal_count = {name: {meal: 0 for meal in meals} for name in people}
# create groups
groups = {meal: {i+1: [] for i in range(3)} for meal in meals}
for meal in meals:
for i in range(3):
group = random.sample(people, 3)
for name in group:
groups[meal][i+1].append(name)
cook_counts[name] += 1
meal_count[name][meal] += 1
# print groups and counts
for meal in meals:
print("{} groups:".format(meal))
for i in range(3):
print("Meal {}: {}".format(i+1, groups[meal][i+1]))
print()
print("Cook Counts:")
for name in sorted(cook_counts, key=lambda x: cook_counts[x]):
print("{}: {}".format(name, cook_counts[name]))
print("\nMeal Counts:")
for name in sorted(meal_count, key=lambda x: sum(meal_count[x].values())):
print("{}: {}".format(name, meal_count[name]))
OUTPUT
Breakfast groups:
Meal 1: ['Matty', 'Steve', 'Nacho']
Meal 2: ['Nacho', 'Steve', 'Teddy']
Meal 3: ['Nacho', 'Teddy', 'Matty']
Lunch groups:
Meal 1: ['Steve', 'Lynn', 'Nacho']
Meal 2: ['Leigh', 'Teddy', 'Jason']
Meal 3: ['Nacho', 'Matty', 'Lynn']
Dinner groups:
Meal 1: ['Steve', 'Jason', 'Nacho']
Meal 2: ['Lynn', 'Leigh', 'Nacho']
Meal 3: ['Teddy', 'Steve', 'Katie']
Cook Counts:
Katie: 1
Leigh: 2
Jason: 2
Matty: 3
Lynn: 3
Teddy: 4
Steve: 5
Nacho: 7
...
Lynn: {'Breakfast': 0, 'Lunch': 2, 'Dinner': 1}
Teddy: {'Breakfast': 2, 'Lunch': 1, 'Dinner': 1}
Steve: {'Breakfast': 2, 'Lunch': 1, 'Dinner': 2}
Nacho: {'Breakfast': 3, 'Lunch': 2, 'Dinner': 2}
Мне нравится подход со словарем, но, пожалуйста, просмотрите вывод и измените исходный код, чтобы исправить.
Один из наших циклов for дал сбой. Хотя я не уточнил, ChatGPT увидел вывод и распознал нарушение баланса счетчика, сказав: «Вот измененный код, который гарантирует, что каждый человек готовит одинаковое или примерно одинаковое количество видов еды, а также добавляет количество блюд. counter:», прежде чем исправлять код следующим образом:
import random
# Input data
people = ['Teddy', 'Katie', 'Leigh', 'Lynn', 'Matty', 'Nacho', 'Steve', 'Jason']
meals = ['Breakfast', 'Lunch', 'Dinner']
meal_counts = {meal: 3 for meal in meals}
meal_counts[meals[random.randint(0, 2)]] += 1
# Shuffle people and assign to meals
random.shuffle(people)
breakfast_groups = [people[i:i+3] for i in range(0, len(people), 3)]
random.shuffle(people)
lunch_groups = [people[i:i+3] for i in range(0, len(people), 3)]
random.shuffle(people)
dinner_groups = [people[i:i+3] for i in range(0, len(people), 3)]
# Count number of meals cooked by each person
cook_counts = {name: 0 for name in people}
meal_count = {name: {meal: 0 for meal in meals} for name in people}
for group in breakfast_groups + lunch_groups + dinner_groups:
for name in group:
cook_counts[name] += 1
for meal in meals:
if meal in meals:
meal_count[name][meal] += 1
# Output results
print("Breakfast groups:")
for i, group in enumerate(breakfast_groups):
print("Meal {}: {}".format(i+1, group))
print("\nLunch groups:")
for i, group in enumerate(lunch_groups):
print("Meal {}: {}".format(i+1, group))
print("\nDinner groups:")
for i, group in enumerate(dinner_groups):
print("Meal {}: {}".format(i+1, group))
print("\nCook Counts:")
for name in sorted(cook_counts, key=lambda x: cook_counts[x]):
print("{}: {}".format(name, cook_counts[name]))
print("\nMeal Counts:")
for name in sorted(meal_count, key=lambda x: cook_counts[x]):
print("{}: {}".format(name, meal_count[name]))
OUTPUT
Breakfast groups:
Meal 1: ['Matty', 'Jason', 'Nacho']
Meal 2: ['Leigh', 'Katie', 'Lynn']
Meal 3: ['Teddy', 'Steve']
Lunch groups:
Meal 1: ['Katie', 'Leigh', 'Teddy']
Meal 2: ['Nacho', 'Steve', 'Jason']
Meal 3: ['Matty', 'Lynn']
Dinner groups:
Meal 1: ['Teddy', 'Jason', 'Nacho']
Meal 2: ['Lynn', 'Katie', 'Leigh']
Meal 3: ['Steve', 'Matty']
Cook Counts:
Teddy: 3
Jason: 3
Nacho: 3
Lynn: 3
Katie: 3
Leigh: 3
Steve: 3
Matty: 3
...
Katie: {'Breakfast': 3, 'Lunch': 3, 'Dinner': 3}
Leigh: {'Breakfast': 3, 'Lunch': 3, 'Dinner': 3}
Steve: {'Breakfast': 3, 'Lunch': 3, 'Dinner': 3}
Matty: {'Breakfast': 3, 'Lunch': 3, 'Dinner': 3}
Это сработало, спасибо. Однако мы потеряли возможность определять количество каждой переменной завтрака, обеда и ужина.
Следующий код делает это, но не включает счетчик приемов пищи каждого человека. Пожалуйста, измените следующий код, чтобы вывести числовое значение словаря, указывающее, сколько раз человек готовил каждое блюдо.
В дополнение к этому быстрому ответу я вставил последнюю версию кода, который позволил нам определить переменные еды, и наблюдал, как печально известный мигающий курсор ChatGPT быстро изложил решение моего запроса.
import random
names = ["Steve", "Leigh", "Jason", "Lynn", "Teddy", "Katie", "Matty", "Nacho"]
group_size = 3
breakfast = 3
lunch = 1
dinner = 3
# Calculate number of meals each person should cook
num_meals = len(names) * (breakfast + lunch + dinner) // group_size
cook_counts = {name: 0 for name in names}
# Initialize meals dictionary
meals = {"breakfast": breakfast, "lunch": lunch, "dinner": dinner}
# Initialize groups dictionary
groups = {name: {meal: 0 for meal in meals} for name in names}
# Assign meals to groups
for meal in meals:
meal_count = meals[meal]
print(meal.title() + " groups:")
for i in range(1, meal_count + 1):
group_list = []
while len(group_list) < group_size:
# Shuffle names
random.shuffle(names)
# Sort shuffled names by cook counts in ascending order
sorted_names = sorted(names, key=lambda x: cook_counts[x])
group = sorted_names[:group_size - len(group_list)]
group_list.extend(group)
for name in group:
cook_counts[name] += 1
groups[name][meal] += 1
print("Meal {}: {}".format(i, group_list))
# Print cook counts
print("\nCook Counts:")
for name in sorted(cook_counts, key=lambda x: cook_counts[x]):
print("{}: {}".format(name, cook_counts[name]))
# Print meal counts
print("\nMeal Counts:")
for name in sorted(groups):
print(name + ": " + str(groups[name]))
OUTPUT
Breakfast groups:
Meal 1: ['Matty', 'Jason', 'Katie']
Meal 2: ['Leigh', 'Lynn', 'Steve']
Meal 3: ['Nacho', 'Teddy', 'Lynn']
Lunch groups:
Meal 1: ['Jason', 'Katie', 'Teddy']
Dinner groups:
Meal 1: ['Steve', 'Nacho', 'Leigh']
Meal 2: ['Matty', 'Lynn', 'Nacho']
Meal 3: ['Steve', 'Teddy', 'Matty']
Cook Counts:
Leigh: 2
Jason: 2
Katie: 2
Steve: 3
Lynn: 3
Teddy: 3
Matty: 3
Nacho: 3
Meal Counts:
Jason: {'breakfast': 1, 'lunch': 1, 'dinner': 0}
Katie: {'breakfast': 1, 'lunch': 1, 'dinner': 0}
Leigh: {'breakfast': 1, 'lunch': 0, 'dinner': 1}
...
Matty: {'breakfast': 1, 'lunch': 0, 'dinner': 2}
Nacho: {'breakfast': 1, 'lunch': 0, 'dinner': 2}
Steve: {'breakfast': 1, 'lunch': 0, 'dinner': 2}
Teddy: {'breakfast': 1, 'lunch': 1, 'dinner': 1}
Замечательный! Это было потрясающе. Теперь, пожалуйста, измените количество приемов пищи, чтобы включить «общее» количество, которое показывает сумму завтрака, обеда и ужина.
import random
names = ["Steve", "Leigh", "Jason", "Lynn", "Teddy", "Katie", "Matty", "Nacho"]
group_size = 3
breakfast = 3
lunch = 1
dinner = 3
# Calculate number of meals each person should cook
num_meals = len(names) * (breakfast + lunch + dinner) // group_size
cook_counts = {name: 0 for name in names}
# Initialize meals dictionary
meals = {"breakfast": breakfast, "lunch": lunch, "dinner": dinner}
# Initialize groups dictionary
groups = {name: {meal: 0 for meal in meals} for name in names}
# Assign meals to groups
for meal in meals:
meal_count = meals[meal]
print(meal.title() + " groups:")
for i in range(1, meal_count + 1):
group_list = []
while len(group_list) < group_size:
# Shuffle names
random.shuffle(names)
# Sort shuffled names by cook counts in ascending order
sorted_names = sorted(names, key=lambda x: cook_counts[x])
group = sorted_names[:group_size - len(group_list)]
group_list.extend(group)
for name in group:
cook_counts[name] += 1
for name in group_list:
groups[name][meal] += 1
print("Meal {}: {}".format(i, group_list))
# Print cook counts
print("\nCook Counts:")
for name in sorted(cook_counts, key=lambda x: cook_counts[x]):
print("{}: {}".format(name, cook_counts[name]))
# Count number of times each person cooked each meal
meal_counts = {}
for name in names:
meal_counts[name] = {"breakfast": 0, "lunch": 0, "dinner": 0, "total": 0}
for meal in meals:
meal_counts[name][meal] = groups[name][meal]
meal_counts[name]["total"] += groups[name][meal]
# Print meal counts
print("\nMeal Counts:")
for name in sorted(meal_counts, key=lambda x: meal_counts[x]["total"]):
print("{}: {}".format(name, meal_counts[name]))
OUTPUT
Breakfast groups:
Meal 1: ['Jason', 'Leigh', 'Steve']
Meal 2: ['Katie', 'Lynn', 'Matty']
Meal 3: ['Nacho', 'Teddy', 'Matty']
Lunch groups:
Meal 1: ['Teddy', 'Lynn', 'Leigh']
Dinner groups:
Meal 1: ['Katie', 'Nacho', 'Jason']
Meal 2: ['Steve', 'Nacho', 'Leigh']
Meal 3: ['Teddy', 'Steve', 'Lynn']
Cook Counts:
Jason: 2
Katie: 2
Matty: 2
Steve: 3
Leigh: 3
Lynn: 3
Teddy: 3
Nacho: 3
Meal Counts:
Katie: {'breakfast': 1, 'lunch': 0, 'dinner': 1, 'total': 2}
Matty: {'breakfast': 2, 'lunch': 0, 'dinner': 0, 'total': 2}
Jason: {'breakfast': 1, 'lunch': 0, 'dinner': 1, 'total': 2}
...
Leigh: {'breakfast': 1, 'lunch': 1, 'dinner': 1, 'total': 3}
Steve: {'breakfast': 1, 'lunch': 0, 'dinner': 2, 'total': 3}
Lynn: {'breakfast': 1, 'lunch': 1, 'dinner': 1, 'total': 3}
Nacho: {'breakfast': 1, 'lunch': 0, 'dinner': 2, 'total': 3}
Используя значения Cook Counts и Meal Counts в качестве перекрестной ссылки, я убедился, что итоговые значения рассчитываются правильно, а затем закомментировал строку, печатающую «Cook Counts», поскольку теперь она стала избыточной. Мой код теперь выглядел следующим образом:
import random
names = ["Steve", "Leigh", "Jason", "Lynn", "Teddy", "Katie", "Matty", "Nacho"]
group_size = 3
breakfast = 3
lunch = 0
dinner = 3
# Calculate number of meals each person should cook
num_meals = len(names) * (breakfast + lunch + dinner) // group_size
cook_counts = {name: 0 for name in names}
# Initialize meals dictionary
meals = {"breakfast": breakfast, "lunch": lunch, "dinner": dinner}
# Initialize groups dictionary
groups = {name: {meal: 0 for meal in meals} for name in names}
# Assign meals to groups
for meal in meals:
meal_count = meals[meal]
print(meal.title() + " groups:")
for i in range(1, meal_count + 1):
group_list = []
while len(group_list) < group_size:
# Shuffle names
random.shuffle(names)
# Sort shuffled names by cook counts in ascending order
sorted_names = sorted(names, key=lambda x: cook_counts[x])
group = sorted_names[:group_size - len(group_list)]
group_list.extend(group)
for name in group:
cook_counts[name] += 1
for name in group_list:
groups[name][meal] += 1
print("Meal {}: {}".format(i, group_list))
# # Print cook counts
# print("\nCook Counts:")
# for name in sorted(cook_counts, key=lambda x: cook_counts[x]):
# print("{}: {}".format(name, cook_counts[name]))
# Count number of times each person cooked each meal
meal_counts = {}
for name in names:
meal_counts[name] = {"breakfast": 0, "lunch": 0, "dinner": 0, "total": 0}
for meal in meals:
meal_counts[name][meal] = groups[name][meal]
meal_counts[name]["total"] += groups[name][meal]
# Print meal counts
print("\nMeal Counts:")
for name in sorted(meal_counts, key=lambda x: meal_counts[x]["total"]):
print("{}: {}".format(name, meal_counts[name]))
OUTPUT
Breakfast groups:
Meal 1: ['Teddy', 'Katie', 'Jason']
Meal 2: ['Leigh', 'Nacho', 'Steve']
Meal 3: ['Lynn', 'Matty', 'Katie']
Lunch groups:
Dinner groups:
Meal 1: ['Leigh', 'Steve', 'Jason']
Meal 2: ['Nacho', 'Lynn', 'Matty']
Meal 3: ['Teddy', 'Matty', 'Leigh']
Meal Counts:
Lynn: {'breakfast': 1, 'lunch': 0, 'dinner': 1, 'total': 2}
Steve: {'breakfast': 1, 'lunch': 0, 'dinner': 1, 'total': 2}
Katie: {'breakfast': 2, 'lunch': 0, 'dinner': 0, 'total': 2}
Jason: {'breakfast': 1, 'lunch': 0, 'dinner': 1, 'total': 2}
Teddy: {'breakfast': 1, 'lunch': 0, 'dinner': 1, 'total': 2}
Nacho: {'breakfast': 1, 'lunch': 0, 'dinner': 1, 'total': 2}
Matty: {'breakfast': 1, 'lunch': 0, 'dinner': 2, 'total': 3}
Leigh: {'breakfast': 1, 'lunch': 0, 'dinner': 2, 'total': 3}
Выглядишь действительно здорово! Давайте немного изменим функцию в последний раз.
Удивительный!! Это потрясающе.
Теперь, придерживаясь этого кода, измените его так, чтобы, если номер определенного приема пищи был установлен на ноль, он печатал «Блюда не запланированы» вместо групп поваров.
import random
names = ["Steve", "Leigh", "Jason", "Lynn", "Teddy", "Katie", "Matty", "Nacho"]
group_size = 3
breakfast = 3
lunch = 0
dinner = 3
# Calculate number of meals each person should cook
num_meals = len(names) * (breakfast + lunch + dinner) // group_size
cook_counts = {name: 0 for name in names}
# Initialize meals dictionary
meals = {"breakfast": breakfast, "lunch": lunch, "dinner": dinner}
# Initialize groups dictionary
groups = {name: {meal: 0 for meal in meals} for name in names}
# Assign meals to groups
for meal in meals:
meal_count = meals[meal]
if meal_count == 0:
print(f"No {meal} planned")
else:
print(meal.title() + " groups:")
for i in range(1, meal_count + 1):
group_list = []
while len(group_list) < group_size:
# Shuffle names
random.shuffle(names)
# Sort shuffled names by cook counts in ascending order
sorted_names = sorted(names, key=lambda x: cook_counts[x])
group = sorted_names[:group_size - len(group_list)]
group_list.extend(group)
for name in group:
cook_counts[name] += 1
for name in group_list:
groups[name][meal] += 1
print("Meal {}: {}".format(i, group_list))
print("")
# # Print cook counts
# print("\nCook Counts:")
# for name in sorted(cook_counts, key=lambda x: cook_counts[x]):
# print("{}: {}".format(name, cook_counts[name]))
# Calculate meal counts
meal_counts = {name: {"breakfast": 0, "lunch": 0, "dinner": 0, "total": 0} for name in names}
for name in names:
for meal in meals:
meal_count = groups[name][meal]
meal_counts[name][meal] = meal_count
meal_counts[name]["total"] += meal_count
# Print meal counts
print("\nMeal Counts:")
for name in sorted(meal_counts):
print(name + " cooks: " + str(meal_counts[name]))
OUTPUT
Breakfast groups:
Meal 1: ['Jason', 'Teddy', 'Lynn']
Meal 2: ['Nacho', 'Matty', 'Leigh']
Meal 3: ['Steve', 'Katie', 'Nacho']
No lunch planned
Dinner groups:
Meal 1: ['Lynn', 'Leigh', 'Steve']
Meal 2: ['Teddy', 'Jason', 'Matty']
Meal 3: ['Katie', 'Nacho', 'Teddy']
Meal Counts:
Jason cooks: {'breakfast': 1, 'lunch': 0, 'dinner': 1, 'total': 2}
Katie cooks: {'breakfast': 1, 'lunch': 0, 'dinner': 1, 'total': 2}
Leigh cooks: {'breakfast': 1, 'lunch': 0, 'dinner': 1, 'total': 2}
Lynn cooks: {'breakfast': 1, 'lunch': 0, 'dinner': 1, 'total': 2}
Matty cooks: {'breakfast': 1, 'lunch': 0, 'dinner': 1, 'total': 2}
Nacho cooks: {'breakfast': 2, 'lunch': 0, 'dinner': 1, 'total': 3}
Steve cooks: {'breakfast': 1, 'lunch': 0, 'dinner': 1, 'total': 2}
Teddy cooks: {'breakfast': 1, 'lunch': 0, 'dinner': 2, 'total': 3}
При этом мы можем изменить начальные параметры и запустить код, чтобы каждый раз получать случайно сбалансированный план распределения еды.
И вот оно!
Объедините базовые знания Python с щепоткой планирования проекта, встряхните вместе с несколькими быстрыми итерациями, затем добавьте здоровую порцию магии языковой модели, и вы получите рецепт успеха. Все дело в паре чашек кофе. К тому же он без сахара!
Но почему?
Я надеюсь, что это упражнение не только подчеркнет невероятную мощь и возможности больших языковых моделей, таких как ChatGPT, но и вдохновит людей любого уровня способностей не пугаться идеи создания собственных приложений с пользовательским кодом. Несколько месяцев назад для создания чего-то подобного требовалось глубокое и всестороннее понимание языка программирования в течение многих лет интенсивного изучения и практики. Но теперь, используя возможности обработки естественного языка таких моделей, как ChatGPT от OpenAI, любой, кто может напечатать предложение, может использовать нетехнический язык и немного настойчивости, чтобы быстро сгенерировать (и устранить неполадки) полностью функциональный код в несколько нажатий клавиш.
Я хочу признать, что, несмотря на оптимизацию, этот подход не всегда может привести к созданию наиболее лаконичного или эффективного кода. Часто результаты, генерируемые ChatGPT, раздуты, неэффективны или просто неверны. Неизбежно лучше просмотреть и изменить выходной код для уточнения, добавив улучшения, такие как более четкие комментарии и более описательные переменные. Настоящий ниндзя Python, вероятно, посмеялся бы над этим выводом на одном дыхании, а на следующем написал бы гораздо более совершенную функцию. Тем не менее, чрезвычайно низкий барьер для входа, отмеченный этим подходом, на мой взгляд, в значительной степени компенсирует недостаток синтаксической элегантности.
Если это показалось вам выше головы, не отчаивайтесь. Поверьте мне (случайному человеку в Интернете): независимо от вашего опыта или способностей, вы можете использовать ChatGPT для изучения этих и многих других концепций прямо сейчас. Это просто требует интереса, энтузиазма и времени (подсказка: чтобы сэкономить часть этого, вы можете попробовать вставить эту статью в чат и запросить у ИИ синопсис с точки зрения собаки. Гав-гав!).
Если этот подход кажется слишком простым, я хотел бы услышать некоторые дополнительные советы о том, как использовать эту невероятную технологию. Я очарован этой верхушкой айсберга и хотел бы погрузиться в более глубокое понимание.
В любом случае, я надеюсь, что вы будете вдохновлены строить и создавать что-то, если мечта вас так тронет.
Я также надеюсь, что *не* увижу, как ты катаешься на лыжах по моей трассе в бэккантри ;)
А теперь, если вы меня извините, пора идти варить еще одну чашку кофе.
Спасибо за прочтение!
Бен Наклас — лыжник, исследователь данных, писатель, медитатор и на 100% настоящий человек. В настоящее время он исследует разработку языковых моделей, которые по своей сути являются разумными, и надеется на более плавную интеграцию человека и машины в будущем. Когда он отключен от сети, его можно найти (или нет) в горах, лесах и реках, а также везде между ними. Оставьте ему сообщение в LinkedIn, но не ждите раскрытия каких-то тайников с порохом.
