Wstęp do programowania / Ćwiczenia 3: Różnice pomiędzy wersjami

Z Studia Informatyczne
Przejdź do nawigacjiPrzejdź do wyszukiwania
Daria (dyskusja | edycje)
Nie podano opisu zmian
Daria (dyskusja | edycje)
Wiekszosc poprawek po wizycie u Piotra (ale jeszcze nie wszystkie)
Linia 8: Linia 8:
'''Rozwiązanie 1'''   
'''Rozwiązanie 1'''   
<div class="mw-collapsible-content" style="display:none">
<div class="mw-collapsible-content" style="display:none">
  '''function''' Znajdz_Pierwsze(N,A,x):integer;
  '''function''' ZnajdzPierwsze(N,x:integer; A:array[1..N] of integer):integer;
  '''var''' l,p,s : integer;
  '''var''' l,p,s : integer;
  '''begin'''
  '''begin'''
Linia 15: Linia 15:
   '''while''' l < p '''do''' '''begin'''
   '''while''' l < p '''do''' '''begin'''
     s:=(l+p)div 2;
     s:=(l+p)div 2;
     '''if''' A[s] < x '''then''' l:=s+1;
     '''if''' x > A[s] '''then''' l:=s+1;
     '''else''' p:=s;
     '''else''' p:=s;
   '''end''';
   '''end''';
   '''if''' A[l] = x '''then''' Znajdz_Pierwsze:=l
   '''if''' A[l] = x '''then''' ZnajdzPierwsze:=l
   '''else''' Znajdz_Pierwsze:=0;
   '''else''' ZnajdzPierwsze:=0;
  '''end''';
  '''end''';
''Koszt czasowy'': logarytmiczny względem N
''Koszt pamięciowy'': stały
</div>
</div>
<div class="mw-collapsible mw-made=collapsible mw-collapsed">
'''Pytanko 1'''
<div class="mw-collapsible-content" style="display:none">
Jaka będzie wartość A[l] w przypadku gdy x nie ma w tablicy A ?
</div>
</div>
</div>
</div>
== Zadanie 2 (Ostatnie wystąpienie x)==
== Zadanie 2 (Ostatnie wystąpienie x)==
Dana jest posortowana niemalejąco tablica A typu array[1..N] of integer i x typu integer. Znajdź
Dana jest posortowana niemalejąco tablica A typu array[1..N] of integer i x typu integer. Znajdź
Linia 31: Linia 39:
'''Rozwiązanie 1'''   
'''Rozwiązanie 1'''   
<div class="mw-collapsible-content" style="display:none">
<div class="mw-collapsible-content" style="display:none">
  '''function''' Znajdz_Ostatnie(N,A,x):integer;
  '''function''' ZnajdzOstatnie(N,x:integer; A:array[1..N] of integer):integer;
  '''var''' l,p,s : integer;
  '''var''' l,p,s : integer;
  '''begin'''
  '''begin'''
Linia 38: Linia 46:
   '''while''' l < p '''do''' '''begin'''
   '''while''' l < p '''do''' '''begin'''
     s:=(l+p+1)div 2;
     s:=(l+p+1)div 2;
     '''if''' A[s] > x '''then''' p:=s-1;
     '''if''' x < A[s] '''then''' p:=s-1;
     '''else''' l:=s;
     '''else''' l:=s;
   '''end''';
   '''end''';
   '''if''' A[l] = x '''then''' Znajdz_Ostatnie:=l
   '''if''' A[l] = x '''then''' ZnajdzOstatnie:=l
   '''else''' Znajdz_Ostatnie:=0;
   '''else''' ZnajdzOstatnie:=0;
  '''end''';
  '''end''';
''Koszt czasowy'': logarytmiczny względem N
''Koszt pamięciowy'': stały
</div>
</div>
<div class="mw-collapsible mw-made=collapsible mw-collapsed">
'''Pytanko 1'''
<div class="mw-collapsible-content" style="display:none">
Jaka będzie wartość A[l] w przypadku gdy x nie ma w tablicy A ?
</div>
</div>
</div>
</div>
== Zadanie 3 (Policz liczbę wystapień x)==
== Zadanie 3 (Policz liczbę wystapień x)==
Dana jest posortowana niemalejąco tablica A typu array[1..N] of integer i x typu integer. Policz ile razy występuje w niej wartość x.
Dana jest posortowana niemalejąco tablica A typu array[1..N] of integer i x typu integer. Wyznacz liczbę wystąpień x w tablicy A.


