Considere o conjunto de expressões aritméticas (Definição 4). Apresente uma funções recursivas para desempenhar as seguintes tarefas:
Calcular o número de operações de soma em uma expressão.

Passo 1

Beleza, vamos lá! Você me pediu para criar uma função recursiva que calcule quantas operações de soma existem em uma expressão aritmética. O conteúdo aqui envolve recursão e expressões aritméticas. Para resolver isso, vamos precisar entender como as expressões são construídas e como a recursão pode nos ajudar a percorrê-las e contar as somas.

Passo 2

Primeiro, vamos lembrar o que é uma expressão aritmética. Basicamente, são combinações de números e operações, como soma, subtração, multiplicação e divisão. Por exemplo, na expressão $ (2 + 3) \times 4 $, temos uma soma e uma multiplicação.
Para contar quantas somas têm em uma expressão, precisamos examinar cada parte dela. Se a expressão for simples, como apenas um número, não há somas para contar. Mas se tiver operações, precisamos verificar se são somas e, se sim, contar uma mais e continuar verificando os demais elementos.

Passo 3

Agora, vamos pensar na recursão. Recursão é quando uma função chama a si mesma para resolver partes menores do problema. No nosso caso, a função vai chamar a si mesma para cada parte da expressão, verificando se aquela parte é uma soma e contando-a se for.
Vamos definir a função chamada contarSomas. Essa função vai receber uma expressão e retornar o número de somas nessa expressão.
Aqui está como podemos fazer isso:
def contarSomas(expressao):
    # Caso base: se a expressão for apenas um número, não há somas
    if isinstance(expressao, (int, float)):
        return 0
    # Se a expressão for uma operação
    operador, esquerda, direita = expressao
    # Inicializa o contador
    contador = 0
    # Se o operador for soma, incrementa o contador
    if operador == '+':
        contador += 1
    # Chama a função recursivamente para os lados esquerdo e direito
    contador += contarSomas(esquerda)
    contador += contarSomas(direita)
    return contador

Passo 4

Vamos entender o que está acontecendo na função:
  1. Caso base: Se a expressão for apenas um número (int ou float), retorna 0 porque não há operações de soma.
  2. Operação: Assume que a expressão é uma tupla com três elementos: o operador e as duas partes da expressão (esquerda e direita).
  3. Contador: Inicia com 0.
  4. Verificação do operador: Se o operador for ‘+’, adiciona 1 ao contador.
  5. Recursão: Chama a mesma função para as partes esquerda e direita da expressão, somando os resultados ao contador.
  6. Retorno: Retorna o total de somas encontradas.

Resposta

A função recursiva para calcular o número de operações de soma em uma expressão aritmética é a seguinte:
def contarSomas(expressao):
    if isinstance(expressao, (int, float)):
        return 0
    operador, esquerda, direita = expressao
    contador = 0
    if operador == '+':
        contador += 1
    contador += contarSomas(esquerda)
    contador += contarSomas(direita)
    return contador

Exercícios relacionados