Test GR

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

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

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>

switch Dobrze

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>

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: <wrongoption reply=„Źle”>Num</wrongoption>

dowolny typ z klasy Num Dobrze

<wrongoption reply=„Źle”>dowolny typ, bez ograniczeń</wrongoption> <wrongoption reply=„Źle”>ta deklaracja jest niepoprawna</wrongoption>

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

Float -> (Float -> Float) Dobrze

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

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

Float -> (Float -> Float) Dobrze

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

Typ [(Integer,Integer)] oznacza: <wrongoption reply=„Źle”>listę liczb całkowitych o długości ograniczonej do dwóch elementów</wrongoption>

listę par liczb całkowitych Dobrze

<wrongoption reply=„Źle”>parę list liczb całkowitych</wrongoption> <wrongoption reply=„Źle”>taki typ nie jest poprawny</wrongoption>

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>

(+)(1, 2) Dobrze

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>

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

<wrongoption reply=„Źle”>zapis taki jest niepoprawny</wrongoption>

Zapis (3 +) oznacza:

funkcję typu Integer -> Integer Dobrze

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

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