Book a Demo!
CoCalc Logo Icon
StoreFeaturesDocsShareSupportNewsAboutPoliciesSign UpSign In
Download
2141 views
Tweet
Share
Share

Zestaw 2: Funkcje, pętle, sterowanie

System Sage wykorzystuje język Python. Ten zestaw ma nauczyć zupełnych podstaw programowania w Pythonie. Jako materiały pomocnicze można użyć podręczników:

Funkcje i sterowanie

Funkcję (w sensie programistycznym) w Sage'u (sensu stricte Pythonie) implementuje się:

def nazwa ( argumenty ) :
    treść
    ...
    return wynik

Zasięg bloku ograniczającego jest wyznaczony przez wcięcie (grrr...)!

Zadanie: Napisać funkcję, która zwraca kwadraty wszystkich dzielników pierwszych argumentu.

def kwadraty(n):
    return [i^2 for i in prime_divisors(n)]

kwadraty(100)
[4, 25]

Jeżeli na początku funkcji (w kolejnej linii po def) umieścimy opis funkcji w potrójnych cudzysłowach, to po skomilowaniu opis ten będzie dodany do systemu pomocy Sage'a i będzie się wyświetlał dla naszej funkcji po naciśnięciu klawisza Tab.

Zadanie: Napisać funkcję, która przyjmuje jako argument liczbę naturalną n∈Nn\in \mathbb{N}, a w wyniku zwraca listę potęg dwójki do nn-tej włącznie.

def potegi_2(n):
    return[2^i for i in [0..n]]

potegi_2(4)
[1, 2, 4, 8, 16] 
︠12f57d78-9f03-429d-8061-9c46b3629ee9︠
def potegi_2( n ) :
    """
    Ta funkcja zwraca kolejne potęgi dwójki 2^0, 2^1,..., 2^n, gdzie n jest argumentem
    """
    # UZUPEŁNIĆ

Zadanie: Napisać funkcję, która przyjmuje jako argument listę LL, zaś w wyniku zwraca dwie listy EE oraz OO, składające się z elementów listy LL, mających odpowiednio parzyste i nieparzyste indeksy.

def podziel_liste(L):
    return [L[i] for i in [0..len(L)-1] if i.mod(2)==0], [L[i] for i in [0..len(L)-1] if i.mod(2)==1]

L=[2..10]
podziel_liste(L)
([2, 4, 6, 8, 10], [3, 5, 7, 9]) 
def podziel_liste1(L):
    return [L[i] for i in [0..len(L)-1] if is_even(i)], [L[i] for i in [0..len(L)-1] if is_odd(i)]

K=[2..10]
podziel_liste1(K)
([2, 4, 6, 8, 10], [3, 5, 7, 9]) 
def podziel_liste( L ) :
    """
    Funkcja zwraca dwie listy E oraz O, składające się z elementów listy L,
    mających odpowiednio parzyste i nieparzyste indeksy.
    """
    # UZUPEŁNIĆ

Zadanie: Napisać funkcję, która przyjmuje jako argument liczbę naturalną nn, a w wyniku zwraca ilość liczb pierwszych mniejszych od nn, które nie dzielą nn.

Przykład: Dla liczby n=10n=10 funkcja winna zwrócić wynik 22, gdyż liczbami pierwszymi <10<10 i nie dzielącymi 1010 są 33 oraz 77.

def ile_pierwszych(n):
    L=[i for i in prime_range(n) if n.mod(i)!=0]
    return len(L)

ile_pierwszych(100)
23

Instrukcja warunkowa ma składnię:

if warunek :
    treść

lub w wersji rozbudowane

if warunek :
    treść
else :
    treść

Zadanie: Napisać funkcję, która przyjmuje jako argument liczbę całkowitą nn i zwraca w wyniku najmniejszą liczbę parzystą ≥n\geq n.

def nastepna_parzysta(n):
    assert n in ZZ
    if is_odd(n):
        return n+1
    else:
        return n

nastepna_parzysta(101)
102 
def nastepna_parzysta( n ) :
    """
    Funkcja zwraca najmniejszą liczbę parzystą większą lub równą od argumentu.
    """
    assert n in ZZ, "Argument musi być liczbą całkowitą!"
    # UZUPEŁNIĆ

Zadanie: Zaimplementować rekurencyjną wersję algorytmu Euklidesa.

def NWD_r(n,m):
    if n.mod(m)==0:
        return abs(m)
    else:
        return NWD_r(m,(n).mod(m))

NWD_r(40,12)
4 
def NWD_r( n, m ) :
    """
    Funkcja wyznacza największy wspólny dzielnik liczb n, m za pomocą rekurencyjnej wersji algorytmu Euklidesa.
    """
    # UZUPEŁNIĆ

L=[(ZZ.random_element(),ZZ.random_element()) for i in [1..100]]
R=[(gcd(n,m)==NWD_r(n,m)) for (n,m) in L]
false in R
False

Zadanie: Zaimplementować w Sage'u funkcję ff zadaną dla listy LL warunkiem rekurencyjnym: f(L):={L,gdy ∣L∣≤1f(prawa połowa L)∪f(lewa połowa L),gdy ∣L∣>1. f(L):= \begin{cases} L, &\text{gdy }|L|\leq 1\\ f(\text{prawa połowa }L) \cup f(\text{lewa połowa }L), & \text{gdy }|L|>1.\end{cases} 

def f(L):
    if len(L)<=1:
        return L
    else:
        n=ceil(len(L)/2)
        return f(L[n:])+f(L[:n])

L=[0..3]
f(L)
[3, 2, 1, 0]

