<jupyter_start><jupyter_text>Python - If elif else - Faça um  programa para calcular o valor da n-ésima derivada da função seno(x). A função deve receber como entradas as variáveis n (número de derivadas) e x (valor dado em graus).<jupyter_code>import numpy as np

def sin(x):
    return np.sin(x)
def cos(x):
    return np.cos(x)			
n = int(input())
x = int(input())
r = (x/180)*np.pi
aux = sin(r)
for i in range(1,n+1,1):
    if i % 2 == 0:
        if aux == cos(r):
            aux = -sin(r)
        else:
            aux = sin(r)
    else:
        if aux == sin(r):
            aux = cos(r)
        else:
            aux = -cos(r)

print(aux)<jupyter_output>20
30
0.49999999999999994<jupyter_text>Python: recebe números em um vetor -O programa deve ler 3 números do tipo float digitados pelo usuário, armazenar em um vetor e, em seguida, apresentar o vetor armazenado.<jupyter_code>vector = []

for v in range(3):
   vector.append(float(input()))
   
print(vector)<jupyter_output>1
2
3
[1.0, 2.0, 3.0]<jupyter_text>Python: Derivada de senoFaça uma rotina para calcular o valor da derivada "n" da função sen(t0), após os valores de "n" e "t0" serem informados pelo usuário<jupyter_code>from math import sin, cos

n = int(input())
t0 = float(input())

ax = sin(t0)


for i in range(n):
    if i % 2 == 0:
        if ax == sin(t0):
            ax = cos(t0)
        else:
            ax = -cos(t0)
            
    else:
        if ax == cos(t0):
            ax = -sin(t0)
        else:
            ax = sin(t0)
                
print(ax)<jupyter_output><empty_output><jupyter_text>Python: Ordena vetor e calcula a mediana<jupyter_code>vector = []
for n in range(5):
    number = float(input())
    vector.append(number)
    vector.sort()
    
print(vector)
print(vector[2])<jupyter_output><empty_output><jupyter_text>Python: Derivada "n" da função "cos(w0*t0)" - ​Implemente um código para calcular o valor da n-ésima derivada da função f(t)=cos(w0*t) em relação a "t" no ponto inicial "t0". Os valores de n, w0 e t0 serem informados pelo usuário.<jupyter_code>import numpy as np

def cos(x,y):
    return np.cos((x*y))
    
def sin(x,y):
    return np.sin((x*y))
    
n = int(input())
w0 = float(input())
t0 = float(input())
ax = cos(w0,t0)

for i in range(n):
    if i % 2 == 0:
        if ax == cos(w0,t0):
            ax = -sin(w0,t0)*(w0**(i+1))
        else:
            ax = sin(w0,t0)*(w0**(i+1))
    else:
        if ax == sin(w0,t0):
            ax = cos(w0,t0)*(w0**(i+1))
        else:
            ax = -cos(w0,t0)*(w0**(i+1))
print(ax)<jupyter_output><empty_output><jupyter_text>Python: Fatorial utilizando laço FOR<jupyter_code>number = int(input())

factorial = 1

for i in range(1, number + 1):
    factorial = factorial * i
    
print(factorial)<jupyter_output><empty_output><jupyter_text>Python: Aproximar por Taylor a função exp(x) - Faça um programa para aproximar a função exe^xe utilizando a série de Taylor. O programa deve solicitar ao usuário os valores de x0(ponto inicial da aproximação),  x (valor onde ocorrerá a aproximação) e o número "n" de termos utilizados na aproximação.<jupyter_code><jupyter_output><empty_output><jupyter_text>Python: Fatorial utilizando o módulo math.<jupyter_code>import math

n = int(input())
f = math.factorial(n)

print(f)<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.1316425120772947, 'fraction_numerical': 0.02747584541062802, 'mean_word_length': 3.075030750307503, 'pattern_counts': {'":': 0, '<': 31, '<?xml version=': 0, '>': 31, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 1, 'word_list_counts': {'cursed_substrings.json': 0, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '8', 'dir': 'jupyter-structured-clean-dedup', 'id': '319016', 'license': 'MIT', 'n_tokens_mistral': 1346, 'n_tokens_neox': 1296, 'n_words': 356, 'path': 'List_one_cn.ipynb', 'repo_name': 'tosantos1/python', 'size': '3312'}