<div class="mw-collapsible mw-made=collapsible mw-collapsed">
<div class="mw-collapsible mw-made=collapsible mw-collapsed">
Linia 58: Linia 74:
'''Rozwiązanie 1'''   
'''Rozwiązanie 1'''   
<div class="mw-collapsible-content" style="display:none">
<div class="mw-collapsible-content" style="display:none">
  '''function''' Liczba_wystapien(N,A,x):integer;
  '''function''' LiczbaWystapien(N,x:integer; A:array[1..N] of integer):integer;
  '''var''' p,l: integer;
  '''var''' p,l: integer;
  '''begin'''
  '''begin'''
   l:= Znajdz_Pierwsze(N,A,x);
   l:= ZnajdzPierwsze(N,A,x);
   p:= Znajdz_Pierwsze(N,A,x);
   p:= ZnajdzPierwsze(N,A,x);
   '''if''' l <> 0 '''then''' Liczba_wystapien:=p-l+1;
   '''if''' l <> 0 '''then''' LiczbaWystapien:=p-l+1;
  '''end''';
  '''end''';
''Koszt czasowy'': logarytmiczny względem N
''Koszt pamięciowy'': stały
</div>
</div>
</div>
</div>


== Zadanie 4 (Wartość równa indeksowi)==
== Zadanie 4 (Wartość równa indeksowi)==
Dana jest posortowana rosnąco tablica A typu array[1..N] of integer.  Sprawdź czy występuje w niej element o wartości równej swojemu indeksowi. Jeśli tak to zwróć ten indeks, jeśli nie to zwróć 0;
Dana jest posortowana rosnąco tablica A typu array[1..N] of integer.  Sprawdź czy występuje w niej element o wartości równej swojemu indeksowi. Jeśli tak to wyznacz ten indeks, jeśli nie to funkcja ma dać wartość 0.


<div class="mw-collapsible mw-made=collapsible mw-collapsed">
<div class="mw-collapsible mw-made=collapsible mw-collapsed">
Linia 79: Linia 98:
'''Rozwiązanie 1'''   
'''Rozwiązanie 1'''   
<div class="mw-collapsible-content" style="display:none">
<div class="mw-collapsible-content" style="display:none">
  '''function''' Rowny(N,A):integer;
  '''function''' Rowny(N:integer; A:array[1..N] of integer):integer;
  '''var''' p,l,s: integer;
  '''var''' p,l,s: integer;
  '''begin'''
  '''begin'''
   '''if''' (A[1] > 1) or (A[N] < N) '''then''' Rowny:=0
   l:=1;
  '''else''' '''begin'''
  p:=N;
    l:=1;
  '''while''' l < p '''do''' '''begin'''
    p:=N;
    s:=(l+p)div 2;
    '''while''' l < p '''do''' '''begin'''
    '''if''' A[s] < s '''then''' l:=s+1;
      s:=(l+p)div 2;
    '''else''' p:=s;
      '''if''' A[s] < s '''then''' l:=s+1;
  '''end''';
      '''else''' p:=s;
  '''if''' (A[l]=l) '''then''' Rowny:=l
    '''end''';
   '''else''' Rowny:=0;
    Rowny:=(A[l]=l);
   '''end''';  
  '''end''';
  '''end''';
Dla tablic posortowanych niemalejąco to rozwiązanie nie działa.
Dla tablic posortowanych niemalejąco to rozwiązanie nie działa.
''Koszt czasowy'': logarytmiczny względem N
''Koszt pamięciowy'': stały
</div>
</div>
</div>
</div>


== Zadanie 5 (Maksimum w ciągu bitonicznym)==
== Zadanie 5 (Maksimum w ciągu bitonicznym)==
Dana jest tablica A typu array[1..N] of integer, w której wartości ułożone są w ciąg bitoniczny (czyli istnieje 1 &le; i &le; N, takie że dla wszystkich k < i zachodzi A[k] < A[k+1] a dla wszystkich k &ge; zachodzi A[k] > A[k+1]). Znajdź maksimum w tym ciągu.
Dana jest tablica A typu array[1..N] of integer, w której wartości ułożone są w ciąg bitoniczny (czyli istnieje 1 &le; i &le; N, takie że dla wszystkich k, takich że 1 \le; k < i zachodzi A[k] < A[k+1] a dla wszystkich k, takich że  i \le; k < N  zachodzi A[k] > A[k+1]). Znajdź maksimum w tym ciągu.


