Usando o Python para avaliar o "Turn Down For What" de Lil John

Ethan Jarrell 15 de dezembro

Recentemente, escutei o clássico intemporal “Turn Down for What”, de Lil John e DJ Snake. Nesta obra-prima, eles fazem uma pergunta, que eu resolvi resolver programaticamente usando Python. A questão é “Turn Down For what?”. Ao resolver esse quebra-cabeça, também irei abordar como utilizar os seguintes conceitos em Python:

  1. Enquanto loop

3. Do While loop (emulado em Python)

4. Declarações Condicionais

5. Variáveis

6. Dados JSON

7. Modelagem de Dados e Simulação

Antes de entrarmos no código, vamos dar uma olhada nas letras para ver como podemos abordar o problema:

 Acione isso alto 
Outra rodada de tiros
 Abaixar para que? 
Abaixar para que?
Abaixar para que?
Abaixar para que?
Abaixar para que?

A primeira pergunta óbvia aqui é: qual é o significado de “Turn Down for What?”. De acordo com o Quora.com:

 "Vire para cima" significa beber, festejar, dançar e possivelmente usar drogas. O oposto (parar de festejar e ficar sóbrio) é "abaixar". Quando Lil Jon diz a frase na música, ele está dizendo aos ouvintes que não há motivo para parar de festejar. 

Então, o que queremos resolver aqui é o seguinte: Haveria uma razão para recusar? E se sim, quando essa condição seria satisfeita?

While Loops vs. Do While Loops

Se analisarmos a primeira linha das letras, parece que Lil John e DJ Snake estão nos dizendo que quando a festa começar, todos os patrocinadores da party serão obrigados a ter outra rodada de tiros. Além disso, o Alto será acionado. Em essência, eles estão executando algumas ações, seguidas por uma declaração condicional, “recusar para quê?”. Este é o fluxo básico de um loop Do While que é comum em muitos idiomas baseados em C. A sintaxe geral para um loop Do While é a seguinte:

Basicamente, um loop Do While difere de outros loops comuns, pois executa o código antes de verificar uma condição. Isso significa que o código a ser executado sempre será executado pelo menos uma vez. Vamos comparar isso com um típico loop While:

Aqui, a condição é a primeira, seguida pelo código a ser executado. Se a condição for satisfeita quando o código for executado pela primeira vez, o código nunca será executado. Vamos ver novamente como isso pode acontecer no Turn Down For What:

A declaração inicial de Lil John parece ser um loop Do While, já que o código a ser executado vem antes da instrução condicional, conforme transposta aqui no Pseudo-Code. Suponha que a condição ou razão para recusar foi que não passava das 21:00. Se esta seção de código tivesse sido executada às 21:01, pelo menos todo mundo teria uma rodada de tiros, e todo mundo teria sido capaz de festejar brevemente. No entanto, no mesmo cenário, se Lil John tivesse escrito o condicional antes do código ser executado:

Então nenhum tiro teria sido tirado e a festa nunca teria sido iniciada. Neste caso, Lil John foi inteligente para escrever de tal maneira, de modo que, não importa o que aconteça, mesmo que a condição seja avaliada como True, todos ainda festejam pelo menos uma vez.

Fazendo um Do While Loop em Python

Embora muitas linguagens baseadas em C tenham uma maneira nativa de escrever um loop Do While, o Python não. Para alcançar o mesmo resultado, precisaremos usar uma sintaxe ligeiramente diferente da do Pseudo-código acima para emular um loop Do While no Python.

Aqui, emulamos o loop Do While no Python. while True simplesmente permite que o loop continue para sempre. Se não tivéssemos condições depois disso, o loop seria executado indefinidamente. No entanto, incluímos uma instrução condicional dentro do loop e, se essa condição for atendida, break o loop, provocando curto-circuito. No final, o código será sempre executado pelo menos uma vez, seguido por sua possível terminação na instrução condicional.

Definindo Variáveis

