Test GR: Różnice pomiędzy wersjami

Z Studia Informatyczne
Przejdź do nawigacjiPrzejdź do wyszukiwania
← poprzednia edycja
WizualnieWikikod
Rogoda (dyskusja | edycje)
1875 edycji
Nie podano opisu zmian
m Zastępowanie tekstu – „<math> ” na „<math>”
 
(Nie pokazano 45 wersji utworzonych przez 2 użytkowników)
Linia 8: Linia 8:




<quiz>
1111111111111111111111111111111111111111111
Wskaż, które z poniższych struktur są monoidami:


<rightoption reply="Dobrze"><math>\displaystyle (\mathds{Z}_{mod\ 2}, \cdot)</math></rightoption>
<wrongoption reply="Źle"><math>\displaystyle (\mathds{N}_1, +)</math>, gdzie <math>\displaystyle \mathds{N}_1=\{1,2,3,...\}</math></wrongoption>
<wrongoption reply="Źle"><math>\displaystyle (\mathds{N}_p,+)</math>, gdzie <math>\displaystyle \mathds{N}_p</math> jest zbiorem wszystkich liczb pierwszych</wrongoption>
<rightoption reply="Dobrze"><math>\displaystyle (\mathds{R}, \cdot)</math></rightoption>
<rightoption reply="Dobrze"><math>\displaystyle (\mathds{Z}, +)</math></rightoption>
</quiz>




<quiz>
1111111111111111111111111111111111111111111
Wskaż stwierdzenia prawdziwe:


<wrongoption reply="Źle"><math>\displaystyle abbaaa \in \{aa,bb\}^*</math></wrongoption>


<rightoption reply="Dobrze"><math>\displaystyle abbaaa \in \{a,b\}^*</math></rightoption>


<rightoption reply="Dobrze"><math>\displaystyle abbaaa \in \{abb,a\}^*</math></rightoption>
22222222222222222222222222222222222222222


<wrongoption reply="Źle"><math>\displaystyle abbaaa \in \{ba, ab\}^*</math></wrongoption>
==Ciągi w przestrzeniach metrycznych. Test==


<rightoption reply="Dobrze"><math>\displaystyle abbaaa \in \{aa, ab, ba\}^*</math></rightoption>
</quiz>


3333333333333333333333333333333333333333333333333333333333333


==Norma. Iloczyn skalarny. Test==