<div class="mw-collapsible mw-made=collapsible mw-collapsed">
<div class="mw-collapsible mw-made=collapsible mw-collapsed">
Linia 109: Linia 130:
'''Rozwiązanie 1'''   
'''Rozwiązanie 1'''   
<div class="mw-collapsible-content" style="display:none">
<div class="mw-collapsible-content" style="display:none">
  '''function''' Maks_bitoniczny(N,A):integer;
  '''function''' MaksBitoniczny(N:integer; A:array[1..N] of integer):integer;
  '''var''' p,l,s: integer;
  '''var''' p,l,s: integer;
  '''begin'''
  '''begin'''
   '''if''' N=1 '''then''' Maks_bitoniczny:=1  
   '''if''' N=1 '''then''' MaksBitoniczny:=1  
   '''else'''  
   '''else'''  
     '''if''' A[N-1] < A[N] '''then''' Maks_bitoniczny:=N  
     '''if''' A[N-1] < A[N] '''then''' MaksBitoniczny:=N  
     '''else''' '''begin'''
     '''else''' '''begin'''
       l:=1;
       l:=1;
Linia 123: Linia 144:
         '''else''' p:=s;
         '''else''' p:=s;
       '''end''';
       '''end''';
       Maks_bitoniczny:=l;
       MaksBitoniczny:=l;
     '''end''';   
     '''end''';   
  '''end''';
  '''end''';
''Koszt czasowy'': logarytmiczny względem N
''Koszt pamięciowy'': stały
</div>
</div>
</div>
</div>


== Zadanie 6 (Pierwiastek z x)==
== Zadanie 6 (Pierwiastek z x)==
Napisz program obliczający sufit z pierwiastka z x, dla x&epsilon;R, x > 0. (Oczywiście bez operacji pierwiastek; za to dostępna jest funkcja Sufit).
Napisz program obliczający sufit z pierwiastka z x, dla x&epsilon;N, x > 0 (oczywiście bez operacji pierwiastek).
<div class="mw-collapsible mw-made=collapsible mw-collapsed">
<div class="mw-collapsible mw-made=collapsible mw-collapsed">
'''Wskazówka 1'''   
'''Wskazówka 1'''   
Linia 139: Linia 163:
'''Rozwiązanie 1'''   
'''Rozwiązanie 1'''   
<div class="mw-collapsible-content" style="display:none">
<div class="mw-collapsible-content" style="display:none">
  '''function''' SufitPierwiastka1(x:Real):integer;
  '''function''' SufitZPierwiastka1(x:integer):integer;
  '''var''' i: integer;
  '''var''' i: integer;
  '''begin'''
  '''begin'''
   i:=1;  
   i:=1;  
   '''while''' i*i < x '''do''' i := i+1;
   '''while''' x > i*i '''do''' i := i+1;
   SufitPierwiastka1 := i;
   SufitPierwiastka1 := i;
  '''end''';
  '''end''';
''Koszt czasowy'': liniowy względem N
''Koszt pamięciowy'': stały
</div>
</div>
</div>
</div>
<div class="mw-collapsible mw-made=collapsible mw-collapsed">
<div class="mw-collapsible mw-made=collapsible mw-collapsed">
'''Wskazówka 2'''   
'''Wskazówka 2'''   
<div class="mw-collapsible-content" style="display:none">Oczywiście lepiej jest to zrobic binarnie. Szukamy takiej liczby całkowitej i z przedziału [1..Sufit(x)], że (i-1)*(i-1) < x &le;  i*i.  
<div class="mw-collapsible-content" style="display:none">Oczywiście lepiej jest to zrobic binarnie. Szukamy takiej liczby całkowitej i z przedziału [1..x], że (i-1)*(i-1) < x &le;  i*i.  
</div>
</div>
</div>
</div>
Linia 156: Linia 183:
'''Rozwiązanie 2'''   
'''Rozwiązanie 2'''   
<div class="mw-collapsible-content" style="display:none">
<div class="mw-collapsible-content" style="display:none">
  '''function''' SufitPierwiastka2(x:Real):integer;
  '''function''' SufitZPierwiastka2(x:Real):integer;
  '''var''' l,p,s : integer;
  '''var''' l,p,s : integer;
  '''begin'''
  '''begin'''
   l:=1;
   l:=1;
   p:=Sufit(x);
   p:=x;
   '''while''' l < p '''do''' '''begin'''
   '''while''' l < p '''do''' '''begin'''
     s:=(l+p)div 2;
     s:=(l+p)div 2;
     '''if''' s*s < x '''then''' l:=s+1;
     '''if''' x > s*s '''then''' l:=s+1;
     '''else''' p:=s;
     '''else''' p:=s;
   '''end''';
   '''end''';
   SufitPierwiastka2:=l;
   SufitPierwiastka2:=l;
  '''end''';
  '''end''';
