<jupyter_start><jupyter_text>Caderno de Exercı́cios Processamento da Informação – Edição Python  3 Laços<jupyter_code># Simule a execução da função abaixo e indique (algebricamente) a 
# sua saı́da. # Considere valores de b diferentes de zero, e p < q.
def funcaoEnigma1(a,b,p,q):
    a = float(a)
    b = float(b)
    p = int(p)
    q = int(q)
    i = 0
    soma = 0
    if (a != 0) and (b != 0) and (p < q):
        while i<=(q-p):
            soma = soma + (a/b)**(i)
            i = i+1
        return soma
    else:
        return print("Não Pode.")

funcaoEnigma1(2,1,2,18)
    
# Simule a execução da função abaixo e indique (algebricamente) 
# a sua saı́da. Considere valores de n > 0
n = int(input('Número: '))
def funcaoEnigma3(n):
    soma = 0
    for i in range(1, n + 1):
        soma = soma + i
    j = 1
    while j <= n:
        soma = soma - j
        j = j + 1
    return soma

funcaoEnigma3(n)
# Simule a execução da função abaixo e indique (algebricamente) 
# a sua saı́da. Considere valores de n > 0;
def funcaoEnigma4(n):
    mult = 1.0
    i = 0
    while i <= n - 2:
        mult = mult * ((i + 1.0)/(i + 2.0))
        i = i + 1
    return mult * n
funcaoEnigma4(5)
# Crie uma função que permita imprimir a palavra SPAM, n vezes.
# Primeira versao usando o laco for
n = int(input('Quantas vezes você quer imprimir? '))
def imprime1(n):
    for i in range(1, n+1):
        print('Viva Nossa Senhora da Penha!')
        

imprime1(n)
# Crie uma função que permita imprimir a palavra SPAM, n vezes.
# Segunda versão usando o laço while
n = int(input('Quantas vezes você quer imprimir? '))
def imprime2(n):
    i = 1
    while i <= n:
        print('Salve Rainha!')
        i = i + 1
        
imprime2(n)
# Crie uma função que permita imprimir os primeiros n números naturais.
# Primeira versao usando o laço for
n = int(input('Digite o número: '))
def imprimen1(n):
    for i in range(1, n+1):
        print(i)
imprimen1(n)

# Crie uma função que permita imprimir os primeiros n números naturais.
# Segunda versao usando o laço while
n = int(input('Digite o numero: '))
def imprimen2(n):
    i = 1
    while i <= n:
        print(i)
        i = i + 1
        
imprimen2(n)
# Crie uma função que permita mostrar uma sequência 
# de números ı́mpares de 1 até n.
# 1º versao laço for
n = int(input("Digite um número: "))
def imprimeImpar1(n):
    for i in range(1, n+1):
        if i%2 == 1:
            print(i)
            
imprimeImpar1(n)
# Crie uma função que permita mostrar uma sequência 
# de números ı́mpares de 1 até n.
# 2º versao laço while
n = int(input('Digite um numero: '))
def imprimeImpar2(n):
    i = 1
    while i <= n:
        if i % 2 == 1:
            print(i)
        i = i + 1
    
imprimeImpar2(n)
# Crie uma função que permita mostrar a sequência de números inteiros, 
# no intervalo [x, y]. Considere x < y.
x = int(input('digite x: '))
y = int(input ('digite y: '))
if x > y:
    ini = y
    fim = x
else:
    ini = x
    fim = y
    
def seqInterv1(n):
    for i in range(ini, fim + 1):
        print(i)
        
seqInterv1(n)
# 9 Crie uma função que permita somar a sequência de números inteiros,
# no intervalo [x, y]. Considere x < y:

    
def sumSeq1(ini, fim):
    x = int(input('digite x: '))
    y = int(input('digite y: '))
    s = 0
    if x > y:
        ini = y
        fim = x
    else:
        ini = x
        fim = y
    for i in range(ini+1, fim):
        s = s + i
        print (i)
    print ('-------')
    print (s)
        
        
sumSeq1(x, y)

# 10 - Crie uma função que permita o calculo da seguinte somatória:
# −1 + 2 − 3 + 4 − 5 + 6 + · · · + n
def calcsomatoria1(n):
    n = int(input('Digite um número: '))
    s = 0
    for i in range(1, n + 1):
        if i % 2 == 0:
            s = s + i
        else:
            s = s -i
    return s