O Python é digitado dinamicamente, o que significa que você não precisa declarar o tipo de cada variável. No Python, as variáveis são um espaço reservado para armazenamento de textos e números. Deve ter um nome para que você possa encontrá-lo novamente. A variável é sempre atribuída com o sinal de igual, seguido pelo valor da variável.

Booleanos

 Valores booleanos são os dois objetos constantes False e True. 

Eles são usados para representar valores de verdade (outros valores também podem ser considerados
falso ou verdadeiro).

Em contextos numéricos (por exemplo, quando usado como argumento para
operador aritmético), eles se comportam como os inteiros 0 e 1, respectivamente.

A função interna bool () pode ser usada para converter qualquer valor para um booleano,
se o valor puder ser interpretado como um valor de verdade

Eles são escritos como Falso e Verdadeiro, respectivamente.

Números

 Variáveis numéricas em Python são usadas para armazenar números. Os números geralmente são armazenados como números inteiros, valores de ponto flutuante ou números complexos, dependendo dos requisitos do programa. 

Nas letras de Lil John, ele não define explicitamente as variáveis, mas está implícito. Não podemos ter certeza de quais são os valores iniciais para Loud , mas apenas de que seria fired up . Nós também não sabemos o quanto ' fired up ' increments o valor de Loud , ou se é um boolean que está ligado ou desligado ( True ou False ).

Incrementando uma Variável Numérica

Se a variable Loud for um valor numerical a ser incremented , pode ser algo como isto:

Configurando uma Variável Booleana

No entanto, se a variable Loud for boolean , pode ser escrita assim:

Antes de tomarmos uma decisão sobre como lidar com a variável Loud, é importante entender exatamente o que é Loud. De acordo com o Urban Dictionary:

 1. (Adjetivo) usado para descrever a maconha de alta qualidade ; erva muito forte. 

2. (Adjetivo) usado para descrever algo (ou alguém) que é de alta qualidade; muito bom ; impressionante; doente (gíria); legal; droga (gíria); surpreendente.

Com base nisso, parece que Lil John pretende usar Loud no contexto anterior. Com isso em mente, provavelmente faria mais sentido tratá-lo como um valor numérico incrementado em vez de um valor booleano. Se nós o tratássemos como um booleano e definíssemos o valor como False, isso indicaria que não havia nenhum Loud sendo acionado atualmente. Por outro lado, se usarmos o valor como um número, podemos incrementá-lo, indicando que mais alto está sendo constantemente acionado.

Nós também podemos provavelmente assumir que o mesmo é verdade para outra rodada de tiros. Os tiros precisariam ser um valor numérico que armazenaria o número de tiros. O formato para isso seria muito semelhante ao nosso exemplo anterior:

Agora que temos uma ideia aproximada de como representar esse cenário via Python, vamos comparar o que temos até agora:

Nesse ponto, parece muito bom. Nós convertemos com sucesso a maior parte deste cenário em um bloco testável de código Python. No entanto, ainda existem alguns problemas que ainda precisamos resolver.

  1. Qual seria uma condition que acabaria com esse loop? A frase “Turn Down For What” parece indicar que não há uma razão para recusar, e talvez nunca haverá. Na programação, isso poderia causar um problema, porque o loop while seria executado indefinidamente se nenhuma condição de terminação fosse atendida.
  2. Também parece confuso que, no cenário, “Turn Down for What”, ou nossa declaração condicional, seja repetida 5 vezes. Normalmente, uma instrução condicional precisa ser executada apenas uma vez. Para tornar as coisas mais simples, provavelmente é mais fácil chamar essa linha apenas uma vez em vez de repetir uma condição várias vezes sem executar nenhum código.

Ao decidir a resposta ao nosso primeiro problema, parece haver pelo menos uma condição que terminaria nosso loop while. Em cada iteração do loop, cada convidado da party será obrigado a ter outra rodada de tiros. Isso significa que, à medida que a festa continua, os convidados começarão a ficar inebriados. Em algum momento, se esse padrão continuar, todos os convidados ficarão muito intoxicados para a festa, e a parte será obrigada a “desligar”, terminando assim o loop while. Com isso em mente, vamos considerar o seguinte:

