Test GR

---

(Monoidy). Wskaż, które z poniższych struktur są monoidami:

a.

Parser nie mógł rozpoznać (nieznana funkcja „\mathds”): {\displaystyle \displaystyle (\mathds{Z}_{mod\ 2}, \cdot)} Dobrze

Parser nie mógł rozpoznać (nieznana funkcja „\mathds”): {\displaystyle \displaystyle (\mathds{N}_1, +)} , gdzie Parser nie mógł rozpoznać (nieznana funkcja „\mathds”): {\displaystyle \displaystyle \mathds{N}_1=\{1,2,3,...\}} Źle

Parser nie mógł rozpoznać (nieznana funkcja „\mathds”): {\displaystyle \displaystyle (\mathds{N}_p,+)} , gdzie Parser nie mógł rozpoznać (nieznana funkcja „\mathds”): {\displaystyle \displaystyle \mathds{N}_p} jest zbiorem wszystkich liczb pierwszych Źle

Parser nie mógł rozpoznać (nieznana funkcja „\mathds”): {\displaystyle \displaystyle (\mathds{R}, \cdot)} Dobrze

Parser nie mógł rozpoznać (nieznana funkcja „\mathds”): {\displaystyle \displaystyle (\mathds{Z}, +)} Dobrze

Ćwiczenie Przynależność do języka

Wskaż stwierdzenia prawdziwe:

a.

$abbaaa\in \{aa,bb{\}}^{*}$

b.

$abbaaa\in \{a,b{\}}^{*}$

c.

$abbaaa\in \{abb,a{\}}^{*}$

d.

$abbaaa\in \{ba,ab{\}}^{*}$

e.

$abbaaa\in \{aa,ab,ba{\}}^{*}$

Rozwiązanie

b, c, e

Ćwiczenie Homomorfizmy

Wskaż, które z poniższych odwzorowań są homomorfizmami:

a.

Parser nie mógł rozpoznać (nieznana funkcja „\mathds”): {\displaystyle \displaystyle h: (\mathds{R},+) \rightarrow (\mathds{Z},+)} , $h(x)=3x$

b.

Parser nie mógł rozpoznać (nieznana funkcja „\mathds”): {\displaystyle \displaystyle h: (\mathds{R},+) \rightarrow (\mathds{R},+)} , $h(x)=3x$

c.

Parser nie mógł rozpoznać (nieznana funkcja „\mathds”): {\displaystyle \displaystyle h: (\mathds{R}, \cdot) \rightarrow (\mathds{R}, \cdot)} ,

$h(x)=3x$

d.

$h:\{a,b{\}}^{*}\to \{a,b{\}}^{*}$, $h(a)=a^2$,

$h(b)=a{b}^2$

e.

Parser nie mógł rozpoznać (nieznana funkcja „\mathds”): {\displaystyle \displaystyle h: \{a,b\}^* \rightarrow (\mathds{Z},+)} , $h(a)=1$,

$h(b)=1$

Rozwiązanie

b, d, e

Ćwiczenie System przepisujący