Defincja: Liczby n,m∈Nn,m\in \mathbb{N} nazywa się zaprzyjaźnionymi (ang. amicable), jeżeli suma dzielników właściwych (czyli różnych od nn) liczby nn jest równa mm, zaś suma dzielników właściwych (czyli różnych od mm) liczby mm jest równa nn.

Przykład: Liczby 220, 284 są zaprzyjaźnione.

Zadanie: Napisać funkcję, która sprawdza czy dwie podane liczby są zaprzyjaźnione.

def czy_zaprzyjaznione(n,m):
    L=[i for i in divisors(n) if i!=n]
    M=[i for i in divisors(m) if i!=m]
    a=sum(L[i] for i in range(len(L)))
    b=sum(M[i] for i in range(len(M)))
    if a==m and b==n:
        return true
    else:
        return false

czy_zaprzyjaznione(120,55)
False 
def czy_zaprzyjaznione(n, m):
    """
    Funkcja sprawdza czy podane liczby n, m są zaprzyjaźnione.
    """
    # UZUPEŁNIĆ

Defincja: Liczby n,m∈Nn,m\in \mathbb{N} nazywa się zaręczonymi (ang. betrothed), jeżeli suma dzielników właściwych (czyli różnych od nn) liczby nn jest równa m+1m+1, zaś suma dzielników właściwych (czyli różnych od mm) liczby mm jest równa n+1n+1.

Przykład: Liczby 48, 75 są zaręczone.

Zadanie: Napisać funkcję, która sprawdza czy dwie podane liczby są zaręczone.

def czy_zareczone(n, m):
    """
    Funkcja sprawdza czy podane liczby n, m są zaręczone.
    """
    # UZUPEŁNIĆ

def czy_zareczone(n,m):
    L=[i for i in divisors(n) if i!=n]
    M=[i for i in divisors(m) if i!=m]
    a=sum(L[i] for i in range(len(L)))
    b=sum(M[i] for i in range(len(M)))
    if a==m+1 and b==n+1:
        return true
    else:
        return false

czy_zareczone(120,87)
False

Dwie podstawowe pętle to

for zmienna in lista :
    terść

oraz

while warunek :
    treść

Zadanie: Zaimplementować algorytm Euklidesa z użyciem pętli.

def NWD_i( n, m ) :
    """
    Funkcja wyznacza największy wspólny dzielnik liczb n, m za pomocą iteracyjnej wersji algorytmu Euklidesa.
    """
    # UZUPEŁNIĆ

Zadanie: Napisać funkcję, która przyjmuje dwa argumenty: listę LL oraz liczbę xx, a w wyniku zwraca dwie listy: zlożoną z elementów LL-a mniejszych od xx oraz większych lub równych xx.

def podziel_liste( L, x ) :
    """
    Funkcja dzieli podaną listę L na część mniejszą oraz większą-bądź-równą od argumentu x
    """
    # UZUPEŁNIĆ

Algorytm "Sito Eratotenesa" wyznacza liczby pierwsze z zakresu {2,…,n}\{2,\dotsc, n\} na następującej zasadzie:

  1. Tworzona jest lista SS wszystkich liczb naturalnych od 22 do nn;
  2. pierwszy element listy jest dołączany do listy liczb pierwszych;
  3. z listy SS usuwane są wszystkie wielokrotności tego elementu;
  4. jeżeli lista SS wciąż zawiera jakieś elementy, to powtarzamy kroki 2-4.

Zadanie: Zaimplementować powyższy algorytm

def sito( n ) :
    """
    Funkcja wyznacza wszystkie liczby pierwsze <= n za pomocą sita Eratostenesa
    """
    # UZUPEŁNIĆ

Jeżeli deklarując argument funkcji, napiszemy argument = wartość, to wywołując tę funkcją można ten argument pominąć i otrzyma on wtedy podaną wartść domyślną. Jeżeli natomiast chcemy, aby ten argument posiadał inną wartość, to wystarczy ją podać przy wywoływaniu funkcji, tak jak dla każdego innego argumentu. Argumenty o ustalonej wartości domyślnej muszą być podawane na końcu listy argumentów.

Zadanie: Napisać funkcję, która scala z zachowaniem porządku dwie posortowane (w porządku rosnącym) listy,  przekazane jako argumenty.

def scal( A, B, relacja = operator.lt ) :
    """
    Funkcja scala POSORTOWANE listy A, B z zachowaniem porządku.
    Argument relacja jest relacją porządkującą, względem której posortowane są listy A, B oraz wynik.
    Domyślnie (gdy argumentu nie podamy) jest to zwykły operator <.
    """
    # UZUPEŁNIĆ

def scal(A,B,relacja=operator.lt):
    L=[] #wprowadzamy listę pomocniczą L
    i=0
    j=0
    #stosujemy pętlę ktora wybiera odpowiednie elementy sposrod dwoch tablic 
    while i<len(A) and j<len(B):
        if relacja(A[i],B[j]): 
            L.append(A[i]) #na koniec listy L dodawany jest element A[i]
            i=i+1
        else: 
            L.append(B[j]) #na koniec listy L dodawany jest element B[j]
            j=j+1
    #gdy jedna z tablic się skonczy przepisuje się pozostała czesc z drugiej tablicy
    while i<len(A):
            L.append(A[i])
            i=i+1
    while j<len(B):
            L.append(B[j])
            j=j+1
    return L