calcsomatoria1(n)
# 10 - Resolução da apostila
def somaQ(n):
    soma = 0
    for i in range(1,n+1):
        soma = soma + i*( (-1)**i)
    return soma

somaQ(6)
# 11. Crie uma função somaP, em que dado um inteiro n > 0, 
# permita somar a seguinte sequência: 1** 2 + 2** 2 + · · · + n ** 2
def somaFat(n):
    n = int(input('Digite um Nº: '))
    s = 0
    for i in range(1, n+1):
        s = (i**2) + s
    return s

somaFat(n)
# 13. Modifique a função somaP em que, além do número n, 
# seja utilizado um outro número k, de tal forma que o 
# calculo da seguinte somatória seja realizada: 
# k ** 1 + k ** 2 + · · · + k ** n

def somaP(n):
    n = int(input('Digite um numero para o expoente máximo: '))
    s = 0
    for i in range(1, n + 1):
        s = (s + (i ** i))
            
    return s

somaP(n)
            
# Crie uma função em que, dado um inteiro não-negativo n, 
# seja possı́vel determinar n!.
# Primeira versao usando o laco for

def fat1(n):
    n = int(input("Nº: "))
    f = 1
    for i in range (1, n):
        f = f * i + f
        
    return f

fat1(n)<jupyter_output>Nº: 6<jupyter_text>**15** - Dizemos que um número natural é triangular se ele é produto de três número naturaisconsecutivos. Por exemplo: 120 é triangular, pois 4x5x6 = 120. 2730 é triangular,pois 13x14x15 = 2730. Dado um inteiro não-negativo n, crie uma função paraverificar se n é triangular. Deve-se devolver True se o número for triangular, casocontrário False.<jupyter_code># Primeira versão laço for
def numTriangular(n):
    n = int(input("Nº: "))
    for i in range(3, n+1):
        if (i - 2)*(i - 1)*(i) == n:
            return print('É triangular.')
    return print('Não é Triangular.')

numTriangular(n)
# Segunda versão laço while
def numTriangular2(n):
    n = int(input("Nº: "))
    i = 3
    while i < n:
        if (i - 2)*(i - 1)*(i) == n:
            return True
        i = i + 1
    return False

numTriangular2(n)<jupyter_output>Nº: 120<jupyter_text>16. Dado um inteiro positivo p, crie uma função para verificar se p é primo.<jupyter_code>def primo(p):
    contador = 0
    for i in range(1,p+1):
        if p%i==0:
            contador = contador+1
    if contador==2:
        return True
    else:
        return False
   
        

primo(3)<jupyter_output><empty_output><jupyter_text>**17**. Escreva uma função que receba um inteiro não-negativo n e imprima a soma dosn primeiros números primos. Por exemplo: Para n=3, resultado 10=2+3+5. Paran=7, resultado 58=2+3+5+7+11+13+17. Para n=100, resultado 24133.<jupyter_code>def soma_primos(n):
    i = 1
    soma = 0
    numero_primos = 0
    while numero_primos<n:
        if primo(i):
            soma = soma + i
            numero_primos = numero_primos+1
        i = i+1
    return soma

soma_primos(100)<jupyter_output><empty_output><jupyter_text>**18.** Faça uma função que calcula a soma:1/1 − 1/2 + 1/3 - 1/4 + ... + 1/9999 - 1/10000<jupyter_code># Adição de termos da esquerda para a direita
def equacaoE():
    soma = 0
    i = 1
    while i <= 10000:
        soma = soma + (1.0/i) * ((-1)**(i+1))
        i=i+1
    return soma

equacaoE()
# Adição de termos da direita para a esquerda.
def equacaoD():
    soma = 0
    i = 10000
    while i >= 1:
        soma = soma + (1.0/i)*((-1)**(i+1))
        i = i - 1
    return soma

equacaoD()

# Adição separada dos termos positivos e dos termos negativos 
# da esquerda para a direita
def equacaoPN():
    somaPos = 0
    i = 1
    while i <= 10000:
        somaPos = somaPos + 1.0/i
        i = i+2
        
    somaNeg = 0
    i = 2
    while i <= 10000:
        somaNeg = somaNeg + 1.0/i
        i = i + 2
    
    
    return somaPos - somaNeg