Dany niech będzie system przepisujący $RS=(\{a,b,c\},\{(a,b),(b,c),(b,a),(cc,b))$ oraz niech $I=\{ccb\}$. Wskaż stwierdzenia prawdziwe:

a.

$abc\in L_{gen}(RS,I)$

b.

$ccb\in L_{gen}(RS,I)$

c.

$bb\in L_{gen}(RS,I)$

d.

$aab\in L_{gen}(RS,I)$

e.

$aa\in L_{gen}(RS,I)$

Rozwiązanie

b, c, e

Ćwiczenie Wyrażenie regularne

Wyrażenie regularne

$((aa+bb{)}^{*}(ab+ba)(aa+bb{)}^{*}(ab+ba){)}^{*}(aa+bb{)}^{*}$

reprezentuje 

język:

a.

$\{w\in \{a,b{\}}^{*}:{\mathrm{♯}}_{a}w=2k$, ${\mathrm{♯}}_{b}w=2l$,

$k,l>0\}$

b.

$\{w\in \{a,b{\}}^{*}:{\mathrm{♯}}_{a}w-{\mathrm{♯}}_{b}w=0(mod2)\}$

c.

$\{w\in \{a,b{\}}^{*}:{\mathrm{♯}}_{a}w={\mathrm{♯}}_{b}w=2k,k\ge 0\}$

d.

$\{w\in \{a,b{\}}^{*}:{\mathrm{♯}}_{a}w-{\mathrm{♯}}_{b}w=1(mod2)\}$

e.

$\{w\in \{a,b{\}}^{*}:{\mathrm{♯}}_{a}w=4k$, ${\mathrm{♯}}_{b}w=4l$, $k,l\ge 0\}$

Rozwiązanie

a

Ćwiczenie Język regularny

Niech $A=\{a,b\}$ oraz $L=a{A}^{*}a$. Wskaż zdania prawdziwe:

a.

minimalny automat akceptujący $L$ ma 5 stanów

b.

ilość klas równoważności prawej kongruencji syntaktycznej

$P_L^r$ wyznaczonej przez $L$ jest równa 4

c.

$A^{*}\mathrm{\setminus }L=b{A}^{*}b+b$

d.

$A^{*}\mathrm{\setminus }L=b{A}^{*}+a{A}^{*}b+a+1$

e.

monoid przejśc minimalnego automatu akceptującego $L$ ma 6

elementów

Rozwiązanie

b, d, e

Ćwiczenie Język regularny a automat

Niech $L$ będzie dowolnym językiem regularnym. Wskaż zdania prawdziwe:

a.

$L$ jest rozpoznawany przez pewien niedeterministyczny

automat skończenie stanowy z pustymi przejściami

b.

$L$ jest rozpoznawany przez automat deterministyczny

skończenie stanowy

c.

$L$ 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 $L$ i taki, że zbiór stanów początkowych jest jednoelementowy

e.

Nie istnieje gramatyka lewoliniowa generująca $L$

Rozwiązanie

a, b, c

Ćwiczenie Język regularny a automat

Niech $L_1$, $L_2$ będą językami rozpoznawanymi odpowiednio przez automaty o $n_1$ i $n_2$ stanach. Aby stwierdzić, dla dowolnego słowa $w$, czy jest ono rozpoznawane przez oba automaty, wystarczy skonstruować odpowiedni automat mający

a.

$n_1\cdot n_2$ stanów

b.

$O(n_1+n_2)$ stanów

c.

$n_1$ stanów

d.

$n_2$ stanów

e.

3 stany

Rozwiązanie

a, b

Ćwiczenie Wyrażenia regularne

Język $L$ składa się ze wszystkich słów nad alfabetem $A=\{a,b\}$ nie zawierających podsłowa $a^3$. Wskaż wyrażenie regularne reprezentujące $L$:

a.

$(b^{*}(1+a+aa)b^{*}{)}^{*}$

b.

$(b^{*}(1+a+aa)b{b}^{*}{)}^{*}$

c.

$(b+ab+aab{)}^{*}+(b+ab+aab{)}^{*}a+(b+ab+aab{)}^{*}aa$

d.

$((1+a+aa)b{b}^{*}{)}^{*}(1+a+aa)$

e.

$b^{*}(a+aa)b{b}^{*}{)}^{*}(1+a+aa)$

Rozwiązanie

c, d, e

Ćwiczenie Języki regularne - warunki równoważne

Wskaż warunki równoważne temu, by język $L$ był akceptowany przez automat skończenie stanowy:

a.

Istnieje liczba naturalna $N\ge 1$ taka, że każde słowo

$w\in L$ o długości $|w|\ge N$ można przedstawić jako katenację $w=v_{1}u{v}_2$, gdzie $v_1,v_2\in A^{*}$, $u\in A^{+}$ oraz $v_1{u}^{*}{v}_2\subset L$.

b.

Istnieje skończony monoid $M$ i homomorfizm $\varphi :A^{*}\to M$ taki, że ${\varphi }^{-1}(\varphi (L))=L$.

c.

$L$ jest sumą wybranych klas równoważności pewnej

kongruencji $\rho$ na $A^{*}$: $L={\cup }_{w\in L}[w{]}_{\rho }.$

d.

$L\in {ℛ}{ℰ}{𝒢}(A^{*})$.

e.

$L$ jest akceptowany przez deterministyczny automat

skończenie stanowy z jednym stanem końcowym.

Rozwiązanie

b,d

Ćwiczenie Automat skończenie stanowy