A=[2,..,17];view(A)
B=[2,2+1/2,..,8];view(B)
L=scal(A,B);view(L)
[2\displaystyle 2, 3\displaystyle 3, 4\displaystyle 4, 5\displaystyle 5, 6\displaystyle 6, 7\displaystyle 7, 8\displaystyle 8, 9\displaystyle 9, 10\displaystyle 10, 11\displaystyle 11, 12\displaystyle 12, 13\displaystyle 13, 14\displaystyle 14, 15\displaystyle 15, 16\displaystyle 16, 17\displaystyle 17]
[2\displaystyle 2, 52\displaystyle \frac{5}{2}, 3\displaystyle 3, 72\displaystyle \frac{7}{2}, 4\displaystyle 4, 92\displaystyle \frac{9}{2}, 5\displaystyle 5, 112\displaystyle \frac{11}{2}, 6\displaystyle 6, 132\displaystyle \frac{13}{2}, 7\displaystyle 7, 152\displaystyle \frac{15}{2}, 8\displaystyle 8]
[2\displaystyle 2, 2\displaystyle 2, 52\displaystyle \frac{5}{2}, 3\displaystyle 3, 3\displaystyle 3, 72\displaystyle \frac{7}{2}, 4\displaystyle 4, 4\displaystyle 4, 92\displaystyle \frac{9}{2}, 5\displaystyle 5, 5\displaystyle 5, 112\displaystyle \frac{11}{2}, 6\displaystyle 6, 6\displaystyle 6, 132\displaystyle \frac{13}{2}, 7\displaystyle 7, 7\displaystyle 7, 152\displaystyle \frac{15}{2}, 8\displaystyle 8, 8\displaystyle 8, 9\displaystyle 9, 10\displaystyle 10, 11\displaystyle 11, 12\displaystyle 12, 13\displaystyle 13, 14\displaystyle 14, 15\displaystyle 15, 16\displaystyle 16, 17\displaystyle 17]
A=[1,1+2,..,13];view(A)
B=[2,2+2,..,14];view(B)
L=scal(A,B);view(L)
[1\displaystyle 1, 3\displaystyle 3, 5\displaystyle 5, 7\displaystyle 7, 9\displaystyle 9, 11\displaystyle 11, 13\displaystyle 13]
[2\displaystyle 2, 4\displaystyle 4, 6\displaystyle 6, 8\displaystyle 8, 10\displaystyle 10, 12\displaystyle 12, 14\displaystyle 14]
[1\displaystyle 1, 2\displaystyle 2, 3\displaystyle 3, 4\displaystyle 4, 5\displaystyle 5, 6\displaystyle 6, 7\displaystyle 7, 8\displaystyle 8, 9\displaystyle 9, 10\displaystyle 10, 11\displaystyle 11, 12\displaystyle 12, 13\displaystyle 13, 14\displaystyle 14]
A=[-5,-9,-4,3,2];view(A)
B=[-11,-7,0,4,1];view(B)
L=scal(A,B);view(L)
[−5\displaystyle -5, −9\displaystyle -9, −4\displaystyle -4, 3\displaystyle 3, 2\displaystyle 2]
[−11\displaystyle -11, −7\displaystyle -7, 0\displaystyle 0, 4\displaystyle 4, 1\displaystyle 1]
[−11\displaystyle -11, −7\displaystyle -7, −5\displaystyle -5, −9\displaystyle -9, −4\displaystyle -4, 0\displaystyle 0, 3\displaystyle 3, 2\displaystyle 2, 4\displaystyle 4, 1\displaystyle 1]

Zadanie: Zaimplementować funkcję sortowania listy algorytmem sortowania przez scalanie (ang. merge sort, zob. np. Wikipedia).

Wskazówka: Wykorzystać funkcję z poprzedniego zadania.

def merge_sort( L ) :
    """
    Funkcja sortuje listę L algorytmem merge-sort.
    """
    # UZUPEŁNIĆ

def merge_sort(L):
    if 1!=len(L): #dopoki dlugosc listy L jest rozna od 1 stosujemy nastepujacy algorytm
        s=int(math.floor((len(L))/2)) #dzielimy dlugosc listy na pol, stosujac funkcje "podloga" z wartosci
        K=merge_sort(L[:s]) #algorytm powtarzamy dla lewej częsci listy
        M=merge_sort(L[s:]) #algorytm powtarzamy dla prawej częsci listy
        L=scal(K,M) #scalamy lewe i prawe częsci poszczegolnych list 
    return(L)

L=[1,15,7,21,11,8,18];
view(merge_sort(L))
[1\displaystyle 1, 7\displaystyle 7, 8\displaystyle 8, 11\displaystyle 11, 15\displaystyle 15, 18\displaystyle 18, 21\displaystyle 21]
L=[38,27,43,3,9,82,10];
view(merge_sort(L))
[3\displaystyle 3, 9\displaystyle 9, 10\displaystyle 10, 27\displaystyle 27, 38\displaystyle 38, 43\displaystyle 43, 82\displaystyle 82]
L=[5,10,16,6,12,10,11,7,14,18,9]
view(merge_sort(L))
[5\displaystyle 5, 6\displaystyle 6, 7\displaystyle 7, 9\displaystyle 9, 10\displaystyle 10, 10\displaystyle 10, 11\displaystyle 11, 12\displaystyle 12, 14\displaystyle 14, 16\displaystyle 16, 18\displaystyle 18]
L=[87,102,5,0,-4,13,6,76,-12,55,42,97,-13,22,76,220,154];
view(merge_sort(L))
[−13\displaystyle -13, −12\displaystyle -12, −4\displaystyle -4, 0\displaystyle 0, 5\displaystyle 5, 6\displaystyle 6, 13\displaystyle 13, 22\displaystyle 22, 42\displaystyle 42, 55\displaystyle 55, 76\displaystyle 76, 76\displaystyle 76, 87\displaystyle 87, 97\displaystyle 97, 102\displaystyle 102, 154\displaystyle 154, 220\displaystyle 220]