O peso médio para uma pessoa nos Estados Unidos é de 180,62 libras. Licor (destilado espíritos) é mais frequentemente consumido em bebidas mistas com 1,5 onças. espíritos. Às vezes, os espíritos (vodka, gin, uísque, bourbon etc.) são misturados com água, club soda ou suco ou servidos “diretamente” ou “nas pedras”. Não importa o quanto os espíritos sejam consumidos, uma porção padrão (1,5 oz. ) de 80 provas (40% de álcool por volume) de destilados tem a mesma quantidade de álcool que as porções padrão de cerveja e vinho. Então 1,5 oz. x 40 por cento de cool por volume = 0,6 oz. de álcool / servindo.

"BAC" é a abreviação de "concentração de álcool no sangue" – uma medida de quanto o álcool está no sangue de uma pessoa. Geralmente, o BAC aumenta quando uma pessoa bebe.

Uma concentração de álcool no sangue maior que 0,14 normalmente significa que um indivíduo começará a sentir-se menos eufórico e provavelmente mais desagradável. Por 0,25, a maioria dos indivíduos seria severamente prejudicada.

O número de tiros que seriam necessários para alcançar uma concentração de 0,14 no álcool no sangue é provavelmente em torno de 8 a 10 drinques (1,5 oz cada) para uma pessoa com peso médio nos EUA (180,62 lbs). Veja a figura 1a.

figura 1a

Assim, podemos supor que, se o Shots for incremented durante cada iteração do nosso loop while, pela 9ª iteração, a parte começaria necessariamente a “virar para baixo”. Talvez a melhor maneira de incorporar isso em nosso código seria definir uma variável chamada Party com um valor inicial de 10 , e conforme aumentamos o número de bebidas, diminuímos a variable party party. Então, se a variable party chegar a 0 , a condition será atendida e a party será recusada. No entanto, isso nos apresenta um problema. Considere como isso ficaria se traçássemos a variável party. Veja a figura 1b.

figura 1b

Basicamente, o grupo começaria realmente divertido, e decrementaria por um valor igual ao número de tiros consumidos. Eu não acho que esse é o tipo de festa que Lil John imaginou quando descreveu este cenário. E isso nos apresenta um enigma. Lil John parece imaginar uma festa que aumenta em Loud e Shots and Fun indefinidamente, mas obviamente haverá limites finitos para a quantidade de diversão que pode ser obtida se o número de bebidas consumidas também aumentar indefinidamente.

Além disso, ao pensar sobre o problema de tal maneira, não estamos considerando outras variáveis. Por exemplo, estamos assumindo que esta é uma parte fechada. Em outras palavras, se houver 20 convidados nesse evento, o loop while começará e será incrementado até que a parte termine com todos os 20 convidados atingindo uma concentração de álcool no sangue maior ou igual a 0,25. Estamos assumindo que nenhum novo convidado chegaria à festa. Na realidade, os novos hóspedes provavelmente chegariam mais tarde do que os outros, o que significa que nem todo o grupo alcançaria a mesma concentração de álcool no sangue ao mesmo tempo.

Outro fator que podemos querer considerar é que, enquanto a festa aumenta e fica mais alta, ela pode atrair mais convidados em potencial para a festa.

Vamos ver como esses dados podem ser representados visualmente. Veja a figura 1c.

figura 1c

Neste exemplo grosseiro, há 7 pessoas na festa de Lil John quando ela começa (ou o loop while começa). Por outro lado, há 22 pessoas que não estão atualmente na festa, mas estão muito próximas a ela. Em cada iteração do loop while, o valor de alto e de tiros é incrementado e, como efeito colateral disso, mais pessoas que não estão participando atualmente, têm mais probabilidade de tomar conhecimento da festa. Aqueles que entrarem na festa serão levados para o nosso loop while, onde serão forçados a desfrutar de mais uma rodada de tiros a cada iteração. Vamos ver outra visualização de como isso pode funcionar em nosso código. Veja a figura 1d.