''Koszt czasowy'': logarytmiczny względem N
''Koszt pamięciowy'': stały
</div>
</div>
</div>
</div>


== Zadanie 7 (Binpower)==
===Inna wersja zadania===
Dla zadanego x &epsilon; R i n &epsilon; N policz x<sup>n</sup> (oczywiscie bez exp i ln).
A jak znaleźć podłogę z pierwiastka z x ?
 
<div class="mw-collapsible mw-made=collapsible mw-collapsed">
'''Wskazówka 3''' 
<div class="mw-collapsible-content" style="display:none"> Analogicznie jak w Rozwiązaniu 2.
</div>
</div>
<div class="mw-collapsible mw-made=collapsible mw-collapsed">
'''Rozwiązanie 3''' 
<div class="mw-collapsible-content" style="display:none">
'''function''' PodlogaZPierwiastka(x:Real):integer;
'''var''' l,p,s : integer;
'''begin'''
  l:=1;
  p:=x;
  '''while''' l < p '''do''' '''begin'''
    s:=(l+p+1)div 2;
    '''if''' x < s*s '''then''' p:=s-1;
    '''else''' l:=s;
  '''end''';
  SufitPierwiastka2:=l;
'''end''';
Uwaga: porównaj różnice między Rozwiązaniami 2 i 3 oraz funkcjami ZnajdzPierwsze, ZnajdzOstatnie z Zadania 1 i 2.
''Koszt czasowy'': logarytmiczny względem N
 
''Koszt pamięciowy'': stały
</div>
</div>
== Zadanie 7 (BinPower)==
Dla zadanych x,n > 0 wyznacz x<sup>n</sup> (oczywiscie bez exp i ln).
<div class="mw-collapsible mw-made=collapsible mw-collapsed">
'''Wskazówka 1''' 
<div class="mw-collapsible-content" style="display:none">
Oczywiście nie chodzi o to by pomnożyć x przez siebie n-1 razy.
</div>
</div>
<div class="mw-collapsible mw-made=collapsible mw-collapsed">
<div class="mw-collapsible mw-made=collapsible mw-collapsed">
'''Rozwiązanie 1'''   
'''Rozwiązanie 1'''   
<div class="mw-collapsible-content" style="display:none">
<div class="mw-collapsible-content" style="display:none">
  '''function''' Binpower(N,A,x):integer;
  '''function''' BinPower(x,n:integer):integer;
  '''var''' z,y,i: integer;
  '''var''' z,y,i: integer;
  '''begin'''
  '''begin'''
Linia 187: Linia 253:
     i:=i div 2;
     i:=i div 2;
   '''end''';
   '''end''';
   Binpower:=z;
   BinPower:=z;
  '''end''';
  '''end''';
''Koszt czasowy'': logarytmiczny względem N
''Koszt pamięciowy'': stały
</div>
</div>
</div>
</div>
Linia 202: Linia 271:
'''Rozwiązanie 1'''   
'''Rozwiązanie 1'''   
<div class="mw-collapsible-content" style="display:none">
<div class="mw-collapsible-content" style="display:none">
  '''function''' Podciag_niemalejący(N,A):integer;
Zacznijmy od pomocniczej funkcji ZnajdźPierwszyWiększy(A:array[1..N] of integer; l,p,x:integer):integer, która w tablicy A, na odcinku od l do p, wyznacza indeks pierwszego elementu o wartości większej od x przy założeniu że A[p] > x.
  '''var''' : integer;
  '''function''' ZnajdzPierwszyWiekszy(A:array[1..N] of integer; l,p,x:integer):integer;
// zakładamy, że A[p] > x
'''var''' s: integer;
'''begin'''
  '''while''' l < p '''do''' '''begin'''
    s:=(l+p)div 2;
    '''if''' x+1 > A[s] '''then''' l:=s+1;
    '''else''' p:=s;
  '''end''';
  ZnajdźPierwszyWiększy:=l;
'''end''';
 
