Test parsera

Z Studia Informatyczne
Przejdź do nawigacjiPrzejdź do wyszukiwania

Wykład 1. Wprowadzenie do algorytmów.

Najważniejszym pojęciem w informatyce jest algorytm. Nazwa ta ma swoje korzenie w średniowieczu i wzięła się ze zniekształconego nazwiska wielkiego uczonego arabskiego \ref{Al Chuwarizmiego}, żyjącego na przełomie VIII i IX wieku i pochodzącego z Chorezmu. Al Chuwarizmi działając w Domu Nauk kalifa Al Mamuna w Bagdadzie opublikował ważne dzieła matematyczne, wśród nich Hisab al dżabr w'al muqabala – traktat o rozwiązywaniu równań, z którego wzięła nazwę algebra – jeden z głównych działów matematyki. W traktacie tym, poza wprowadzeniem systemu zapisu pozycyjnego, zaczerpniętego od Hindusów, a zwanego arabskim, podał między innymi metody rozwiązywania równań kwadratowych. Metody te odwoływały się do pojęć geometrycznych – wtedy utożsamiano liczby i działania z miarami obiektów geometrycznych. W szczególności liczby rzeczywiste, to były długości odcinków, dodawanie to było sklejanie odcinków, mnożenie odpowiadało braniu pola prostokąta o danych bokach, a dzielenie wyznaczaniu boku kwadratu o zadanym polu. Arabowie, podobnie jak starożytni Grecy, nie znali pojęcia liczby ujemnej, stąd gdy dziś patrzymy na metody Al Chuwarizmiego, poza oczywistym pięknem, wydają się nam one nieco dziwaczne, ale cóż – wtedy inaczej po prostu nie dawało się.

Al Chuwarizmi rozważał zatem równania postaci dla różnych klas b i c: dodatnich, ujemnych i równych zero. Miał zatem do czynienia z 9 różnymi przypadkami i dla każdego z nich podał metodę wyznaczania pierwiastka takiego równania. Przyjrzyjmy się jednemu z nich: dane są zaczerpnięte bezpośrednio z omawianej księgi. Rozwiązujemy równanie

\[x^2+10x =39\]

Jest to zatem równanie z klasy równań, w których współczynnik przy x jest dodatni, a wyraz wolny ujemny (dla wygody przenieśliśmy go na prawą stronę, więc po tamtej stronie jawi się nam jako c dodatnie). Oto co proponował Al Chuwarizmi.

\input{rys.AlChuwarizmi.gif}

Rysujemy kwadrat o boku x. Po jednej jego stronie doklejamy prostokąt o bokach x oraz , po drugiej, pod kątem prostym identyczny prostokąt. Uzupełniamy powstały kąt prosty wyznaczony przez 2 odcinki długości 5 do kwadratu i otrzymujemy duży kwadrat, którego pole wynosi . Bok tego dużego kwadratu ma więc długość , a że powstał on przez sklejenie odcinka o długości x oraz odcinka o długości 5, więc . Drugi pierwiastek w tym przypadku nas nie interesuje: jest ujemny, a więc go ,,nie ma – liczby ujemne nie istniały wówczas w świadomości współczesnych.

Zauważmy, że konstrukcję tę, a zatem i stosowne obliczenia, można powtórzyć dla każdej pary (b,c) w której b>0, zaś c<0. Wyrażając jednym wzorem efekt obliczeń uzyskalibyśmy wyrażenie [\ \label{RownanieKwadratowe} x=\sqrt{c+(\frac{b}{2})^2}-\frac{b}{2} \] Obliczenie wartości mogłoby się odbywać według następującego schematu:

  1. podziel b przez 2 i zapamiętaj wynik na zmiennej pomocniczej b'
  2. podnieś b' do kwadratu
  3. dodaj do otrzymanej liczby wartość c
  4. wyciągnij z otrzymanej sumy pierwiastek kwadratowy
  5. odejmij od tego, co uzyskałeś uprzednio zapamiętaną wartość b'
  6. otrzymana liczba jest szukanym (nieujemnym) pierwiastkiem równania .

Zróbmy parę obserwacji.

Po pierwsze powyższa procedura jest wykonywalna dla każdych danych b,c>0. Zauważmy, że jedyna operacja, która mogłaby mieć kłopoty z wykonaniem, to odejmowanie w punkcie 5 naszej procedury. Jednak można łatwo sprawdzić, że daje ono zawsze wynik dodatni: w końcu .

Po drugie, zastosowaliśmy tu pewne niewielkie, ale ważne uproszczenie algorytmu: użyliśmy w jego opisie pomocniczej zmiennej , dzięki której nie musieliśmy dwukrotnie dzielić wartości przez .