figura 1d

Isso nos ajuda a ver qual é a relação entre o nível de barulho na festa, o número de convidados na festa e o número de convidados inebriados na festa. No início da festa, o barulho provavelmente não começará em 0, mas em algum lugar talvez em torno de 50. Todos os convidados na festa não ficarão inebriados quando a festa começar. À medida que os convidados começam a ficar inebriados, ao mesmo tempo, novos convidados se juntam à festa que ainda não está inebriada. Mas podemos ver que eventualmente cada um desses pontos de dados atingirá um patamar. Pense nos dados dessa maneira, provavelmente podemos fazer três suposições seguras antes de avançarmos:

  1. O nível de ruído tem um máximo (um estéreo só pode ser aumentado para 100%). Além disso, o nível de ruído provavelmente atingirá seu valor máximo antes que todos os convidados cheguem à festa, e também antes que os primeiros convidados fiquem completamente inebriados (isso ocorre principalmente porque o nível de ruído provavelmente começará em um nível alto, e atingirá seu máximo mais cedo do que tarde).
  2. O segundo ponto de dados com probabilidade de estabilizar seria o número de convidados na festa. Este ponto de dados pode ser baseado na população máxima e / ou densidade populacional. Isso não significa necessariamente que toda a população participará da festa. Em vez disso, existe um número finito da população que eventualmente irá participar.
  3. O último ponto de dados para atingir seu valor máximo é o número de convidados inebriados na festa. Uma vez que o número máximo de possíveis fregueses de festa chegar à festa, e o total de convidados estiver completamente inebriado, então a festa provavelmente terminará (e a condição de recusar o que retornará True).

Dados JSON

Como há uma variação na maneira como calcularíamos o CAS, dependendo do sexo do patrocinador do partido, e como o peso de cada parte do cliente varia, provavelmente seria melhor tratar a embriaguez de cada hóspede individualmente. Uma boa maneira de fazer isso é com dados JSON. JSON significa JavaScript Object Notation e é uma maneira comum de armazenar dados. Um objeto JSON padrão consiste em pares chave / valor. Vamos dar uma olhada em como podemos acompanhar nossos convidados usando dados JSON. Cada objeto JSON de convidados pode se parecer com o seguinte:

figura 2a

Em nosso diagrama anterior, vimos um cenário potencial em que inicialmente havia 7 convidados na festa de Lil John e 22 que ainda não estavam presentes. Se representássemos isso com dados JSON como o mostrado na figura 2a, cada convidado teria um perfil de dados. As chaves nos forneceriam dados significativos sobre cada convidado. As teclas "sexo", "gênero constante", "peso" e "doses consumidas" nos ajudariam a calcular o teor atual de álcool no sangue de cada hóspede. a chave 'atParty' nos informa se o convidado está envolvido no 'round of shots' durante cada iteração.

Em cada iteração do loop, se o valor 'atParty' de um convidado estiver definido como True, e o convidado atual também tiver um teor de álcool no sangue inferior a 0, então o valor de 'tiros consumidos' do convidado será incrementado por um valor de 1, e a mesma chave 'bac' do convidado será recalculada com o novo valor de 'tiros consumidos'.

Se, a qualquer momento, o teor de álcool no sangue dos convidados for maior que 0,2, podemos presumir que o hóspede está bêbado demais para continuar bebendo. Depois que todos os convidados que comparecerem à festa tiverem chegado à festa e cada convidado também tiver um teor de álcool no sangue de 0,2, a condição retornará True e o loop while será encerrado. Para fazer isso, podemos usar a seguinte estrutura de código:

figura 2b