Albo ZnajdźOstatni(x)+1
 
Teraz funkcja MaxNiemalejący:
 
'''function''' MaxNiemalejący(N:integer; A:array[1..N] of integer):integer;
  '''var''' ia,ib,z: integer;
     B: array[1..N] of integer;
     B: array[1..N] of integer;
  '''begin'''
  '''begin'''
   ib:=1;
   ib:=1;
   B[ib]:=A[1];
   B[ib]:=A[1];  
   ia:=2;
   '''for''' ia:=2 '''to''' N '''do''' '''begin'''
  '''while''' ia <= N '''do''' '''begin'''
     '''if''' A[ia] >= B[ib] '''then''' '''begin'''
     '''if''' A[ia] >= B[ib] '''then''' '''begin'''
       ib:=ib+1;     
       ib:=ib+1;     
Linia 215: Linia 300:
     '''end'''
     '''end'''
     '''else''' '''begin'''  
     '''else''' '''begin'''  
       z:=ZnajdzPierwszyWiekszy(B,1,ib);
       z:=ZnajdzPierwszyWiekszy(B,1,ib,ia);
       B[z]:=A[ia];
       B[z]:=A[ia];
      '''if''' z = ib+1 '''then''' ib:=ib+1;
     '''end''';
     '''end''';
     ia:=ia+1;
     ia:=ia+1;
   '''end''';
   '''end''';
   Podciag_niemalejący:=ib;
   MaxNiemalejący:=ib;
  '''end''';
  '''end''';
Ponieważ dla każdego elementu A wykonujemy wyszukiwanie binarne w B to:
''Koszt czasowy'': O(N×logN)
''Koszt pamięciowy'': liniowy względem N
</div>
</div>
</div>
</div>

Wersja z 19:14, 17 lip 2006

To są zadania na wyszukiwanie binarne.

Zadanie 1 (Pierwsze wystąpienie x)

Dana jest posortowana niemalejąco tablica A typu array[1..N] of integer i x typu integer. Znajdź miejsce pierwszego wystąpienia x (lub 0 gdy nie ma żadnego x)

Rozwiązanie 1

Pytanko 1

Zadanie 2 (Ostatnie wystąpienie x)

Dana jest posortowana niemalejąco tablica A typu array[1..N] of integer i x typu integer. Znajdź miejsce ostatniego wystąpienia x (lub 0 gdy nie ma żadnego x)

Rozwiązanie 1

Pytanko 1

Zadanie 3 (Policz liczbę wystapień x)

Dana jest posortowana niemalejąco tablica A typu array[1..N] of integer i x typu integer. Wyznacz liczbę wystąpień x w tablicy A.

Wskazówka 1

Rozwiązanie 1

Zadanie 4 (Wartość równa indeksowi)

Dana jest posortowana rosnąco tablica A typu array[1..N] of integer. Sprawdź czy występuje w niej element o wartości równej swojemu indeksowi. Jeśli tak to wyznacz ten indeks, jeśli nie to funkcja ma dać wartość 0.

Wskazówka 1

Rozwiązanie 1

Zadanie 5 (Maksimum w ciągu bitonicznym)

Dana jest tablica A typu array[1..N] of integer, w której wartości ułożone są w ciąg bitoniczny (czyli istnieje 1 ≤ i ≤ N, takie że dla wszystkich k, takich że 1 \le; k < i zachodzi A[k] < A[k+1] a dla wszystkich k, takich że i \le; k < N zachodzi A[k] > A[k+1]). Znajdź maksimum w tym ciągu.

Wskazówka 1

Rozwiązanie 1

Zadanie 6 (Pierwiastek z x)

Napisz program obliczający sufit z pierwiastka z x, dla xεN, x > 0 (oczywiście bez operacji pierwiastek).

Wskazówka 1

Rozwiązanie 1

Wskazówka 2

Rozwiązanie 2

Inna wersja zadania

A jak znaleźć podłogę z pierwiastka z x ?

Wskazówka 3

Rozwiązanie 3

Zadanie 7 (BinPower)

Dla zadanych x,n > 0 wyznacz xn (oczywiscie bez exp i ln).

Wskazówka 1

Rozwiązanie 1

Zadanie 8 (Najdłuższy podciąg niemalejący)

Dana jest tablica A typu array[1..N] of integer, N > 1. Należy obliczyć długość najdłuższego podciągu niemalejącego w A.

Wskazówka 1

Rozwiązanie 1