1. Utilizando a Função Integrada sum()

A função sum() do Python é altamente otimizada para calcular o total de elementos em iteráveis como listas, tuplas e conjuntos. Além disso, ela aceita um segundo argumento opcional que define um valor inicial para o somatório.

valores = [10, 20, 30, 40]
total_agregado = sum(valores)
print(total_agregado)  # Saída: 100

sequencia = [5, 10, 15]
# O segundo parâmetro define o valor base antes de somar os elementos
total_com_offset = sum(sequencia, 100)
print(total_com_offset)  # Saída: 130

2. Fatiamento de Listas e Processamento de Entradas no Modo ACM

Em competições de programação, é comum precisar processar apenas uma parte de uma sequência de dados. O fatiamento de listas (slicing) permite ignorar elementos específicos, como o primeiro item de uma lista, de forma concisa. Abaixo está um exemplo de leitura de múltiplos casos de teste no padrão ACM, onde o primeiro número de cada linha indica a quantidade de elementos, mas não deve ser incluído na soma.

import sys

def processar_entradas():
    dados = sys.stdin.read().strip().splitlines()
    if not dados:
        return
        
    num_casos = int(dados[0])
    
    for i in range(1, num_casos + 1):
        elementos = list(map(int, dados[i].split()))
        # Fatiamento para excluir o primeiro elemento (índice 0)
        soma_subconjunto = sum(elementos[1:])
        
        print(soma_subconjunto)
        if i < num_casos:
            print()

if __name__ == "__main__":
    processar_entradas()

3. Formatação e Truncamento de Números Decimais

O contrloe de precisão decimal é frequente em problemas algorítmicos. Existem abordagens distintas dependendo se o arredondamento matemático é necessário ou se o número deve ser apenas truncado.

valor_pi = 3.1415926535

# Arredondamento utilizando f-strings (Padrão moderno do Python)
print(f"{valor_pi:.3f}")  # Saída: 3.142

# Arredondamento com a função nativa round()
valor_arredondado = round(valor_pi, 4)
print(valor_arredondado)  # Saída: 3.1416

# Truncamento sem arredondamento usando manipulação de strings
string_pi = str(valor_pi)
parte_inteira, parte_fracionaria = string_pi.split(".")
valor_truncado = f"{parte_inteira}.{parte_fracionaria[:3]}"
print(valor_truncado)  # Saída: 3.141

4. Operadores Matemáticos: Divisão Inteira e Recursão

Problemas que envolvem trocas ou conversões cíclicas (como trocar tampas de garrafa por novas bebidas) exigem o uso de divisão inteira (//) e módulo (%). A lógica pode ser implementada tanto com laços de repetição quanto com recursão.

Abordagem Iterativa:

import sys

def calcular_total_consumido(inicial, taxa_troca):
    total = inicial
    recipientes_vazios = inicial
    
    while recipientes_vazios >= taxa_troca:
        novos_itens = recipientes_vazios // taxa_troca
        total += novos_itens
        recipientes_vazios = (recipientes_vazios % taxa_troca) + novos_itens
        
    return total

def main():
    for linha in sys.stdin:
        garrafas_iniciais, taxa = map(int, linha.split())
        if garrafas_iniciais == 0 and taxa == 0:
            break
        print(calcular_total_consumido(garrafas_iniciais, taxa))

if __name__ == "__main__":
    main()

Abordagem Recursiva:

A recursão oferece uma solução elegante ao decompor o problema em etapas de troca, somando os novos itens obtidos ao resultado da chamada recursiva com os recipientes restantes.

import sys

def computar_trocas(recipientes_atuais, taxa):
    if recipientes_atuais < taxa:
        return 0
    novas_garrafas = recipientes_atuais // taxa
    sobras = recipientes_atuais % taxa
    return novas_garrafas + computar_trocas(novas_garrafas + sobras, taxa)

def main():
    for linha in sys.stdin:
        inicial, taxa = map(int, linha.split())
        if inicial == 0 and taxa == 0:
            break
        # O total é a quantidade inicial mais o que foi obtido através das trocas
        print(inicial + computar_trocas(inicial, taxa))

if __name__ == "__main__":
    main()