equacaoPN()<jupyter_output><empty_output><jupyter_text>**19** Crie uma função que permita somar apenas os números impares da sequência de inteiros contida no intervalos [x, y], para x < y.<jupyter_code>def somaImpares():
    x = int(input('X: '))
    y = int(input('Y: '))
    s = 0
    if x > y:
        for i in range(y+1, x):
            if i % 2 != 0:
                s = s + i
                
    else:
        for i in range(x+1, y):
            if i % 2 != 0:
                s = s + i
                
    return s

somaImpares()<jupyter_output>X: 10
Y: 20<jupyter_text>**20** -  Dado um inteiro positivo n, crie uma função para calcular a seguinte soma:1/n + 2/n-1 + 3/n-2 + 2/n-1 + n/1<jupyter_code>def soma1(n):
    soma = 0
    
    for i in range(1, n + 1):
        soma = soma + float (i)/(n-(i-1))
        
        
    return soma

soma1(3)<jupyter_output><empty_output><jupyter_text>**21.** Crie uma função arctan que recebe o número real x ∈ [0, 1] e devolve uma apro-ximação do arco tangente de x (em radianos) através da série:arctan(x) = x - x³/3 + (x ** 5)/5 - (x ** 7)/7 + ...considere somente os 100 primeiros termos da série:<jupyter_code>def arctan(x):
    x = float(x)
    soma = 0
    sinal = -1
    for i in range(1, 100 +1):
        coef = 2 * i - 1
        sinal = sinal *-1
        soma = soma + sinal * (x ** coef)/coef
    return soma

arctan(15)<jupyter_output><empty_output><jupyter_text>**23.** Escreva uma função encaixa que, recebendo dois números inteiros a e b comoparâmetros, verifica se b corresponde a os últimos dı́gitos de a. Por exemplo 45encaixa em 12345, 2026 encaixa em 2026, 12345 não encaixa em 45.<jupyter_code>def encaixa(a,b):
    while True:
        if a % 10 == b % 10:
            a = a/10
            b = b/10
            if b == 0 or a == 0:
                return 'encaixa'
        else:
            return 'não encaixa'
        
encaixa(10045, 45)<jupyter_output><empty_output><jupyter_text>**24.** Problema 3n+1 (Conjectura Collatz): As vezes nem sempre é fácil determinar se olaço irá terminar. Um exemplo:<jupyter_code>def sequencia3n1(n):
    i = 0
    maior = 0
    while n != 1:
        
        i = i + 1
        print (i, '-',n)
        if n%2 == 0:
            n = n/2
        else:
            n = n*3+1
        if n > maior:
            maior = n
        
    print ('Finalizou')
    print (f'O laço foi executado {i} vezes')
    print (f'O maior número obtido foi {maior}')
    
sequencia3n1(27)<jupyter_output>1 - 27
2 - 82
3 - 41.0
4 - 124.0
5 - 62.0
6 - 31.0
7 - 94.0
8 - 47.0
9 - 142.0
10 - 71.0
11 - 214.0
12 - 107.0
13 - 322.0
14 - 161.0
15 - 484.0
16 - 242.0
17 - 121.0
18 - 364.0
19 - 182.0
20 - 91.0
21 - 274.0
22 - 137.0
23 - 412.0
24 - 206.0
25 - 103.0
26 - 310.0
27 - 155.0
28 - 466.0
29 - 233.0
30 - 700.0
31 - 350.0
32 - 175.0
33 - 526.0
34 - 263.0
35 - 790.0
36 - 395.0
37 - 1186.0
38 - 593.0
39 - 1780.0
40 - 890.0
41 - 445.0
42 - 1336.0
43 - 668.0
44 - 334.0
45 - 167.0
46 - 502.0
47 - 251.0
48 - 754.0
49 - 377.0
50 - 1132.0
51 - 566.0
52 - 283.0
53 - 850.0
54 - 425.0
55 - 1276.0
56 - 638.0
57 - 319.0
58 - 958.0
59 - 479.0
60 - 1438.0
61 - 719.0
62 - 2158.0
63 - 1079.0
64 - 3238.0
65 - 1619.0
66 - 4858.0
67 - 2429.0
68 - 7288.0
69 - 3644.0
70 - 1822.0
71 - 911.0
72 - 2734.0
73 - 1367.0
74 - 4102.0
75 - 2051.0
76 - 6154.0
77 - 3077.0
78 - 9232.0
79 - 4616.0
80 - 2308.0
81 - 1154.0
82 - 577.0
83 - 1732.0
84 - 866.0
85 - 433.0
86 - 1300.0
87 - 650.0
88 - 325.0
89 - 976.0
90 - 488.0
91 - [...]<jupyter_text>**25.** Crie uma função que permita imprimir os n primeiros números da sequência deFibonacci. Considere n ≥ 2 e apenas um laço ‘while’.<jupyter_code>def fibonacci(n):
    k = 2
    t1 = 0
    t2 = 1
    print(t1)
    print(t2)
    while k <= n:
        seguinte = t1 + t2
        print (seguinte)
        t1 = t2
        t2 = seguinte
        k = k + 1
        
