W programowaniu, algorytm jest wiele wszechstronnie scharakteryzowanych kierunków w celu rozwiązania problemu.

Charakterystyka przyzwoitego algorytmu

Informacje i wydajność powinny być charakteryzowane w sposób jednoznaczny.

Każdy postęp w obliczeniach powinien być jasny i jednoznaczny.

Algorytm powinien być najlepszy spośród szerokiego wachlarza sposobów podejścia do danego zagadnienia.

Algorytm nie powinien mieć kodu PC. Powinien być raczej tak napisany, aby mógł być wykorzystany w porównywalnych dialektach programistycznych.

Przykłady Algorytmów w programowaniu

Napisz algorytm, który doda dwie liczby wprowadzone przez użytkownika.

Krok 1: Start

Krok 2: Ogłosić zmienne numer 1, numer 2 i sumę.

Krok 3: Odczytać wartości num1 i num2.

Krok 4: Dodaj zmienne numer 1 i numer 2 i przypisz wynik do sumy.

sum←num1+num2

Krok 5: Wyświetlanie sumy

Krok 6: Zatrzymanie

Napisz algorytm, aby znaleźć największą z trzech różnych liczb wprowadzonych przez użytkownika.

Krok 1: Start

Etap 2: Ogłaszanie zmiennych a, b i c.

Etap 3: Odczytać zmienne a, b i c.

Etap 4: Jeśli a>b

Jeśli a>c

Wyświetlacz a jest największą liczbą.

Else

Wyświetlacz c jest największą liczbą.

Inaczej .

Jeśli b>c

Wyświetlacz b jest największą liczbą.

Inaczej .

Wyświetlacz c jest największą liczbą.

Krok 5: Zatrzymanie

Napisz algorytm, aby znaleźć wszystkie korzenie równania kwadratowego ax2+bx+c=0.

Krok 1: Start

Etap 2: Ogłaszanie zmiennych a, b, c, D, x1, x2, rp i ip;

Etap 3: Obliczenie wartości dyskryminującej

D←b2-4ac

Etap 4: Jeśli D≥0

r1←(-b+√D)/2a

r2←(-b-√D)/2a

Wyświetlaj r1 i r2 jako korzenie.

Inaczej

Obliczyć część rzeczywistą i część urojoną

rp←b/2a

ip←√(-D)/2a

Wyświetlaj rp+j(ip) i rp-j(ip) jako korzenie

Napisz algorytm odnajdywania czynnikowej liczby wprowadzonej przez użytkownika.

Krok 1: Start

Etap 2: Ogłaszanie zmiennych n, czynnikowych i i.

Etap 3: Inicjalizacja zmiennych

factorial←1

i←1

Krok 4: Odczytanie wartości n

Krok 5: Powtarzać kroki do momentu, gdy i=n

5.1: factorial←factorial*i

5.2: i←i+1

Krok 6: Wyświetlanie współczynnika

Krok 7: Zatrzymanie

Napisz algorytm sprawdzający, czy liczba wprowadzona przez użytkownika jest liczbą pierwszą, czy też nie.

Krok 1: Start

Krok 2: Ogłosić zmienne n, i, flaga.

Etap 3: Inicjalizacja zmiennych

flag←1

i←2

Krok 4: Odczytaj n od użytkownika.

Krok 5: Powtarzaj te kroki aż do i<(n/2)

5.1 Jeśli reszta n÷i wynosi 0

flag←0

Przejdź do kroku 6

5.2 i←i+1

Krok 6: Jeśli flaga=0

Wyświetlacz n nie jest główny

W przeciwnym razie

Wyświetlacz n jest główny

Krok 7: Zatrzymanie

Napisz algorytm, aby znaleźć serię Fibonacciego do terminu ≤1000.

Krok 1: Start

Krok 2: Deklarowanie zmiennych first_term, second_term i temp.

Etap 3: Inicjalizacja zmiennych najpierw_term←0 drugi_term←1

Krok 4: Wyświetlenie pierwszego_termu i drugiego_termu

Krok 5: Powtórzyć kroki do sekundy_term≤1000

5.1: temp←second_term

5.2: second_term←second_term+first term

5.3: po pierwsze: term←temp

5.4: Wyświetlanie drugiego_termenu

Krok 6: Zatrzymanie

Dlaczego każdy programista powinien nauczyć się optymalizować algorytmy

Czym są Algorytmy?

Przypadkowo wyliczenie jest tylko wskazówką kroków, które należy podjąć, aby zająć się danym problemem. W zasadzie są one odpowiedzią.

Na przykład, obliczenie, aby zająć się kwestią faktoriów może wyglądać coś takiego:

Problem: Znajdź czynnikowy n

Fakt inicjalizacji = 1

Dla każdej wartości v w zakresie od 1 do n:

Pomnóż ten fakt przez v

fakt zawiera czynnik n

Tutaj, algorytm jest napisany w języku angielskim. Gdyby był on napisany w języku programowania, nazwalibyśmy go kodem. Tutaj jest kod do znalezienia czynnikowego numeru w C++.

int factorial(int n) {

int fact = 1;

dla (int v = 1; v <= n; v++) {

fakt = fakt * n;

}

wrócić do faktu;

}

Programowanie dotyczy struktur informacyjnych i obliczeń. Struktury informacyjne są wykorzystywane do przechowywania informacji, podczas gdy obliczenia są wykorzystywane do rozwiązywania problemów wykorzystujących te informacje.