No exemplo acima, a estrutura básica para este exercício é definir nossas variáveis primeiro. Acima estão alguns possíveis valores iniciais para cada uma dessas variáveis. Nossa função que cria um novo convidado precisará determinar se o novo hóspede é um homem ou uma mulher. Para determinar isso, vamos escolher uma seleção aleatória de nosso array maleFemale. Depois que o novo convidado for criado, podemos adicionar esse novo convidado aos nossos arrayOfGuests. Nossa outra função, calcular o BAC, usará os valores de cada convidado atual e calculará seu teor atual de álcool no sangue. Finalmente, nossos 'valores de edição do convidado existente' adicionarão o número total de fotos consumidas para cada convidado e, em seguida, chamarão a função calcular BAC para recalcular o BAC do hóspede.

Vamos dar uma olhada em cada uma dessas funções individualmente para ver como elas funcionariam:

Calculando o BAC:

 def calculateBAC (shotsConsumed, weight, genderConstant): 
newBAC = shotsConsumed / (weight * genderConstant) * 50
devolver newBAC

Esta função terá três parâmetros:

  1. tiros consumidos
  2. peso
  3. constante de gênero.

A função calculará um novo teor de álcool no sangue e retornará esse valor.

Criando uma nova pessoa:

 def createNewPerson (): 
genderConstant = 0
escolha = random.choice (maleFemale)
sConsumed = 0
peso = random.randint (115, 260)
se escolha == 'masculino':
genderConstant = 0,68
escolha elif == 'feminino':
genderConstant = 0,55
pessoa = {
'gênero': escolha,
'genderConstant': genderConstant,
'peso': peso,
'shotsConsumed': sConsumo,
'bac': 0,
'atParty': bool (random.getrandbits (1))
}
pessoa de retorno

Aqui, criar uma nova pessoa não precisará de argumentos. Ele irá gerar uma nova pessoa aleatoriamente. Nossa variável maleFemale provavelmente será assim:

 maleFemale = ['male', 'female'] 

A função começa escolhendo um dos valores dessa matriz aleatoriamente. Com base no valor escolhido, ele determinará um genderConstant de 0,68 ou 0,55. Em seguida, ele escolherá um peso entre 115 e 260. Como o peso humano médio nos EUA é de aproximadamente 180, esses valores representam uma faixa mais ampla de pesos possíveis para cada partier. Finalmente, a função irá construir um dict, que é basicamente um objeto JSON. Esse objeto JSON consistirá nos mesmos pares de chave / valor que discutimos anteriormente. Em seguida, a função retornará apenas o objeto JSON que ele cria.

Edite uma pessoa existente:

 def editExisting (x): 
isAtPartyNow = bool (random.getrandbits (1))
if x ['atParty'] == Verdadeiro:
newShots = x ['shotsConsumed'] + 1
x ['shotsConsumed'] = newShots
x ['bac'] = calculateBAC (newShots, x ['weight'], x ['genderConstant'])
if isAtPartyNow == Verdadeiro:
x ['atParty'] = Verdadeiro
se alto> 50 e isAtPartyNow == Falso:
isAtPartyNow = bool (random.getrandbits (1))
if isAtPartyNow == Verdadeiro:
x ['atParty'] = Verdadeiro
se alto> 60 e isAtPartyNow == False:
isAtPartyNow = bool (random.getrandbits (1))
if isAtPartyNow == Verdadeiro:
x ['atParty'] = Verdadeiro
se alto> 70 e isAtPartyNow == Falso:
isAtPartyNow = bool (random.getrandbits (1))
if isAtPartyNow == Verdadeiro:
x ['atParty'] = Verdadeiro
se alto> 80 e isAtPartyNow == Falso:
isAtPartyNow = bool (random.getrandbits (1))
if isAtPartyNow == Verdadeiro:
x ['atParty'] = Verdadeiro
se alto> 90 e isAtPartyNow == Falso:
isAtPartyNow = bool (random.getrandbits (1))
if isAtPartyNow == Verdadeiro:
x ['atParty'] = Verdadeiro
return x