fibonacci(10)<jupyter_output>0
1
1
2
3
5
8
13
21
34
55<jupyter_text>**26.** Dado um número natural n na base decimal, crie uma função que permita trans-formá-lo para a base b.<jupyter_code>def converter(n, b):
    resposta = ''
    while n>0:
        r = n%b
        n = n/b
        resposta = str(r)+resposta
    return (resposta)

converter(2, 10)<jupyter_output><empty_output><jupyter_text>4 Laços aninhados **1.** Crie uma função para imprimir a tabuada de a até b. Considere a ≤ b.<jupyter_code>a = int(input('Digite a: '))
b = int(input('Digite b: '))

def tabuada1(a, b):
    
    
    if a <= b:
        for i in range(a, b+1):
            print ("\nTabuada: "+str(i))
            for j in range(0, 11):
                print(i, ' x ', j, ' = ', (i*j))
    
    else:
        print('"A" deve ser menor ou igual a "B"')
        

        
tabuada1(a, b)
                
# Resolução da apostila

def tabuada(a,b):
    for i in range(a,b+1):
        print ("\nTabuada: "+str(i))
        for j in range(1,11):
            print (str(i)+"x"+str(j)+"="+str(i*j))
            
tabuada(1, 3)<jupyter_output>Tabuada: 1
1x1=1
1x2=2
1x3=3
1x4=4
1x5=5
1x6=6
1x7=7
1x8=8
1x9=9
1x10=10

Tabuada: 2
2x1=2
2x2=4
2x3=6
2x4=8
2x5=10
2x6=12
2x7=14
2x8=16
2x9=18
2x10=20

Tabuada: 3
3x1=3
3x2=6
3x3=9
3x4=12
3x5=15
3x6=18
3x7=21
3x8=24
3x9=27
3x10=30<jupyter_text>**2.** Dada a função:Indique algebricamente a somatória que a função realiza.<jupyter_code>def funcao(n):
    soma = 0
    for i in range(1, n+1):
        for j in range(1, n+1):
            for k in range(1, n+1):
                soma = soma + i
    return soma

funcao(10)<jupyter_output><empty_output><jupyter_text>**3.** Dados os números reais x e  > 0, calcular a aproximação para e x usando a seguinteexpansão da Série de Taylor:1 + x¹/1! + x²/2! + x³/3! + (x ** 4)/4! + (x ** 5)/5! + ... Incluindo todos os termos da série até que:|x ** k| / |k!| < epsilon<jupyter_code>def exp2(x, epsilon):
    x = float(x)
    soma = 1
    i = 1
    while True:
        fact = 1
        for i in range(1, i + 1):
            fact = fact * i
        termo = (x ** i)/fact
        soma = soma + termo
        if abs(termo) < epsilon:
            break
        i = i + 1
        
    return soma

exp2(14,100)<jupyter_output><empty_output><jupyter_text>**6.** O matemático Srin<NAME> encontrou uma série infinita, que pode ser usadapara gerar uma aproximação numérica de pi:<jupyter_code># Solucao 1
from math import sqrt
def estimar_pi():
    soma = 0.0
    termo = 1.0
    k = 0
    while termo>=1e-15:
        fact = 1
        for i in range(1,4*k+1):
            fact = fact*i
        fact2 = 1
        for i in range(1,k+1):
            fact2 = fact2*i
        termo = (fact*(1103+26390*k))/((fact2**4)*396**(4*k))
        soma = soma+termo
        k = k+1
    return (1/((2*sqrt(2)/9801)*soma))

estimar_pi()<jupyter_output><empty_output><jupyter_text>**7.** Dado um inteiro positivo n, imprimir as n primeiras linhas do triângulo de Pascal.<jupyter_code># Solucao 2
def criar_matriz_uns(l,c):
    matriz = [1]*l
    for i in range(0,l):
        matriz[i] = [1]*c
    return matriz