Struktury informacyjne i obliczenia (DSA) znają szczegółowo odpowiedzi na standardowe zagadnienia i wiedzą, że wykorzystanie każdego z nich jest tak wydajne. Pokazuje to również badania nad oceną produktywności obliczeń. Pozwala to na wybór najlepszych z różnych decyzji.

Wykorzystanie struktur danych i algorytmów sprawia, że Twój kod jest skalowalny.

Czas jest cenny.

Załóżmy, że Alice i Bob próbują zająć się podstawową kwestią znalezienia sumy początkowych 1011 liczb normalnych. Podczas gdy Bob komponował obliczenia, Alice dokonała ich aktualizacji wykazując, że są one tak samo podstawowe jak potępienie Trąba Donalda.

Algorytm (autorstwa Boba)

Suma inicjująca = 0

dla każdej liczby naturalnej n w zakresie od 1 do 1011 (włącznie):

dodać n do sumy

suma jest twoją odpowiedzią

Kod (autorstwa Alice)

Int findSum() {\i0}

suma wewnętrzna = 0;

dla (int v = 1; <= 100000000000; v++) {

suma += v;

}

suma zwrotu;

}

Alice i Bob odczuwają euforię w stosunku do siebie samych, że w ciągu kilku sekund mogliby sfabrykować coś własnego. Może zakradniemy się do ich miejsca pracy i dostosujemy do ich dyskusji.

Alice: Uruchommy ten kod i odkryjmy całość.

Sway: Uruchomiłam ten kod kilka chwil temu, ale wciąż nie wskazuje on na wydajność. Co się z nim dzieje?

O nie, coś się źle ułożyło! Komputer to najbardziej deterministyczna maszyna. Powrót i próba uruchomienia go ponownie nie pomoże. Więc powinniśmy przeprowadzić sekcję, co się dzieje z tym prostym kodem.

Dwa najważniejsze atuty programu komputerowego to czas i pamięć.

Czas potrzebny do uruchomienia kodu to czas:

Czas na uruchomienie kodu = liczba instrukcji * czas na wykonanie każdej instrukcji

Ilość wskazówek zależy od wykorzystanego kodu, a czas potrzebny na wykonanie każdego z nich zależy od maszyny i kompilatora.

W tej sytuacji całkowita liczba wykonanych wytycznych (załóżmy, że x) wyniesie x = 1 + (1011 + 1) + (1011) + 1, co stanowi x = 2 * 1011 + 3

Daj nam szansę zaakceptować, że komputer może wykonać y = 108 wytycznych w ciągu jednej sekundy (może się wahać w zależności od układu maszyny). Czas potrzebny do uruchomienia powyższego kodu to

Czas potrzebny do uruchomienia kodu = x/y (więcej niż 16 minut)

Czy możliwe jest usprawnienie obliczeń w taki sposób, aby Alice i Bob nie musieli trzymać się mocno przez 16 minut za każdym razem, gdy uruchamiają ten kod?

Jestem pewien, że wcześniej spekulowałeś na temat właściwej techniki. Cała pierwsza N charakterystycznych liczb jest podana w przepisie:

Całość = N * (N + 1)/2

Przeliczenie go na kod będzie wyglądało tak:

int sum(int N) {\i1}

powrót N * (N + 1)/2;

}

Ten kod wykonuje się tylko w jednej instrukcji i kończy zadanie niezależnie od jego wartości. Daj mu szansę na bycie bardziej godnym uwagi niż cała znana ludzkości liczba cząstek. W mgnieniu oka odkryje wynik.

W tym przypadku całkowita liczba wykonanych instrukcji (powiedzmy x) wynosi x = 1 + (1011 + 1) + (1011) + 1, czyli x = 2 * 1011 + 3

Załóżmy, że komputer może wykonać y = 108

Daj nam szansę zaakceptować, że komputer może wykonać y = 108 wytycznych w ciągu jednej sekundy (może się wahać w zależności od konfiguracji maszyny). Czas potrzebny do uruchomienia powyższego kodu wynosi:

Czas potrzebny do uruchomienia kodu = x/y (więcej warte uwagi niż 16 minut)

Czy możliwe jest poprawienie obliczeń w taki sposób, aby Alice i Bob nie musieli trzymać się mocno przez 16 minut za każdym razem, gdy uruchamiają ten kod?

Jestem pewien, że wcześniej spekulowałeś na temat właściwej techniki. Całe pierwsze N liczb normalnych jest podane przez równanie:

Całe = N * (N + 1)/2

Przeliczenie go na kod będzie wyglądało tak:

int sum(int N) {\i1}

powrót N * (N + 1)/2;

}

Ten kod wykonuje się tylko w jednej instrukcji i kończy zadanie niezależnie od jego wartości. Daj mu szansę na bycie bardziej widocznym niż wszystkie inne molekuły znane ludzkości. Odkryje on wynik w ciągu kilku chwil.

Czas potrzebny na rozwiązanie problemu w tej sytuacji wynosi 1/rok (czyli 10 nanosekund). Przypadkowo kombinacja reakcji bomby atomowej trwa 40-50 ns, co oznacza, że Twój program zakończy się efektywnie niezależnie od tego czy ktoś podrzuci bombę atomową na Twój komputer jednocześnie uruchomił Twój kod. 🙂

Uwaga: Komputery potrzebują kilku wskazówek (nie 1) aby obliczyć augmentację i podział. Powiedziałem 1 tylko za prostolinijność.