Automat ${𝒜}=(S,A,s_0,f,F)$, gdzie $S=\{s_0,s_1,s_2,s_3\}$, $A=\{a,b\}$, $F=\{s_1\}$, {

{

Rozwiązanie

a,d

Ćwiczenie Równość wyrażeń regularnych

Które z poniższych równości dla wyrażeń regularnych są prawdziwe?

a.

$r^{*}{r}^{*}=r^{*}$

b.

$(r+s{)}^{*}=r^{*}+s^{*}$

c.

$(r^{*}+s^{*}{)}^{*}=(r^{*}{s}^{*}{)}^{*}$

d.

$r+r=r$

e.

$(rs{)}^{*}r=r(sr{)}^{*}$

Rozwiązanie

a,c,d,e

Ćwiczenie Języki regularne

Wskaż języki regularne:

a.

$\{w\in \{a,b{\}}^{*}:{\mathrm{♯}}_{a}w={\mathrm{♯}}_{b}w(mod3)\}$

b.

$\{w\in \{a,b{\}}^{*}:{\mathrm{♯}}_{a}w={\mathrm{♯}}_{b}w\}$

c.

$\{w\in \{a,b{\}}^{*}:|w|=2^n,n>0\}$

d.

$\{w\in \{a,b{\}}^{*}:{\mathrm{♯}}_{a}w\cdot {\mathrm{♯}}_{b}w=100\}$

e.

$\{a^n:n=3k$ lub $n=5k,k\ge 0\}$

Rozwiązanie

a,d,e

Ćwiczenie Automat skończenie stanowy

Dany jest automat ${𝒜}=(S,A,s_0,f,F)$, gdzie $S=\{s_0,s_1,s_2\}$, $A=\{a,b\}$, $F=\{s_0,s_1\}$,

{

{

Rozwiązanie

a,c

Ćwiczenie Automat niedeterministyczny

Dany niech będzie automat niedeterministyczny ${{𝒜}}_{ND}=(Q,A,\{q_0\},f,F)$, gdzie $Q=\{q_0,q_1,q_2\}$, $A=\{a,b\}$, $F=\{q_2\}$,

{

{

Rozwiązanie

a,b,e

Ćwiczenie Równość ${ℛ}{ℰ}{𝒞}(A^{*})={ℛ}{ℰ}{𝒢}(A^{*})$

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

Rozwiązanie

e

Ćwiczenie Monoid przejść

Wskaż monoid przejść automatu o następującej funkcji przejścia:

{

{

Rozwiązanie

a

Ćwiczenie Problemy rozstrzygalne

Niech $L_1,L_2$ będą językami regularnymi. Wskaż problemy rozstrzygalne.

a.

$w\in L_1$

b.

$w\in L_1\cap L_2$

c.

$L_1\cap L_2=\mathrm{\varnothing }$

d.

nieskończoność $L_1$

e.

$L_1=\mathrm{\varnothing }$

Rozwiązanie

a,b,c,d,e

Ćwiczenie Algorytm determinizacji automatu

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

Rozwiązanie

a, d

Ćwiczenie Algorytmy minimalizacji automatu

Wskaż zdania prawdziwe:

a.

istnieje algorytm minimalizacji automatu działający w

czasie $n\log n$

b.

żaden algorytm minimalizacji nie może działać szybciej niż

w czasie $O(n^2)$

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

Rozwiązanie

a

---

Test 11 Deklaracja data Nat = Zero | Nast Nat

deklaruje Zero jako element istniejącego wcześniej typu Nat Źle

deklaruje Nast jako funkcję działającą na istniejącym wcześniej typie Nat Źle

tworzy nowy typ o nazwie Nat; do typu tego należy m.in. element Zero Dobrze

jest niepoprawna Źle

Dla liczb naturalnych zdefiniowanych jak powyżej dodawanie f można określić pisząc f (x, Zero) \= x oraz:

f (x, Nast y) \= f (Nast x, y) Źle

f (x, Nast y) \= Nast (f (x, y)) Dobrze

f (Nast x, Nast y) \= Nast (f (x, y)) Źle

f (Nast x, y) \= Nast (f (x, y)) Źle

Załóżmy, że mamy już zdefiniowane dodawanie liczb naturalnych f. Która z poniższych definicji poprawnie zdefiniuje operator dodawania liczb naturalnych w typowej dla Haskella postaci rozwiniętej? Pomijamy kwestię sygnatury.

+ \= curry f Źle

+ \= f Źle

(+) \= curry f Dobrze

(+) \= f Źle

Która definicja poprawnie określi funkcję f pobierającą pierwszy element pary? Pomijamy kwestię sygnatury.

f x y \= x Źle

f (x, y) \= x Dobrze

(f) x y \= x Źle

(f) (x, y) \= x Źle

Która lista jest niepoprawna?

[1, 2, 3] Źle

[1, [2]] Dobrze

[[1, 2, 3], [4, 5], [6]] Źle

[[], []] Źle

Operator ++ służy w Haskellu do:

łączenia list Dobrze

obliczania długości listy Źle

odwracania listy Źle

nie ma takiego operatora Źle

Wyrażenie map (+1) [1, 2, 3] daje w wyniku:

liczbę 4 Źle

liczbę 6 Źle

listę [2, 3, 4] Dobrze

to wyrażenie jest niepoprawne Źle

Wyrażenie filter (<0) [–1, 0, 1, -2] daje w wyniku:

liczbę -1 Źle

listę [-1, -2] Dobrze

listę [0, 1] Źle

to wyrażenie jest niepoprawne Źle

Wyrażenie [(x, y) | x <- [1..4], y <- [1..3]] wytworzy:

listę o długości 4 Źle

listę o długości 12 Dobrze

parę liczb całkowitych (4, 3) Źle

to wyrażenie jest niepoprawne Źle

Wyrażenie [x + y | x <- [1..3], y <- [1..3]] wytworzy:

liczbę 6 Źle

listę o długości 5 Źle

listę o długości 9 Dobrze

to wyrażenie jest niepoprawne Źle

Test 9 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>
  
  rachunek lambda  Dobrze

  
  teorię mnogości  Źle

  
  rachunek sigma w ogóle nie zajmuje się obiektami  Źle

Podobnie jak w rachunku sigma, obiekty bez klas pojawiają się w języku:

  
  C++ Źle

  
  C Źle

  
  Java  Źle

  
  JavaScript  Dobrze

Która relacja nie pasuje do pozostałych w kontekście języka C++?

  
  relacja dziedziczenia  Źle

  
  relacja podklasy  Źle

  
  relacja podtypu  Źle

  
  relacja zawierania bloków kodu  Dobrze

W rachunku sigma obiekt to zbiór metod, dla których mamy dwie operacje -- wywołanie i:

  
  nadpisanie  Dobrze

  
  pobranie historii wywołań  Źle

  
  zapamiętanie wyniku  Źle

  
  zliczenie parametrów  Źle

W rachunku sigma każda metoda posiada ciało oraz parametr reprezentujący:

  
  historię wywołań  Źle

  
  jaźń obiektu  Dobrze

  
  nazwę obiektu  Źle

  
  wynik obliczeń  Źle

Zapis $[l=\varsigma (x)[]]$ oznacza:

  
  obiekt pusty  Źle

  
  obiekt zawierający metodę pustą  Źle

  
  obiekt zawierający jedną metodę, zwracającą obiekt pusty  Dobrze

  
  ten zapis jest niepoprawny  Źle

Jeśli $o$ jest obiektem $[l=\varsigma (x)x.l]$, to wywołanie $o.l$ da w wyniku:

  
  obiekt pusty  Źle

  
  obiekt $o$ Źle

  
  $o.l$ Źle

  
  wywołanie to nie da wyniku, gdyż obliczenia nie kończą się  Dobrze

Jeśli $o$ jest obiektem $[l=\varsigma (x)x]$, to wywołanie $o.l$ da w wyniku:

  
  obiekt pusty  Źle

  
  obiekt $o$ Dobrze

  
  $o.l$ Źle

  
  wywołanie to nie da wyniku, gdyż obliczenia nie kończą się  Źle

Relacja redukcji (rozszerzona, z gwiazdką) w rachunku sigma spełnia własność Churcha-Rossera. Oznacza to, że jeśli $a{\to }^{*}b$ i $a{\to }^{*}c$, to:

  
  $b=c$ Źle

  
  $b{\to }^{*}c$ Źle

  
  $c{\to }^{*}b$ Źle

  
  istnieje $d$ takie, że $b{\to }^{*}d$ i $c{\to }^{*}d$ Dobrze

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?

  
  obliczenia nieskończone  Źle

  
  wyliczenie wartości, która nie jest poprawnym wynikiem  Dobrze

  
  wyliczenie poprawnego wyniku  Źle

  
  zgłoszenie błędu w wyrażeniu  Źle

Test 10 Zapisany w Haskellu nagłówek f \:\: (Integer -> Integer) -> (Integer -> Integer) deklaruje f jako funkcję, której parametrami i wynikiem są:

parametr\: funkcja biorąca liczbę całkowitą i zwracająca liczbę całkowitą, wynik\: takaż funkcja Dobrze

parametry\: dwie liczby całkowite, wynik\: dwie liczby całkowite Źle

parametr\: liczba całkowita, wynik\: liczba całkowita i funkcja biorąca liczbę całkowitą i zwracająca liczbę całkowitą Źle

taka deklaracja nie jest w Haskellu poprawna Źle

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?

dopasowywanie do wzorca Źle

dozory Źle

if-then-else Źle

switch Dobrze

Haskellowy typ Integer obejmuje liczby całkowite mieszczące się:

w dwóch bajtach Źle

w czterech bajtach Źle

to zależy od implementacji Źle

bez ograniczeń (Haskell przydziela dostępną pamięć w miarę potrzeby) Dobrze

W nagłówku kw :: Num a \=> a -> a określamy typ parametru i wyniku funkcji kw jako:

Num Źle

dowolny typ z klasy Num Dobrze

dowolny typ, bez ograniczeń Źle

ta deklaracja jest niepoprawna Źle

Jeśli funkcja ma typ (Float, Float) -> Float, to po rozwinięciu będzie miała typ:

Float -> (Float -> Float) Dobrze

Float -> (Float, Float) Źle

(Float -> Float) -> Float Źle

rozwinięcie nie jest w tym przypadku możliwe Źle

Zapis Float -> Float -> Float jest interpretowany jako:

Float -> (Float -> Float) Dobrze

Float -> (Float, Float) Źle

(Float -> Float) -> Float Źle

nawiasy są tu konieczne, nie można ich pominąć Źle

Typ [(Integer,Integer)] oznacza:

listę liczb całkowitych o długości ograniczonej do dwóch elementów Źle

listę par liczb całkowitych Dobrze

parę list liczb całkowitych Źle

taki typ nie jest poprawny Źle

Które użycie operatora dodawania jest w Haskellu niepoprawne?

1 + 2 Źle

(+) 1 2 Źle

((+) 1) 2 Źle

(+)(1, 2) Dobrze

Jeśli funkcja f jest typu Integer -> Integer -> Integer, to `f` (nazwa funkcji ujęta w odwrócone apostrofy) jest:

funkcją typu (Integer, Integer) -> Integer Źle

funkcją typu (Integer -> Integer) -> Integer Źle

operatorem, którego można używać infiksowo, np. 1 `f` 2 Dobrze

zapis taki jest niepoprawny Źle

Zapis (3 +) oznacza:

funkcję typu Integer -> Integer Dobrze

parę złożoną z liczby 3 i znaku plus Źle

trzyargumentową wersję operatora dodawania Źle

zapis taki jest niepoprawny Źle

Używane w Prologu klauzule Horna mają w następniku:

co najmniej jeden term Źle

dokładnie jeden term Źle

dokładnie dwa termy Źle

zero lub jeden term Dobrze

Stosowana w Prologu metoda wnioskowania to:

indukcja pozaskończona Źle

rezolucja Dobrze

unifikacja Źle

zasada instancjonowania prostego Źle

Klauzula ,,dziadek(X, Z) \:- ojciec(X, Y), ojciec(Y, Z)".:

mówi tylko, że jeśli X jest ojcem Y i Y jest ojcem Z, to X jest dziadkiem Z Dobrze

wyklucza, by któs mógł być swoim własnym dziadkiem Źle

wyklucza, by któs mógł być swoim własnym ojcem Źle

jest niepoprawna składniowo Źle

Do tworzenia i rozkładania list w Prologu stosuje się:

funkcje cons, head i tail Źle

operatory ++, + i - Źle

operator | i odpowiednie dopasowania Dobrze

w Prologu nie ma list Źle

Zapis ,,X is 3 * Y + 4 w Prologu powoduje:

podstawienie wartości wyrażenia 3*Y+4 pod zmienną X Źle

utożsamienie (lub sprawdzenie utożsamienia) zmiennej X z wartością wyrażenia 3*Y+4 Dobrze

wypisanie rozwiązania równania X\=3*Y+4 Źle

taki zapis jest niepoprawny Źle

Jeśli Prologowi nie uda się udowodnić jednego z podcelów, to:

wraca do poprzednich podcelów, próbując znaleźć alternatywne rozwiązania Dobrze

wypisuje komunikat o niepowodzeniu rezolucji Źle

zgłasza błąd wykonania Źle

nie robi nic, tzn. kontynuuje działanie Źle

Dla stwierdzeń złożonych Prolog stosuje:

przeszukiwanie w głąb Dobrze

przeszukiwanie wszerz Źle

przeszukiwanie w głąb lub wszerz, w zależności od dostępnej pamięci Źle

inną metdoę, nie wymienioną tutaj Źle

Zapis [X | Y] w Prologu oznacza:

konkatenację list X i Y Źle

listę, gdzie X jest głową, a Y -- ogonem listy Dobrze

parę uporządkowaną złożoną z elementów X i Y Źle

wyrażenie warunkowe z dozorem X Źle

Jaką klauzulę należałoby dopisać przed ,,f(X, [_ | Y]) \:- f(X, Y).", by otrzymać funktor sprawdzający przynależność elementu do listy?

f(X, []). Źle

f(X, [X]). Źle

f(X, [X | _]). Dobrze

tego nie da się tak zrobić Źle

Lista [1, [2, 3], 4, []] ma długość:

3 Źle

4 Dobrze

5 Źle

jest niepoprawna składniowo Źle

Test 6

Czego z zasady nie ma w językach funkcyjnych?

parametrów z domyślnymi wartościami Źle

pętli Dobrze

wyrażeń warunkowych Źle

wywołań rekurencyjnych Źle

Która cecha jest typowa dla języków funkcyjnych, a rzadko występuje w językach imperatywnych i obiektowych?

kompilacja do kodu pośredniego Źle

możliwość używania funkcji wyższego rzędu Dobrze

silne typowanie Źle

zaawansowane konstrukcje enkapsulacyjne Źle

Listy służą w Lispie do zapisywania:

tylko danych Źle

tylko kodu Źle

i danych, i kodu Dobrze

w Lispie nie ma list Źle

Wywołanie ((LAMBDA (x) (* x x)) 2) w języku Scheme:

podstawi 2 pod wskaźnik do zmiennej x Źle

wyświetli 4 Dobrze

zdefiniuje gwiazdkę jako operator o priorytecie 2 Źle

zdefiniuje LAMBDA jako funkcję dwuargumentową Źle

Funkcja DISPLAY w języku Scheme:

nie ma żadnych efektów ubocznych Źle

nie może być używana wewnątrz funkcji rekurencyjnej Źle

wyświetla opis stanu interpretera Źle

wyświetla swój argument na ekranie Dobrze

Wartością wyrażenia (CAR ‘(A B C)) w języku Scheme jest:

A Dobrze

(B C) Źle

C Źle

to wyrażenie jest niepoprawne Źle

Wartością wyrażenia (CONS ‘(A B) ‘(C D)) w języku Scheme jest:

(A B C D) Źle

(A B (C D)) Źle

((A B) C D) Dobrze

to wyrażenie jest niepoprawne Źle

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)?

(f (f x)) Dobrze

f(f(x)) Źle

((f f) x) Źle

składanie funkcji nie jest w tym języku dozwolone Źle

Które stwierdzenie nie jest prawdziwe w odniesieniu do języka ML?

lista może zawierać elementy różnych typów Dobrze

można pisać funkcje polimorficzne Źle

ML stosuje niejawne nadawanie typów Źle

wyrażenia arytmetyczne zapisuje się w postaci infiksowej Źle

Do łączenia list w Haskellu służy:

funkcja CONS Źle

operator ++ Dobrze

operator & Źle

nie ma operatora, po prostu zapisuje się dwie listy obok siebie Źle

Test 5 Której cechy język obiektowy nie musi posiadać?

abstrakcyjne typy danych Źle

dynamiczne wiązanie wywołań metod z metodami Źle

dziedziczenie Źle

podprogramy rodzajowe Dobrze

Jakie ograniczenie na przedefiniowywanie metod trzeba narzucić w języku silnie typowanym?

przedefiniowana metoda musi być bezparametrowa Źle

przedefiniowana metoda musi być typu void Źle

przedefiniowana metoda musi zachować taki sam protokół Dobrze

nie trzeba narzucać żadnych ograniczeń Źle

Rozstrzyganie odwołań do bytów o takiej samej nazwie mających definicje w dwóch klasach bazowych odbywa się w C++ za pomocą:

operatora \:\: (dwa dwukropki) Dobrze

operatora . (kropka) Źle

tego nie da się zrobić Źle

dziedziczenie wielokrotne nie jest w C++ dozwolone Źle

W języku C++ obiekty zaalokowane na stosie dealokowane są:

niejawnie Dobrze

za pomocą delete Źle

za pomocą free Źle

w C++ nie ma takich obiektów Źle

Językiem, w którym stosowane jest zawsze dynamiczne wiązanie wywołań z metodami, jest:

C++ Źle

C\# Źle

Java Źle

Smalltalk Dobrze

Językiem, w któym klasa może być samoistna (tzn. nie mieć nadlasy), jest:

C++ Dobrze

C\# Źle

Java Źle

Smalltalk Źle

W języku C++ metody, które mają być wiązane dynamicznie, deklaruje się za pomocą:

operatora -> (strzałka) Źle

słowa abstract Źle

słowa dynamic Źle

słowa virtual Dobrze

Który nagłówek poprawnie deklaruje w C++ metodę abstrakcyjną?

virtual void p(); Źle

virtual void p() \=0; Dobrze

void p() \=0; Źle

abstract void p(); Źle

Klasy ,,lekkie, deklarowane jako struct, alokowane na stosie i nie pozwalające na dziedziczenie występują w:

C++ Źle

C\# Dobrze

Javie Źle

we wszystkich wymienionych tu językach Źle

Który element nie występuje w JavaScripcie?

klasy Dobrze

obiekty złożone z par (nazwa własności, wartość) Źle

operator new Źle

zmienne Źle

Test 4 Który język nie pozwala na użycie parametrów z wartością domyślną?

Ada Źle

C Dobrze

C++ Źle

PHP Źle

Przekazanie funkcji jako parametru można w C\# osiągnąć za pomocą mechanizmu:

bezpośrednio, bez dodatkowych mechanizmów Źle

delegatów Dobrze

tablic wielowymiarowych Źle

wskaźników do funkcji Źle

Który język nie sprawdza zgodności typów parametrów?

Ada Źle

C# Źle

Java Źle

PHP Dobrze

Przy której deklaracji procedury f wywołanie f(2*x + 3) jest poprawne?

procedure f(n: in out Integer) w Adzie Źle

procedure f(n: out Integer) w Adzie Źle

void f(int n) w języku C Dobrze

void f(int *n) w języku C Źle

Chcąc w języku C przekazać do funkcji tablicę przez wartość, trzeba:

,,obudować ją strukturą i przekazać tę strukturę Dobrze

użyć nawiasów kwadratowych po nazwie tablicy w wywołaniu funkcji Źle

użyć nawiasów kwadratowych po nazwie parametru w nagłówku funkcji Źle

nie trzeba robić niczego szczególnego Źle

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?

nie mogą być zmieniane nawet w obrębie podprogramu Dobrze

są zawsze alokowane statycznie Źle

wymuszają statyczne sprawdzenie zgodności typu Źle

nie mają żadnej dodatkowej cechy Źle

Załóżmy, że x jest parametrem w trybie out w procedurze w Adzie. Która instrukcja ma szansę być poprawna?

x \:\= x + 1 Źle

x \:\= y + 1 Dobrze

y \:\= x + 1 Źle

y \:\= T(x) Źle

Jawne przekazywanie przez referencję jest w C\# możliwe, jeśli umieścimy słowo kluczowe ref:

przy parametrze aktualnym Źle

przy parametrze formalnym Źle

i przy parametrze formalnym, i przy aktualnym Dobrze

to w ogóle nie jest możliwe Źle

W językach z zakresem widoczności zmiennych wiązanym statycznie jako środowiska wykonywania przekazanego przez parametr podprogramu najczęściej używa się:

środowiska instrukcji (w podprogramie), wywołującej przekazany podprogram Źle

środowiska definicji przekazanego podprogramu Dobrze

środowiska instrukcji, która przekazała podprogram jako parametr Źle

żadnego z wymienioinych środowisk Źle

W implementacji podprogramów bez zagnieżdżeń, ale z rekurencją i z dynamicznymi zmiennymi lokalnymi na stosie potrzebne jest przechowywanie w rekordzie aktywacyjnym:

tylko łącza dynamicznego Dobrze

tylko łącza statycznego Źle

łącza dynamicznego i statycznego Źle

żadnego z nich Źle

Test 3 Pojęcie typu w językach imperatywnych bliskie jest pojęciu:

całki Riemanna Źle

pary uporządkowanej Źle

zbioru nieskończonego Źle

zbioru skończonego Dobrze

Który z opisanych poniżej typów można uznać za typ abstrakcyjny? Rzecz dzieje się w języku C:

struktura wraz z kilkoma działającymi na niej funkcjami Źle

typ wskaźnikowy T *, gdzie T jest zdefiniowane następująco\: typedef int T[10]; Źle

wbudowany typ float Dobrze

unia złożona z pól tego samego typu Źle

W której sytuacji tablica asocjacyjna byłaby istotnie wygodniejsza niż zwykła tablica?

mamy katalogi ponumerowane od 1 do 100 i zapisujemy ich rozmiar Źle

sortujemy obszerną tablicę liczb typu double Źle

wyszukujemy największą liczbę w tablicy Źle

zapisujemy kolor przejeżdżających samochodów, identyfikując je numerami rejestracyjnymi Dobrze

Ewentualne luki między przechowywanymi w pamięci polami rekordu biorą się z:

konieczności sprawdzenia zgodności typów Źle

konieczności umieszczania pól pod adresami, których 1 lub 2 najmniej znaczące bity są zerami Dobrze

niedoskonałości kompilatorów Źle

szybkich przesunięć cyklicznych w jednostce arytmetyczno-logicznej procesora Źle

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?

istnieje kilka rozmiarów liczb całkowitych Źle

napisy mogą zawierać nieistotne znaki za znacznikiem końca Dobrze

nie można z góry przewidzieć, czy napisy są zapisane w kodzie ASCII, czy Unicode Źle

reprezentacja liczb float i double nie jest jednoznaczna Źle

Który operator języka C jest potrzebny, gdy wykorzystujemy wskaźniki do adresowania pośredniego?

& Dobrze

++ Źle

-- Źle

nawiasy kwadratowe do indeksowania Źle

Załóżmy, że p jest zmienną wskaźnikową. W którym języku wyrażenie ++p jest poprawne?

C++ Dobrze

C\# Źle

Java Źle

Pascal Źle

Które stwierdzenie jest fałszywe w odniesieniu do klas w języku C++?

definicja klasy nie musi zawierać destruktora Źle

funkcje z klasy mogą być kompilowane jako inline Źle

konstruktor ma taką samą nazwę jak klasa Źle

konstruktor nie może być przeciążany Dobrze

W Javie obiekty są alokowane:

dynamicznie na stercie Dobrze

dynamicznie na stosie Źle

statycznie na stercie Źle

statycznie na stosie Źle

Sparametryzowane typy abstrakcyjne uzyskuje się w C++ za pomocą deklaracji z użyciem słowa kluczowego:

args Źle

generic Źle

params Źle

template Dobrze

Test 2 Program może zawierać dwie różne zmienne o tej samej nazwie, gdy są to zmienne:

alokowane dynamicznie Źle

globalne Źle

lokalne w dwóch różnych blokach Dobrze

lokalne w tym samym bloku Źle

L-wartością nazywamy:

bieżący adres zmiennej Dobrze

wynik wyrażenia arytmetycznego Źle

indeks tablicy Źle

wartość zmiennej po dokonaniu podstawienia Źle

Wiązanie statyczne:

może zmienić się w trakcie wykonania programu Źle

następuje w trakcie wykonania programu Źle

następuje przed wykonaniem programu Dobrze

odnosi się tylko do zmiennych globalnych Źle

Wnioskowanie o typie zmiennej jest najczęstsze w językach:

funkcyjnych Dobrze

logicznych Źle

obiektowych Źle

nie występuje w żadnym przyzwoitym języku Źle

Okres życia zmiennej to:

czas pomiędzy alokacją zmiennej a jej dealokacją Dobrze

czas od uruchomienia programu do chwili wykonania na tej zmiennej delete, free itp. Źle

obszar kodu pomiędzy deklaracją zmiennej a końcem zawierającego ją bloku Źle

czas od pierwszego podstawienia pod tę zmienną do ostatniego jej użycia w programie Źle

Obiekty w Javie są alokowane:

dynamicznie, na stercie Dobrze

dynamicznie, na stosie Źle

dynamicznie, na stosie lub na stercie (decyzję podejmuje kompilator) Źle

statycznie Źle

Spośród wymienionych tu języków najbliższy silnemu typowaniu jest:

C Źle

C++ Źle

C\# Dobrze

PHP Źle

Silne typowanie bywa ,,osłabiane przez:

jawne konwersje typów Źle

niejawne konwersje typów Dobrze

dynamiczne sprawdzanie zgodności typów Źle

statyczne sprawdzanie zgodności typów Źle

Podtyp to:

typ powstały przez ograniczenie zakresu istniejącego typu, zgodny z owym typem Dobrze

nowy typ oparty na już istniejącym, niezgodny z dotychczasowym Źle

typ tablicowy, w którym ograniczono zakres indeksów Źle

jedno z pól unii Źle

W języku C++ dostęp do przesłoniętej zmiennej nielokalnej można uzyskać za pomocą operatora:

\:\: (dwa dwukropki) Dobrze

. (kropka) Źle

* (gwiazdka) Źle

-> (strzałka) Źle