Zadanie: Zaimplementować funkcję sortowania listy algorytmem quick sort (zob. np. Wikipedia).

def quick_sort( L ) :
    """
    Funkcja sortuje listę L algorytmem quick sort.
    """
    # UZUPEŁNIĆ

Zadanie: Utworzyć trójkąt Pascala o wysokości 77.

def pascal_triangle(n):
    P=[1];show(P)
    P=[1,1];show(P)
    for i in [1,..,n-1]:
        Robocza=[1]
        for j in [1,..,i]:
            Wartosc=P[j-1]+P[j]
            Robocza=Robocza+[Wartosc]
        Robocza=Robocza+[1]
        P=Robocza
        show(P)
    return
pascal_triangle(7)
[1\displaystyle 1]
[1\displaystyle 1, 1\displaystyle 1]
[1\displaystyle 1, 2\displaystyle 2, 1\displaystyle 1]
[1\displaystyle 1, 3\displaystyle 3, 3\displaystyle 3, 1\displaystyle 1]
[1\displaystyle 1, 4\displaystyle 4, 6\displaystyle 6, 4\displaystyle 4, 1\displaystyle 1]
[1\displaystyle 1, 5\displaystyle 5, 10\displaystyle 10, 10\displaystyle 10, 5\displaystyle 5, 1\displaystyle 1]
[1\displaystyle 1, 6\displaystyle 6, 15\displaystyle 15, 20\displaystyle 20, 15\displaystyle 15, 6\displaystyle 6, 1\displaystyle 1]
[1\displaystyle 1, 7\displaystyle 7, 21\displaystyle 21, 35\displaystyle 35, 35\displaystyle 35, 21\displaystyle 21, 7\displaystyle 7, 1\displaystyle 1]

Zadanie: Zaimplementować funkcję dwuargumentową intperm( n, sigma ), która permutuje za pomocą permutacji σ\sigma dzielniki pierwsze liczby nn. Przykładowo, dla pary argumentów n=2520=23⋅32⋅51⋅71n = 2520 = 2^3\cdot 3^2\cdot 5^1\cdot 7^1 oraz σ=(1,3)(2,4)\sigma = (1,3)(2,4), funkcja winna zwracać w wyniku liczbę 36750=53⋅72⋅21⋅31=σ(2)3⋅σ(3)2⋅σ(5)1⋅σ(7)136750 = 5^3\cdot 7^2\cdot 2^1\cdot 3^1= \sigma(2)^3\cdot \sigma(3)^2\cdot \sigma(5)^1\cdot \sigma(7)^1

def intperm(n, sigma) :
    """
    Funkcja permutuje dzielniki pierwsze liczby n.
    """
    # UZUPEŁNIĆ

Zadanie: Napisać funkcję sprawdzającą czy podane słowo jest palindromem.

def czy_palindrom( T ) :
    """
    Funkcja zwraca wartość true <=> T jest palindromem
    """
    # następująca linia sprawdza czy T jest napisem
    assert isinstance(T, str), "Argumentem funkcji musi być napis!"
    # UZUPEŁNIĆ

def czy_palindrom(n):
    m=len(n)/2
    for i in range(m):
    j=i+1
    if n[i]!=n[-j]:
         return False
    return True

print czy_palindrom('przyklad')
print czy_palindrom('kajak')
print czy_palindrom('kobylamamalybok')
print czy_palindrom('slowo')
print czy_palindrom('fortepian')
print czy_palindrom('mozejutrotadamasamadatortujezom')
print czy_palindrom('1234567887654321')
print czy_palindrom('abcba')
Error in lines 1-7 Traceback (most recent call last): File "/projects/sage/sage-6.9/local/lib/python2.7/site-packages/smc_sagews/sage_server.py", line 905, in execute exec compile(block+'\n', '', 'single') in namespace, locals File "<string>", line 4 j=i+Integer(1) ^ IndentationError: expected an indented block

Zadanie: Napisać funkcję sprawdzającą czy dwa podane teksty są anagramami.

# wersja z użyciem sortowania - prostsza, ale o większej złożoności

def czy_anagramy( T1, T2 ) :
    """
    Funkcja zwraca wartość true <=> T1, T2 są anagramami
    """
    # następująca linia sprawdza czy T1 i T2 są napisami
    assert isinstance(T1, str) and isinstance(T2, str), "Argumentami funkcji muszą być napisy!"
    # UZUPEŁNIĆ

def podziel_liste (L, x) :
    L1 = [ n for n in L if n<x]
    L2 = [ n for n in L if n>=x]
    return L1, L2
def quick_sort(L) :
    if len(L) <=1 :
        return L
    else:
        x = L[0]
        L1, L2 = podziel_liste(L[1:], x)
        return quick_sort(L1) + [x] + quick_sort(L2) 
    
def czy_anagramy (T1, T2) :
    assert isinstance(T1, str) and isinstance(T2, str), "Argumentami funkcji muszą być napisy"
    T1 = quick_sort([a.lower() for a in T1 if a != ''])
    T2 = quick_sort([a.lower() for a in T2 if a != ''])
    return T1==T2

czy_anagramy("abc", "cba")   
czy_anagramy("malina glon", "gall anonim")
czy_anagramy("eliza orzeszkowa", "zoza szewalierko")   
czy_anagramy("przyklad", "inny")
True True True False