def pascal2(n):
    M = criar_matriz_uns (n, n)
    for i in range (0, len(M)):
        for j in range (0, len(M[0])):
            if i<j:
                M[i][j] = 0
    k = 0
    while k < n:
        i = k
        for j in range (1,i):
            M[i][j] = M[i-1][j-1] + M[i-1][j]
        print (M[i][0:i+1])
        k = k+1
        
pascal2(10)<jupyter_output>[1]
[1, 1]
[1, 2, 1]
[1, 3, 3, 1]
[1, 4, 6, 4, 1]
[1, 5, 10, 10, 5, 1]
[1, 6, 15, 20, 15, 6, 1]
[1, 7, 21, 35, 35, 21, 7, 1]
[1, 8, 28, 56, 70, 56, 28, 8, 1]
[1, 9, 36, 84, 126, 126, 84, 36, 9, 1]<jupyter_text>**8.** Dados dois inteiros positivos m e n, determinar, entre todos os pares de númerosinteiros (x,y) tais que 0 ≤ x ≤ m, e 0 ≤ y ≤ n, um par para o qual o valor daexpressão: xy − x 2 + y seja máximo, e calcular também esse máximo.<jupyter_code>def maximo(m,n):
    max = 0
    indx = 0
    indy = 0
    for x in range(0,m+1):
        for y in range(0,n+1):
            if max <= x*y-x**2+y:
                max = x*y-x**2+y
                indx = x
                indy = y
                
    print ('Maximo: '+str(max))
    print ('Par: '+str(indx)+','+str(indy))
    
    
maximo(20, 5)
    
                
                
            
        
    
# fibonacci 
def fibonacci(n):
    n1 = 0
    n2 = 1
    f = 1
    if (n == 0):
        return n1
    elif (n == 2):
        return n2
    else:
        for i in range(3, n+1):
                n1 = n2
                n2 = f
                f = n1 + n2
        return f
            
    
    
    
    
    
    
    
    
    
fibonacci(1000)
def fib(n):
    
    t1 = 0
    t2 = 1
    
    if n != 0:
        for k in range(0, n):
            seguinte = t1 + t2
            t1 = t2
            t2 = seguinte          

        return seguinte
    
    else:
        return 0
        
        
#fib(0)
#fib(1)
fib(2)
#fib(3)
#fib(4)
#fib(5)
#fib(1000)<jupyter_output><empty_output><jupyter_text>Conte o número de duplicadosEscreva uma função que retornará a contagem de caracteres alfabéticos distintos que não diferenciam maiúsculas de minúsculas e dígitos numéricos que ocorrem mais de uma vez na string de entrada. Pode-se presumir que a string de entrada contém apenas letras (maiúsculas e minúsculas) e dígitos numéricos.  Exemplo"abcde" -> 0  no characters repeats more than once "aabbcde" -> 2  'a' and 'b'"aabBcde" -> 2  'a' occurs twice and 'b' twice (`b` and `B`)"indivisibilidade" -> 1  'i' occurs six times"Indivisibilidades" -> 2  'i' occurs seven times and 's' occurs twice"aA11" -> 2  'a' and '1'"ABBA" -> 2  'A' and 'B' each occur<jupyter_code>def duplicate_count(text):
    # Your code goes here
    new_text = text.lower()

    count = 0
    dictionary = {}

    for i in range(0,len(new_text)):
        dictionary[new_text[i]] = 0

    for key in dictionary:
        for i in range(0,len(new_text)):
            if(key == new_text[i]):
                dictionary[key] = dictionary[key] + 1

    for key in dictionary:
        if(dictionary[key] > 1):
            count = count + 1

    
    return count

duplicate_count("abcdeaa")<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.12988414357110403, 'fraction_numerical': 0.07632894139027714, 'mean_word_length': 2.0308089500860587, 'pattern_counts': {'":': 0, '<': 94, '<?xml version=': 0, '>': 90, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 3, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '19', 'dir': 'jupyter-structured-clean-dedup', 'id': '331904', 'license': 'MIT', 'n_tokens_mistral': 8075, 'n_tokens_neox': 7270, 'n_words': 2230, 'path': 'Python/Python inicial/CadernoExercicios01/Caderno de Exercicios - exercicios livres.ipynb', 'repo_name': 'guimaraesalves/material-python', 'size': '17617'}