diff --git a/bruna_heleodoro/bruna_heleodoro_atividade.ipynb b/bruna_heleodoro/bruna_heleodoro_atividade.ipynb
new file mode 100644
index 0000000..aa72e47
--- /dev/null
+++ b/bruna_heleodoro/bruna_heleodoro_atividade.ipynb
@@ -0,0 +1,261 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### [Exercício 36](https://wiki.python.org.br/EstruturaDeRepeticao): Lógica utilizada para a construção da Tabuada com For in Range.\n",
+    "\n",
+    "* Criada a variável `num_usuário`, para armazenar o valor que será multiplicado;\n",
+    "  \n",
+    "* Criada a variável `num_start`, para armazenar o valor que iniciará a tabuada;\n",
+    "  \n",
+    "* Criada a variável `num_end`, para armazenar o valor que finalizará a tabuada;\n",
+    "  \n",
+    "* Chamada a estrutura de repetição For in Range:\n",
+    "  \n",
+    "  * `for i in range(num_start, num_end + 1):` -> Aqui informo que a sintaxe básica do range(start, stop, step) utilizará os dados armazenados nas variáveis num_start e num_end. O acréscimo de + 1 em num_end garante que o valor final (num_end) seja incluído na sequência, pois o stop é exclusivo.\n",
+    "    \n",
+    "  * Exemplo: `num_start = 4` e `num_end = 8 -> range(4, 8)` gerará a sequência `[4, 5, 6, 7]`, pois 8 é exclusivo por ser o stop.\n",
+    "    \n",
+    "  * A atribuição do `+ 1` como argumento do stop garante que `num_end` seja incluído na sequência. Exemplo: `num_end + 1 -> num_end = 8 + 1 (9) -> [4,5,6,7,8] `."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "num_usuario = int(input('Informe um número que você gostaria de montar a tabuada: '))\n",
+    "num_start = int(input('Informe por qual número deve começar a tabuada: '))\n",
+    "num_end = int(input('Informe em qual número deve finalizar a tabuada: '))\n",
+    "\n",
+    "for i in range(num_start, num_end + 1):\n",
+    "    print(f'{num_usuario} X {i} = {num_usuario * i}')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### [Exercício 36](https://wiki.python.org.br/EstruturaDeRepeticao): Lógica utilizada para a construção da Tabuada com While.\n",
+    "\n",
+    "* Criada a variável `num_usuario`, para armazenar o valor que será multiplicado;\n",
+    "  \n",
+    "* Criada a variável `num_start`, para armazenar o valor que iniciará a tabuada;\n",
+    "  \n",
+    "* Criada a variável `num_end`, para armazenar o valor que finalizará a tabuada;\n",
+    "\n",
+    "* Criado a variável `s` e atribuindo à ela o valor que será recebido na variável `num_start`. Pois `s` é a variável utilizada como o contador na repetição.\n",
+    "  \n",
+    "* Chamada a estrutura de repetição While:\n",
+    "  \n",
+    "  * `while s <= num_end:` -> Aqui inicio a repetição com While, informando que deve se começar com o valor em `s` e repita até o mesmo ser menor ou igual ao valor de `num_end`.\n",
+    "    \n",
+    "  * Dentro da estrutura eu peço `print(f'{num_usuario} X {s} = {num_usuario * s}')`, ou seja, que seja exibido o número que gostaria de montar a tabuada armazenado na variável `num_usuario` X o valor armazenado na variável `s`, mais o calculo de multiplicação desses valores.\n",
+    "    \n",
+    "  * E a operação de atribuição em `s += 1`, realiza o incremento na váriavel `s` para a mesma ir avançando nos valores até o valor definido na variável `num_end`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "num_usuario = int(input('Informe um número que você gostaria de montar a tabuada: '))\n",
+    "num_start = int(input('Informe por qual número deve começar a tabuada: '))\n",
+    "num_end = int(input('Informe em qual número deve finalizar a tabuada: '))\n",
+    "\n",
+    "s = num_start\n",
+    "\n",
+    "while s <= num_end:\n",
+    "    print(f'{num_usuario} X {s} = {num_usuario * s}')\n",
+    "    s += 1"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### [Exercício 38](https://wiki.python.org.br/EstruturaDeRepeticao): Lógica utilizada para a construção do Sistema de Consulta de Salário com For in Range.\n",
+    "\n",
+    "* Criada a variável `ano_contrato` para armazenar o ano em que o colaborador foi contratado;\n",
+    "  \n",
+    "* Criada a variável `salario_inicial` para armazenar o salário inicial do colaborador;\n",
+    "  \n",
+    "* Criada a variável `ano_atual` para armazenar o ano atual vigente;\n",
+    "  \n",
+    "* Criada a variável `porcentagem_inicial` para armazenar a porcentagem de aumento aplicada no salário inicial;\n",
+    "  \n",
+    "* Criada a variável `primeiro_aumento` para armazenar o cálculo do aumento ocorrido no salário inicial do colaborador:\n",
+    "  \n",
+    "  * `round((), 2)` - aplicado o arredondamento para que o resultado do cálculo retorne arredondado para duas casas decimais;\n",
+    "  * `porcentagem_inicial / 100` - cálculo que converte o percentual de aumento de forma percentual (por exemplo, 1,5%) para uma fração decimal (0,015). A escolha do cálculo veio da realização de consultas para verificar que o Python padrão não apresenta um operador específico para calcular aumentos percentuais diretamente;\n",
+    "  * `(1 + porcentagem_inicial / 100)` - a adição de 1 ao cálculo de conversão de um formato percentual para uma fração decimal é necessária porque representa o valor original. Por exemplo, se quisermos aumentar o `salario_inicial` em `1,5%`, é necessário adicionar `1` a `0,015`, resultando em `1,015`;\n",
+    "  * `(salario_inicial * (1 + porcentagem_inicial / 100))` - por fim, é realizado o cálculo onde o `salario_inicial` é multiplicado pelo fator calculado `1 + porcentagem_inicial / 100`;\n",
+    "* Chamando a estrutura de repetição For in Range():\n",
+    "  \n",
+    "  * `for ano in range(1997, ano_atual + 1):` - conforme solicitado pelo exercício, aplicado no range com início em 1997, pois é a partir deste ano a solicitação, e finalizando no ano atual. Assim, para cada `ano` dentro da faixa de 1997 a 2024, o bloco de código a seguir será executado;\n",
+    "  * `porcentagem_anual = porcentagem_inicial * 2` - aqui é realizado o cálculo para dobrar a porcentagem inicial e o valor é armazenado na variável `porcentagem_anual`;\n",
+    "  * `primeiro_aumento` - é atualizada a variável com o cálculo da multiplicação do primeiro aumento pelo percentual do ano vigente;\n",
+    "  * `primeiro_aumento = round(primeiro_aumento, 2)` - o `round()` é utilizado para formatar o valor armazenado na variável `primeiro_aumento` para duas casas decimais;\n",
+    "  * `print(f'Salário no ano {ano}: {primeiro_aumento}')` e `print(f'Porcentagem Anual: {porcentagem_inicial}')` - são utilizados para validar o processo realizado dentro da estrutura de repetição;\n",
+    "* `print(f'Salário Atual: {salario_atual_formatado}')` - realiza a impressão do salário atual do colaborador;\n",
+    "  \n",
+    "* Após consultas, realizei a inclusão da biblioteca `locale`, pois acreditei que o valor final do salário do colaborador deveria estar formatado para melhor compreensão, dado o aumento exponencial da porcentagem de aumento salarial ao final do código. Abaixo explico o processo:\n",
+    "  \n",
+    "  * `import locale` - importo a biblioteca para o meu ambiente, permitindo-me chamar suas funções quando necessário. Ela permite formatar números, datas e moedas de acordo com as convenções regionais, incluindo o uso de pontos e vírgulas;\n",
+    "  * `locale.setlocale(locale.LC_ALL, 'pt_BR.UTF-8')` - define a configuração local e aplica a categoria `locale.LC_ALL` para todas as categorias (strings, data e hora, moedas, formatação de números), utilizando a localização específica desejada;\n",
+    "  * `salario_atual_formatado = locale.currency(primeiro_aumento, grouping=True)` - cria a variável `salario_atual_formatado`, que utiliza a função `locale.currency` para formatar um valor como uma string monetária de acordo com as configurações locais. Neste caso, formata o valor de `primeiro_aumento`. O parâmetro `grouping` é opcional e normalmente padrão como `False`, mas aqui é definido como `True` para aplicar o agrupamento de milhares à formatação."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import locale\n",
+    "\n",
+    "locale.setlocale(locale.LC_ALL, 'pt_BR.UTF-8')\n",
+    "\n",
+    "ano_contrato = 1995\n",
+    "salario_inicial = 1000.00\n",
+    "ano_atual = 2024\n",
+    "porcentagem_inicial = 1.5\n",
+    "\n",
+    "primeiro_aumento = round(salario_inicial * (1 + porcentagem_inicial / 100),2)\n",
+    "\n",
+    "for ano in range(1997,ano_atual + 1):\n",
+    "    porcentagem_anual = porcentagem_inicial * 2\n",
+    "    primeiro_aumento *=  1 + porcentagem_anual / 100\n",
+    "    primeiro_aumento = round(primeiro_aumento,2)\n",
+    "    porcentagem_inicial = porcentagem_anual\n",
+    "    print(f'Salário no ano {ano}: {primeiro_aumento}')\n",
+    "    print(f'Porcentagem Anual: {porcentagem_inicial}')\n",
+    "\n",
+    "salario_atual_formatado = locale.currency(primeiro_aumento, grouping=True)\n",
+    "\n",
+    "print(f'Salário Atual: {salario_atual_formatado}')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### [Exercício 38](https://wiki.python.org.br/EstruturaDeRepeticao): Lógica utilizada para a construção do Sistema de Consulta de Salário com For in Range e input do usuário.\n",
+    "\n",
+    "Aqui é seguido a mesma lógica do código acima, apenas realizando a alteração na atribuição da variável `salario_inicial`.\n",
+    "\n",
+    "* `salario_inicial` - agora é atribuido com um `float(input('mensagem para o usuário'))`, onde `float` converte o dado informado pelo usuário em um número de ponto e `input` solicita um dado ao usuário."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import locale\n",
+    "\n",
+    "locale.setlocale(locale.LC_ALL, 'pt_BR.UTF-8')\n",
+    "\n",
+    "ano_contrato = 1995\n",
+    "salario_inicial = float(input('Informe o seu salário inicial: '))\n",
+    "ano_atual = 2024\n",
+    "porcentagem_inicial = 1.5\n",
+    "\n",
+    "primeiro_aumento = round(salario_inicial * (1 + porcentagem_inicial / 100),2)\n",
+    "\n",
+    "for ano in range(1997,ano_atual + 1):\n",
+    "    porcentagem_anual = porcentagem_inicial * 2\n",
+    "    primeiro_aumento *=  1 + porcentagem_anual / 100\n",
+    "    primeiro_aumento = round(primeiro_aumento,2)\n",
+    "    porcentagem_inicial = porcentagem_anual\n",
+    "    print(f'Salário no ano {ano}: {primeiro_aumento}')\n",
+    "    print(f'Porcentagem Anual: {porcentagem_inicial}')\n",
+    "\n",
+    "salario_atual_formatado = locale.currency(primeiro_aumento, grouping=True)\n",
+    "\n",
+    "print(f'Salário Atual: {salario_atual_formatado}')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### [Exercício 32](https://wiki.python.org.br/EstruturaDeRepeticao): Lógica utilizada para a construção do Sistema de Cálculo de Fatorial de Número inteiro usando For in Range.\n",
+    "\n",
+    "* Inicio o código criando uma função chamada `fatorial(numero)` que recebe o parâmetro `numero` e realiza o cálculo fatorial de um número inteiro;\n",
+    "  \n",
+    "  * `resultado = 1` - criada a variável pois é necessário para o cálculo do fatorial, porque o fatorial de 0 e 1 é sempre 1;\n",
+    "    \n",
+    "  * `fatorial_str = str(numero) + '! = '` - criada variável string para referenciar o número que será calculado o fatorial;\n",
+    "    \n",
+    "  * `for i in range(numero, 0, -1):` - Iniciada estrutura de repetição, onde `i` irá percorrer a faixa de repetição iniciando (start) com o `numero` informado pelo usuário, com fim (stop) em `0` e passo (step) como `-1` para que ocorra de forma decrescente;\n",
+    "    \n",
+    "  * Dentro da estrutura de repetição ocorre a implementação da variável `resultado *= i`, que realiza a multiplicação do `resultado = 1` com o valor de `i`;\n",
+    "    \n",
+    "  * `fatorial_str += str(i)` - recebe a atribuição do valor convertido em string armazenado no `i`.\n",
+    "    \n",
+    "  * `if i != 1:` - adiciona uma condição também para a formatação textual do cálculo, pois se `i` for diferente de `1`, então é adicionado um `x` na variável `fatorial_str`.\n",
+    "    \n",
+    "  * `fatorial_str += ' = ' + str(resultado)` - por fim, adiciona também à variável `fatorial_str` o símbolo de `=` + o `str(resultado)` convertido em string.\n",
+    "    \n",
+    "  * `return fatorial_str` - permite que o resultado do cálculo e a string formatada sejam enviados de volta para onde a função foi chamada;\n",
+    "    \n",
+    "* Criada a variável `numero`, declarando a mesma `int` e solicitando ao usuário `input()` que informe um número inteiro;\n",
+    "  \n",
+    "* `resultado_fatorial = fatorial(numero)` - criada variável que chama a função aplicando o parâmetro `numero`, que contém o número informado pelo usuário;\n",
+    "  \n",
+    "* `print(resultado_fatorial)` - exibe o resultado da função;"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def fatorial(numero):\n",
+    "    resultado = 1\n",
+    "    fatorial_str = str(numero) + '! = '\n",
+    "    for i in range(numero, 0, -1):\n",
+    "        resultado *= i\n",
+    "        fatorial_str += str(i)\n",
+    "        if i != 1:\n",
+    "            fatorial_str += ' x '\n",
+    "    fatorial_str += ' = ' + str(resultado)\n",
+    "    return fatorial_str\n",
+    "\n",
+    "numero = int(input(\"Digite um número inteiro para calcular o seu fatorial: \"))\n",
+    "\n",
+    "resultado_fatorial = fatorial(numero)\n",
+    "print(resultado_fatorial)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.4"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}