Zadanie: Napisać funkcję wyznaczającą wszystkie permutacje liter słowa podanego jako argument.

def permutacje( T ) :
    """
    Funkcja zwraca wszystkie permutacje napisu T
    """
    # następująca linia sprawdza czy T jest napisem
    assert isinstance(T, str), "Argumentem funkcji musi być napis!"

    # UZUPEŁNIĆ

def permutacje( T ) :
    assert isinstance(T, str), "Argumentem funkcji musi być napis!"
    K = list(T)
    M = [1..len(K)]
    G = SymmetricGroup(len(K))
    return [ ''.join([ K[p(x)-1] for x in M ]) for p in G ]



permutacje("kabc")
['kabc', 'akbc', 'abck', 'bcka', 'back', 'kbca', 'ckab', 'bkca', 'bcak', 'cbka', 'ackb', 'kcab', 'cakb', 'cbak', 'ckba', 'bkac', 'bakc', 'kacb', 'kcba', 'cabk', 'kbac', 'akcb', 'abkc', 'acbk']

Zadanie: Napisać funkcję, która przyjmuje jako argumenty macierz zero-jedynkową oraz pozycję elementu tej macierzy, następnie wypełnia jedynkami maksymalny obszar 4-spójny złożony z zer i zawierający wskazany element.

Wskazówka: Obszar 4-spójny to taki obszar jaki się odsłania w windowsowym saperze po kliknięciu.

def saper( M, (i,j) ) :
    """
    Funkcja wypełnia jedynkami maksymalny zerowy obszar 4-spójny wokół punktu (i,j) w macierzy M
    """
    # UZUPEŁNIĆ

def saper (M,(i,j) ) :
    if i>=M.nrows() or i<0 or j>=M.ncols() or j<0:
        return M
    if i<M.nrows()-1 and i>0 and j<M.ncols()-1 and j>0:
        M[i-1,j]=1
        M[i-1,j-1]=1
        M[i-1,j+1]=1
        M[i,j-1]=1
        M[i,j+1]=1
        M[i+1,j-1]=1
        M[i+1,j]=1
        M[i+1,j+1]=1
        return M
    if i==0 and j==0:
        M[i,j+1]=1
        M[i+1,j]=1
        M[i+1,j+1]=1
        return M
    if i==M.nrows()-1 and j==M.ncols()-1:
        M[i,j-1]=1
        M[i-1,j]=1
        M[i-1,j-1]=1
        return M
    if i==M.nrows()-1 and j==0:
        M[i,j+1]=1
        M[i-1,j]=1
        M[i-1,j+1]=1
        return M
    if i==0 and j==M.ncols()-1:
        M[i,j-1]=1
        M[i+1,j]=1
        M[i+1,j-1]=1
        return M
    if i==M.nrows()-1 and j>0 and j<M.ncols()-1:
        M[i-1,j]=1
        M[i-1,j-1]=1
        M[i-1,j+1]=1
        M[i,j-1]=1
        M[i,j+1]=1
        return M
    if j==0 and i>0 and i<M.nrows()-1:
        M[i-1,j]=1
        M[i-1,j+1]=1
        M[i,j+1]=1
        M[i+1,j]=1
        M[i+1,j+1]=1
        return M
    if i==0 and j>0 and j<M.ncols()-1:
        M[i,j-1]=1
        M[i,j+1]=1
        M[i+1,j-1]=1
        M[i+1,j]=1
        M[i+1,j+1]=1
        return M
    if j==M.ncols()-1 and i>0 and i<M.nrows()-1:
        M[i-1,j]=1
        M[i-1,j-1]=1
        M[i,j-1]=1
        M[i+1,j-1]=1
        M[i+1,j]=1
        return M

︠d6576bbe-d083-49f9-9e9c-1dd2e5f28799︠
M = matrix( GF(2), [
[1,1,1,1,1,1,1,1,1,1],
[1,1,1,1,1,1,1,1,1,1],
[1,1,1,0,1,1,1,1,1,1],
[1,1,0,0,0,1,0,1,1,1],
[1,1,0,1,0,0,1,1,1,1],
[1,1,1,1,1,0,1,1,1,1],
[1,1,1,1,1,1,1,0,1,1],
[1,1,1,1,1,0,0,1,1,1],
[1,0,0,0,1,1,0,1,1,1],
[1,1,1,1,1,1,1,1,1,1] 
])
saper()
︠834a375a-5681-4419-99f7-199c1daffb2c︠
︠34c9ea47-d628-4b13-9382-65f4716b30d5︠
# przetestować na tej macierzy 

M = matrix( GF(2), [
[1,1,1,1,1,1,1,1,1,1],
[1,1,1,1,1,1,1,1,1,1],
[1,1,1,0,1,1,1,1,1,1],
[1,1,0,0,0,1,0,1,1,1],
[1,1,0,1,0,0,1,1,1,1],
[1,1,1,1,1,0,1,1,1,1],
[1,1,1,1,1,1,1,0,1,1],
[1,1,1,1,1,0,0,1,1,1],
[1,0,0,0,1,1,0,1,1,1],
[1,1,1,1,1,1,1,1,1,1] 
])
M

Zadanie (*): W opowiadaniu Artura Clarke'a ,,Dziewięć miliardów imion Boga'' z roku 1955 specjalnie przystosowany komputer miał za zadanie wygenerować wszystkie słowa złożone z nie wiecej niż dziewięciu liter z wyłączeniem słów zawierających trzy (lub więcej) kolejne takie same litery. Słowa te miały jakoby zawierać wszystkie prawdziwe imiona Boga. W opowiadaniu zatrudniony do tego celu komputer wykonał pracę w ciągu trzech miesięcy.