Po trzecie, zapisując wzór \ref{RownanieKwadratowe} skorzystaliśmy z tradycji notacyjnej, w myśl której w wyrażeniach arytmetycznych zawsze wiadomo w jakiej kolejności wykonuje się działania. W szczególności w wyrażeniu podpierwiastkowym najpierw dzieliliśmy  przez , potem podnosiliśmy wynik do kwadratu, a na końcu dodawaliśmy do niego . To, co w podanym przez Al Chuwarizmiego przepisie wymagało uściślenia kolejności, można wyrazić wzorem w zwartej formie, umówiwszy się zawczasu co do interpretacji podanej notacji. Niezwykle ważne jest, aby używana notacja była jednoznaczna i abyśmy nie popełniali błędu przy interpretacji wyrażeń. Wrócimy do tego zagadnienia w wykładzie o gramatykach.

Problemy: – Jak będzie działała podana metoda, dla c=0? – Zaprojektuj geometryczną metodę w stylu Al Chuwarizmiego dla równania . Czy metoda ta da poprawne wyniki dla wszystkich równań postaci przy dodatnich b,c?

Co to są zatem algorytmy? Ogólnie określamy tym mianem wszelkie przepisy postępowania, które doprowadzają do uzyskania pożądanego efektu – rozwiązania zadania. W potocznej mowie mówimy czasem o algorytmach postępowania niewiele mających wspólnego z komputerami, jednak dla informatyków algorytmy wiążą się nierozerwalnie z programowaniem.

Prawdziwe problemy pojawiają się, gdy chcemy algorytm zakodować w taki sposób, żeby był dobrze wykonany przez maszynę. Nie możemy sobie pozwolić na odwoływanie się do doświadczenia, machanie rękami, domysły. Komputer nie rozumie języka naturalnego i potrzebna będzie nam precyzyjna notacja do komunikacji z nim. Istotą programowania jest bowiem wyrażanie algorytmów w sposób ścisły, podlegający rygorom skończonej liczby reguł, których znaczenie w jednoznaczny sposób jesteśmy określić.

Al Chuwarizmi nie był wcale pierwszym człowiekiem, który stosował podejście algorytmiczne do rozwiązywania problemów. W rzeczywistości każdy z nas stosuje algorytmy w rozmaitych sytuacjach życiowych. Człowiek pierwotny miał algorytm polowania na mamuty, czy rozpalania ognia. Dzisiaj często wykonujemy pewne algorytmy, nie zdając sobie sprawy Warto przytoczyć parę przykładów algorytmów z życia codziennego

1. Przepisy kucharskie. Typowy przepis zawiera deklaracje obiektów (składników pichcenia) ich początkowe wartości (miary) oraz opis działań doprowadzający do przyrządzenia potrawy. \ref{PrzepisKucharski} 2. Zapis nutowy muzyki. Za pomocą szczególnego systemu notacyjnego określa się wysokości i względne czasy trwania nut i pauz między nimi. Można również i tu określić dane: są to zazwyczaj określenia instrumentów, które w partyturze występują, oraz dane początkowe, takie jak metrum czy dynamika części. Zauważmy, że poza standardowymi znakami na pięciolinii kompozytorzy często stosują dodatkowe określenia takie jak crescendo, poco allegretto, piano, con fuoco itp, pozwalające wykonawcy lepiej wyczuć ich intencje. \ref{Nuty} Szczególnie atrakcyjnie wyglądają niektóre nuty kompozytorów współczesnych, którzy odchodzą czasem od tradycyjnego zapisu nutowego i starają się niekiedy wymyśleć i opisać własny system notacyjny, wyrażający ich intencje. 3. Instrukcje montażu. Często do zestawów mebli, czy klocków lego dołączona jest kartka z instrukcją montażu zapisaną za pomocą sekwencji rycin obrazujących kolejne fazy powstawania składanego obiektu. Użytkownik porównując zmiany na poszczególnych obrazkach ma się domyślić, jakie czynności, w jakiej kolejności i za pomocą jakich części ma wykonywać. Zauważmy, że i tu występuje charakterystyczny dla algorytmów opis danych: najczęściej zestaw części składowych jest wyrysowany obok historyjki obrazkowej z zaznaczeniem liczby poszczególnych elementów. \ref{InstrukcjaMontażu} 4. Opisy dojazdu. Wyjaśniając, jak dotrzeć do danego miejsca (mappy.com) wiele serwisów udostępnia opis drogi z zaznaczeniem kluczowych punktów i decyzji. \ref{Mappy} 5. Opis układów choreograficznych, scenopisy przedstawień. Tutaj też stosuje się specyficzną symbolikę i skróty notacyjne.

