Если вы следили за мной на эту сагу, чтобы сократить свой оригинальный бегемот решения для ножниц рок-бумаги, то вы знаете, что мы переместили 1 389 символов до 864 от Представляем модульную арифметику Отказ Затем мы сжали программу снова до 645 символов через некоторую рефакторинг. Теперь мы собираемся попытаться получить программу до размера Tweet или 280 символов. Это можно сделать?
Эта статья не ClickBait. Это абсолютно возможно написать ножницы для рок-бумаги в 280 символов, и я сделал это! Это сказано, я не думаю, что это возможно, не делая некоторые жертвы оригинальным требованиям.
Во всяком случае, давайте начнем!
На чем мы остановились?
На данный момент вовремя, вот последняя версия программы:
import random
# Generate default outcome
choices = ["Rock", "Paper", "Scissors"]
pc_index = random.randint(0, 2)
pc_choice = choices[pc_index]
output = [f"I chose {pc_choice}", "You chose nothing.", "You lose by default."]
# Play game
user_pick = input("Choose Rock (0), Paper (1), or Scissors (2): ")
if user_pick.isdecimal() and (user_index := int(user_pick)) in range(3):
user_choice = choices[user_index]
output[1:] = [
f"You chose {user_choice}",
[
"Tie!",
f"{user_choice} beats {pc_choice} - you win!",
f"{pc_choice} beats {user_choice} - I win!"
][(user_index - pc_index) % 3]]
# Share outcome
print("\n".join(output))
В настоящее время наша программа удобно сидит на 644 символа, и она все еще очень читается. В конечном итоге, то, что я хочу сделать сейчас, это использует несколько вещей, которые можно найти в моя статья обфускации -Замино удалить пробелы и сократить имена переменной. Кроме того, мы собираемся попробовать несколько трюков в Этот код гольф-нить Отказ Давайте начнем!
Начать сжатие
На протяжении всей остальной части этой статьи я буду документировать весь свой процесс для попытки сокращать ножницы для усадки рок-бумаги до 280 символов (A.k.a. размер твита).
Как быстрое предупреждение, сжатый код вручную – это длительный и грязный процесс, и есть определенно лучшие способы пойти об этом. Тем не хватает, что одна из вещей, которые я несмотря на пропал в образовании, является «экспертным» обоснованием. Я не рассматриваю себя экспертом здесь, но я думаю, что это будет ценным, чтобы увидеть мой подход к решению проблем.
И если ничего другого, вы можете посмотреть, как я изо всех сил пытался сделать это! Не волнуйся. Мне удается добиться его в Tweet Size -Не без нескольких ударов по пути.
Потенциал Распаковывать
Одно из самых первых предложений в этом коде гольф-нить заключается в том, чтобы воспользоваться уникальным распаковкой при назначении переменных. В нашем случае у нас есть несколько переменных назначений в верхней части, что мы можем попробовать слияние. Например, мы могли бы сделать следующее:
choices = ["Rock", "Paper", "Scissors"]
pc_index = random.randint(0, 2)
pc_choice = choices[pc_index]
output = [f"I chose {pc_choice}", "You chose nothing.", "You lose by default."]
И превратить его в это:
choices, pc_index, pc_choice, output = ["Rock", "Paper", "Scissors"], random.randint(0, 2), choices[pc_index], [f"I chose {pc_choice}", "You chose nothing.", "You lose by default."]
К сожалению, это на самом деле не имеет выплаты, которую я ожидал. Возможно, потому что ответ, который я ссылаюсь, использует строку как утечку. Это сказано, я решил выжать какой-то выплата из этого, поэтому я собираюсь попытаться реструктурировать это:
*choices, pc_index, pc_choice = "Rock", "Paper", "Scissors", random.randint(0, 2), choices[pc_index]
output = [f"I chose {pc_choice}", "You chose nothing.", "You lose by default."]
Хорошо, так это было немного пусть, но это может помочь нам позже. Давайте сохраним оригинальную программу сейчас и попробуйте что-нибудь еще!
Переписать входную строку
Поскольку все наши варианты хранятся в списке, я полагал, что мы можем попробовать динамически генерировать входную строку. Возможно, это было бы немного чище. Другими словами, вместо того, чтобы написать это:
user_pick = input("Choose Rock (0), Paper (1), or Scissors (2): ")
Мы могли бы написать что-то вроде этого:
user_pick = input(f'{", ".join(choices)}! (0, 1, 2):')
Теперь это некоторые сбережения! Это не так явное, как оригинал, но мы собираемся на сжатие. Я возьму 54 персонажей более 66 в любой день. Вот что сейчас выглядит программа:
import random
# Generate default outcome
choices = ["Rock", "Paper", "Scissors"]
pc_index = random.randint(0, 2)
pc_choice = choices[pc_index]
output = [f"I chose {pc_choice}", "You chose nothing.", "You lose by default."]
# Play game
user_pick = input(f'{", ".join(choices)}! (0, 1, 2):')
if user_pick.isdecimal() and (user_index := int(user_pick)) in range(3):
user_choice = choices[user_index]
output[1:] = [
f"You chose {user_choice}",
[
"Tie!",
f"{user_choice} beats {pc_choice} - you win!",
f"{pc_choice} beats {user_choice} - I win!"
][(user_index - pc_index) % 3]]
# Share outcome
print("\n".join(output))
Теперь мы до 653! Не волнуйтесь; Большие изменения впереди.
Переименование импорта
На данный момент я не думаю, что есть способ, используя случайную библиотеку. Тем не менее, мы можем дать ему имя, которое может сэкономить нам пару персонажей. Другими словами, вместо того, чтобы качаться это:
import random pc_index = random.randint(0, 2)
Мы могли бы попробовать что-то вроде этого:
import random as r pc_index = r.randint(0, 2)
К сожалению, изменение, подобное этому, на самом деле не спасает нас любые персонажи: 45 независимо от того, как вы нарезаете его! Тем не менее, это, возможно, сработало, если мы использовали случайные несколько раз.
Переименование всех переменных
На данный момент я не вижу никакой ценности в попытке играть с существующим кодом. Давайте пойдем вперед и уменьшаемся все наши переменные и оптимизировать на другом конце, если мы все еще вне диапазона. Вот что это было бы похоже:
import random
# Generate default outcome
a = ["Rock", "Paper", "Scissors"]
b = random.randint(0, 2)
c = a[b]
d = [f"I chose {c}", "You chose nothing.", "You lose by default."]
# Play game
e = input(f'{", ".join(a)}! (0, 1, 2):')
if e.isdecimal() and (f := int(e)) in range(3):
g = a[f]
d[1:] = [
f"You chose {g}",
[
"Tie!",
f"{g} beats {c} - you win!",
f"{c} beats {g} - I win!"
][(f - b) % 3]]
# Share outcome
print("\n".join(d))
Теперь мы до 470 символов! Как это для сбережений? Мы на нашем пути в чирикать размер. Далее давайте попробуем удалить все комментарии и пустые строки.
Удаление комментариев и пустых строк
Еще одно быстрое изменение, которое мы можем сделать, это удаление всех комментариев и пустых строк. Таким образом, мы просто получим стену кода, как это:
import random
a = ["Rock", "Paper", "Scissors"]
b = random.randint(0, 2)
c = a[b]
d = [f"I chose {c}", "You chose nothing.", "You lose by default."]
e = input(f'{", ".join(a)}! (0, 1, 2):')
if e.isdecimal() and (f := int(e)) in range(3):
g = a[f]
d[1:] = [
f"You chose {g}",
[
"Tie!",
f"{g} beats {c} - you win!",
f"{c} beats {g} - I win!"
][(f - b) % 3]]
print("\n".join(d))
К сожалению, это только покупает нас еще 58 символов. Теперь мы сидим на 412 символах. Как мы когда-нибудь будем сократить еще 132 персонажей? Ну, мы можем начать обрезать пространства.
Устранение посторонних пространств
На данный момент я начинаю понимать соломинку, поэтому я подумал, что мы могли бы попытаться удалить любые ненужные пробелы. Например, нам действительно нужны пробелы вокруг наших операторов по назначению? Конечно, нет! Видеть:
import random
a=["Rock","Paper","Scissors"]
b=random.randint(0,2)
c=a[b]
d=[f"I chose {c}","You chose nothing.","You lose by default."]
e=input(f'{", ".join(a)}! (0, 1, 2):')
if e.isdecimal() and (f:=int(e)) in range(3):
g=a[f]
d[1:]=[f"You chose {g}",["Tie!",f"{g} beats {c} - you win!",f"{c} beats {g} - I win!"][(f-b)%3]]
print("\n".join(d))
Теперь это действительно имеет номер на общий счет. К сожалению, это не достаточно! Мы до 348 символов. Как мы будем побрить еще 68? Ну, так как мы на тему удаления дополнительных пробелов, как насчет наших правителей победителя? Посмотри:
import random
a=["Rock","Paper","Scissors"]
b=random.randint(0,2)
c=a[b]
d=[f"I chose {c}","You chose nothing.","You lose by default."]
e=input(f'{", ".join(a)}! (0, 1, 2):')
if e.isdecimal() and (f:=int(e)) in range(3):
g=a[f]
d[1:]=[f"You chose {g}",["Tie!",f"{g} beats {c}—you win!",f"{c} beats {g}—I win!"][(f-b)%3]]
print("\n".join(d))
Это просыпает еще четыре персонажа! Теперь мы всего в 64 от свободы (то есть всего 344), и у меня есть пара идей.
Сокрушительные ветви
Одна идея, которую я имел, чтобы посмотреть, сможем ли мы уменьшить заявление о если в одну строку. Для этого нам нужно будет удалить создание g . Результат выглядит так:
import random
a=["Rock","Paper","Scissors"]
b=random.randint(0,2)
c=a[b]
d=[f"I chose {c}","You chose nothing.","You lose by default."]
e=input(f'{", ".join(a)}! (0, 1, 2):')
if e.isdecimal() and (f:=int(e)) in range(3):d[1:]=[f"You chose {a[f]}",["Tie!",f"{a[f]} beats {c}—you win!",f"{c} beats {a[f]}—I win!"][(f-b)%3]]
print("\n".join(d))
К сожалению, похоже g Делал много тяжелого подъема, потому что это только побрилось с парой персонажей! Ну, хорошо, мы до 341. Что еще мы можем сделать?
Удаление избыточных кронштейнов
На данный момент я действительно заканчиваюсь от вариантов. Тем не менее, одна идея, которую у меня было, было удалить любые брекеты, которые не делали ничего полезного. Например, наше А Список хранит выбор ножниц рок-бумаги. Конечно, мы можем превратить это в кортеж, верно? Ну, вот сохранить еще два персонажа:
import random
a="Rock","Paper","Scissors"
b=random.randint(0,2)
c=a[b]
d=[f"I chose {c}","You chose nothing.","You lose by default."]
e=input(f'{", ".join(a)}! (0, 1, 2):')
if e.isdecimal() and (f:=int(e)) in range(3):d[1:]=[f"You chose {a[f]}",["Tie!",f"{a[f]} beats {c}—you win!",f"{c} beats {a[f]}—I win!"][(f-b)%3]]
print("\n".join(d))
К сожалению, подобные идеи не могут быть использованы на D список. То, что сказал, список, используемый наседанию на куски, может быть абсолютно обрезан:
import random
a="Rock","Paper","Scissors"
b=random.randint(0,2)
c=a[b]
d=[f"I chose {c}","You chose nothing.","You lose by default."]
e=input(f'{", ".join(a)}! (0, 1, 2):')
if e.isdecimal() and (f:=int(e)) in range(3):d[1:]=f"You chose {a[f]}",["Tie!",f"{a[f]} beats {c}—you win!",f"{c} beats {a[f]}—I win!"][(f-b)%3]
print("\n".join(d))
Отсюда, хотя, похоже, нет никаких списков, которые мы можем обрезать. Тем не менее, мы сохранили еще больше персонажей. Теперь мы до 337! Можем ли мы достичь 280?
Уменьшение избыточных струн
На данный момент у меня было эпопание! Что делать, если мы ссылаемся D При строительстве успешной игровой строки? Другими словами, почему выбирают «вы выбрали» дважды, когда мы можем извлечь его из D ? Вот что это было бы похоже:
import random
a="Rock","Paper","Scissors"
b=random.randint(0,2)
c=a[b]
d=[f"I chose {c}","You chose nothing.","You lose by default."]
e=input(f'{", ".join(a)}! (0, 1, 2):')
if e.isdecimal() and (f:=int(e)) in range(3):d[1:]=f"{d[1][:10]}{a[f]}",["Tie!",f"{a[f]} beats {c}—you win!",f"{c} beats {a[f]}—I win!"][(f-b)%3]
print("\n".join(d))
К сожалению, этот бит обмана на самом деле стоит нам персонаж. Даже в лучшем случае мы бы даже разбились. Итак, что если вместо этого мы просто спасли, «вы выбрали» в переменную? Вот результат:
import random
a="Rock","Paper","Scissors"
b=random.randint(0,2)
c=a[b]
g="You chose "
d=[f"I chose {c}",f"{g}nothing.","You lose by default."]
e=input(f'{", ".join(a)}! (0, 1, 2):')
if e.isdecimal() and (f:=int(e)) in range(3):d[1:]=f"{g}{a[f]}",["Tie!",f"{a[f]} beats {c}—you win!",f"{c} beats {a[f]}—I win!"][(f-b)%3]
print("\n".join(d))
Опять же, мы теряем пару персонажей! Возможно, если эти строки не были такими короткими, мы получили некоторые виды сбережений, но до сих пор это было огромное снижение. Давайте попробуем что-то еще!
Снятие вызовов функций
С 57 символами, я не уверен, что мы встретим нашу цель. Однако мы можем продолжать пытаться. Например, я уже знаю место, где мы можем обрезать пару персонажей. И, я мог бы даже позволить ему подавать двойной обязанности! Давайте пойдем вперед и удалите наш звонок в Диапазон () :
import random
a="Rock","Paper","Scissors"
g=0,1,2
b=random.choice(g)
c=a[b]
d=[f"I chose {c}","You chose nothing.","You lose by default."]
e=input(f'{", ".join(a)}! {g}:')
if e.isdecimal() and (f:=int(e)) in g:d[1:]=f"You chose {a[f]}",["Tie!",f"{a[f]} beats {c}—you win!",f"{c} beats {a[f]}—I win!"][(f-b)%3]
print("\n".join(d))
Сохраняя наш выбор в качестве кортежа, мы смогли удалить наш звонок в Диапазон () Отказ В то же время я увидел возможность заменить часть входной строки с нашим новым кортежом. Даже лучше, нам больше не нужно использовать Randint () Функция случайных. Вместо этого мы можем потянуть случайный выбор из нашего кортежа. Поговорите о тройной обязанности!
Хотя это очень захватывающе, нам удалось всего сэкономить 8 символов (то есть всего 329). С 49, чтобы пойти, я не уверен, что мы собираемся ударить нашу цель, но мы можем продолжать пытаться!
Преобразование списков на строки
Одна вещь, которую я думал, мы могли бы попробовать, что может быть немного более радикальным будет капитальному ремонту D Так что это строка, а не список. Другими словами, если мы можем как-то избавиться от необходимости в списках, мы можем бросить звонок в Присоединяйтесь () и распечатайте строку напрямую. Я думаю, что стоит выстрел! Вот что это было бы похоже:
import random
a="Rock","Paper","Scissors"
g=0,1,2
b=random.choice(g)
c=a[b]
d=f"I chose {c}\nYou chose nothing.\nYou lose by default."
e=input(f'{", ".join(a)}! {g}:')
if e.isdecimal() and (f:=int(e)) in g:d=f"{d[0:9+len(c)]}You chose {a[f]}\n{['Tie!',f'{a[f]} beats {c}—you win!',f'{c} beats {a[f]}—I win!'][(f-b)%3]}"
print(d)
Несмотря на это изменение, нам удается сохранить один символ. Вместо этого давайте попробуем что-то еще!
Другая идея, которую я должен был попробовать использовать строковый список вместо числового списка g . Одной из основных проблем с этой программой является то, что мы должны подтвердить вход. Возможно, самый простой способ подтвердить это, чтобы проверить три значения, которые мы ожидаем напрямую. Другими словами, сделайте g Храните строки и преобразуйте их обратно в целые числа по мере необходимости:
import random
a="Rock","Paper","Scissors"
*g,='012'
b=random.randint(0,2)
c=a[b]
d=[f"I chose {c}","You chose nothing.","You lose by default."]
e=input(f'{", ".join(a)}! {g}:')
if e in g:d[1:]=f"You chose {(f:=a[int(e)])}",["Tie!",f"{f} beats {c}—you win!",f"{c} beats {f}—I win!"][(int(e)-b)%3]
print("\n".join(d))
Удивительно, что это на самом деле работает! Очистка нашего заявления, нам удалось сэкономить еще 14 символов. Теперь мы до 315. Можем ли мы удалить еще 35?
Использование операторов Walrus везде
Другая идея, которую у меня было, было использовать операторы Walrus на месте традиционного назначения. К сожалению, это, похоже, на самом деле не сохраняет никаких персонажей, потому что оператор Walrus имеет дополнительный персонаж. Кроме того, он часто должен быть встроен в скобки для работы. Это сказано, я дал ему выстрел ради удовольствия!
import random
*g,='012'
d=[f"I chose {(c:=(a:=('Rock','Paper','Scissors'))[(b:=random.randint(0,2))])}","You chose nothing.","You lose by default."]
if (e:=input(f'{", ".join(a)}! {g}:')) in g:d[1:]=f"You chose {(f:=a[int(e)])}",["Tie!",f"{f} beats {c}—you win!",f"{c} beats {f}—I win!"][(int(e)-b)%3]
print("\n".join(d))
Теперь это полный кошмар! Но удивительно, что нет тонны дополнительного багажа. Насколько я могу сказать, это возвращает нас к 321 символам, и это работает. Итак, давайте отступим!
Воспользоваться импортом
Читая через этот код гольф-нить, я нашел этот драгоценный камень Отказ Вместо того, чтобы импортировать случайные и использование его, я могу импортировать все случайные и сохранять символ:
from random import*
a="Rock","Paper","Scissors"
*g,='012'
b=randint(0,2)
c=a[b]
d=[f"I chose {c}","You chose nothing.","You lose by default."]
e=input(f'{", ".join(a)}! {g}:')
if e in g:d[1:]=f"You chose {(f:=a[int(e)])}",["Tie!",f"{f} beats {c}—you win!",f"{c} beats {f}—I win!"][(int(e)-b)%3]
print("\n".join(d))
Это не так много, но мы полностью в «не очень» на территории. Другими словами, с 34 символами, чтобы пойти, один символ может быть всем, что нам нужно!
Редактирующая струнная манипуляция
Несколько разделов назад я упомянул, что преобразование списков на строки не окупилось. Ну, я нашел способ сделать это работать!
from random import*
a="Rock","Paper","Scissors"
*g,='012'
b=randint(0,2)
c=a[b]
h=" chose "
d=f"I{h}{c}\nYou{h}nothing\nYou lose by default"
e=input(f'{", ".join(a)}—{g}:')
if e in g:d=f"I{h}{c}\nYou{h}{(f:=a[int(e)])}\n{['Tie',f'{f} beats {c}—you win',f'{c} beats {f}—I win'][(int(e)-b)%3]}"
print(d)
Ранее у меня была какая-то нарезанная ерунда, которая требовала вычисления, чтобы получить право. На этот раз я полагал, что мы могли бы точно воспроизвести строки. Затем замените дубликаты слов с переменной. И, как-то, это сработало!
Теперь мы сидим довольно у 301 персонажей. Мы опасно близки к 280, и я начинаю взволнован.
Отсюда я начал думать: «Что бы произошло, если мы начали удалить часть дублирования в струнах?» Ну, это не отработало:
from random import*
a="Rock","Paper","Scissors"
*g,='012'
b=randint(0,2)
c=a[b]
h,i,j,k,n="chose "," beats ","You ","I ","\n"
l=k+h+c+n+j+h
d=f"{l}nothing{n+j}lose by default"
e=input(f'{", ".join(a)}—{g}:')
if e in g:d=f"{l}{(f:=a[int(e)])}\n{['Tie',f'{f+i+c+n+j}win',f'{c+i+f+n+k}win'][(int(e)-b)%3]}"
print(d)
Это не только это смешно не читается, но это также большая программа, чем раньше. Итак, я ускорил его и начал с предыдущей версии.
Переработка пользовательских запросов
На данный момент я чувствовал себя вроде побежденного, поэтому я решил удалить язык из игровых струн. Например, вместо того, чтобы сказать «вы», программа говорит «U». В конце концов, он спустился, чтобы немного повеселиться с этим:
from random import*
a="Rock","Paper","Scissors"
*g,='012'
b=randint(0,2)
c=a[b]
h=" chose "
d=f"I{h}{c}\nU{h}death\nI win"
e=input(f'{", ".join(a)}!—{g}:')
if e in g:d=f"I{h}{c}\nU{h}{(f:=a[int(e)])}\n{['Tie',f'{f} beats {c}—u win',f'{c} beats {f}—I win'][(int(e)-b)%3]}"
print(d)
Другими словами, я в основном отпустил именно тот же выход. Например, я смог поменять слова как «вы» на «U» и «ничего» на «смерть». В каком-то мировом пути я чувствую, что эти изменения делают программу лучше: это заставляет меня чувствовать себя чувствительным.
То, что сказано, что истинная магия этих изменений нам удалось раздавить программу от 301 символов до ровно 280. Вот и все! Это ножницы рок-бумаги в Tweet Отказ
Уроки выучены
Домашний момент, когда я получил этот код до 280 символов, я пошел вперед и опубликовал это:
Это сказано, как вы видите, я не уверен, что все усилия стоили того. В лучшем случае двое моих друзей нашли это смешно, но я не уверен, что это то, что я буду делать снова. Честно говоря, есть только так много ценности MEME, вы можете выбраться из чего-то вроде этого, и это просто не ударило, как я ожидал.
Конечно, если вы думали, что это было забавно, и вы хотели бы сделать что-то подобное, дайте мне знать! Я бы понравился глупое задание, подобное этому, чтобы взять на себя социальные сети на день или два. И если нет, никаких забот! Мне было весело, пытаясь сделать это.
Кроме того, я знаю, что эта статья такая грязная, так что дайте мне знать, если вы хотите, чтобы я передисрил некоторых из того, что я узнал в другую статью. Это было бы наслаждаться этим! Но, только если это то, что вы хотите прочитать. Это, конечно, не то, что люди собираются искать в Google.
Во всяком случае, снова спасибо, за то, что высунул его со мной! Если вы пропустили это, вот статьи, которые вдохновили эту:
- Скальные бумажные ножницы с использованием модульной арифметики
- Как запутать код в Python: Мыслительный эксперимент
Наконец, если вы хотите поддержать сайт напрямую, Вот список способов, которыми вы можете сделать это Отказ В противном случае, спасибо за остановку! Заботиться.
Оригинал: “https://dev.to/renegadecoder94/can-we-fit-rock-paper-scissors-in-python-in-a-tweet-2hhm”