Zrealizować to zadanie z użyciem programu Sage - w zależności od ilości dostępnej w komputerze pamięci, można zmniejszyć długość słów (np. do 5-6 liter).

Uwaga: W opowiadaniu wypisanie wszystkich imion Boga okazało się być celem istnienia wszechświata. Zakończenie działania programu spowodowało koniec świata. Wykonanie zatem zadania, dla pełnej długości słów, wyłącznie na własną odpowiedzialność studenta.

Zadania dodatkowe: elementy analizy matematycznej I

Funkcje

Funkcję w sensi matematycznym (nie mylić z funkcją w sensie informatycznym we wcześniejszej części zestawu!) deklarujemy nazwa( argumenty ) = wyrażenia.

Zadanie: Zdefiniować funkcje f(x,y)=x+y2xf(x,y) = x+\frac{y^2}{x}, g(x)=f(sin⁡(x),cos⁡(x))⋅sin⁡(x)g(x) = f\bigl(\sin(x), \cos(x)\bigr)\cdot \sin(x). Doprowadzić gg do najprostszej postaci.

var('x y')
f(x,y)=x+y^2/x;show(f)
g(x,y)=f(sin(x),cos(x))*sin(x);show(g)
show(g.simplify_full())
(x, y)
(x,y) ↦ x+y2x\displaystyle \left( x, y \right) \ {\mapsto} \ x + \frac{y^{2}}{x}
(x,y) ↦ (cos⁡(x)2sin⁡(x)+sin⁡(x))sin⁡(x)\displaystyle \left( x, y \right) \ {\mapsto} \ {\left(\frac{\cos\left(x\right)^{2}}{\sin\left(x\right)} + \sin\left(x\right)\right)} \sin\left(x\right)
1\displaystyle 1

Zadanie: Zdefiniować funkcję t↦t⋅(sin⁡(t)2,t⋅cos⁡(t)2)t\mapsto t\cdot \bigl(\frac{\sin(t)}{2}, t\cdot \frac{\cos(t)}{2} \bigr).

var('t')
f(t)=(t*sin(t)/2,t*cos(t)/2)
show(f)
t
t ↦ (12 tsin⁡(t), 12 tcos⁡(t))\displaystyle t \ {\mapsto}\ \left(\frac{1}{2} \, t \sin\left(t\right),\,\frac{1}{2} \, t \cos\left(t\right)\right)

Wykresy

Polecenie plot( wyrażenia, (zmienna, początek zakresu, koniec zakresu) ) służy do rysowania wykresu.

Zadanie: Narysować wykres funkcji f(x)=ln⁡(x)⋅sin⁡(x2)f(x) = \ln(x)\cdot \sin(x^2) na przedziale [1,2π][1,2\pi].

︠ba0496d8-bec4-4a85-9459-41f9f7fb8300︠

︠c968d9fb-c8d1-4d03-89cf-ec18df449f99︠
var('x')
f(x)=ln(x)*sin(x^2);show(f)
plot(f,(x,1,2*pi),color="darkgreen")
x
x ↦ log⁡(x)sin⁡(x2)\displaystyle x \ {\mapsto}\ \log\left(x\right) \sin\left(x^{2}\right)

Do rysowania krzywych parametrycznych służy funkcja parametric_plot a do rysowania krzywych w postaci uwikłanej implicit_plot

Zadanie: Narysować wykres krzywej parametrycznej zadanej wzorem t↦t⋅(sin⁡(t)2,t⋅cos⁡(t)2)t\mapsto t\cdot \bigl(\frac{\sin(t)}{2}, t\cdot \frac{\cos(t)}{2} \bigr) dla t∈[0,8π]t\in [0,8\pi].

var('t')
f(t)=(t*sin(t)/2,t*cos(t)/2);show(f)
parametric_plot(f,(t,0,8*pi),color="darkgrey")
t
t ↦ (12 tsin⁡(t), 12 tcos⁡(t))\displaystyle t \ {\mapsto}\ \left(\frac{1}{2} \, t \sin\left(t\right),\,\frac{1}{2} \, t \cos\left(t\right)\right)

Zadanie: Narysować wykres krzywej parametrycznej zadanej wzorem t↦(sin⁡(2t),cos⁡(t))t\mapsto \bigl(\sin(2t), \cos(t)\bigr).

var('t')
f(t)=(sin(2*t),cos(t));show(f)
parametric_plot(f,(t,-10,10))
t
t ↦ (sin⁡(2 t), cos⁡(t))\displaystyle t \ {\mapsto}\ \left(\sin\left(2 \, t\right),\,\cos\left(t\right)\right)

Zadanie: Narysować zbiór punktów spełniających warunek x2−4⋅y2⋅(1−y2)=0x^2-4\cdot y^2\cdot (1-y^2) = 0 dla x,y∈[−1,1]x,y\in [-1,1].

var('x y')
f(x,y)=x^2-4*y^2*(1-y^2);show(f)
implicit_plot(f(x,y)==0,(x,-1,1),(y,-1,1))
(x, y)
(x,y) ↦ 4 (y2−1)y2+x2\displaystyle \left( x, y \right) \ {\mapsto} \ 4 \, {\left(y^{2} - 1\right)} y^{2} + x^{2}