Takich przykładów można mnożyć tysiące. Właściwie niemal wszystko, co robimy, podlega jakiemuś algorytmowi działania – przy czym warto podkreślić, że ludzie nie muszą mieć algorytmów objaśnianych dokładnie: wiele mogą wywnioskować z kontekstu, doświadczenia, po prostu domyślając się, o co może chodzić. Kucharce nie trzeba wyjaśniać, co to znaczy zeszklić cebulkę na ciemnozłoty kolor, a monterowi, co to znaczy zaizolować przewody.

Z komputerami jest jednak inaczej. Są to wyjątkowo głupie urządzenia i jeśli dokładnie nie wytłumaczymy, co mają zrobić, stają się bezradne. Między bajki należy włożyć rozmaite sytuacje znane z literatury fantastyczno-naukowej, w których komputery są równorzędnymi partnerami intelektualnymi dla ludzi. Sztuczna inteligencja, nawet jeśli istnieje, bazuje na ściśle określonych algorytmach działania i nie ma tam miejsca na intuicję, domyślenie się czegokolwiek, czy nagłe olśnienie, które są doskonale znane istotom myślącym. Ludzie często nie zdają sobie sprawy, jak wiele w algorytmach, którymi się posługują, zależy od nieuświadamianego kontekstu, jak dużo muszą dopowiadać do rzekomo precyzyjnych procedur działania. Komputery bezlitośnie wyłapują luki w specyfikacji procedur i nie ma mowy, żeby domyśliły się, że wykonują jakąś bezsensowną akcję, typu wydrukowanie żądania zapłacenia 0 zł. Jeśli wyraźnie nie zapiszemy w algorytmie, że takich żądań nie należy produkować, to komputer ślepo wykona nasze polecenie, choćby było ono w oczywisty sposób bezsensowne. W dalszych wykładach zobaczymy przykłady, w których algorytmy z pozoru wyglądające na poprawne i kompletne, będą miały luki powodujące błędne działanie.

Ćwiczenie: znajdź w Internecie przykłady bezsensownego zachowania się komputerów. Spróbuj domyśleć się, jakiego rodzaju błąd programisty był przyczyną blamażu.

Spróbujmy przymierzyć się do problemu znanego jeszcze ze starożytności. Przy dodawaniu sprowadza się mianowniki do najmniejszej wspólnej wielokrotności. Wyznaczenie jej najczęściej polega na tym, że oblicza się największy wspólny dzielnik, dzieli się jedną z liczb przez niego i mnoży przez drugą. Jak jednak znaleźć największy wspólny dzielnik?


Operacje dzielenia z resztą. Dla danych liczb całkowitych x,y, z zastrzeżeniem, że określamy dwie operacje: wynik i resztę z dzielenia x przez y następująco:

x div y = c x mod y = r, gdzie liczby c i r spełniają następujące zależności: .

Zatem na przykład 11 div 3 = 3, 11 mod 3 = 2, -7 div 2 = -4 -7 mod 2 =1 7 div -2 = -4 7 mod -2 = 1

Pytanie: czy zawsze oraz ?

Podpowiedź: Nie. Sprawdź choćby dla oraz Odpowiedź: Nie. Na przykład , bo , a -7 = (-3)\cdot 3 + 2$.

Problem [NWD(a,b)]: Dane są dwie liczby całkowite nieujemne a, b takie, że a+b>0. Wyznacz największą liczbę naturalną d taką, że = 0 i . Liczbę tę nazywamy największym wspólnym dzielnikiem a i b oraz oznaczamy przez (a,b).

Zauważmy, że zawsze . Załóżmy więc od tej pory, że .

Wiadomo, ze nie istnieje ogólny wzór na największy wspólny dzielnik. Jak więc go można wyznaczyć? Metoda, którą poznamy, to jeden z najstarszych algorytmów zwany algorytmem Euklidesa od imienia jednego z największych matematyków w całej historii, który go opublikował w swoim wiekopomnym dziele „Elementy”. \ref{Elementy}