Esta função levará apenas um argumento (a pessoa existente). Em seguida, ele usará as chaves da pessoa (no formato JSON) para acessar os valores associados a essas chaves. Também temos uma declaração condicional aqui, pois vamos editar o convidado de forma diferente, dependendo se eles estão ou não na festa.

Se o convidado já estiver na festa (atParty == True), incrementaremos as fotos da pessoa atual por 1, e recalcularemos o conteúdo de álcool no sangue da pessoa atual.

Se o convidado não estiver na festa, faremos um pouco mais de trabalho. Começaremos obtendo aleatoriamente outro valor booleano e, se for True, redefiniremos o valor de partParty do convidado como True. No entanto, se o valor atParty do convidado ainda for falso, executaremos esse código novamente (obtendo um novo valor booleano) para cada vez que o alto tiver sido incrementado. Isso se encaixa muito bem com o nosso diagrama 1c, que indica que é mais provável que os convidados se envolvam na festa à medida que o nível de ruído é incrementado.

Criando todos os convidados:

 para i em xrange (0, 20): 
pessoa = createNewPerson ()
people.append (pessoa)

Esta função será um loop simples. No loop for, vamos percorrer um intervalo. Esse intervalo representa o número total de convidados que pretendemos ter. Neste exemplo, teríamos apenas um total de 20 pessoas em nosso caso de teste. Cada pessoa seria criada pela função que analisamos anteriormente e depois anexada à nossa gama de pessoas.

Função para simular a festa:

 enquanto verdadeiro: 
 se alto <90: 
alto = alto + 10
para p em pessoas:
se p ['bac'] <.2 e p ['atParty'] = Verdadeiro:
editExisting (p)
roundsOfShots = roundsOfShots + 1
se roundsOfShots> = 10:
pausa

Este é o esboço básico que analisamos anteriormente, com algumas modificações. As mudanças aqui são:

  1. O valor de Loud só aumenta se o valor for atualmente menor que 90. Além disso, em vez de incrementar em 1, estamos incrementando o valor de Loud em 10 a cada iteração.
  2. Incluímos um loop for que está aninhado dentro do loop while. Cada vez que o loop while é executado, ele faz um loop sobre todas as pessoas na festa. Se a pessoa atual no ciclo aninhado estiver abaixo de 0,2 e a pessoa atual também estiver na festa, então executamos a função editExisting que examinamos anteriormente, o que aumentará o número de fotos e calculará novamente o teor de álcool no sangue.
  3. Por fim, também incrementaremos a variável roundsOfShots.
  4. Neste caso, estamos curto-circuitando o loop while quando a variável roundsOfShots atinge 10. Obviamente, isso não é o que queremos que aconteça no final, mas dessa forma podemos pelo menos testar o código para garantir que partes dele funcionem. e, em seguida, ajuste a instrução condicional de curto-circuito mais tarde.

Vamos ver como todo o código parece unido. Eu também fiz alguns ajustes em nossas variáveis iniciais e ajustei nossa declaração condicional para curto-circuito no loop while:

 importação aleatória 
alto = 50
roundsOfShots = 0
totalPessoas = 300
peopleAtParty = 0
peopleNotAtParty = 0
peopleInebriated = 0
timeElapsed = 0
pessoas = []
maleFemale = ['male', 'female']
 def calculateBAC (shotsConsumed, weight, genderConstant): 
newBAC = shotsConsumed / (weight * genderConstant)
devolver newBAC
 def createNewPerson (): 
genderConstant = 0
escolha = random.choice (maleFemale)
sConsumed = 0
peso = random.randint (115, 260)
se escolha == 'masculino':
genderConstant = 0,68
escolha elif == 'feminino':
genderConstant = 0,55
pessoa = {
'gênero': escolha,
'genderConstant': genderConstant,
'peso': peso,
'shotsConsumed': sConsumo,
'bac': 0,
'atParty': bool (random.getrandbits (1))
}
pessoa de retorno
 def editExisting (x): 