︠3424f139-78e3-4dc5-b4f3-801cac1151b8i︠
%html
<p>Wykresy tr&oacute;jwymiarowe tworzy się podobnymi komendami jak wykresy dwuwymiarowe, tele że z końc&oacute;wką `3d': <span style="font-family: courier new,courier;">plot3d, parametric_plot3d, implicit_plot3d</span></p>
<p><strong>Zadanie:</strong> Narysować wykres funkcji \[ f(x,y) := \ e^{\left(-\frac{x^{2} + y^{2}}{\pi}\right)} \cos\left(x^{2} + y^{2}\right) \] w kwadracie $[-\pi,\pi]\times [-\pi,\pi]$.</p>

Wykresy trójwymiarowe tworzy się podobnymi komendami jak wykresy dwuwymiarowe, tele że z końcówką `3d': plot3d, parametric_plot3d, implicit_plot3d

Zadanie: Narysować wykres funkcji f(x,y):= e(−x2+y2π)cos⁡(x2+y2) f(x,y) := \ e^{\left(-\frac{x^{2} + y^{2}}{\pi}\right)} \cos\left(x^{2} + y^{2}\right) w kwadracie [−π,π]×[−π,π][-\pi,\pi]\times [-\pi,\pi].

var('x y')
f(x,y)=e^(-(x^2+y^2)/pi)*cos(x^2+y^2);show(f)
plot3d(f,(x,-pi,pi),(y,-pi,pi))
(x, y)
(x,y) ↦ cos⁡(x2+y2)e(−x2+y2π)\displaystyle \left( x, y \right) \ {\mapsto} \ \cos\left(x^{2} + y^{2}\right) e^{\left(-\frac{x^{2} + y^{2}}{\pi}\right)}
3D rendering not yet implemented

Elementy rachunku różniczkowego/całkowego

Granice ciągów i funkcji

Zadanie: Zdefiniować ciąg an:=1n2+1a_n := \frac{1}{n^2+1}. Sprawdzić w helpie składnię funkcji lim. Obliczyć granicę lim⁡n→∞an \lim_{n\to \infty} a_n 

var('n')
a(n)=1/(n^2+1);show(a(n))
lim(a(n),n=oo)
n
1n2+1\displaystyle \frac{1}{n^{2} + 1}
0

Sumę szeregu (skończonego lub nie) oblicza się funkcją sum — sprawdzić składnię w pomocy. (Uwaga. Nie mylić sumy szeregu z sumą listy! Obie funkcje mają tę samą nazwę, lecz różne składnie!)

Zadanie: Obliczyć sumy: ∑n=110anoraz∑n=1∞an \sum_{n=1}^{10} a_n\qquad\text{oraz}\qquad \sum_{n=1}^\infty a_n Drugi z wyników przekształcić następnie na przybliżoną wartość numeryczną.

var('n')
a(n)=1/(n^2+1)
show(sum(a(n),n,1,10))
show(sum(a(n),n,1,oo))
n
16622222271693047850\displaystyle \frac{1662222227}{1693047850}
−12i ψ(i+1)+12i ψ(−i+1)\displaystyle -\frac{1}{2} i \, \psi\left(i + 1\right) + \frac{1}{2} i \, \psi\left(-i + 1\right)

Zadanie: Obliczyć następujące granice:

  • lim⁡n→∞3n2−2n+54n2+8n−1\displaystyle\lim\limits_{n\to\infty}\frac{3n^2-2n+5}{4n^2+8n-1}
  • lim⁡n→∞32n+1−79n+4\displaystyle\lim\limits_{n\to\infty} \frac{3^{2n+1}-7}{9^n+4}
  • lim⁡n→∞(2n−1)3(4n−1)2(1−5n)\displaystyle\lim\limits_{n\to\infty}\frac{(2n-1)^3}{(4n-1)^2(1-5n)}
  • lim⁡n→∞1+2+⋯+nn2\displaystyle\lim\limits_{n\to\infty}\frac{1+2+\dotsb+n}{n^2}
  • lim⁡n→∞1+2+⋯+2n2n\displaystyle\lim\limits_{n\to\infty}\frac{1+2+\dotsb + 2^n}{2^n}
var('n')
f=(3*n^2-2*n+5)/(4*n^2+8*n-1);show(f)
show(limit(f,n=oo))
n
3 n2−2 n+54 n2+8 n−1\displaystyle \frac{3 \, n^{2} - 2 \, n + 5}{4 \, n^{2} + 8 \, n - 1}
34\displaystyle \frac{3}{4}
var('n')
g=(3^(2*n+1)-7)/(9^n+4);show(g)
show(g.limit(n=oo))
n
32 n+1−79n+4\displaystyle \frac{3^{2 \, n + 1} - 7}{9^{n} + 4}
3\displaystyle 3
var('n')
h=(2*n-1)^3/(((4*n-1)^2)*(1-5*n));show(h)
show(limit(h,n=oo))
n
−(2 n−1)3(5 n−1)(4 n−1)2\displaystyle -\frac{{\left(2 \, n - 1\right)}^{3}}{{\left(5 \, n - 1\right)} {\left(4 \, n - 1\right)}^{2}}
−110\displaystyle -\frac{1}{10}
var('i')
a(n)=i
k=sum(a(n),i,1,n);view(k)
view(lim((k/n^(2)),n=oo))
i
12 n2+12 n\displaystyle \frac{1}{2} \, n^{2} + \frac{1}{2} \, n
12\displaystyle \frac{1}{2}
var('i')
a(n)=2^(i)
k=sum(a(n),i,0,n);view(k)
view(lim((k/2^(n)),n=oo))
i
2n+1−1\displaystyle 2^{n + 1} - 1
2\displaystyle 2