Euklides zauważył, że po pierwsze gdy mniejsza z liczb jest równa zero, to największy wspólny dzielnik jest równy drugiej z nich, a gdy obie są dodatnie, to jest równy największemu wspólnemu dzielnikowi ich różnicy oraz mniejszej z nich. ref{MatematykaDyskretna...} Zapisując to zdanie za pomocą wzoru otrzymujemy \[ (a,b) =\left\{ \begin{array}{ll}

                                           a & \mbox{jeśli } \\
                                          (a-b,b) \mbox{jeśli } 
                   \end{array}
         \right.

\] Taki wzór jak powyżej nazywamy \mathit{ rekurencyjnym}. Istotą definiowania rekurencyjnego jest odwoływanie się w definicji jakiegoś pojęcia do niego samego. Tak jak tutaj: żeby zdefiniować największy wspólny dzielnik wykorzystujemy w definicji też największy wspólny dzielnik, tylko dla nieco mniejszych argumentów. Na dobrą sprawę taka definicja wygląda nieco podejrzanie, ale w rzeczywistości jest całkowicie poprawna. W końcu za jej pomocą jesteśmy w stanie obliczyć największy wspólny dzielnik dla dowolnej pary argumentów. Spróbujmy: . W ciągu tym odejmowaliśmy od pierwszego argumentu drugi, a gdy wynik okazywał się od niego mniejszy, zamienialiśmy argumenty miejscami. Czy możemy być pewni, że zawsze w ten sposób postępując otrzymamy w końcu jeden z argumentów równy zero?

Ćwiczenie: Udowodnij, że zawsze w skończonej liczbie kroków zejdziemy z jednym argumentem do zera.

Podpowiedź 1: Rozważ, jak się zachowuje suma argumentów w badanym ciągu.

Rozwiązanie: Argumenty po każdym kroku są nieujemne, więc nieujemna jest też ich suma. Suma argumentów po każdym kroku maleje, a nie może ciąg liczb naturalnych ściśle maleć w nieskończoność – jego długość jest ograniczona przez początkową wartość tej sumy: w końcu jej wartość w każdym kroku pomniejsza się co najmniej o jedynkę. Zatem ciąg naszych operacji jest skończony. A jedyny powód przerwania obliczeń rekurencyjnych może być tylko taki, że mniejszy z argumentów równa się zero.


Zauważmy, że podaliśmy przepis otrzymywania największego wspólnego dzielnika. Jest to \mathit{ algorytm Euklidesa}. Za jego pomocą możemy znaleźć największy wspólny dzielnik dla dowolnej pary argumentów.

Przedstawmy program w notacji, którą formalnie wprowadzimy nieco później, obliczający największy wspólny dzielnik zgodnie z podanym algorytmem.

Euklides 1 \begin{verbatim} Read(a,b); //Wczytujemy a i b, zakładając że użytkownik wie, że a>=b, a+b>0 while b > 0 do begin

 if a< b then zamień(a,b); //po wykonaniu tej instrukcji zawsze a>=b
 a:=a-b                              // tutaj być może raz wykonamy niepotrzebnie odejmowanie zera 

end; Write(a) \end{verbatim}

Zastanówmy się, jak długo będziemy wykonywali nasz algorytm. Załóżmy, że dane, na których pracujemy nie przekraczają . Nie jest to jakieś dziwactwo: w rzeczywistości szukanie największego wspólnego dzielnika jest częścią szyfrowania RSA – powszechnie stosowanego protokołu kryptograficznego i wykonuje się na znacznie większych liczbach – ponadstucyfrowych.

Dobierzmy możliwie złośliwe dane. Oczywiście aby algorytm działał jak najdłużej, należy odejmować jak najmniejsze wartości w każdym kroku. Weźmy zatem . Widać, że dla tych danych wykona się obrotów pętli: będziemy żmudnie odejmowali jedyneczkę od sporej dość liczby. Jak długo to może potrwać.

Przyjmijmy, że mamy do czynienia z bardzo szybkim komputerem, który jeden obrót pętli wykonuje jedną dziesięciomiliardową sekundy (10^{-10}sParser nie mógł rozpoznać (błąd składni): {\displaystyle . Zatem w ciągu doby mamy } 86400\cdot 10^{10}Parser nie mógł rozpoznać (błąd składni): {\displaystyle obrotów pętli. Dób w ciągu roku jest 365, czyli razem mamy } 31536\cdot 10^{13}Parser nie mógł rozpoznać (błąd składni): {\displaystyle obrotów pętli na rok. A od Wielkiego Wybuchu minęło niespełna 14 miliardów lat, łącznie niespełna } 5\cdot 10^{28} obrotów pętli, przyjąwszy, że ktoś włączył nasz komputer na początku Wszechświata i on do dziś z tą zawrotną prędkością wykonuje nasz program dla tych właśnie danych. Do dziś zatem wykonałby niespełna jedną dwudziestą wszystkich obliczeń. Jeszcze dwadzieścia parę takich Wszechświatów i program zakończy swoje działanie.

Co należy w takiej sytuacji zrobić? Niektórzy myślą, że trzeba kupić szybszy komputer. Żarty na bok. Ale istnieją użytkownicy, którzy gdy im program działa zbyt wolno, myślą przede wszystkim o sprzęcie. W wielu przypadkach jednak główne rezerwy tkwią w samym algorytmie.

Zauważmy (a Euklides to wiedział długo przed nami), że tak naprawdę odejmowanie wykonujemy tylko po to, żeby wyznaczyć resztę z dzielenia a przez b. W końcu dopóki a jest większe od b odejmujemy od a całkowite wielokrotności b, a zamieniamy rolami a z b gdy tylko a spadnie poniżej b. Gdy się to dzieje, a ma wartość właśnie reszty z dzielenia a przez b. Można by zatem pominąć całe to odejmowanie, jeśli udałoby się nam od razu znaleźć tę resztę z dzielenia. A to nie jest takie trudne – można choćby stosować poznane w szkole podstawowej słupkowe dzielenie, które nad kreską daje wynik dzielenia, a na dole – resztę. Zmodyfikujmy zatem algorytm Euklidesa:

Euklides 2 \begin{verbatim} Read(a,b); //Wczytujemy a i b, zakładając że użytkownik wie, że a>=b, a+b>0 while b > 0 do begin

 a:=a mod b;                     
 zamień (a,b)  // reszta jest zawsze mniejsza od dzielnika, więc w ciemno możemy zamienić a z b

end; Write(a) \end{verbatim}

Podobnie jak poprzednio możemy bez trudu pokazać, że program się zawsze zakończy.

Jak długo się tym razem będzie wykonywała nasza pętla programu? Jeśli dobranie najbardziej złośliwych danych w poprzednim przypadku było proste, to teraz wcale nie jest oczywiste dla jakich danych spośród liczb 30-cyfrowych program będzie działał najdłużej. Załóżmy, że tak jak poprzednio interesuje nas liczba obrotów pętli. Pomijamy na razie koszt związany z operacją dzielenia z resztą, zakładając że jest on stały.

Ćwiczenie: Znajdź dwie liczby dwucyfrowe, dla których algorytm Euklides 2 wykona się najwięcej razy.

Podpowiedź 1:

Podpowiedź 2: Nie bądź rozrzutny: jeśli tę samą liczbę obrotów pętli możesz uzyskać mniejszymi liczbami, to to zrób.

Odpowiedź: (89,55). Wykonując kolejne dzielenia z resztą otrzymujemy ciąg . Za każdym razem wynik dzielenia był równy zero, a reszta była po prostu różnicą argumentów.

Aby rozwiązać ten problem doboru najbardziej złośliwych danych, należy spojrzeć się na problem od drugiej strony: jak za pomocą najmniejszych liczb uzyskać z góry zadaną liczbę obrotów pętli? Widać, że aby pętla wykonała się raz, wystarczą dane (1,1). Ale te dane nie mogą być wynikiem wcześniejszego obrotu pętli: pamiętajmy, że pierwszy z argumentów jest zawsze dzielnikiem z poprzedniego obrotu pętli, a skoro jest nim jedynka, to reszta nie mogła być równa jeden. Zatem przy więcej niż jednym obrocie pętli najmniejsze dane dla ostatniego obrotu pętli, to (2,1). Jakie były zatem dane przedostatnie? Widać, że dzieliliśmy przez 2 i dostaliśmy resztę 1. Zatem w poprzednim kroku mogliśmy mieć pary (3,2) lub (5,2) lub (7,2),... Z nich para (3,2) jest najoszczędniejsza – są to liczby, które dają najmniejszą sumę, a liczba obrotów naszej pętli jest równa 2. . Jak wyglądała zatem para dwa kroki wstecz? Dzielnik musiał być równy 3, a reszta równa 2, więc w grę wchodzą pary (5,3), (8,3), (11,3),... Z nich znów najoszczędniejsza jest para (5,3). Dalej cofając się i rozumując w analogiczny sposób dostaniemy pary (8,5) i kolejno (13,8), (21,13),... . Widać zatem, że zawsze najoszczędniej będzie tak dobierać kolejną parę, aby wynik dzielenia był równy 1, czyli innymi słowy, jeśli w kolejnym obrocie pętli argumenty są równe , to w poprzednim powinny być równe . Wtedy bowiem jest resztą z dzielenia przez , natomiast iloraz równy jest .

Zbadajmy zatem, jakie najmniejsze argumenty dają zadaną liczbę obrotów pętli. \begin{tabular}{|r||r|r|} \hline \hline Liczba obrotów & a & b \\ \hline \hline 0 && 1 & 0\\ 1 && 1 & 1\\ 2 && 2 & 1\\ 3 && 3 & 2\\ 4 && 5 & 3\\ 5 && 8 & 5\\ 6 && 13&8\\ 7 && 21&13\\ \dots \hline \end{tabular} Liczby, które występują w tabeli, są znane pod nazwą \mathit{ liczb Fibonacciego}. Mają one w informatyce duże znaczenie i warto znać podstawowe fakty o nich. Definiuje się je następująco: \\ \\ dla \\ Każda kolejna liczba Fibonacciego jest sumą dwóch swoich poprzedniczek. Parę początkowych wyrazów tego ciągu warto znać na pamięć. \begin{tabular}{|r|r|} \hline \hline & \\ \hline \hline 0 & 0\\ 1 & 1\\ 2 & 1\\ 3 & 2\\ 4 & 3\\ 5 & 5\\ 6 &8\\ 7 &13\\ \dots \hline \end{tabular}

Widzimy więc, że poczynając od trzeciego wiersza tabeli () najbardziej złośliwych danych dla algorytmu Euklides2 mamy zawsze Parser nie mógł rozpoznać (błąd składni): {\displaystyle a=F_{n+1}, b={F_n}. Aby wymusić } nParser nie mógł rozpoznać (błąd składni): {\displaystyle obrotów pętli musimy wziąć zatem co najmniej } n+1Parser nie mógł rozpoznać (błąd składni): {\displaystyle -szą i } n-tą liczbę Fibonacciego.

Liczby Fibonacciego rosną dość szybko. Konkretnie znany jest ogólny wzór na -tą liczbę Fibonacciego przypisywany Binetowi, a znany jeszcze na pewno Eulerowi 100 lat przed Binetem. \[ F_n=\frac{1}{\sqrt{5}}((\frac{1+\sqrt{5}}{2})^n-\frac{1-\sqrt{5}})^n) \] Dowód tego wzoru można znaleźć w \ref{MatematykaDyskretna-xxx}. Wprowadzając oznaczenia Parser nie mógł rozpoznać (nieznana funkcja „\fi”): {\displaystyle \fi=\frac{1+\sqrt{5}}{2}, \hat{\fi}=\frac{1-\sqrt{5}}{2}} , otrzymujemy wzór w nieco bardziej czytelnej postaci Parser nie mógł rozpoznać (nieznana funkcja „\fi”): {\displaystyle F_n=\frac{1}{\sqrt{5}}(\fi^n-\hat{\fi}^n)} . Biorąc pod uwagę to, że Parser nie mógł rozpoznać (nieznana funkcja „\fi”): {\displaystyle \fi=1,618...} , zaś Parser nie mógł rozpoznać (nieznana funkcja „\fi”): {\displaystyle \hat{\fi}=-0,381...} i to, że w związku z tym składnik Parser nie mógł rozpoznać (nieznana funkcja „\fi”): {\displaystyle \hat{\fi}^n)} w naszym wzorze bardzo szybko dąży do zera, możemy łatwo pokazać, że n-ta liczba Fibonacciego jest równa Parser nie mógł rozpoznać (nieznana funkcja „\fi”): {\displaystyle F_n=[\frac{1}{\sqrt{5}}\fi^n]} , gdzie przez oznaczamy najbliższą liczbę całkowitą danej liczby rzeczywistej . Zatem n-ta liczba Fibonacciego jest prawie dokładnie równa n-tej potędze Parser nie mógł rozpoznać (nieznana funkcja „\fi”): {\displaystyle \fi} podzielonej przez . Zauważmy jeszcze, że skoro tak, to po zlogarytmowaniu obustronnie ostatniego wzoru przy podstawie Parser nie mógł rozpoznać (nieznana funkcja „\fi”): {\displaystyle \fi} otrzymujemy wzór Parser nie mógł rozpoznać (nieznana funkcja „\fi”): {\displaystyle \log_{\fi}F_n = n - log_{\fi}\sqrt{5}} . Zatem indeks zadanej liczby Fibonacciego F_n wynosi Parser nie mógł rozpoznać (nieznana funkcja „\fi”): {\displaystyle n=\log_{\fi}F_n + log_{\fi}\sqrt{5}} . Zapamiętajmy sobie niezwykle ważny wniosek:

\begin{ramka} Liczby Fibonacciego rosną wykładniczo szybko. Ich wzrost jest prawie identyczny, jak funkcji wykładniczej Parser nie mógł rozpoznać (nieznana funkcja „\fi”): {\displaystyle \frac{1}{\sqrt{5}}\fi^n} . \end{ramka}

Wprowadźmy oznaczenie na największą liczbę Fibonacciego nieprzekraczającą , a przez jej indeks. Ponieważ dla dowolnych argumentów liczba obrotów pętli algorytmu Euklides2 nie przekracza liczby obrotów pętli dla argumentów najbardziej złośliwych, czyli oraz poprzedniej liczby Fibonacciego , a liczba obrotów pętli dla tych argumentów jest o 1 mniejsza, niż indeks większej z nich, więc otrzymujemy szacowanie na liczbę obrotów pętli dla dowolnych argumentów i : \[ M(a,b) \le M(FIB(a),FIB(FIB(a)-1) = [n]FIB(a)-1, \mbox{\rm skąd} \\ M(a,b)+1 \le Parser nie mógł rozpoznać (nieznana funkcja „\fi”): {\displaystyle n=\log_{\fi}F_n + log_{\fi}\sqrt{5}} , \\ \mbox{\rm a biorąc pod uwagę, że} Parser nie mógł rozpoznać (nieznana funkcja „\fi”): {\displaystyle log_{\fi}\sqrt{5}=1,67...} \mbox{\rm otrzymujemy} \\ M(a,b)\le \log_{fi}a +1 \] bowiem (o jeden większy logarytm od ma kolejna liczba Fibonacciego, która już jest większa od ).

Zapamiętajmy jeszcze jedną ważną prawidłowość. \begin{ramka} Indeksy liczb Fibonacciego rosną logarytmicznie wolno w stosunku do wartości tych liczb. \end{ramka} Zatem funkcja [n]FIB(x) rośnie logarytmicznie ze względu na x.

Wracając do naszych danych trzydziestocyfrowych: możemy oszacować liczbę obrotów pętli przez . Zatem wykonamy nie więcej niż 150 obrotów pętli, co oczywiście będzie w zasięgu nawet bardzo wolnego komputera. Pamiętajmy, że przy dużych liczbach możemy zapomnieć o wbudowanych w języki programowania procedurach arytmetycznych. O arytmetykę musimy zadbać sami, co zostanie zilustrowane w późniejszych wykładach.

Zauważmy pewną niedogodność. W algorytmie Euklides2 jeden krok pętli jest nieco trudniejszy: w poprzednim algorytmie Euklides1 mieliśmy tylko porównywanie liczb i ich odejmowanie. Tutaj musimy zaprogramować dzielenie z resztą. Jest to nie tylko trudniejsze, ale i wolniejsze od odejmowania. Jeśli zdecydujemy się na algorytm szkolny dzielenia słupkowego, to trzeba będzie wykonać całą serię obliczeń realizujących kolejne kroki wyznaczania cyfr ilorazu. Każdy z tych kroków wymaga wyznaczenia stosownej cyfry wyniku, przemnożenia jej wartości przez dzielnik, a następnie odjęcia od fragmentu dzielnej tego wyniku. Robimy to z grubsza tyle razy, ile cyfr ma iloraz.

Jeżeli za miarę wielkości liczby przyjmiemy długość jej reprezentacji w systemie pozycyjnym, to o ile porównywanie odejmowanie można zrobić w czasie proporcjonalnym do długości tej reprezentacji, to dzielenie może wymagać kwadratowego czasu. Niech długość dzielnej wynosi . Zauważmy, że jeśli dzielnik jest o połowę krótszy od dzielnej, (czyli mając długość jest mniej więcej równy pierwiastkowi kwadratowemu z dzielnej), to iloraz będzie miał długość podobną jak dzielnik, czyli i tyle razy będzie się musiała wykonać zasadnicza pętla algorytmu dzielącego, bo tyle cyfr trzeba wyznaczyć. Z kolei wyznaczenie każdej cyfry ilorazu wymaga odjęcia jakiejś niewielkiej wielokrotności dzielnika, a więc liczby również -cyfrowej. A odejmowanie jest proporcjonalnie kosztowne do długości argumentów. Łącznie zatem cyfr ilorazu razy jednocyfrowych kroków przy odejmowaniu daje nam łącznie , więc kwadratowo wiele w stosunku do .

Liczba obrotów głównej pętli algorytmu jest też proporcjonalna do , bo w dowolnym systemie pozycyjnym liczba cyfr jest proporcjonalna do logarytmu z danej liczby przy podstawie będącej bazą systemu, czyli również proporcjonalna do logarytmu przy podstawie Parser nie mógł rozpoznać (nieznana funkcja „\fi”): {\displaystyle \fi} , bo logarytmy o różnych podstawach różnią się od siebie tylko o czynnik stały.

Jeśli skupimy się na operacjach na pojedynczych cyfrach, to łączna liczba wszystkich operacji nie przekroczy zatem . W rzeczywistości możemy się pokusić o przypuszczenie, że będzie to nawet mniej. Zauważmy bowiem, że złośliwe dane dla głównej pętli, to kolejne liczby Fibonacciego, a te długością różnią się co najwyżej o 1, natomiast złośliwe dane dla algorytmu dzielenia z resztą, to dane różniące się długością dwukrotnie; liczby Fibonacciego można podzielić w czasie liniowym, a nie kwadratowym. i to liczby Fibonacciego będą się pojawiały cały czas, w każdym kroku algorytmu. Jeżeli zatem zaczniemy od pary kolejnych liczb Fibonacciego, to -krotnie wykonamy dzieleni kosztujące , co nam da . Jeśli natomiast będziemy się starali wywindować koszt dzielenia, to długości kolejnych par powinny być równe . Ale wtedy łączny koszt dzieleń będzie równy . Zatem obie skrajności: złośliwe dane dla zewnętrznej i dla wewnętrznej pętli dają koszt kwadratowy. Ale czy nie można wypośrodkować złośliwości tak, aby uzyskać jednak złożoność sześcienną?

Problem: Czy można tak dobrać dane, żeby wymusić sześcienną złożoność algorytmu Euklides2? Odpowiedź: NIE. Złożoność algorytmu Euklides2 jest jednak kwadratowa.

Powstaje pytanie, czy nie dałoby się znaleźć takiego algorytmu znajdowania największego wspólnego dzielnika tak, aby zachowując złożoność kwadratową uzyskać łatwiejsze operacje niż dzielenie z resztą. Rozwiązanie jest zaskakująco proste, jeśli zauważymy parę dość oczywistych faktów. Będziemy rozważać parzystość argumentów i redukować problem ze względu na tę właśnie własność. Oznaczmy zbiór liczb parzystych przez .

Euklides3 \[ (a,b) =\left\{ \begin{array}{ll}

                                           a & \mbox{jeśli } \\
                                          2(a,b)& \mbox{jeśli }\\
                                          (\frac{a}{2},b)   &\mbox{jeśli }\\
                                          (a,\frac{b}{2})  & \mbox{jeśli }\\                         
                                          (a-b,b)  & \mbox{jeśli }\\
                   \end{array}
         \right.

\] Oczywiście, podobnie jak poprzednio, dbamy zawsze o to, żeby pierwszy argument nie był mniejszy od drugiego i w razie czego zamieniamy je miejscami.

Euklides 3 \begin{verbatim} Read(a,b); //Wczytujemy a i b, zakładając że użytkownik wie, że a>=b, a+b>0 wynik:=1; while b > 0 do begin

 if a< b then zamień(a,b); //po wykonaniu tej instrukcji zawsze a>=b
 if parzyste(a) and parzyste(b) then wynik:=wynik*2 else // w przeciwnym razie
 if parzyste(a) and not parzyste(b) then a:=a div 2 else 
 if not parzyste(a) and parzyste(b) then b:=b div 2 else
 a:=a-b

end; wynik:=wynik*a; Write(a) \end{verbatim}

W kodzie tym posługujemy się predykatem {\tt parzyste(x)}, który przyjmuje wartość true (prawda), jeśli x jest parzyste i false (fałsz) jeśli jest nieparzyste. Operacja div daje nam wynik dzielenia całkowitego (z ucięciem reszty).

Przyjrzyjmy się naszemu algorytmowi pod kątem liczby obrotów pętli. Zauważmy, że w każdym obrocie we wszystkich przypadkach, poza sytuacją obu argumentów nieparzystych, co najmniej jeden z argumentów jest połowiony. Natomiast w przypadku obu argumentów nieparzystych jeden z argumentów stanie się parzysty w wyniku odejmowania i w następnym obrocie pętli zostanie podzielony przez 2. Zatem co najmniej raz na dwa obroty pętli co najmniej jeden z argumentów jest dzielony przez 2. Ale dzieleń przez 2 można wykonać tylko logarytmicznie dużo.

\begin{ramka} W dziedzinie całkowitoliczbowej możemy się spojrzeć na logarytm jak na liczbę możliwych dzieleń przez 2, zanim dojdziemy do jedynki. Liczba ta jest równa podłodze z logarytmu rzeczywistego przy podstawie 2. \end{ramka}

Zatem łączna liczba obrotów pętli nie przekracza . Co się dzieje w każdym obrocie pętli? Każda z operacji ma złożoność liniową. Sprawdzenie parzystości liczby wymaga zajrzenia do ostatniej cyfry. Sprawdzenie, czy liczba jest równa zero wymaga przejrzenia w najgorszym razie wszystkich jej cyfr jednokrotnie. Dzielenie przez 2 i mnożenie przez dwa, podobnie jak odejmowanie, mają złożoność liniową (czyli proporcjonalną do logarytmu z wartości a i b). Zatem złożoność algorytmu na poziomie operacji na cyfrach jest kwadratowa, czyli proporcjonalna do kwadratu z logarytmu .


DZIEDZINA ALGORYTMICZNA

Ważnym pojęciem przy określaniu algorytmu jest pojęcie dziedziny algorytmicznej. Algorytmy wykonują pewne operacje na argumentach i wyrażenie własności algorytmu, a w tym określenie jego złożoności dokonywane jest za pomocą tych operacji. Dziedziną algorytmiczną nazwiemy zatem system relacyjny Parser nie mógł rozpoznać (nieznana funkcja „\inI”): {\displaystyle \langle A, \{o_i\}_{i\inI}, \{r_j\}_{j\inJ}\rangle} , gdzie nazywany jest nośnikiem, a zbiory Parser nie mógł rozpoznać (nieznana funkcja „\inI”): {\displaystyle \{o_i\}_{i\inI}, \{r_j\}_{j\inJ}\rangle} , ...