|
|
Linia 623: |
Linia 623: |
| a | | a |
| </div></div> | | </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 type="exclusive">
| |
| 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">
| |
| 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.
| |
| <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">
| |
| Która lista jest niepoprawna?
| |
| <wrongoption reply="Źle">[1, 2, 3]</wrongoption>
| |
| <rightoption reply="Dobrze">[1, [2]]</rightoption>
| |
| <wrongoption reply="Źle">[[1, 2, 3], [4, 5], [6]]</wrongoption>
| |
| <wrongoption reply="Źle">[[], []]</wrongoption>
| |
| </quiz>
| |
|
| |
| <quiz type="exclusive">
| |
| Operator ++ służy w Haskellu do:
| |
| <rightoption reply="Dobrze">łączenia list</rightoption>
| |
| <wrongoption reply="Źle">obliczania długości listy</wrongoption>
| |
| <wrongoption reply="Źle">odwracania listy</wrongoption>
| |
| <wrongoption reply="Źle">nie ma takiego operatora</wrongoption>
| |
| </quiz>
| |
|
| |
| <quiz type="exclusive">
| |
| 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">
| |
| Wyrażenie filter (<0) [–1, 0, 1, -2] daje w wyniku:
| |
| <wrongoption reply="Źle">liczbę -1</wrongoption>
| |
| <rightoption reply="Dobrze">listę [-1, -2]</rightoption>
| |
| <wrongoption reply="Źle">listę [0, 1]</wrongoption>
| |
| <wrongoption reply="Źle">to wyrażenie jest niepoprawne</wrongoption>
| |
| </quiz>
| |
|
| |
| <quiz type="exclusive">
| |
| 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">
| |
| Wyrażenie [x + y | x <- [1..3], y <- [1..3]] wytworzy:
| |
| <wrongoption reply="Źle">liczbę 6</wrongoption>
| |
| <wrongoption reply="Źle">listę o długości 5</wrongoption>
| |
| <rightoption reply="Dobrze">listę o długości 9</rightoption>
| |
| <wrongoption reply="Źle">to wyrażenie jest niepoprawne</wrongoption>
| |
| </quiz>
| |
|
| |
|
| |
|
| |
|
| |
|
| |
|
| |
|
| |
|
| |
|
| |
|
| |
|
| |
|
| |
| 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 type="exclusive">
| |
| 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">
| |
| Która relacja nie pasuje do pozostałych w kontekście języka C++?
| |
| <wrongoption reply="Źle"> relacja dziedziczenia </wrongoption>
| |
| <wrongoption reply="Źle"> relacja podklasy </wrongoption>
| |
| <wrongoption reply="Źle"> relacja podtypu </wrongoption>
| |
| <rightoption reply="Dobrze"> relacja zawierania bloków kodu </rightoption>
| |
| </quiz>
| |
|
| |
| <quiz type="exclusive">
| |
| 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">
| |
| W rachunku sigma każda metoda posiada ciało oraz parametr reprezentujący:
| |
| <wrongoption reply="Źle"> historię wywołań </wrongoption>
| |
| <rightoption reply="Dobrze"> jaźń obiektu </rightoption>
| |
| <wrongoption reply="Źle"> nazwę obiektu </wrongoption>
| |
| <wrongoption reply="Źle"> wynik obliczeń </wrongoption>
| |
| </quiz>
| |
|
| |
| <quiz type="exclusive">
| |
| 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">
| |
| 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
| |
| w wyniku:
| |
| <wrongoption reply="Źle"> obiekt pusty </wrongoption>
| |
| <wrongoption reply="Źle"> obiekt <math>\displaystyle o</math></wrongoption>
| |
| <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>
| |
| </quiz>
| |
|
| |
| <quiz type="exclusive">
| |
| 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">
| |
| Relacja redukcji (rozszerzona, z gwiazdką) w rachunku sigma spełnia
| |
| własność Churcha-Rossera. Oznacza to, że jeśli <math>\displaystyle a \to^* b</math> i <math>\displaystyle a \to^* c</math>, to:
| |
| <wrongoption reply="Źle"> <math>\displaystyle b = c</math></wrongoption>
| |
| <wrongoption reply="Źle"> <math>\displaystyle b \to^* c</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>
| |
| </quiz>
| |
|
| |
| <quiz type="exclusive">
| |
| 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>
| |
|
| |
|
| |
|
| |
|
| |
|
| |
|
| |
|
| |
|
| |
|
| |
|
| |
|
| |
|
| |
|
| |
|
| |
|
| |
| Test 10
| |
| <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">
| |
| 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">
| |
| 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>
| |