isAtPartyNow = bool (random.getrandbits (1))
if x ['atParty'] == Verdadeiro:
newShots = x ['shotsConsumed'] + 1
x ['shotsConsumed'] = newShots
x ['bac'] = calculateBAC (newShots, x ['weight'], x ['genderConstant'])
if x ['atParty'] == Falso:
if isAtPartyNow == Verdadeiro:
x ['atParty'] = Verdadeiro
se alto> 50 e isAtPartyNow == Falso:
isAtPartyNow = bool (random.getrandbits (1))
if isAtPartyNow == Verdadeiro:
x ['atParty'] = Verdadeiro
elif alto> 60 e isAtPartyNow == Falso:
isAtPartyNow = bool (random.getrandbits (1))
if isAtPartyNow == Verdadeiro:
x ['atParty'] = Verdadeiro
elif alto> 70 e isAtPartyNow == Falso:
isAtPartyNow = bool (random.getrandbits (1))
if isAtPartyNow == Verdadeiro:
x ['atParty'] = Verdadeiro
elif loud> 80 e isAtPartyNow == False:
isAtPartyNow = bool (random.getrandbits (1))
if isAtPartyNow == Verdadeiro:
x ['atParty'] = Verdadeiro
elif alto> 90 e isAtPartyNow == Falso:
isAtPartyNow = bool (random.getrandbits (1))
if isAtPartyNow == Verdadeiro:
x ['atParty'] = Verdadeiro
return x
 para i em xrange (0, totalPeople): 
pessoa = createNewPerson ()
people.append (pessoa)
 enquanto verdadeiro: 
timeElapsed + = 10
se alto <= 100:
alto = alto + 10
para p em pessoas:
se p ['bac'] <.2 e p ['atParty'] == Verdadeiro:
editExisting (p)
if p ['bac']> = .2 and p ['atParty'] == Verdadeiro e pessoasInibriadas <totalPeople:
peopleInebriated + = 1
if p ['atParty'] == Falso:
editExisting (p)
roundsOfShots = roundsOfShots + 1
imprimir pessoasInibriado
if peopleInebriated> = totalPeople:
pausa
 para p em pessoas: 
if p ['atParty'] == Falso:
peopleNotAtParty + = 1
outro:
peopleAtParty + = 1
imprimir p
totalConsumed = 1,5 * (peopleInebriated * roundsOfShots)
print "Total Consumed:", totalConsumed
print "Tempo decorrido é:", timeElapsed, "minutos"
print "Total de pessoas:", totalPessoas
print "Pessoas Inebriadas:", pessoas Inebriadas
print "Pessoas na festa:", peopleAtParty
print "Pessoas não estão na festa:", peopleNotAtParty
print ("alto é:", alto)
print ("rodadas totais de filmagens:", roundsOfShots)

Aqui, o número total de patrocinadores partidários foi ajustado para um número mais realista de 300. O cálculo do BAC também foi modificado para permitir que as pessoas participem mais tempo por mais tempo. Além disso, uma variável para timeElapased foi adicionada, teorizando que o Loud seria disparado, e rodadas de tiros seriam adicionadas aproximadamente a cada 10 minutos. Por esses cálculos, essa festa duraria cerca de 3 horas e 20 minutos. Neste ponto, todos os convidados da festa que potencialmente estariam ao alcance do Alto, também seriam embriagados para continuar a festa. Como resultado, a condição de recusar seria atendida e a parte terminaria. Também é interessante notar aqui a variável totalConsumed, que registra a quantidade total de álcool consumido. Porque isso é baseado no valor de 1,5 oz que chegamos anteriormente, o total consumido é geralmente em torno de 9000oz, ou cerca de 72 galões.

Em resumo, Turn Down For What?

A resposta parece ser depois de 72 galões de álcool terem sido consumidos pelos fregueses do partido, se o número total de clientes do partido for de cerca de 300.

Espero que este tenha sido um exercício divertido e divertido. Sinta-se à vontade para compartilhar qualquer feedback. Obrigado!