{{cwiczenie|Homomorfizmy||


<br>
444444444444444444444444444444444444444444444444444444444444444
Wskaż, które z poniższych odwzorowań są homomorfizmami:


; a.
==Ciągi i szeregi funkcyjne. Szereg Taylora. Test==
:  <math>\displaystyle h: (\mathds{R},+) \rightarrow (\mathds{Z},+)</math>, <math>\displaystyle h(x)=3x</math>


; b.
<quiz>
:  <math>\displaystyle h: (\mathds{R},+) \rightarrow (\mathds{R},+)</math>, <math>\displaystyle h(x)=3x</math>
Dany jest ciąg funkcyjny <math>\{f_n\}</math> gdzie
 
<math>
; c.
  f_n(x)=
:  <math>\displaystyle h: (\mathds{R}, \cdot) \rightarrow (\mathds{R}, \cdot)</math>,
  \left\{
<math>\displaystyle h(x)=3x</math>
  \begin{array} {lll}
 
  1 & \text{dla} & x\in[n,n+1]\\
; d.
   0 & \text{dla} & x\in \mathbb{R}\setminus[n,n+1]
:  <math>\displaystyle h: \{a,b\}^* \rightarrow \{a,b\}^*</math>, <math>\displaystyle h(a)=a^2</math>,
   \end{array}  
<math>\displaystyle h(b)=ab^2</math>
   \right</math>
 
dla <math>n\in\mathbb{N}</math>
; e.
Ciąg ten jest
:  <math>\displaystyle h: \{a,b\}^* \rightarrow (\mathds{Z},+)</math>, <math>\displaystyle h(a)=1</math>,
<rightoption>zbieżny punktowo do <math>f(x)\equiv 0</math></rightoption>
<math>\displaystyle h(b)=1</math>
<wrongoption>zbieżny jednostajnie do <math>f(x)\equiv 0</math></wrongoption>
<wrongoption>zbieżny punktowo do funkcji <math>f(x)=
}}
   \left\{
 
  \begin{array} {lll}
<div class="mw-collapsible mw-made=collapsible mw-collapsed"><span class="mw-collapsible-toogle mw-collapsible-toogle-default style="font-variant:small-caps">Rozwiązanie </span><div class="mw-collapsible-content" style="display:none"> 
    1 & \text{dla} & x\geq 1\\
b, d, e
    0 & \text{dla} & x<0
</div></div>
  \end{array}  
 
  \right</math></wrongoption>
{{cwiczenie|System przepisujący||
 
<br>
Dany niech będzie system przepisujący <math>\displaystyle RS=(\{a,b,c\},
\{(a,b),(b,c),(b,a),(cc,b))</math> oraz niech <math>\displaystyle I=\{ccb\}</math>. Wskaż
stwierdzenia prawdziwe:
 
; a.
:  <math>\displaystyle abc \in L_{gen}(RS, I)</math>  
 
; b.
:  <math>\displaystyle ccb \in L_{gen}(RS, I)</math>
 
; c.
:  <math>\displaystyle bb \in L_{gen}(RS, I)</math>
 
; d.
:  <math>\displaystyle aab \in L_{gen}(RS, I)</math>
 
; e.
:  <math>\displaystyle aa \in L_{gen}(RS, I)</math>
}}
 
<div class="mw-collapsible mw-made=collapsible mw-collapsed"><span class="mw-collapsible-toogle mw-collapsible-toogle-default style="font-variant:small-caps">Rozwiązanie </span><div class="mw-collapsible-content" style="display:none"> 
b, c, e
</div></div>
 
{{cwiczenie|Wyrażenie regularne||
 
<br>
Wyrażenie regularne
<center><math>\displaystyle ((aa+bb)^*(ab+ba)(aa+bb)^*(ab+ba))^*(aa+bb)^*</math></center>
reprezentuje
język:
; a.
:  <math>\displaystyle \{w \in \{a,b\}^*:\ \sharp_aw = 2k</math>, <math>\displaystyle \sharp_bw = 2l</math>,
<math>\displaystyle k,l >0\}</math>
 
; b.
:  <math>\displaystyle \{w \in \{a,b\}^*:\ \sharp_aw - \sharp_bw = 0 (mod 2)\}</math>
 
; c.
:  <math>\displaystyle \{w \in \{a,b\}^*:\ \sharp_aw = \sharp_bw = 2k, k \geq
0\}</math>
 
; d.
:  <math>\displaystyle \{w \in \{a,b\}^*:\ \sharp_aw - \sharp_bw = 1 (mod 2)\}</math>
 
; e.
:  <math>\displaystyle \{w \in \{a,b\}^*: \sharp_aw = 4k</math>, <math>\displaystyle \sharp_bw = 4l</math>, <math>\displaystyle k,
l \geq 0\}</math>
}}
 
<div class="mw-collapsible mw-made=collapsible mw-collapsed"><span class="mw-collapsible-toogle mw-collapsible-toogle-default style="font-variant:small-caps">Rozwiązanie </span><div class="mw-collapsible-content" style="display:none"> 
a
</div></div>
 
{{cwiczenie|Język regularny||
 
<br>
Niech <math>\displaystyle A=\{a,b\}</math> oraz <math>\displaystyle L=aA^*a</math>. Wskaż zdania prawdziwe:
 
; a.
:  minimalny automat akceptujący <math>\displaystyle L</math> ma 5 stanów
 
; b.
:  ilość klas równoważności prawej kongruencji syntaktycznej
<math>\displaystyle P_L^r</math> wyznaczonej przez <math>\displaystyle L</math> jest równa 4
 
; c.
:  <math>\displaystyle A^* \backslash L = bA^*b + b</math>
 
; d.
:  <math>\displaystyle A^* \backslash L = bA^*+aA^*b+a+1</math>
 
; e.
:  monoid przejśc minimalnego automatu akceptującego <math>\displaystyle L</math> ma 6
elementów
}}
 
<div class="mw-collapsible mw-made=collapsible mw-collapsed"><span class="mw-collapsible-toogle mw-collapsible-toogle-default style="font-variant:small-caps">Rozwiązanie </span><div class="mw-collapsible-content" style="display:none"> 
b, d, e
</div></div>
 
{{cwiczenie|Język regularny a automat||
 
<br>
Niech <math>\displaystyle L</math> będzie dowolnym językiem regularnym. Wskaż zdania
prawdziwe:
 
; a.
:  <math>\displaystyle L</math> jest rozpoznawany przez pewien niedeterministyczny
automat skończenie stanowy z pustymi przejściami
 
; b.
:  <math>\displaystyle L</math> jest rozpoznawany przez automat deterministyczny
skończenie stanowy
 
; c.
:  <math>\displaystyle L</math> jest rozpoznawany przez niedeterministyczny automat
z pustymi przejściami o jednoelementowym zbiorze stanów początkowych
 
; d.
:  Nie istnieje automat niedeterministyczny z pustymi
przejściami rozpoznający <math>\displaystyle L</math> i taki, że zbiór stanów początkowych
jest jednoelementowy
 
; e.
:  Nie istnieje gramatyka lewoliniowa generująca <math>\displaystyle L</math>
}}
 
<div class="mw-collapsible mw-made=collapsible mw-collapsed"><span class="mw-collapsible-toogle mw-collapsible-toogle-default style="font-variant:small-caps">Rozwiązanie </span><div class="mw-collapsible-content" style="display:none"> 
a, b, c
</div></div>
 
{{cwiczenie|Język regularny a automat||
 
<br>
Niech <math>\displaystyle L_1</math>, <math>\displaystyle L_2</math> będą językami rozpoznawanymi odpowiednio przez
automaty o <math>\displaystyle n_1</math> i <math>\displaystyle n_2</math> stanach. Aby stwierdzić, dla dowolnego
słowa <math>\displaystyle w</math>, czy jest ono rozpoznawane przez oba automaty, wystarczy
skonstruować odpowiedni automat mający
 
; a.
:  <math>\displaystyle n_1 \cdot n_2</math> stanów
 
; b.
:  <math>\displaystyle O(n_1+n_2)</math> stanów
 
; c.
:  <math>\displaystyle n_1</math> stanów
 
; d.
:  <math>\displaystyle n_2</math> stanów
 
; e.
:  3 stany
}}
 
<div class="mw-collapsible mw-made=collapsible mw-collapsed"><span class="mw-collapsible-toogle mw-collapsible-toogle-default style="font-variant:small-caps">Rozwiązanie </span><div class="mw-collapsible-content" style="display:none"> 
a, b
</div></div>
 
{{cwiczenie|Wyrażenia regularne||
 
<br>
Język <math>\displaystyle L</math> składa się ze wszystkich słów nad alfabetem <math>\displaystyle A=\{a,b\}</math>
nie zawierających podsłowa <math>\displaystyle a^3</math>. Wskaż wyrażenie regularne
reprezentujące <math>\displaystyle L</math>:
 
; a.
:  <math>\displaystyle (b^*(1+a+aa)b^*)^*</math>
 
; b.
:  <math>\displaystyle (b^*(1+a+aa)bb^*)^*</math>
 
; c.
:  <math>\displaystyle (b+ab+aab)^*+(b+ab+aab)^*a+(b+ab+aab)^*aa</math>
 
; d.
:  <math>\displaystyle ((1+a+aa)bb^*)^*(1+a+aa)</math>
 
; e.
:  <math>\displaystyle b^*(a+aa)bb^*)^*(1+a+aa)</math>
}}
 
<div class="mw-collapsible mw-made=collapsible mw-collapsed"><span class="mw-collapsible-toogle mw-collapsible-toogle-default style="font-variant:small-caps">Rozwiązanie </span><div class="mw-collapsible-content" style="display:none"> 
c, d, e
</div></div>
 
{{cwiczenie|Języki regularne - warunki równoważne||
 
<br>
Wskaż warunki równoważne temu, by język <math>\displaystyle L</math> był akceptowany przez
automat skończenie stanowy:
; a.
:  Istnieje liczba naturalna <math>\displaystyle N \geq 1</math> taka, że każde słowo
<math>\displaystyle w \in L</math> o długości <math>\displaystyle |w| \geq N</math> można przedstawić jako katenację
<math>\displaystyle w = v_1uv_2</math>, gdzie <math>\displaystyle v_1, v_2 \in A^*</math>, <math>\displaystyle u \in A^+</math> oraz <math>\displaystyle v_1u^*v_2
\subset L</math>.
 
; b.
:  Istnieje skończony monoid <math>\displaystyle M</math> i homomorfizm <math>\displaystyle \phi: A^*
\rightarrow M</math> taki, że <math>\displaystyle \phi^{-1}(\phi(L)) = L</math>.
 
; c.
:  <math>\displaystyle L</math> jest sumą wybranych klas równoważności pewnej
kongruencji <math>\displaystyle \rho</math> na <math>\displaystyle A^*</math>: <center><math>\displaystyle L = \cup_{w \in L}[w]_\rho.</math></center>
 
; d.
:  <math>\displaystyle L \in \mathcal{REG}(A^*)</math>.
 
; e.
:  <math>\displaystyle L</math> jest akceptowany przez deterministyczny automat
skończenie stanowy z jednym stanem końcowym.
}}
 
<div class="mw-collapsible mw-made=collapsible mw-collapsed"><span class="mw-collapsible-toogle mw-collapsible-toogle-default style="font-variant:small-caps">Rozwiązanie </span><div class="mw-collapsible-content" style="display:none"> 
b,d
</div></div>
 
{{cwiczenie|Automat skończenie stanowy||
 
<br>
Automat <math>\displaystyle \mathcal{A}=(S, A, s_0, f, F)</math>, gdzie <math>\displaystyle S=\{s_0, s_1, s_2,
s_3\}</math>, <math>\displaystyle A=\{a,b\}</math>, <math>\displaystyle F=\{s_1\}</math>, {
 
{| border=1
|+ <span style="font-variant:small-caps">Uzupelnij tytul</span>
|-
|  <math>\displaystyle f</math>  ||  <math>\displaystyle s_0</math>  ||  <math>\displaystyle s_1</math>  ||  <math>\displaystyle s_2</math>  || 
<math>\displaystyle s_3</math>
|-
|   <math>\displaystyle a</math>  ||  <math>\displaystyle s_1</math>  ||  <math>\displaystyle s_0</math>  ||  <math>\displaystyle s_3</math>  ||  <math>\displaystyle s_2</math>
|-
|  <math>\displaystyle b</math>  ||  <math>\displaystyle s_3</math>  ||  <math>\displaystyle s_2</math>  ||  <math>\displaystyle s_1</math> ||  <math>\displaystyle s_0</math>
|-
|
 
|}
 
}
 
; a.
:  jest automatem minimalnym
 
; b.
:  rozpoznaje język <math>\displaystyle \{w \in \{a,b\}^*:\ \sharp_aw = 2k,
\sharp_bw = 2l+1</math>, <math>\displaystyle k,l \geq 0\}</math>
 
; c.
:  rozpoznaje język <math>\displaystyle \{w \in \{a,b\}^*:\ \sharp_aw = 2k,
\sharp_bw = 2l</math>, <math>\displaystyle k,l \geq 0\}</math>
 
; d.
:  rozpoznaje język <math>\displaystyle \{w \in \{a,b\}^*:\ \sharp_aw = 2k+1,
\sharp_bw = 2l</math>, <math>\displaystyle k,l \geq 0\}</math>
 
; e.
:  rozpoznaje język <math>\displaystyle \{w \in \{a,b\}^*:\ \sharp_aw = 2k+1,
\sharp_bw = 2l+1</math>, <math>\displaystyle k,l \geq 0\}</math>
 
}}
 
<div class="mw-collapsible mw-made=collapsible mw-collapsed"><span class="mw-collapsible-toogle mw-collapsible-toogle-default style="font-variant:small-caps">Rozwiązanie </span><div class="mw-collapsible-content" style="display:none"> 
a,d
</div></div>
 
{{cwiczenie|Równość wyrażeń regularnych||
 
<br>
Które z poniższych równości dla wyrażeń regularnych są prawdziwe?
; a.
:  <math>\displaystyle r^*r^*=r^*</math>
 
; b.
:  <math>\displaystyle (r+s)^*=r^*+s^*</math>
 
; c.
:  <math>\displaystyle (r^*+s^*)^*=(r^*s^*)^*</math>
 
; d.
:  <math>\displaystyle r+r=r</math>
 
; e.
:  <math>\displaystyle (rs)^*r=r(sr)^*</math>
 
}}
 
<div class="mw-collapsible mw-made=collapsible mw-collapsed"><span class="mw-collapsible-toogle mw-collapsible-toogle-default style="font-variant:small-caps">Rozwiązanie </span><div class="mw-collapsible-content" style="display:none"> 
a,c,d,e
</div></div>
 
{{cwiczenie|Języki regularne||
 
<br>
Wskaż języki regularne:
; a.
:  <math>\displaystyle \{w \in \{a,b\}^*:\ \sharp_aw = \sharp_bw\ (mod\ 3)\}</math>
 
; b.
:  <math>\displaystyle \{w \in \{a,b\}^*:\ \sharp_aw = \sharp_bw\}</math>
 
; c.
:  <math>\displaystyle \{w \in \{a,b\}^*:\ |w|=2^n, n > 0\}</math>
 
; d.
:  <math>\displaystyle \{w \in \{a,b\}^*:\ \sharp_aw \cdot \sharp_bw = 100\}</math>
 
; e.
:  <math>\displaystyle \{a^n:\ n=3k  </math>  lub  <math>\displaystyle   n=5k,\ k \geq 0\}</math>
 
}}
 
<div class="mw-collapsible mw-made=collapsible mw-collapsed"><span class="mw-collapsible-toogle mw-collapsible-toogle-default style="font-variant:small-caps">Rozwiązanie </span><div class="mw-collapsible-content" style="display:none"> 
a,d,e
</div></div>
 
{{cwiczenie|Automat skończenie stanowy||
 
<br>
Dany jest automat <math>\displaystyle \mathcal{A}=(S, A, s_0, f, F)</math>, gdzie
<math>\displaystyle S=\{s_0,s_1,s_2\}</math>, <math>\displaystyle A=\{a,b\}</math>, <math>\displaystyle F=\{s_0,s_1\}</math>,<br>
 
{
 
{| border=1
|+ <span style="font-variant:small-caps">Uzupelnij tytul</span>
|-
|  <math>\displaystyle f</math>  ||  <math>\displaystyle s_0</math>  ||  <math>\displaystyle s_1</math>  ||  <math>\displaystyle s_2</math>
|-
|   <math>\displaystyle a</math> ||  <math>\displaystyle s_1</math>  ||  <math>\displaystyle s_0</math>  ||  <math>\displaystyle s_2</math>
|-
|  <math>\displaystyle b</math>  ||  <math>\displaystyle s_0</math>  ||  <math>\displaystyle s_2</math>  ||  <math>\displaystyle s_2</math>
|-
|
 
|}
 
}
Wskaż zdania prawdziwe:
 
; a.
:  <math>\displaystyle L(\mathcal{A})=(a^2+b)^*(a+1)</math>.
 
; b.
:  Równoważny automat minimalny ma 2 stany.
 
; c.
:  Jeśli <math>\displaystyle w \in L(\mathcal{A})</math>, to dla każdych <math>\displaystyle v,u \in A^*</math> takich, że
<math>\displaystyle w=vbu</math> zachodzi <math>\displaystyle \sharp_av = 2k</math> dla pewnego <math>\displaystyle k \geq 0</math>.
 
; d.
:  <math>\displaystyle a^*b^* \subset L(\mathcal{A})</math>.
 
; e.
:  Jeśli <math>\displaystyle w \in L(\mathcal{A})</math>, to <math>\displaystyle a^2b</math> jest podsłowem
słowa <math>\displaystyle w</math>.
 
}}
 
<div class="mw-collapsible mw-made=collapsible mw-collapsed"><span class="mw-collapsible-toogle mw-collapsible-toogle-default style="font-variant:small-caps">Rozwiązanie </span><div class="mw-collapsible-content" style="display:none"> 
a,c
</div></div>
 
{{cwiczenie|Automat niedeterministyczny||
 
<br>
Dany niech będzie automat niedeterministyczny <math>\displaystyle \mathcal{A}_{ND}=(Q,
A, \{q_0\}, f, F)</math>, gdzie <math>\displaystyle Q=\{q_0, q_1, q_2\}</math>, <math>\displaystyle A=\{a,b\}</math>,
<math>\displaystyle F=\{q_2\}</math>,<br>
 
{
 
{| border=1
|+ <span style="font-variant:small-caps">Uzupelnij tytul</span>
|-
| <math>\displaystyle f</math>  ||  <math>\displaystyle q_0</math>  ||  <math>\displaystyle q_1</math>  ||  <math>\displaystyle q_2</math>
|-
|  <math>\displaystyle a</math>  ||  <math>\displaystyle \{q_1\}</math>  ||  <math>\displaystyle \{q_0,q_2\}</math>  ||  <math>\displaystyle \{q_2\}</math>
|-
|  <math>\displaystyle b</math>  ||  <math>\displaystyle \emptyset</math>  ||  <math>\displaystyle \emptyset</math>  ||  <math>\displaystyle \{q_1\}</math>
|-
|
 
|}
 
}
Wskaż zdania prawdziwe:
; a.
:  <math>\displaystyle L(\mathcal{A}_{ND})=a^2(a+ba)^*</math>.
 
; b.
:  <math>\displaystyle L(\mathcal{A}_{ND})=a(aa^*b)^*aa^*</math>.
 
; c.
:  Równoważny automat deterministyczny posiada 3 stany.
 
; d.
:  <math>\displaystyle L(\mathcal{A}_{ND})=a^2(a^*b)^*aa^*</math>.
 
; e.
:  Równoważny minimalny automat deterministyczny posiada 4 stany.
 
}}
 
<div class="mw-collapsible mw-made=collapsible mw-collapsed"><span class="mw-collapsible-toogle mw-collapsible-toogle-default style="font-variant:small-caps">Rozwiązanie </span><div class="mw-collapsible-content" style="display:none"> 
a,b,e
</div></div>
 
{{cwiczenie|Równość <math>\displaystyle \mathcal{REC}(A^*)=\mathcal{REG}(A^*)</math>||
 
<br>
Twierdzenie orzekające o równości zachodzącej pomiędzy rodziną
języków regularnych a rodziną języków rozpoznawanych przez automaty
o skończonej liczbie stanów znane jest jako:
; a.
:  twierdzenie Nerode'a
 
; b.
:  teza Churcha
 
; c.
:  lemat Ardena
 
; d.
:  lemat o pompowaniu
 
; e.
:  twierdzenie Kleene'ego
 
}}
 
<div class="mw-collapsible mw-made=collapsible mw-collapsed"><span class="mw-collapsible-toogle mw-collapsible-toogle-default style="font-variant:small-caps">Rozwiązanie </span><div class="mw-collapsible-content" style="display:none"> 
e
</div></div>
 
{{cwiczenie|Monoid przejść||
 
<br>
Wskaż monoid przejść automatu o następującej funkcji przejścia: <br>
 
{
 
{| border=1
|+ <span style="font-variant:small-caps">Uzupelnij tytul</span>
|-
|  <math>\displaystyle f</math>  ||  <math>\displaystyle s_0</math>  ||  <math>\displaystyle s_1</math>  ||  <math>\displaystyle s_2</math>  ||  <math>\displaystyle s_3</math>
|-
|   <math>\displaystyle a</math>  ||  <math>\displaystyle s_1</math>  ||  <math>\displaystyle s_0</math>  ||  <math>\displaystyle s_3</math>  ||  <math>\displaystyle s_2</math>
|-
|  <math>\displaystyle b</math>  ||  <math>\displaystyle s_3</math>  ||  <math>\displaystyle s_2</math>  ||  <math>\displaystyle s_1</math>  ||  <math>\displaystyle s_0</math>
|-
|
 
|}
 
}
 
; a.
:  <math>\displaystyle (\{\tau_{\mathcal{A}}(1),\tau_{\mathcal{A}}(a),\tau_{\mathcal{A}}(b),\tau_{\mathcal{A}}(ab)\},
\circ)</math>
 
; b.
:  <math>\displaystyle (\{\tau_{\mathcal{A}}(1),\tau_{\mathcal{A}}(a)\},\circ)</math>
 
; c.
:  <math>\displaystyle (\{\tau_{\mathcal{A}}(1),\tau_{\mathcal{A}}(a),\tau_{\mathcal{A}}(ab)\},\circ)</math>
 
; d.
:  <math>\displaystyle (\{\tau_{\mathcal{A}}(1),\tau_{\mathcal{A}}(a),\tau_{\mathcal{A}}(b)\},\circ)</math>
 
; e.
:  <math>\displaystyle (\{\tau_{\mathcal{A}}(a),\tau_{\mathcal{A}}(b),\tau_{\mathcal{A}}(ab),\tau_{\mathcal{A}}(ba)\},
\circ)</math>
 
}}
 
<div class="mw-collapsible mw-made=collapsible mw-collapsed"><span class="mw-collapsible-toogle mw-collapsible-toogle-default style="font-variant:small-caps">Rozwiązanie </span><div class="mw-collapsible-content" style="display:none"> 
a
</div></div>
 
{{cwiczenie|Problemy rozstrzygalne||
 
<br>
Niech <math>\displaystyle L_1,L_2</math> będą językami regularnymi. Wskaż problemy
rozstrzygalne.
; a.
:  <math>\displaystyle w \in L_1</math>
 
; b.
:  <math>\displaystyle w \in L_1 \cap L_2</math>
 
; c.
:  <math>\displaystyle L_1 \cap L_2 = \emptyset</math>
 
; d.
:  nieskończoność <math>\displaystyle L_1</math>
 
; e.
:  <math>\displaystyle L_1 = \emptyset</math>
 
}}
 
<div class="mw-collapsible mw-made=collapsible mw-collapsed"><span class="mw-collapsible-toogle mw-collapsible-toogle-default style="font-variant:small-caps">Rozwiązanie </span><div class="mw-collapsible-content" style="display:none"> 
a,b,c,d,e
</div></div>
 
{{cwiczenie|Algorytm determinizacji automatu||
 
<br>
Algorytm determinizacji automatu:
; a.
:  jest deterministyczny
 
; b.
:  działa w czasie wielomianowym
 
; c.
:  może się zapętlić
 
; d.
:  działa w czasie eksponencjalnym
 
; e.
:  kończy działanie błędem, jeśli na wejściu podany został
automat deterministyczny
}}
 
<div class="mw-collapsible mw-made=collapsible mw-collapsed"><span class="mw-collapsible-toogle mw-collapsible-toogle-default style="font-variant:small-caps">Rozwiązanie </span><div class="mw-collapsible-content" style="display:none"> 
a, d
</div></div>
 
{{cwiczenie|Algorytmy minimalizacji automatu||
 
<br>
Wskaż zdania prawdziwe:
; a.
:  istnieje algorytm minimalizacji automatu działający w
czasie <math>\displaystyle n\log n</math>
 
; b.
:  żaden algorytm minimalizacji nie może działać szybciej niż
w czasie <math>\displaystyle O(n^2)</math>
 
; c.
:  algorytm minimalizacji zawsze zwróci automat o mniejszej
liczbie stanów niż automat podany na wejściu
 
; d.
:  algorytmy minimalizacji są algorytmami
niedeterministycznymi
 
; e.
:  algorytmy minimalizacji nie działają dla automatów
jednostanowych
}}
 
<div class="mw-collapsible mw-made=collapsible mw-collapsed"><span class="mw-collapsible-toogle mw-collapsible-toogle-default style="font-variant:small-caps">Rozwiązanie </span><div class="mw-collapsible-content" style="display:none"> 
a
</div></div>
 
 
 
 
 
 
-------------------------------
 
Test 11
<quiz type="exclusive">
Deklaracja data Nat = Zero | Nast Nat
<wrongoption reply="Źle">deklaruje Zero jako element istniejącego wcześniej typu Nat</wrongoption>
<wrongoption reply="Źle">deklaruje Nast jako funkcję działającą na istniejącym wcześniej typie Nat</wrongoption>
<rightoption reply="Dobrze">tworzy nowy typ o nazwie Nat; do typu tego należy m.in. element Zero</rightoption>
<wrongoption reply="Źle">jest niepoprawna</wrongoption>
</quiz>
</quiz>


<quiz type="exclusive">
  tak, nie, nie
Dla liczb naturalnych zdefiniowanych jak powyżej dodawanie f można
określić pisząc f (x, Zero) \= x oraz:
<wrongoption reply="Źle">f (x, Nast y) \= f (Nast x, y)</wrongoption>
<rightoption reply="Dobrze">f (x, Nast y) \= Nast (f (x, y))</rightoption>
<wrongoption reply="Źle">f (Nast x, Nast y) \= Nast (f (x, y))</wrongoption>
<wrongoption reply="Źle">f (Nast x, y) \= Nast (f (x, y))</wrongoption>
</quiz>


<quiz type="exclusive">
<quiz>
Załóżmy, że mamy już zdefiniowane dodawanie liczb naturalnych f.
Dany jest ciąg funkcyjny <math>\{f_n\}</math> gdzie
Która z poniższych definicji poprawnie zdefiniuje operator dodawania liczb naturalnych w typowej dla Haskella postaci rozwiniętej? Pomijamy kwestię sygnatury.
<wrongoption reply="Źle">+ \= curry f</wrongoption>
<wrongoption reply="Źle">+ \= f</wrongoption>
<rightoption reply="Dobrze">(+) \= curry f</rightoption>
<wrongoption reply="Źle">(+) \= f</wrongoption>
</quiz>
 
<quiz type="exclusive">
Która definicja poprawnie określi funkcję f pobierającą pierwszy element
pary? Pomijamy kwestię sygnatury.
<wrongoption reply="Źle">f x y \= x</wrongoption>
<rightoption reply="Dobrze">f (x, y) \= x</rightoption>
<wrongoption reply="Źle">(f) x y \= x</wrongoption>
<wrongoption reply="Źle">(f) (x, y) \= x</wrongoption>
</quiz>


<quiz type="exclusive">
<center><math>f_n(x)=
Która lista jest niepoprawna?
  \left\{
<wrongoption reply="Źle">[1, 2, 3]</wrongoption>
  \begin{array} {lll}
<rightoption reply="Dobrze">[1, [2]]</rightoption>
\frac{1-n^{-x}}{1+n^{-x}} & \text{dla} & x>0\\
<wrongoption reply="Źle">[[1, 2, 3], [4, 5], [6]]</wrongoption>
  \\
<wrongoption reply="Źle">[[], []]</wrongoption>
\frac{2-n^{x}}{2+n^{x}} & \text{dla} & x<0\\
</quiz>
  \\
  0 & \text{dla} & x=0\\
  \end{array}
  \right.
  \quad</math> dla <math>\ n=1,2,\ldots
</math></center>


<quiz type="exclusive">
Ten ciąg funkcyjny jest
Operator ++ służy w Haskellu do:
<wrongoption>zbieżny jednostajnie</wrongoption>
<rightoption reply="Dobrze">łączenia list</rightoption>
<rightoption>zbieżny punktowo ale nie jednostajnie</rightoption>
<wrongoption reply="Źle">obliczania długości listy</wrongoption>
<wrongoption>rozbieżny</wrongoption>
<wrongoption reply="Źle">odwracania listy</wrongoption>
<wrongoption reply="Źle">nie ma takiego operatora</wrongoption>
</quiz>
</quiz>


<quiz type="exclusive">
  nie, tak, nie
Wyrażenie map (+1) [1, 2, 3] daje w wyniku:
<wrongoption reply="Źle">liczbę 4</wrongoption>
<wrongoption reply="Źle">liczbę 6</wrongoption>
<rightoption reply="Dobrze">listę [2, 3, 4]</rightoption>
<wrongoption reply="Źle">to wyrażenie jest niepoprawne</wrongoption>
</quiz>


<quiz type="exclusive">
<quiz>
Wyrażenie filter (<0) [–1, 0, 1, -2] daje w wyniku:
Dany jest ciąg funkcyjny <math>f_n(x)=\sqrt[n]{x}</math> dla <math>x\ge 0</math> Ten ciąg
<wrongoption reply="Źle">liczbę -1</wrongoption>
<wrongoption>jest zbieżny punktowo i jego granica jest ciągła</wrongoption>
<rightoption reply="Dobrze">listę [-1, -2]</rightoption>
<wrongoption>jest zbieżny jednostajnie i jego granica jest ciągła</wrongoption>
<wrongoption reply="Źle">listę [0, 1]</wrongoption>
<rightoption>jest zbieżny punktowo i jego granica nie jest ciągła</rightoption>
<wrongoption reply="Źle">to wyrażenie jest niepoprawne</wrongoption>
</quiz>
</quiz>


<quiz type="exclusive">
  nie, nie, tak
Wyrażenie [(x, y) | x <- [1..4], y <- [1..3]] wytworzy:
<wrongoption reply="Źle">listę o długości 4</wrongoption>
<rightoption reply="Dobrze">listę o długości 12</rightoption>
<wrongoption reply="Źle">parę liczb całkowitych (4, 3)</wrongoption>
<wrongoption reply="Źle">to wyrażenie jest niepoprawne</wrongoption>
</quiz>


<quiz type="exclusive">
<quiz>
Wyrażenie [x + y | x <- [1..3], y <- [1..3]] wytworzy:
Dany jest szereg <math>\sum_{n=1}^{\infty}\frac{\sin nx}{2^n(x^2+1)}, \ x\in \mathbb{R}</math> Ten szereg jest
<wrongoption reply="Źle">liczbę 6</wrongoption>
<wrongoption>zbieżny jednostajnie do funkcji <math>f(x)\equiv 0</math></wrongoption>
<wrongoption reply="Źle">listę o długości 5</wrongoption>
<rightoption>zbieżny jednostajnie do funkcji <math>f</math> takiej, że <math>0<f(x)<3</math></rightoption>
<rightoption reply="Dobrze">listę o długości 9</rightoption>
<wrongoption>zbieżny jednostajnie do funkcji <math>f(x)=\frac{1}{2(x^2+1)}</math></wrongoption>
<wrongoption reply="Źle">to wyrażenie jest niepoprawne</wrongoption>
</quiz>
</quiz>


  nie, tak, nie


 
<quiz>
 
Funkcja <math>
 
    f(x):=\sum_{n=1}^{\infty}\frac{\sqrt[n]{x}}{n(n+1)(x^2+1)}</math>
 
Granica <math>\lim_{x\to 3}f(x)</math> wynosi
 
<rightoption><math>\frac{1}{10}</math></rightoption>
 
<wrongoption><math>\sqrt{3}</math></wrongoption>
 
<wrongoption><math>0</math></wrongoption>
 
 
 
Test 9
<quiz type="exclusive">
Rachunek sigma opisuje obiekty na poziomie abstrakcji podobnym do tego,
na którym funkcje są opisywane przez:
  <wrongoption reply =  „Źle”> języki wysokiego poziomu, np. Pascal, C, Java </wrongoption>
  <rightoption reply="Dobrze"> rachunek lambda </rightoption>
  <wrongoption reply="Źle"> teorię mnogości </wrongoption>
  <wrongoption reply="Źle"> rachunek sigma w ogóle nie zajmuje się obiektami </wrongoption>
</quiz>
</quiz>


<quiz type="exclusive">
  tak, nie, nie
Podobnie jak w rachunku sigma, obiekty bez klas pojawiają się w języku:
  <wrongoption reply="Źle"> C++</wrongoption>
  <wrongoption reply="Źle"> C</wrongoption>
  <wrongoption reply="Źle"> Java </wrongoption>
  <rightoption reply="Dobrze"> JavaScript </rightoption>
</quiz>


<quiz type="exclusive">
<quiz>
Która relacja nie pasuje do pozostałych w kontekście języka C++?
Szereg <math>\sum_{n=1}^{\infty}\frac{1}{n(x^4+4)}</math> jest
  <wrongoption reply="Źle"> relacja dziedziczenia </wrongoption>
<wrongoption>zbieżny punktowo</wrongoption>
  <wrongoption reply="Źle"> relacja podklasy </wrongoption>
<wrongoption>zbieżny jednostajnie </wrongoption>
  <wrongoption reply="Źle"> relacja podtypu </wrongoption>
<rightoption>rozbieżny</rightoption>
  <rightoption reply="Dobrze"> relacja zawierania bloków kodu </rightoption>
</quiz>
</quiz>


<quiz type="exclusive">
  nie, nie, tak
W rachunku sigma obiekt to zbiór metod, dla których mamy dwie operacje
-- wywołanie i:
  <rightoption reply="Dobrze"> nadpisanie </rightoption>
  <wrongoption reply="Źle"> pobranie historii wywołań </wrongoption>
  <wrongoption reply="Źle"> zapamiętanie wyniku </wrongoption>
  <wrongoption reply="Źle"> zliczenie parametrów </wrongoption>
</quiz>


<quiz type="exclusive">
<quiz>
W rachunku sigma każda metoda posiada ciało oraz parametr reprezentujący:
Czwarty z kolei wyraz rozwinięcia w szereg Maclaurina funkcji <math>f(x)=\cos 2x</math> to
  <wrongoption reply="Źle"> historię wywołań </wrongoption>
<wrongoption><math>-\frac{2^6}{6!}</math></wrongoption>
  <rightoption reply="Dobrze"> jaźń obiektu </rightoption>
 
  <wrongoption reply="Źle"> nazwę obiektu </wrongoption>
<wrongoption><math>\frac{2^6}{6!}x^6</math></wrongoption>
  <wrongoption reply="Źle"> wynik obliczeń </wrongoption>
 
<rightoption><math>\frac{-4}{45}x^6</math></rightoption>
</quiz>
</quiz>


<quiz type="exclusive">
  nie, nie, tak
Zapis <math>\displaystyle [l=\varsigma(x)[]]</math> oznacza:
  <wrongoption reply="Źle"> obiekt pusty </wrongoption>
  <wrongoption reply="Źle"> obiekt zawierający metodę pustą </wrongoption>
  <rightoption reply="Dobrze"> obiekt zawierający jedną metodę, zwracającą obiekt pusty </rightoption>
  <wrongoption reply="Źle"> ten zapis jest niepoprawny </wrongoption>
</quiz>


<quiz type="exclusive">
<quiz>
Jeśli <math>\displaystyle o</math> jest obiektem <math>\displaystyle [l=\varsigma(x)x.l]</math>, to wywołanie <math>\displaystyle o.l</math> da
Szósty z kolei wyraz rozwinięcia w szereg Taylora funkcji <math>f(x)=\frac{1}{2+x}</math> o środku w <math>x_0=0</math> wynosi
w wyniku:
<wrongoption><math>\frac{-1}{64}x^6</math></wrongoption>
  <wrongoption reply="Źle"> obiekt pusty </wrongoption>
 
  <wrongoption reply="Źle"> obiekt <math>\displaystyle o</math></wrongoption>
<rightoption><math>\frac{-1}{64}x^5</math></rightoption>
  <wrongoption reply="Źle"> <math>\displaystyle o.l</math></wrongoption>
 
  <rightoption reply="Dobrze"> wywołanie to nie da wyniku, gdyż obliczenia nie kończą się </rightoption>
<wrongoption><math>\frac{1}{2}x^6</math></wrongoption>
</quiz>
</quiz>


<quiz type="exclusive">
  nie, tak, nie
Jeśli <math>\displaystyle o</math> jest obiektem <math>\displaystyle [l=\varsigma(x)x]</math>, to wywołanie <math>\displaystyle o.l</math> da
w wyniku:
  <wrongoption reply="Źle"> obiekt pusty </wrongoption>
  <rightoption reply="Dobrze"> obiekt <math>\displaystyle o</math></rightoption>
  <wrongoption reply="Źle"> <math>\displaystyle o.l</math></wrongoption>
  <wrongoption reply="Źle"> wywołanie to nie da wyniku, gdyż obliczenia nie kończą się </wrongoption>
</quiz>


<quiz type="exclusive">
<quiz>
Relacja redukcji (rozszerzona, z gwiazdką) w rachunku sigma spełnia
Sumujemy cztery kolejne wyrazy rozwinięcia w szereg Taylora funkcji <math>\sqrt{x}</math> ośrodku w <math>x_0=1</math> Współczynnik przy <math>x</math> wynosi
własność Churcha-Rossera. Oznacza to, że jeśli <math>\displaystyle a \to^* b</math> i <math>\displaystyle a \to^* c</math>, to:
<rightoption><math>\frac{15}{16}</math></rightoption>
  <wrongoption reply="Źle"> <math>\displaystyle b = c</math></wrongoption>
 
  <wrongoption reply="Źle"> <math>\displaystyle b \to^* c</math></wrongoption>
<wrongoption><math>\frac{5}{16}</math></wrongoption>
  <wrongoption reply="Źle"> <math>\displaystyle c \to^* b</math></wrongoption>
 
  <rightoption reply="Dobrze"> istnieje <math>\displaystyle d</math> takie, że <math>\displaystyle b \to^* d</math> i <math>\displaystyle c \to^* d</math></rightoption>
<wrongoption><math>\frac{1}{16}</math></wrongoption>
</quiz>
</quiz>


<quiz type="exclusive">
  tak, nie, nie
Otrzymawszy wyrażenie, maszyna wirtualna rachunku sigma może zachować się
na jeden z trzech sposobów.  Które z wymienionych poniżej zachowań nie odpowiada żadnemu z nich?
  <wrongoption reply="Źle"> obliczenia nieskończone </wrongoption>
  <rightoption reply="Dobrze"> wyliczenie wartości, która nie jest poprawnym wynikiem </rightoption>
  <wrongoption reply="Źle"> wyliczenie poprawnego wyniku </wrongoption>
  <wrongoption reply="Źle"> zgłoszenie błędu w wyrażeniu </wrongoption>
</quiz> 
 
 
 
 


5555555555555555555555555555555555555555555555555555


==Szereg potęgowy. Trygonometryczny szereg Fouriera. Test==




101010101010101010101010101010101010101010101010101010101010


==Wielowymiarowa całka Riemanna. Test==




1111111111111111111111111111111111111111111111111111


==Twierdzenie Fubiniego. Twierdzenie o zmianie zmiennych. Test==




1212121212121212121212121212121212121212121212121212121212


Test 10
==Całki krzywoliniowe. Twierdzenie Greena. Test==
<quiz type="exclusive">
Zapisany w Haskellu nagłówek f \:\: (Integer -> Integer) -> (Integer -> Integer) deklaruje f jako funkcję, której parametrami i wynikiem są:
<rightoption reply="Dobrze">parametr\: funkcja biorąca liczbę całkowitą i zwracająca liczbę całkowitą, wynik\: takaż funkcja</rightoption>
<wrongoption reply="Źle">parametry\: dwie liczby całkowite, wynik\: dwie liczby całkowite</wrongoption>
<wrongoption reply="Źle">parametr\: liczba całkowita, wynik\: liczba całkowita i funkcja biorąca liczbę całkowitą i zwracająca liczbę całkowitą</wrongoption>
<wrongoption reply="Źle">taka deklaracja nie jest w Haskellu poprawna</wrongoption>
</quiz>


<quiz type="exclusive">
Definicje funkcji, w których trzeba rozpatrzyć osobne przypadki, można w Haskellu zapisać na kilka sposobów.  Który z wymienionych sposobów nie jest poprawny?
<wrongoption reply="Źle">dopasowywanie do wzorca</wrongoption>
<wrongoption reply="Źle">dozory</wrongoption>
<wrongoption reply="Źle">if-then-else</wrongoption>
<rightoption reply="Dobrze">switch</rightoption>
</quiz>


<quiz type="exclusive">
1414141414141414141414141414141414141414141414141414
Haskellowy typ Integer obejmuje liczby całkowite mieszczące się:
<wrongoption reply="Źle">w dwóch bajtach</wrongoption>
<wrongoption reply="Źle">w czterech bajtach</wrongoption>
<wrongoption reply="Źle">to zależy od implementacji</wrongoption>
<rightoption reply="Dobrze">bez ograniczeń (Haskell przydziela dostępną pamięć w miarę potrzeby)</rightoption>
</quiz>


<quiz type="exclusive">
==Równania różniczkowe zwyczajne -- przegląd metod rozwiązywania. Test==
W nagłówku kw :: Num a \=> a -> a określamy typ parametru i wyniku
funkcji kw jako:
<wrongoption reply="Źle">Num</wrongoption>
<rightoption reply="Dobrze">dowolny typ z klasy Num</rightoption>
<wrongoption reply="Źle">dowolny typ, bez ograniczeń</wrongoption>
<wrongoption reply="Źle">ta deklaracja jest niepoprawna</wrongoption>
</quiz>
 
<quiz type="exclusive">
Jeśli funkcja ma typ (Float, Float) -> Float, to po rozwinięciu będzie miała typ:
<rightoption reply="Dobrze">Float -> (Float -> Float)</rightoption>
<wrongoption reply="Źle">Float -> (Float, Float)</wrongoption>
<wrongoption reply="Źle">(Float -> Float) -> Float</wrongoption>
<wrongoption reply="Źle">rozwinięcie nie jest w tym przypadku możliwe</wrongoption>
</quiz>
 
<quiz type="exclusive">
Zapis Float -> Float -> Float jest interpretowany jako:
<rightoption reply="Dobrze">Float -> (Float -> Float)</rightoption>
<wrongoption reply="Źle">Float -> (Float, Float)</wrongoption>
<wrongoption reply="Źle">(Float -> Float) -> Float</wrongoption>
<wrongoption reply="Źle">nawiasy są tu konieczne, nie można ich pominąć</wrongoption>
</quiz>
 
<quiz type="exclusive">
Typ [(Integer,Integer)] oznacza:
<wrongoption reply="Źle">listę liczb całkowitych o długości ograniczonej do dwóch elementów</wrongoption>
<rightoption reply="Dobrze">listę par liczb całkowitych</rightoption>
<wrongoption reply="Źle">parę list liczb całkowitych</wrongoption>
<wrongoption reply="Źle">taki typ nie jest poprawny</wrongoption>
</quiz>
 
<quiz type="exclusive">
Które użycie operatora dodawania jest w Haskellu niepoprawne?
<wrongoption reply="Źle">1 + 2</wrongoption>
<wrongoption reply="Źle">(+) 1 2</wrongoption>
<wrongoption reply="Źle">((+) 1) 2</wrongoption>
<rightoption reply="Dobrze">(+)(1, 2)</rightoption>
</quiz>
 
<quiz type="exclusive">
Jeśli funkcja f jest typu Integer -> Integer -> Integer, to `f` (nazwa funkcji ujęta w odwrócone apostrofy) jest:
<wrongoption reply="Źle">funkcją typu (Integer, Integer) -> Integer</wrongoption>
<wrongoption reply="Źle">funkcją typu (Integer -> Integer) -> Integer</wrongoption>
<rightoption reply="Dobrze">operatorem, którego można używać infiksowo, np. 1 `f` 2</rightoption>
<wrongoption reply="Źle">zapis taki jest niepoprawny</wrongoption>
</quiz>
 
<quiz type="exclusive">
Zapis (3 +) oznacza:
<rightoption reply="Dobrze">funkcję typu Integer -> Integer</rightoption>
<wrongoption reply="Źle">parę złożoną z liczby 3 i znaku plus</wrongoption>
<wrongoption reply="Źle">trzyargumentową wersję operatora dodawania</wrongoption>
<wrongoption reply="Źle">zapis taki jest niepoprawny</wrongoption>
</quiz>
 
 
 
 
 
 
 
 
 
 
 
 
 
<quiz type="exclusive">
Używane w Prologu klauzule Horna mają w następniku:
<wrongoption reply="Źle">co najmniej jeden term</wrongoption>
<wrongoption reply="Źle">dokładnie jeden term</wrongoption>
<wrongoption reply="Źle">dokładnie dwa termy</wrongoption>
<rightoption reply="Dobrze">zero lub jeden term</rightoption>
</quiz>
 
<quiz type="exclusive">
Stosowana w Prologu metoda wnioskowania to:
<wrongoption reply="Źle">indukcja pozaskończona</wrongoption>
<rightoption reply="Dobrze">rezolucja</rightoption>
<wrongoption reply="Źle">unifikacja</wrongoption>
<wrongoption reply="Źle">zasada instancjonowania prostego</wrongoption>
</quiz>
 
<quiz type="exclusive">
Klauzula ,,dziadek(X, Z) \:- ojciec(X, Y), ojciec(Y, Z)".:
<rightoption reply="Dobrze">mówi tylko, że jeśli X jest ojcem Y i Y jest ojcem Z, to X jest dziadkiem Z</rightoption>
<wrongoption reply="Źle">wyklucza, by któs mógł być swoim własnym dziadkiem</wrongoption>
<wrongoption reply="Źle">wyklucza, by któs mógł być swoim własnym ojcem</wrongoption>
<wrongoption reply="Źle">jest niepoprawna składniowo</wrongoption>
</quiz>
 
<quiz type="exclusive">
Do tworzenia i rozkładania list w Prologu stosuje się:
<wrongoption reply="Źle">funkcje cons, head i tail</wrongoption>
<wrongoption reply="Źle">operatory ++, + i -</wrongoption>
<rightoption reply="Dobrze">operator | i odpowiednie dopasowania</rightoption>
<wrongoption reply="Źle">w Prologu nie ma list</wrongoption>
</quiz>
 
<quiz type="exclusive">
Zapis ,,X is 3 * Y + 4'' w Prologu powoduje:
<wrongoption reply="Źle">podstawienie wartości wyrażenia 3*Y+4 pod zmienną X</wrongoption>
<rightoption reply="Dobrze">utożsamienie (lub sprawdzenie utożsamienia) zmiennej X z wartością wyrażenia 3*Y+4</rightoption>
<wrongoption reply="Źle">wypisanie rozwiązania równania X\=3*Y+4</wrongoption>
<wrongoption reply="Źle">taki zapis jest niepoprawny</wrongoption>
</quiz>
 
<quiz type="exclusive">
Jeśli Prologowi nie uda się udowodnić jednego z podcelów, to:
<rightoption reply="Dobrze">wraca do poprzednich podcelów, próbując znaleźć alternatywne rozwiązania</rightoption>
<wrongoption reply="Źle">wypisuje komunikat o niepowodzeniu rezolucji</wrongoption>
<wrongoption reply="Źle">zgłasza błąd wykonania</wrongoption>
<wrongoption reply="Źle">nie robi nic, tzn. kontynuuje działanie</wrongoption>
</quiz>
 
<quiz type="exclusive">
Dla stwierdzeń złożonych Prolog stosuje:
<rightoption reply="Dobrze">przeszukiwanie w głąb</rightoption>
<wrongoption reply="Źle">przeszukiwanie wszerz</wrongoption>
<wrongoption reply="Źle">przeszukiwanie w głąb lub wszerz, w zależności od dostępnej pamięci</wrongoption>
<wrongoption reply="Źle">inną metdoę, nie wymienioną tutaj</wrongoption>
</quiz>
 
<quiz type="exclusive">
Zapis [X | Y] w Prologu oznacza:
<wrongoption reply="Źle">konkatenację list X i Y</wrongoption>
<rightoption reply="Dobrze">listę, gdzie X jest głową, a Y -- ogonem listy</rightoption>
<wrongoption reply="Źle">parę uporządkowaną złożoną z elementów X i Y</wrongoption>
<wrongoption reply="Źle">wyrażenie warunkowe z dozorem X</wrongoption>
</quiz>
 
<quiz type="exclusive">
Jaką klauzulę należałoby dopisać przed ,,f(X, [_ | Y]) \:- f(X, Y).",
by otrzymać funktor sprawdzający przynależność elementu do listy?
<wrongoption reply="Źle">f(X, []).</wrongoption>
<wrongoption reply="Źle">f(X, [X]).</wrongoption>
<rightoption reply="Dobrze">f(X, [X | _]).</rightoption>
<wrongoption reply="Źle">tego nie da się tak zrobić</wrongoption>
</quiz>
 
<quiz type="exclusive">
Lista [1, [2, 3], 4, []] ma długość:
<wrongoption reply="Źle">3</wrongoption>
<rightoption reply="Dobrze">4</rightoption>
<wrongoption reply="Źle">5</wrongoption>
<wrongoption reply="Źle">jest niepoprawna składniowo</wrongoption>
</quiz>
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Test 6
 
<quiz type="exclusive">
Czego z zasady nie ma w językach funkcyjnych?
<wrongoption reply="Źle">parametrów z domyślnymi wartościami</wrongoption>
<rightoption reply="Dobrze">pętli</rightoption>
<wrongoption reply="Źle">wyrażeń warunkowych</wrongoption>
<wrongoption reply="Źle">wywołań rekurencyjnych</wrongoption>
</quiz>
 
<quiz type="exclusive">
Która cecha jest typowa dla języków funkcyjnych, a rzadko występuje w językach imperatywnych i obiektowych?
<wrongoption reply="Źle">kompilacja do kodu pośredniego</wrongoption>
<rightoption reply="Dobrze">możliwość używania funkcji wyższego rzędu</rightoption>
<wrongoption reply="Źle">silne typowanie</wrongoption>
<wrongoption reply="Źle">zaawansowane konstrukcje enkapsulacyjne</wrongoption>
</quiz>
 
<quiz type="exclusive">
Listy służą w Lispie do zapisywania:
<wrongoption reply="Źle">tylko danych</wrongoption>
<wrongoption reply="Źle">tylko kodu</wrongoption>
<rightoption reply="Dobrze">i danych, i kodu</rightoption>
<wrongoption reply="Źle">w Lispie nie ma list</wrongoption>
</quiz>
 
<quiz type="exclusive">
Wywołanie ((LAMBDA (x) (* x x)) 2) w języku Scheme:
<wrongoption reply="Źle">podstawi 2 pod wskaźnik do zmiennej x</wrongoption>
<rightoption reply="Dobrze">wyświetli 4</rightoption>
<wrongoption reply="Źle">zdefiniuje gwiazdkę jako operator o priorytecie 2</wrongoption>
<wrongoption reply="Źle">zdefiniuje LAMBDA jako funkcję dwuargumentową</wrongoption>
</quiz>
 
<quiz type="exclusive">
Funkcja DISPLAY w języku Scheme:
<wrongoption reply="Źle">nie ma żadnych efektów ubocznych</wrongoption>
<wrongoption reply="Źle">nie może być używana wewnątrz funkcji rekurencyjnej</wrongoption>
<wrongoption reply="Źle">wyświetla opis stanu interpretera</wrongoption>
<rightoption reply="Dobrze">wyświetla swój argument na ekranie</rightoption>
</quiz>
 
<quiz type="exclusive">
Wartością wyrażenia (CAR ‘(A B C)) w języku Scheme jest:
<rightoption reply="Dobrze">A</rightoption>
<wrongoption reply="Źle">(B C)</wrongoption>
<wrongoption reply="Źle">C</wrongoption>
<wrongoption reply="Źle">to wyrażenie jest niepoprawne</wrongoption>
</quiz>
 
<quiz type="exclusive">
Wartością wyrażenia (CONS ‘(A B) ‘(C D)) w języku Scheme jest:
<wrongoption reply="Źle">(A B C D)</wrongoption>
<wrongoption reply="Źle">(A B (C D))</wrongoption>
<rightoption reply="Dobrze">((A B) C D)</rightoption>
<wrongoption reply="Źle">to wyrażenie jest niepoprawne</wrongoption>
</quiz>
 
<quiz type="exclusive">
Jak w języku Scheme należy zapisać wywołanie złożenia funkcji f
z samą sobą na argumencie x, czyli (f o f)(x)?
<rightoption reply="Dobrze">(f (f x))</rightoption>
<wrongoption reply="Źle">f(f(x))</wrongoption>
<wrongoption reply="Źle">((f f) x)</wrongoption>
<wrongoption reply="Źle">składanie funkcji nie jest w tym języku dozwolone</wrongoption>
</quiz>
 
<quiz type="exclusive">
Które stwierdzenie nie jest prawdziwe w odniesieniu do języka ML?
<rightoption reply="Dobrze">lista może zawierać elementy różnych typów</rightoption>
<wrongoption reply="Źle">można pisać funkcje polimorficzne</wrongoption>
<wrongoption reply="Źle">ML stosuje niejawne nadawanie typów</wrongoption>
<wrongoption reply="Źle">wyrażenia arytmetyczne zapisuje się w postaci infiksowej</wrongoption>
</quiz>
 
<quiz type="exclusive">
Do łączenia list w Haskellu służy:
<wrongoption reply="Źle">funkcja CONS</wrongoption>
<rightoption reply="Dobrze">operator ++</rightoption>
<wrongoption reply="Źle">operator &</wrongoption>
<wrongoption reply="Źle">nie ma operatora, po prostu zapisuje się dwie listy obok siebie</wrongoption>
</quiz>
 
 
 
 
 
 
 
 
 
Test 5
<quiz type="exclusive">
Której cechy język obiektowy nie musi posiadać?
<wrongoption reply="Źle">abstrakcyjne typy danych</wrongoption>
<wrongoption reply="Źle">dynamiczne wiązanie wywołań metod z metodami</wrongoption>
<wrongoption reply="Źle">dziedziczenie</wrongoption>
<rightoption reply="Dobrze">podprogramy rodzajowe</rightoption>
</quiz>
 
<quiz type="exclusive">
Jakie ograniczenie na przedefiniowywanie metod trzeba narzucić
w języku silnie typowanym?
<wrongoption reply="Źle">przedefiniowana metoda musi być bezparametrowa</wrongoption>
<wrongoption reply="Źle">przedefiniowana metoda musi być typu void</wrongoption>
<rightoption reply="Dobrze">przedefiniowana metoda musi zachować taki sam protokół</rightoption>
<wrongoption reply="Źle">nie trzeba narzucać żadnych ograniczeń</wrongoption>
</quiz>
 
<quiz type="exclusive">
Rozstrzyganie odwołań do bytów o takiej samej nazwie mających definicje w dwóch klasach bazowych odbywa się w C++ za pomocą:
<rightoption reply="Dobrze">operatora \:\: (dwa dwukropki)</rightoption>
<wrongoption reply="Źle">operatora . (kropka)</wrongoption>
<wrongoption reply="Źle">tego nie da się zrobić</wrongoption>
<wrongoption reply="Źle">dziedziczenie wielokrotne nie jest w C++ dozwolone</wrongoption>
</quiz>
 
<quiz type="exclusive">
W języku C++ obiekty zaalokowane na stosie dealokowane są:
<rightoption reply="Dobrze">niejawnie</rightoption>
<wrongoption reply="Źle">za pomocą delete</wrongoption>
<wrongoption reply="Źle">za pomocą free</wrongoption>
<wrongoption reply="Źle">w C++ nie ma takich obiektów</wrongoption>
</quiz>
 
<quiz type="exclusive">
Językiem, w którym stosowane jest zawsze dynamiczne wiązanie
wywołań z metodami, jest:
<wrongoption reply="Źle">C++</wrongoption>
<wrongoption reply="Źle">C\#</wrongoption>
<wrongoption reply="Źle">Java</wrongoption>
<rightoption reply="Dobrze">Smalltalk</rightoption>
</quiz>
 
<quiz type="exclusive">
Językiem, w któym klasa może być samoistna (tzn. nie mieć nadlasy), jest:
<rightoption reply="Dobrze">C++</rightoption>
<wrongoption reply="Źle">C\#</wrongoption>
<wrongoption reply="Źle">Java</wrongoption>
<wrongoption reply="Źle">Smalltalk</wrongoption>
</quiz>
 
<quiz type="exclusive">
W języku C++ metody, które mają być wiązane dynamicznie, deklaruje się za pomocą:
<wrongoption reply="Źle">operatora -> (strzałka)</wrongoption>
<wrongoption reply="Źle">słowa abstract</wrongoption>
<wrongoption reply="Źle">słowa dynamic</wrongoption>
<rightoption reply="Dobrze">słowa virtual</rightoption>
</quiz>
 
<quiz type="exclusive">
Który nagłówek poprawnie deklaruje w C++ metodę abstrakcyjną?
<wrongoption reply="Źle">virtual void p();</wrongoption>
<rightoption reply="Dobrze">virtual void p() \=0;</rightoption>
<wrongoption reply="Źle">void p() \=0;</wrongoption>
<wrongoption reply="Źle">abstract void p();</wrongoption>
</quiz>
 
<quiz type="exclusive">
Klasy ,,lekkie'', deklarowane jako struct, alokowane na stosie i nie
pozwalające na dziedziczenie występują w:
<wrongoption reply="Źle">C++</wrongoption>
<rightoption reply="Dobrze">C\#</rightoption>
<wrongoption reply="Źle">Javie</wrongoption>
<wrongoption reply="Źle">we wszystkich wymienionych tu językach</wrongoption>
</quiz>
 
<quiz type="exclusive">
Który element nie występuje w JavaScripcie?
<rightoption reply="Dobrze">klasy</rightoption>
<wrongoption reply="Źle">obiekty złożone z par (nazwa własności, wartość)</wrongoption>
<wrongoption reply="Źle">operator new</wrongoption>
<wrongoption reply="Źle">zmienne</wrongoption>
</quiz>
 
 
 
 
 
 
 
 
 
 
 
 
Test 4
<quiz type="exclusive">
Który język nie pozwala na użycie parametrów z wartością domyślną?
<wrongoption reply="Źle">Ada</wrongoption>
<rightoption reply="Dobrze">C</rightoption>
<wrongoption reply="Źle">C++</wrongoption>
<wrongoption reply="Źle">PHP</wrongoption>
</quiz>
 
<quiz type="exclusive">
Przekazanie funkcji jako parametru można w C\# osiągnąć za pomocą mechanizmu:
<wrongoption reply="Źle">bezpośrednio, bez dodatkowych mechanizmów</wrongoption>
<rightoption reply="Dobrze">delegatów</rightoption>
<wrongoption reply="Źle">tablic wielowymiarowych</wrongoption>
<wrongoption reply="Źle">wskaźników do funkcji</wrongoption>
</quiz>
 
<quiz type="exclusive">
Który język nie sprawdza zgodności typów parametrów?
<wrongoption reply="Źle">Ada</wrongoption>
<wrongoption reply="Źle">C#</wrongoption>
<wrongoption reply="Źle">Java</wrongoption>
<rightoption reply="Dobrze">PHP</rightoption>
</quiz>
 
<quiz type="exclusive">
Przy której deklaracji procedury f wywołanie f(2*x + 3) jest poprawne?
<wrongoption reply="Źle">procedure f(n: in out Integer) w Adzie</wrongoption>
<wrongoption reply="Źle">procedure f(n: out Integer) w Adzie</wrongoption>
<rightoption reply="Dobrze">void f(int n) w języku C</rightoption>
<wrongoption reply="Źle">void f(int *n) w języku C</wrongoption>
</quiz>
 
<quiz type="exclusive">
Chcąc w języku C przekazać do funkcji tablicę przez wartość, trzeba:
<rightoption reply="Dobrze">,,obudować'' ją strukturą i przekazać tę strukturę</rightoption>
<wrongoption reply="Źle">użyć nawiasów kwadratowych po nazwie tablicy w wywołaniu funkcji</wrongoption>
<wrongoption reply="Źle">użyć nawiasów kwadratowych po nazwie parametru w nagłówku funkcji</wrongoption>
<wrongoption reply="Źle">nie trzeba robić niczego szczególnego</wrongoption>
</quiz>
 
<quiz type="exclusive">
Jaką dodatkową cechę mają parametry stałe deklarowane w C++
z użyciem const w stosunku do parametrów w trybie wejściowym w ogóle?
<rightoption reply="Dobrze">nie mogą być zmieniane nawet w obrębie podprogramu</rightoption>
<wrongoption reply="Źle">są zawsze alokowane statycznie</wrongoption>
<wrongoption reply="Źle">wymuszają statyczne sprawdzenie zgodności typu</wrongoption>
<wrongoption reply="Źle">nie mają żadnej dodatkowej cechy</wrongoption>
</quiz>
 
 
<quiz type="exclusive">
Załóżmy, że x jest parametrem w trybie out w procedurze w Adzie.
Która instrukcja ma szansę być poprawna?
<wrongoption reply="Źle">x \:\= x + 1</wrongoption>
<rightoption reply="Dobrze">x \:\= y + 1</rightoption>
<wrongoption reply="Źle">y \:\= x + 1</wrongoption>
<wrongoption reply="Źle">y \:\= T(x)</wrongoption>
</quiz>
 
<quiz type="exclusive">
Jawne przekazywanie przez referencję jest w C\# możliwe, jeśli
umieścimy słowo kluczowe ref:
<wrongoption reply="Źle">przy parametrze aktualnym</wrongoption>
<wrongoption reply="Źle">przy parametrze formalnym</wrongoption>
<rightoption reply="Dobrze">i przy parametrze formalnym, i przy aktualnym</rightoption>
<wrongoption reply="Źle">to w ogóle nie jest możliwe</wrongoption>
</quiz>
 
<quiz type="exclusive">
W językach z zakresem widoczności zmiennych wiązanym statycznie
jako środowiska wykonywania przekazanego przez parametr podprogramu najczęściej używa się:
<wrongoption reply="Źle">środowiska instrukcji (w podprogramie), wywołującej przekazany podprogram</wrongoption>
<rightoption reply="Dobrze">środowiska definicji przekazanego podprogramu</rightoption>
<wrongoption reply="Źle">środowiska instrukcji, która przekazała podprogram jako parametr</wrongoption>
<wrongoption reply="Źle">żadnego z wymienioinych środowisk</wrongoption>
</quiz>
 
<quiz type="exclusive">
W implementacji podprogramów bez zagnieżdżeń, ale z rekurencją
i z dynamicznymi zmiennymi lokalnymi na stosie potrzebne jest przechowywanie w rekordzie aktywacyjnym:
<rightoption reply="Dobrze">tylko łącza dynamicznego</rightoption>
<wrongoption reply="Źle">tylko łącza statycznego</wrongoption>
<wrongoption reply="Źle">łącza dynamicznego i statycznego</wrongoption>
<wrongoption reply="Źle">żadnego z nich</wrongoption>
 
</quiz>
 
 
 
 
 
 
 
 
 
 
 
Test 3
<quiz type="exclusive">
Pojęcie typu w językach imperatywnych bliskie jest pojęciu:
<wrongoption reply="Źle">całki Riemanna</wrongoption>
<wrongoption reply="Źle">pary uporządkowanej</wrongoption>
<wrongoption reply="Źle">zbioru nieskończonego</wrongoption>
<rightoption reply="Dobrze">zbioru skończonego</rightoption>
</quiz>
 
<quiz type="exclusive">
Który z opisanych poniżej typów można uznać za typ abstrakcyjny?
Rzecz dzieje się w języku C:
<wrongoption reply="Źle">struktura wraz z kilkoma działającymi na niej funkcjami</wrongoption>
<wrongoption reply="Źle">typ wskaźnikowy T *, gdzie T jest zdefiniowane następująco\: typedef int T[10];</wrongoption>
<rightoption reply="Dobrze">wbudowany typ float</rightoption>
<wrongoption reply="Źle">unia złożona z pól tego samego typu</wrongoption>
</quiz>
 
<quiz type="exclusive">
W której sytuacji tablica asocjacyjna byłaby istotnie wygodniejsza
niż zwykła tablica?
<wrongoption reply="Źle">mamy katalogi ponumerowane od 1 do 100 i zapisujemy ich rozmiar</wrongoption>
<wrongoption reply="Źle">sortujemy obszerną tablicę liczb typu double</wrongoption>
<wrongoption reply="Źle">wyszukujemy największą liczbę w tablicy</wrongoption>
<rightoption reply="Dobrze">zapisujemy kolor przejeżdżających samochodów, identyfikując je numerami rejestracyjnymi</rightoption>
</quiz>
 
<quiz type="exclusive">
Ewentualne luki między przechowywanymi w pamięci polami rekordu biorą się z:
<wrongoption reply="Źle">konieczności sprawdzenia zgodności typów</wrongoption>
<rightoption reply="Dobrze">konieczności umieszczania pól pod adresami, których 1 lub 2 najmniej znaczące bity są zerami</rightoption>
<wrongoption reply="Źle">niedoskonałości kompilatorów</wrongoption>
<wrongoption reply="Źle">szybkich przesunięć cyklicznych w jednostce arytmetyczno-logicznej procesora</wrongoption>
</quiz>
 
<quiz type="exclusive">
Załóżmy, że w języku C sprawdzamy równość struktur (oczywiście tego samego typu).
Dlaczego w ogólności nie można tego zrobić przez porównywanie bloków pamięci?
<wrongoption reply="Źle">istnieje kilka rozmiarów liczb całkowitych</wrongoption>
<rightoption reply="Dobrze">napisy mogą zawierać nieistotne znaki za znacznikiem końca</rightoption>
<wrongoption reply="Źle">nie można z góry przewidzieć, czy napisy są zapisane w kodzie ASCII, czy Unicode</wrongoption>
<wrongoption reply="Źle">reprezentacja liczb float i double nie jest jednoznaczna</wrongoption>
</quiz>
 
<quiz type="exclusive">
Który operator języka C jest potrzebny, gdy wykorzystujemy wskaźniki
do adresowania pośredniego?
<rightoption reply="Dobrze">&</rightoption>
<wrongoption reply="Źle">++</wrongoption>
<wrongoption reply="Źle">--</wrongoption>
<wrongoption reply="Źle">nawiasy kwadratowe do indeksowania</wrongoption>
</quiz>
 
<quiz type="exclusive">
Załóżmy, że p jest zmienną wskaźnikową. W którym języku wyrażenie ++p
jest poprawne?
<rightoption reply="Dobrze">C++</rightoption>
<wrongoption reply="Źle">C\#</wrongoption>
<wrongoption reply="Źle">Java</wrongoption>
<wrongoption reply="Źle">Pascal</wrongoption>
</quiz>
 
<quiz type="exclusive">
Które stwierdzenie jest fałszywe w odniesieniu do klas w języku C++?
<wrongoption reply="Źle">definicja klasy nie musi zawierać destruktora</wrongoption>
<wrongoption reply="Źle">funkcje z klasy mogą być kompilowane jako inline</wrongoption>
<wrongoption reply="Źle">konstruktor ma taką samą nazwę jak klasa</wrongoption>
<rightoption reply="Dobrze">konstruktor nie może być przeciążany</rightoption>
</quiz>
 
<quiz type="exclusive">
W Javie obiekty są alokowane:
<rightoption reply="Dobrze">dynamicznie na stercie</rightoption>
<wrongoption reply="Źle">dynamicznie na stosie</wrongoption>
<wrongoption reply="Źle">statycznie na stercie</wrongoption>
<wrongoption reply="Źle">statycznie na stosie</wrongoption>
</quiz>
 
<quiz type="exclusive">
Sparametryzowane typy abstrakcyjne uzyskuje się w C++ za pomocą
deklaracji z użyciem słowa kluczowego:
<wrongoption reply="Źle">args</wrongoption>
<wrongoption reply="Źle">generic</wrongoption>
<wrongoption reply="Źle">params</wrongoption>
<rightoption reply="Dobrze">template</rightoption>
</quiz>
 
 
 
 
 
 
 
 
 
 
 
 
Test 2
<quiz type="exclusive">
Program może zawierać dwie różne zmienne o tej samej nazwie, gdy są to zmienne:
<wrongoption reply="Źle">alokowane dynamicznie</wrongoption>
<wrongoption reply="Źle">globalne</wrongoption>
<rightoption reply="Dobrze">lokalne w dwóch różnych blokach</rightoption>
<wrongoption reply="Źle">lokalne w tym samym bloku</wrongoption>
</quiz>
 
<quiz type="exclusive">
L-wartością nazywamy:
<rightoption reply="Dobrze">bieżący adres zmiennej</rightoption>
<wrongoption reply="Źle">wynik wyrażenia arytmetycznego</wrongoption>
<wrongoption reply="Źle">indeks tablicy</wrongoption>
<wrongoption reply="Źle">wartość zmiennej po dokonaniu podstawienia</wrongoption>
</quiz>
 
<quiz type="exclusive">
Wiązanie statyczne:
<wrongoption reply="Źle">może zmienić się w trakcie wykonania programu</wrongoption>
<wrongoption reply="Źle">następuje w trakcie wykonania programu</wrongoption>
<rightoption reply="Dobrze">następuje przed wykonaniem programu</rightoption>
<wrongoption reply="Źle">odnosi się tylko do zmiennych globalnych</wrongoption>
</quiz>
 
<quiz type="exclusive">
Wnioskowanie o typie zmiennej jest najczęstsze w językach:
<rightoption reply="Dobrze">funkcyjnych</rightoption>
<wrongoption reply="Źle">logicznych</wrongoption>
<wrongoption reply="Źle">obiektowych</wrongoption>
<wrongoption reply="Źle">nie występuje w żadnym przyzwoitym języku</wrongoption>
</quiz>
 
<quiz type="exclusive">
Okres życia zmiennej to:
<rightoption reply="Dobrze">czas pomiędzy alokacją zmiennej a jej dealokacją</rightoption>
<wrongoption reply="Źle">czas od uruchomienia programu do chwili wykonania na tej zmiennej delete, free itp.</wrongoption>
<wrongoption reply="Źle">obszar kodu pomiędzy deklaracją zmiennej a końcem zawierającego ją bloku</wrongoption>
<wrongoption reply="Źle">czas od pierwszego podstawienia pod tę zmienną do ostatniego jej użycia w programie</wrongoption>
</quiz>
 
<quiz type="exclusive">
Obiekty w Javie są alokowane:
<rightoption reply="Dobrze">dynamicznie, na stercie</rightoption>
<wrongoption reply="Źle">dynamicznie, na stosie</wrongoption>
<wrongoption reply="Źle">dynamicznie, na stosie lub na stercie (decyzję podejmuje kompilator)</wrongoption>
<wrongoption reply="Źle">statycznie</wrongoption>
</quiz>
 
<quiz type="exclusive">
Spośród wymienionych tu języków najbliższy silnemu typowaniu jest:
<wrongoption reply="Źle">C</wrongoption>
<wrongoption reply="Źle">C++</wrongoption>
<rightoption reply="Dobrze">C\#</rightoption>
<wrongoption reply="Źle">PHP</wrongoption>
</quiz>
 
<quiz type="exclusive">
Silne typowanie bywa ,,osłabiane'' przez:
<wrongoption reply="Źle">jawne konwersje typów</wrongoption>
<rightoption reply="Dobrze">niejawne konwersje typów</rightoption>
<wrongoption reply="Źle">dynamiczne sprawdzanie zgodności typów</wrongoption>
<wrongoption reply="Źle">statyczne sprawdzanie zgodności typów</wrongoption>
</quiz>
 
<quiz type="exclusive">
Podtyp to:
<rightoption reply="Dobrze">typ powstały przez ograniczenie zakresu istniejącego typu, zgodny z owym typem</rightoption>
<wrongoption reply="Źle">nowy typ oparty na już istniejącym, niezgodny z dotychczasowym</wrongoption>
<wrongoption reply="Źle">typ tablicowy, w którym ograniczono zakres indeksów</wrongoption>
<wrongoption reply="Źle">jedno z pól unii</wrongoption>
</quiz>
 
<quiz type="exclusive">
W języku C++ dostęp do przesłoniętej zmiennej nielokalnej można
uzyskać za pomocą operatora:
<rightoption reply="Dobrze">\:\: (dwa dwukropki)</rightoption>
<wrongoption reply="Źle">. (kropka)</wrongoption>
<wrongoption reply="Źle">* (gwiazdka)</wrongoption>
<wrongoption reply="Źle">-> (strzałka)</wrongoption>
</quiz>

Aktualna wersja na dzień 22:12, 11 wrz 2023




1111111111111111111111111111111111111111111


1111111111111111111111111111111111111111111


22222222222222222222222222222222222222222

Ciągi w przestrzeniach metrycznych. Test

3333333333333333333333333333333333333333333333333333333333333

Norma. Iloczyn skalarny. Test

444444444444444444444444444444444444444444444444444444444444444

Ciągi i szeregi funkcyjne. Szereg Taylora. Test

Dany jest ciąg funkcyjny {fn} gdzie Parser nie mógł rozpoznać (błąd składni): {\displaystyle f_n(x)= \left\{ \begin{array} {lll} 1 & \text{dla} & x\in[n,n+1]\\ 0 & \text{dla} & x\in \mathbb{R}\setminus[n,n+1] \end{array} \right} dla n∈ℕ Ciąg ten jest

zbieżny punktowo do f(x)≡0

zbieżny jednostajnie do f(x)≡0

zbieżny punktowo do funkcji Parser nie mógł rozpoznać (błąd składni): {\displaystyle f(x)= \left\{ \begin{array} {lll} 1 & \text{dla} & x\geq 1\\ 0 & \text{dla} & x<0 \end{array} \right} 

 tak, nie, nie

Dany jest ciąg funkcyjny {fn} gdzie

fn(x)={1−n−x1+n−xdlax>02−nx2+nxdlax<00dlax=0 dla  n=1,2,…

Ten ciąg funkcyjny jest

zbieżny jednostajnie

zbieżny punktowo ale nie jednostajnie

rozbieżny 

 nie, tak, nie

Dany jest ciąg funkcyjny fn(x)=xn dla x≥0 Ten ciąg

jest zbieżny punktowo i jego granica jest ciągła

jest zbieżny jednostajnie i jego granica jest ciągła

jest zbieżny punktowo i jego granica nie jest ciągła 

 nie, nie, tak

Dany jest szereg ∑n=1∞sin⁡nx2n(x2+1), x∈ℝ Ten szereg jest

zbieżny jednostajnie do funkcji f(x)≡0

zbieżny jednostajnie do funkcji f takiej, że 0<f(x)<3

zbieżny jednostajnie do funkcji f(x)=12(x2+1) 

 nie, tak, nie

Funkcja f(x):=∑n=1∞xnn(n+1)(x2+1) Granica limx→3f(x) wynosi

110

3

0 

 tak, nie, nie

Szereg ∑n=1∞1n(x4+4) jest

zbieżny punktowo

zbieżny jednostajnie

rozbieżny 

 nie, nie, tak

Czwarty z kolei wyraz rozwinięcia w szereg Maclaurina funkcji f(x)=cos⁡2x to

−266!

266!x6

−445x6 

 nie, nie, tak

Szósty z kolei wyraz rozwinięcia w szereg Taylora funkcji f(x)=12+x o środku w x0=0 wynosi

−164x6

−164x5

12x6 

 nie, tak, nie

Sumujemy cztery kolejne wyrazy rozwinięcia w szereg Taylora funkcji x ośrodku w x0=1 Współczynnik przy x wynosi

1516

516

116 

 tak, nie, nie

5555555555555555555555555555555555555555555555555555

Szereg potęgowy. Trygonometryczny szereg Fouriera. Test

101010101010101010101010101010101010101010101010101010101010

Wielowymiarowa całka Riemanna. Test

1111111111111111111111111111111111111111111111111111

Twierdzenie Fubiniego. Twierdzenie o zmianie zmiennych. Test

1212121212121212121212121212121212121212121212121212121212

Całki krzywoliniowe. Twierdzenie Greena. Test

1414141414141414141414141414141414141414141414141414

Równania różniczkowe zwyczajne -- przegląd metod rozwiązywania. Test

Źródło: „https://wazniak.mimuw.edu.pl/index.php?title=Test_GR&oldid=82477”