Zadanie: Obliczyć następujące granice funkcji:

  • lim⁡x→0(1−cos⁡xx2+1−cos⁡xx)\lim\limits_{x\to 0}\left(\frac{1-\cos x}{x^2}+\frac{1-\cos x}{x}\right)
  • lim⁡x→∞(x2sin⁡x+sin⁡(x3)x)\lim\limits_{x\to\infty}\left(\frac{x^2}{\sin x}+\frac{\sin(x^3)}{x}\right)
  • lim⁡x→2±1x2−5x+6\lim\limits_{x\to 2^\pm}\frac{1}{x^2-5x+6}

︠32a71793-208e-4553-822a-9eb704608100︠
var('x')
f=(1-cos(x))/x^2+(1-cos(x))/x
g=(x^2/sin(x)+sin(x^3)/x)
k=1/(x^2-5*x+6)
limit(f,x=0)
g.limit(x=oo)
limit(k,x=2,dir='+')
limit(k,x=2,dir='-')
x 1/2 und -Infinity +Infinity

Pochodna

Pochodną oblicza się funkcją diff.

Zadanie: Obliczyć pochodną z funkcji x↦cos⁡(x2+1)⋅sin⁡(x2−1)x\mapsto \cos(x^2+1)\cdot\sin(x^2-1)

var('x')
show(diff(cos(x^2+1)*sin(x^2-1),x))
x
2 xcos⁡(x2+1)cos⁡(x2−1)−2 xsin⁡(x2+1)sin⁡(x2−1)\displaystyle 2 \, x \cos\left(x^{2} + 1\right) \cos\left(x^{2} - 1\right) - 2 \, x \sin\left(x^{2} + 1\right) \sin\left(x^{2} - 1\right)

Zadanie: Obliczyć następujące pochodne:

  • x2xx343\sqrt[3]{x^2\sqrt{x\sqrt[4]{x^3}}}
  • arcsin⁡x3\arcsin\sqrt{x^3}
  • sin⁡ex2+3x−2\sin e^{x^2+3x-2}
  • xxxx^{x^x}
var('x')
show(diff((x^2*(x*x^(1/4))^(1/2))^(1/3),x))
show(diff(arcsin(x^(3/2)),x))
show(diff(sin(e^(x^2+3*x-2)),x))
show(diff(x^x^x,x))
x
5 x94x54+16 x54x24 (x54x2)23\displaystyle \frac{\frac{5 \, x^{\frac{9}{4}}}{\sqrt{x^{\frac{5}{4}}}} + 16 \, \sqrt{x^{\frac{5}{4}}} x}{24 \, \left(\sqrt{x^{\frac{5}{4}}} x^{2}\right)^{\frac{2}{3}}}
3 x2 −x3+1\displaystyle \frac{3 \, \sqrt{x}}{2 \, \sqrt{-x^{3} + 1}}
(2 x+3)cos⁡(e(x2+3 x−2))e(x2+3 x−2)\displaystyle {\left(2 \, x + 3\right)} \cos\left(e^{\left(x^{2} + 3 \, x - 2\right)}\right) e^{\left(x^{2} + 3 \, x - 2\right)}
(xx(log⁡(x)+1)log⁡(x)+xxx)x(xx)\displaystyle {\left(x^{x} {\left(\log\left(x\right) + 1\right)} \log\left(x\right) + \frac{x^{x}}{x}\right)} x^{\left(x^{x}\right)}

Całka

Całkę oblicza się funkcją integrate.

Zadanie: Sprawdzić w helpie składnię funkcji integrate. Policzyć całkę ∫2cos⁡(x)−sin⁡(x)sin⁡2(x)+1dx. \int \frac{2 \cos\left(x\right) - \sin\left(x\right) }{\sin^2(x) + 1} dx. Narysować wykres części rzeczywistej obliczonej całki na przedziale [−π,π][-\pi,\pi].

show(integrate((2*cos(x)-sin(x))/(sin(x)^2+1),x))
f=integrate((2*cos(x)-sin(x))/(sin(x)^2+1),x)
plot(real(f),(x,-pi,pi))
−14 2log⁡(−2 2−2 cos⁡(x)2 2+2 cos⁡(x))+2 arctan⁡(sin⁡(x))\displaystyle -\frac{1}{4} \, \sqrt{2} \log\left(-\frac{2 \, \sqrt{2} - 2 \, \cos\left(x\right)}{2 \, \sqrt{2} + 2 \, \cos\left(x\right)}\right) + 2 \, \arctan\left(\sin\left(x\right)\right)

Zadanie: Niech funkcja ff będzie dana wzorem f(x)=−sin⁡(sin⁡(x))cos⁡(x)x+1−cos⁡(sin⁡(x))(x+1)2 f(x) = -\frac{\sin\bigl(\sin(x)\bigr) \cos(x)}{x + 1} - \frac{\cos\bigl(\sin(x)\bigr)}{(x + 1)^2} Narysować wykres funkcji F=∫f(x)dxF = \int f(x) dx na przedziale [pi/2,10π][pi/2, 10\pi ].

var('x')
f(x)=-(sin(sin(x))*cos(x))/(x+1)-cos(sin(x))/(x+1)^2;show(f)
F=f.integrate(x)
plot(F,(x,pi/2,10*pi))
x
x ↦ −cos⁡(x)sin⁡(sin⁡(x))x+1−cos⁡(sin⁡(x))(x+1)2\displaystyle x \ {\mapsto}\ -\frac{\cos\left(x\right) \sin\left(\sin\left(x\right)\right)}{x + 1} - \frac{\cos\left(\sin\left(x\right)\right)}{{\left(x + 1\right)}^{2}}