zwierzak/deklaratywne-machen
1
0
Fork 0
forked from ZoltyKaplan/deklaratywne-machen
Code Pull Requests Activity

Initial QAML question data

Browse Source
This commit is contained in:
ZoltyKaplan
2026-05-18 16:40:38 +02:00
commit ac3490f4f4
7 changed files with 1010 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

17
.github/pull_request_template.md vendored Normal file
View File

@@ -0,0 +1,17 @@
## Co zmieniasz?
- [ ] poprawiam treść pytania
- [ ] poprawiam odpowiedź
- [ ] dodaję nowe pytanie
- [ ] dodaję/zmieniam obrazek w `img/`
- [ ] usuwam duplikat albo błąd
## Źródło / uzasadnienie
Opisz krótko skąd pochodzi poprawka albo dlaczego obecna wersja jest błędna.
## Checklist
- [ ] każde pytanie i każda odpowiedź mieści się w jednej linii
- [ ] każda odpowiedź zaczyna się od `-` albo `-|`
- [ ] obrazki użyte jako `img/...` istnieją w repozytorium

14
.github/workflows/validate.yml vendored Normal file
View File

@@ -0,0 +1,14 @@
name: Validate QAML
on:
pull_request:
push:
branches: [main]
jobs:
validate:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- name: Validate pytania.txt
run: php tools/validate_qaml.php pytania.txt

6
.gitignore vendored Normal file
View File

@@ -0,0 +1,6 @@
ip.txt
ip.txt.old
*.log
*.bak
*.old
.DS_Store

13
CONTRIBUTING.md Normal file
View File

@@ -0,0 +1,13 @@
# Jak zgłaszać poprawki
Poprawki zgłaszamy przez Pull Request.
Najczęstsze dobre zmiany:
- poprawienie literówki,
- oznaczenie prawidłowej odpowiedzi jako `-|`,
- usunięcie błędnej odpowiedzi,
- dopisanie źródła w komentarzu `//`,
- dodanie brakującego obrazka do `img/`.
Nie zmieniaj formatu pliku na pełny Markdown, JSON, CSV ani HTML. To repozytorium używa prostego formatu QAML opisanego w `README.md`.

203
README.md Normal file
View File

@@ -0,0 +1,203 @@
# Baza pytań quizu
To repozytorium zawiera dane quizu: `pytania.txt` oraz opcjonalny katalog `img/` z obrazkami używanymi w pytaniach.
Kod aplikacji nie jest częścią tego repozytorium. Zmiany w pytaniach należy zgłaszać przez Pull Request.
## QAML — Question Answer Markdown Lines
QAML to prosty liniowy format zapisu pytań testowych wielokrotnego wyboru.
Format wygląda jak Markdown, ale jego składnia strukturalna jest znacznie prostsza. Parser nie analizuje pełnego Markdowna. Interpretuje wyłącznie początki linii:
- linia pytania,
- linia odpowiedzi błędnej,
- linia odpowiedzi poprawnej,
- komentarz,
- pusta linia.
Treść pytania i odpowiedzi może zawierać Markdown, HTML oraz inline LaTeX, ale parser traktuje je jako zwykły tekst.
## Minimalny przykład
```text
// Przykładowa sekcja
Zaznacz zdania prawdziwe
- To jest odpowiedź błędna.
-| To jest odpowiedź poprawna.
- To jest kolejna odpowiedź błędna.
Ile wynosi $2 + 2$?
- 3
-| 4
- 5
```
## Reguły składni
### 1. Pytanie
Pytaniem jest każda niepusta linia, która:
- nie zaczyna się od znaku `-`,
- nie zaczyna się od `//`.
Pytanie musi mieścić się w jednej linii.
Poprawnie:
```text
Zaznacz zdania prawdziwe dotyczące indukcji matematycznej.
```
Niepoprawnie:
```text
Zaznacz zdania prawdziwe
dotyczące indukcji matematycznej.
```
Drugi zapis zostanie zinterpretowany jako dwa osobne pytania.
### 2. Odpowiedź błędna
Odpowiedź błędna zaczyna się od pojedynczego myślnika `-`.
Poprawne są oba style:
```text
- Odpowiedź błędna
-Odpowiedź błędna
```
Parser usuwa znak `-`, a następnie przycina białe znaki z początku i końca odpowiedzi.
### 3. Odpowiedź poprawna
Odpowiedź poprawna zaczyna się od `-|`.
Poprawne są oba style:
```text
-| Odpowiedź poprawna
-|Odpowiedź poprawna
```
Parser usuwa prefiks `-|`, a następnie przycina białe znaki z początku i końca odpowiedzi.
### 4. Pytania jednokrotnego i wielokrotnego wyboru
Format dopuszcza dowolną liczbę poprawnych odpowiedzi, w tym zero poprawnych odpowiedzi albo wszystkie odpowiedzi poprawne.
Pytanie jednokrotnego wyboru:
```text
Ile wynosi $2 + 2$?
- 3
-| 4
- 5
```
Pytanie wielokrotnego wyboru:
```text
Wskaż liczby pierwsze
-| 2
-| 3
- 4
-| 5
```
Parser nie narzuca liczby poprawnych odpowiedzi. Zero poprawnych odpowiedzi może oznaczać zadanie, w którym żadna odpowiedź nie jest prawdziwa, a oznaczenie wszystkich odpowiedzi jako `-|` może oznaczać zadanie, w którym wszystkie odpowiedzi są prawdziwe.
### 5. Komentarze
Komentarzem jest linia zaczynająca się od `//`.
Przykłady:
```text
// Sterna 2024/2025 B
// Formanowicz 2021-2022
```
Komentarze są ignorowane przez parser demonstracyjny. Można ich używać jako nagłówków sekcji, źródeł, dat albo notatek.
### 6. Puste linie
Puste linie są ignorowane. Można ich używać do oddzielania pytań, odpowiedzi lub sekcji.
## LaTeX
Dozwolony jest inline LaTeX między pojedynczymi znakami dolara:
```text
Ile wynosi $\binom{n}{k}$?
```
Dozwolony przykład:
```text
-| Liczba kombinacji wynosi $\binom{n}{k}$.
```
Nie jest częścią formalnej składni:
```text
$$
a^2 + b^2 = c^2
$$
```
oraz:
```text
\[ a^2 + b^2 = c^2 \]
```
Parser demonstracyjny nie waliduje poprawności LaTeX-a. Traktuje zapis `$...$` jako zwykły fragment tekstu.
## HTML i obrazki
HTML jest dopuszczony jako część treści pytania lub odpowiedzi.
Przykład:
```text
Zaznacz funkcję odpowiadającą obrazkowi <img src="img/example.png" height="100" />
-| $f(x) = x^2$
- $f(x) = x$
```
Jeżeli `pytania.txt` odwołuje się do obrazka przez `img/...`, plik musi istnieć w katalogu `img/` w tym repozytorium.
## Jedna linia = jeden element
To najważniejsza zasada formatu.
Każde pytanie i każda odpowiedź muszą mieścić się w jednej fizycznej linii.
Poprawnie:
```text
Zaznacz zdania prawdziwe dotyczące funkcji $f(x) = x^2$.
-| Funkcja jest parzysta.
- Funkcja jest nieparzysta.
```
Niepoprawnie:
```text
Zaznacz zdania prawdziwe dotyczące funkcji
$f(x) = x^2$.
-| Funkcja jest parzysta.
```
Parser potraktuje drugą linię jako nowe pytanie.
## Walidacja lokalna
```bash
php tools/validate_qaml.php pytania.txt
```

667
pytania.txt Normal file
View File

@@ -0,0 +1,667 @@
// BAZA PYTAŃ - PROGRAMOWANIE DEKLARATYWNE
// Deklaratywne - PDF zadania z sugerowanymi
Mając na uwadze fakt, iż negacja w języku Prolog realizowana jest przez niepowodzenie należy dla faktów q(a,b).q(a,c). oraz reguły s(X,Y) :- not(X=Y), q(Z,X), q(Z,Y). wybrać odpowiedź będącą rezultatem zapytania ?- s(P,R). :
-| False
- P=_G327 R=_G417i
- P=b R=c; P=c R=b; False
- P=a R=b; P=b R=c; P=a R=c; False
Elementy programu prologowego, które decydują o jego interpretacji proceduralnej to:
-| kolejność reguł w programie
- sumaryczna liczba odcięć w regułach
-| kolejność warunków w regułach
-| umiejscowienie odcięć w regułach
- sumaryczna liczba reguł w programie
Weryfikacja rodzaju termu odbywa się w języku Prolog za pomocą następujących metapredykatów systemowych:
- name
- functor
-| atom
- setof
-| var
- arg
-| atomic
Do rodziny predykatów, umożliwiających automatyczną generację (w postaci listy) wszystkich rozwiązań celu, uzyskiwanych w drodze nawrotów zaliczamy następujące metapredykaty systemowe:
- repeat
-| bagof
- forall
-| findall
-| setof
- call
- assert
Predykaty użytkownika mogą być argumentami wywołania następujących metapredykatów systemowych:
- repeat
-| bagof
-| setof
-| findall
-| assert
-| not
-| call
Które z poniższych zapytań zakończą się spełnieniem celu :
- ?- X=Z, Y=Z, X\==Y.
-| ?- X=Z, Y=Z, X==Y.
- ?- X=a, Y=a, X\==Y.
-| ?- X=a, Y=a, X==Y.
-| ?- _\==_.
- ?- _==_
-| ?- X=f(_), Y=f(_), X\==Y.
- ?- X=f(_), Y=f(_), X==Y.
-| ?- f(a,_)\==f(a,_)
- ?- f(a,_)==f(a,_)
Nagłówek w klauzuli prologowej w sensie formalnym:
- może zawierać negację predykatu
-| nie może zawierać negacji predykatu
- może zawierać operatory koniunkcji lub dysjunkcji
- nie może zawierać operatorów koniunkcji i dysjunkcji (nie może ani tego ani koniunkcji, ani dysjunkcji - niejasno sformułowana odpowiedź)
-| nie może zawierać operatorów koniunkcji lub dysjunkcji
-| może zawierać predykatu o arności 0
- nie może zawierać predykatu o arności 0
-| może być pusty
- nie może być pusty
Odcięcie:
-| uniemożliwia spełnienie celów poprzedzających je w części warunkowej klauzuli w inny, alternatywny sposób
-| uniemożliwia analizę wszystkich pozostałych klauzul z tym samym nagłówkiem, które znajdują się w programie poniżej klauzuli, w której odcięcie wystąpiło
- powoduje natychmiastowe spełnienie celu, który został dopasowany do nagłówka klauzuli je zawierającej
- powoduje, że występujące za nim cele w części warunkowej klauzuli nie są analizowane
Przetwarzanie składowych złożonych struktur danych (reprezentowanych w języku Prolog za pomocą zagnieżdżonych termów) realizowane jest z wykorzystaniem następujących operatorów i metapredykatów systemowych:
- call
- atomic
- assert
-| =..
- var
-| arg
- setof
-| functor
Do ewaluacji wartości wyrażenia będącego termem złożonym z funktorem arytmetycznym dochodzi, kiedy użyjemy operatora:
-| is
-| <
-| =:=
-| >
-| =\=
- =
- =..
- ==
-| >=
-| =<
Mając na uwadze fakt iż negacja w języku Prolog realizowana jest przez niepowodzenie należy dla reguły postaci: s(X,Y) :- not(X=Y), r(Z, X), r(Z, Y). oraz dwóch faktów: r(a, m). r(a, n). Wybrać odpowiedzi będące rezultatem zapytania: ?-s(P,R).
- P=n R=n; False
- P=n R=n; P=n, R=m; False
-| False
- P=n R=m; P=m R=n; P=n R=m; P=n R=n; False
Jaki będzie rezultat wykonania operacji uzgodnienia ?- p(a,X,f(g(X))) = p(Z,f(Z),f(W)).
- X = f(a), Z = a, W = X.
-| X = f(a), Z = a, W = g(f(a)).
- False.
- X = Z, Z = a, W = g(f).
Jaki będzie wynik wykonania zapytania: ?- [a,[b,c]]=..[X,_,Z].
- X=’.’ Z=[b,c]
- X=’|’ Z=[[b,c]]
-| X=’.’ Z=[[b,c]]
- X=’|’ Z=[b,c]
Do grupy predykatów dekompozycji wyrażeń języka Prolog zaliczamy następujące metapredykaty systemowe:
- call
- assert
-| arg
- findall
Jaki będzie rezultat wykonania operacji uzgadniania: ?- n(k,Y,g(h(Y)),h(Y))=n(W,p(W),g(X),h(p(W))).
- X=h(p(k)) W=k Y=X
- False
- X=h(k) W=k Y=h(p(k))
-| X=h(p(k)) W=k Y=p(k)
Jaki będzie wynik wykonania zapytania ?- [a,[b,c]] =.. [_, X, Y]
- X=[] Y=[a,[b,c]]
-| X=a Y=[[b,c]]
- X=a Y=[b,c]
- X=[a] Y=[b,c]
Jaki będzie wynik zapytania: ?- functor(X,'.',2), arg(1,X,a), arg(2,X,[b]) :
- X=[a,b,[]]
- X=[a,[b]]
-| X=[a,b]
- X=[a|b]
Jaki będzie wynik wykonania zapytania ?- functor([A|[B|[C]]], F, N). :
-| F='.' N=2
- F='|' N=3
- F="," N=2
- F='.' N=3
Jaki będzie wynik wykonania zapytania ?- functor(f(m,n,n),F, N). :
- F='.' N=2
-| F='f' N=3
- False
- F=',' N=3
Jaki będzie wynik wykonania zapytania ?- arg(2,[a,b,c,d],K).:
- K=[b]
- False
-| K=[b,c,d]
- K=b
Jaki będzie wynik wykonania zapytania ?- arg(3,[a,b,c,d],K).:
- K=[c,d]
-| False
- K=[c]
- K=c
Jaki będzie wynik wykonania zapytania ?- arg(2,[[a],[b],[c],[d]],K).:
- False
- K=[[b]]
-| K=[[b],[c],[d]]
- K=[b]
Jaki będzie wynik wykonania zapytania ?- arg(3,[[a],[b],[c],[d]],K).:
-| False
- K=c
- K=[c]
- K=[[c],[d]]
Jaki będzie wynik wykonania zapytania ?- N is 6, K=4, K is N-2. :
-| N=6 K=4
- N=4 K=2
- N=4 K=4
- False
Jaki będzie wynik wykonania zapytania ?- N is 7, K=5, K is N-2.:
- N=5 K=5
-| N=7 K=5
- N=7 K=3
- False
Jaki będzie wynik zapytania ?- N is 6, K=5, K is N-2.:
- N=6 K=3
-| False
- N=6 K=4
- N=6 K=5
Jaki będzie wynik zapytania ?- K=4, N=K, N is K-2. :
- K=2 N=2
- K=4 N=2
-| False
- K=4 N=4
Jaki będzie wynik wykonania zapytania ?- N is 7, K=4, K is N-2. :
- N=7 K=3
- N=7 K=4
- N=7 K=5
-| False
Która z interpretacji deklaratywnych definicji klauzuli p:-!,a,b. p:-!,c,d. p:-e. jest kompletna i poprawna:
-| p<=>(a AND b)
- p<=>(a AND b) OR (c AND d) OR e
- p<=>(a AND b) OR (¬a AND ¬c AND e)
- p<=>(¬a AND b) OR (¬c AND d) OR e
Która z interpretacji deklaratywnych klauzuli p:-a,!,b. p:-c,!,d. p:-e. jest kompletna i poprawna:
- p<=>(a and ¬b) OR (c AND ¬d) OR e
- p<=>(¬a AND b) OR (¬c aND d) OR e
-| p<=>(a AND b) OR (¬a AND c AND d) OR (¬a AND ¬c AND e)
- p<=>(¬a AND ¬c AND e)
Która z interpretacji deklaratywnych klauzuli p:-!,a,!,b,c. p:-d. jest kompletna i poprawna:
- p<=>(¬a AND ¬b AND c) OR d
- p<=>(a AND b AND c) OR (¬a AND d) OR (¬b AND d)
- p<=>(a AND b AND c) OR (¬a AND ¬b AND d)
-| p<=>(a ANd b AND c)
Która z interpretacji deklaratywnych definicji klauzuli p:-a,!,b. p:-!,c,d. p:-e.
-| p<=>(a AND b) OR (¬a AND c AND d)
- p<=>(¬a AND e)
- p<=>(a AND ¬b) OR (¬c AND d) OR e
- p<=>(¬a AND b) OR (c AND d) OR e
Która z interpretacji deklaratywnych klauzuli p:-a,!,b,!,c. p:-d. jest kompletna i poprawna:
-| p<=>(a AND b AND c) OR (¬a AND d)
- p<=>(a AND b AND c) OR (¬a AND d) OR (¬b AND d)
- p<=>(a AND ¬b AND ¬c) OR d
- p<=>(a AND b AND c) OR (¬a AND ¬b AND d)
Która z interpretacji deklaratywnych klauzuli p:-!,a,b. p:-c,!,d. p:-e. jest kompletna i poprawna: (?)
- p<=>(a AND b) OR (¬a AND c AND e)
- p<=>(¬a AND b) OR (c ANd ¬d) OR e
-| p<=>(a AND b)
- p<=>¬(a AND b) OR (c AND ¬d) OR e
Która z interpretacji deklaratywnych definicji klauzuli p:-!,a,b,!,c. p:-d. jest kompletna i poprawna:
- p<=>(¬a AND b AND ¬c) OR d
- p<=>(a AND b AND c) OR (¬a AND d) OR (¬c AND d)
-| p<=>(a AND b AND c)
- p<=>(a AND b AND c) OR (¬a AND b AND ¬d)
Dla definicji operatorów op(100,xfy,#). oraz op(100,fy,@). wyrażenie a # @ b # c jest:
-| równoważne wyrażeniu: a # (@ b # c)
- niepoprawne
- równoważne wyrażeniu: a # ((@ b) # c)
-| równoważne wyrażeniu: a # @ (b # c)
Dla definicji operatorów op(100, xfy, ^). oraz op(50, fy, ~). wyrażenie a ^ ~ b ^ c jest:
- niepoprawne
- równoważne wyrażeniu: a ^ ~ (b ^ c)
-| równoważne wyrażeniu: a ^ ((~ b) ^ c)
-| równoważne wyrażeniu: a ^ (~ b ^ c)
Dla definicji operatorów op(100, xfy, #). oraz op(50, xf, @). wyrażenie a # b @ # c jest"
- niepoprawne
- równoważne wyrażeniu: (a # b @) # c)
-| równoważne wyrażeniu: a # ((b @) # c)
- równoważne wyrażeniu: (a # b) @ # c)
Dla definicji operatorów op(100, xfy, ^). oraz op(100, fy, ~). wyrażenie a ^ ~ b ^ c jest:
- niepoprawne
-| równoważne wyrażeniu: a ^ ~ (b ^ c)
- równoważne wyrażeniu: a ^ ((~ b) ^ c)
-| równoważne wyrażeniu: a ^ (~ b ^ c)
Dla definicji operatorów op(100,xfx,^). oraz op(50,xf,~). wyrażenie a ^ b ~ ^ c jest:
- równoważne wyrażeniu: (a ^ b) ~ ^ c
- równoważne wyrażeniu: a ^ ((b ~) ^ c)
- równoważne wyrażeniu: (a ^ b ~) ^ c
-| niepoprawne
Dla definicji operatorów op(100,xfx,^). oraz op(100,fy,~). Wyrażenie a ^ b ~ b ^ c jest:
- równoważne wyrażeniu: a^ (~b ^ c)
- równoważne wyrażeniu: a^ ((~b) ^ c)
- równoważne wyrażeniu: a^ ~ (b ^ c)
-| niepoprawne
Dla definicji operatorów op(100, xfy, #). oraz op(55, xf, ~). wyrażenie a # b ~ # c jest:
- równoważne wyrażeniu (a # b) ~ # c
- równoważne wyrażeniu (a # b ~) # c
-| równoważne wyrażeniu a # (b ~) # c
- niepoprawne
Jakie będą wszystkie możliwe wyniki wykonania niedeterministycznego zapytania: ?- member(X,[a,A,b,B,c,C]), var(X). :
-| X=A; X=B; X=C; False
- X=a; False
- False
- X=a; X=b; X=c; False
Jakie będą wszystkie możliwe wyniki wykonania niedeterministycznego zapytania: ?- member(X,[a,A,b,B,c,C]), nonvar(X). :
-| X=a; X=b; X=c; False
- X=A; X=B; X=C; False
- False
- X=a; False
Jakie będą wszystkie możliwe wyniki wykonania niedeterministycznego zapytania: ?- append([_|_], [X|_], [A,a,B,b,C,c]), var(X). :
- X=b; X=c; False
-| X=B, X=C; False
- X=A; X=B; X=C; False
- X=a; X=b; X=c; False
Jakie będą wszystkie możliwe wyniki wykonania niedeterministycznego zapytania: ?- append([_|_], [X|_], [A,a,B,b,C,c]), nonvar(X). :
- X=b; X=c; False
- X=B, X=C; False
- X=A; X=B; X=C; False
-| X=a; X=b; X=c; False
Które z poniższych zapytań wybiera dowolną parę w dowolnej kolejności dwóch nie tych samych elementów z listy L:
-| ?- append(P, [X|R],L), append(P,R,Q), append(_,[Y|_],Q).
- ?- append(_, [X|R],L), append(_,[Y|_],R).
- ?- append(_, [X,Y|_],L).
- ?- append(_, [X|_],L), append(_,[Y|_],L).
Które z poniższych zapytań wybiera dowolną parę dwóch zupełnie dowolnych elementów (bez ograniczeń kolejnościowych z listy L:
-| ?- append(_,[X|_],L), append(_,[Y|_],L).
- ?- append(_,[X|R],L), append(_,[Y|_],R).
- ?- append(_,[X,Y|_],L).
- ?- append([X],[_|Y],L).
Niech abs oznacza funkcję arytmetyczną, zwracającą wartość bezwzględną liczby. Jaki będzie wynik działania zapytania ?- m([1,-3,8,-5,2,-4],X). dla definicji predykatów: m(L,X) :- member(X,L), a(X,L). a(X,L) :- L=[]; L=[H|T], abs(H)=<abs(X), a(X,T).
- X = -4
- X = -5
-| X = 8
- X = 1
Niech abs oznacza funkcję arytmetyczną, zwracającą wartość bezwzględną liczby. Jaki będzie wynik działania zapytania ?- m([1,-3,8,-5,2,-4],X). dla definicji predykatów: m(L,X) :- member(X,L), a(X,L). a(X,L) :- L=[]; L=[H|T], abs(H)>=abs(X), a(X,T).
- X = -4
- X = -5
- X = 8
-| X = 1
Niech abs oznacza funkcję arytmetyczną, zwracającą wartość bezwzględną liczby. Jaki będzie wynik działania zapytania ?- m([-1,3,-8,5,-2,1],X). dla definicji predykatów: m(L,X) :- member(X,L), a(X,L). a(X,L) :- L=[]; L=[H|T], abs(H)=<abs(X), a(X,T).
-| X = -8
- X = -1
- X = 5
- X = 1
Niech abs oznacza funkcję arytmetyczną, zwracającą wartość bezwzględną liczby. Jaki będzie wynik działania zapytania ?- m([-1,3,-8,5,-2,1],X). dla definicji predykatów: m(L,X) :- member(X,L), a(X,L). a(X,L) :- L=[]; L=[H|T], abs(H)>=abs(X), a(X,T).
- X = -8
-| X = -1
- X = 5
-| X = 1
Jaki będzie wynik działania zapytania ?- m([-1,3,-8,5,-2,1],X). dla definicji predykatów: m(L,X) :- member(X,L), a(X,L). a(X,L) :- L=[]; L=[H|T], H>=X, a(X,T).
- X = -4
- X = 5
-| X = -8
- X = 1
Mając na uwadze niedeterminizm predykatu retract należy wskazać, które z poniższych odpowiedzi dla celu ?-g(X). są poprawne, jeżeli wcześniej zostały wydane zapytania ?- asserta(g(3)),asserta(g(2)),asserta(g(1)). ?- retract(g(X)). :
-| X=2; X=3; False
-| X=3; False
- X=1; X=2; X=3; False
-| False
Mając na uwadze niedeterminizm predykatu retract należy wskazać, które z poniższych odpowiedzi dla celu ?-g(X). są poprawne, jeżeli wcześniej zostały wydane zapytania ?- assertz(g(3)),assertz(g(2)),assertz(g(1)). ?- retract(g(X)). :
- X=3; X=2; False
- X=3; False
- X=3; X=2; X=1; False
-| False
-| X=2; X=1; False
-| X=1; False
Mając na uwadze niedeterminizm predykatu retract należy wskazać, które z poniższych odpowiedzi dla celu ?-g(X). są poprawne, jeżeli wcześniej zostały wydane zapytania ?- asserta(g(1)),asserta(g(2)),asserta(g(3)). ?- retract(g(X)). :
- X=3; X=2; False
- X=3; False
- X=3; X=2; X=1; False
-| False
Mając na uwadze niedeterminizm predykatu retract należy wskazać, które z poniższych odpowiedzi dla celu ?-g(X). są poprawne, jeżeli wcześniej zostały wydane zapytania ?- assertz(g(1)),assertz(g(2)),assertz(g(3)). ?- retract(g(X)). :
- X=1; X=2; False
- X=1; False
- X=1; X=2; X=3; False
-| False
Które z poniższych zapytań języka Prolog zakończą się spełnieniem celu:
- ?- atomic("X").
-| ?- atomic('X').
- ?- atomic(X).
- ?- atomic(_x_).
- ?- atomic(_ma).
-| ?- atomic('ROK').
- ?- atomic("kok").
-| ?- atomic('_').
- ?- atomic(_).
- ?- atomic("_").
Które z poniższych obiektów języka Prolog są stałymi:
- "kok"
-| 'ROK'
- _ma
- X
-| 'x'
- "x"
-| x
-| '_'
-| 'X'
- _
- "_"
- _x_
Stałe Symboliczne w języku Prolog
-| mają charakter globalnych obiektów języka
- mają zasięg lokalny ograniczony wyłącznie do jednej reguły
- mogą występować wyłącznie w zapytaniach albo w klauzulach, będących faktami
- mają zasięg ograniczony wyłącznie do zbioru klauzul o tym samym nagłówku
Łańcuchy znakowe (ang. string) w języku Prolog:
- mogą występować wyłącznie w zapytaniach albo klauzulach, będących faktami
-| wymagają użycia ograniczników w postaci znaków apostrofu
- wymagają użycia ograniczników w postaci znaków cudzysłowu
- mają zasięg lokalny ograniczony wyłącznie do jednej reguły
-| zaliczane są do atomów (inaczej: stałych atomowych)
-wymagają wcześniejszej deklaracji i określenia zasięgu wartości
Identyfikator zmiennej w języku Prolog:
- ma zasięg globalny
-| jest lokalny względem pojedynczej klauzuli
- jest definiowany w momencie deklarowania dziedziny wartości zmiennej
- jest lokalny względem zbioru klauzul o tym samym nagłówku
Wartości zmiennej w języku Prolog:
-| są lokalne względem jednej instancji klauzuli
- mają charakter globalny
- muszą być zgodne z zadeklarowanym wcześniej typem wartości
-| są ustalane w procesie unifikacji (uzgadniania)
Atomy w języku Prolog:
-| obejmują stałe symboliczne oraz łańcuchy znakowe
- mogą występować wyłącznie w zapytaniach albo w klauzulach będących faktami
-| mają charakter globalnych obiektów języka
- mają zasięg lokalny ograniczony wyłącznie do jednej reguły
- wymagają wcześniejszej deklaracji i określenia zasięgu wartości
Jaki będzie wynik wykonania poniższego zapytania: ?- [X|Y]=[d,d,c,b,b,a], bagof(Z^X, member(Z,Y), W).:
- W=[d^d,c^d,b^d,a^d]; False
- W=[d^d]; W=[d^d]; W=[c^d]; W=[b^d]; W=[b^d]; W=[a^d]; False
-| W=[d^d,c^d,b^d,b^d,a^d]; False
- W=[d^d]; W=[c^d]; W=[b^d]; W=[b^d]; W=[a^d]; False
Jaki będzie wynik wykonania poniższego zapytania: ?- [X|Y]=[d,d,c,b,b,a], setof(Z^X, member(Z,Y), W).:
- W=[a^d]; W=[b^d]; W=[c^d]; W=[d^d]; False
-| W=[a^d, b^d, c^d, d^d]; False
- W=[a^d]; W=[b^d]; W=[b^d]; W=[c^d]; W=[d^d]; W=[d^d]; False
- W=[a^d, b^d, b^d, c^d, d^d, d^d]; False
Jaki będzie wynik wykonania poniższego zapytania: ?- [X|Y]=[a,b,c,d], bagof(X#Z, append(_, [Z|_], Y), W).:
- W=[a#b, b#c, c#d]; False
- W=[a#b]; W=[b#c]; W=[c#d]; False
-| W=[a#b]; W=[a#c]; W=[a#d]; False
- W=[a#b]; False
Jaki będzie wynik wykonania poniższego zapytania: ?- [X|Y]=[a,b,c,d], bagof(X^Z, append(_, [Z|_], [X|Y]), W).
- W=[a^b, a^c, a^d]; False
- W=[a^b]; W=[a^c]; W=[a^d]; False
- W=[a^a, a^b, a^c, a^d]; False
-| W=[a^a]; W=[a^b]; W=[a^c]; W=[a^d]; False
Jaki będzie wynik wykonania poniższego zapytania: ?- [X|Y]=[a,b,c,d], findall(X^Z, append(_, [Z,_|_], [X|Y]), W).
- W=[a^b, c^d]
- W=[a^a, a^b, a^c, a^d]
- W=[a^b, a^c, a^d]
-| W=[a^a, a^b, a^c]
Dla następującego programu prologowego: p(N):-N=1; N=2,!; N=3,!. , które z poniższych odpowiedzi są wszystkimi rozwiązaniami dla zapytania ?- p(X),!,p(Y). :
- X=1 Y=1
- X=1 Y=1; X=2 Y=2
-| X=1 Y=1; X=1 Y=2
- X=1 Y=1; X=1 Y=2; X=1 Y=3
Dla następującego programu prologowego: p(1). p(2). p(3):-!., które z poniższych odpowiedzi są wszystkimi rozwiązaniami dla zapytania ?- p(X),!,p(Y). :
- X=1 Y=1
-| X=1 Y=1; X=1 Y=2; X=1 Y=3
- X=1 Y=1; X=1 Y=2
- X=1 Y=1; X=1 Y=2; X=1 Y=3; X=2 Y=1; X=2 Y=2; X=2 Y=3; X=3 Y=1; X=3 Y=2; X=3 Y=3;
Dla następującego programu prologowego: p(1). p(2):-!. p(3):-!., które z poniższych odpowiedzi są wszystkimi rozwiązaniami dla zapytania ?- p(X),p(Y),!. :
- X=1 Y=1; X=1 Y=2; X=2 Y=1; X=2 Y=2
- X=1 Y=1; X=2 Y=2
-| X=1 Y=1
- X=1 Y=1; X=1 Y=2; X=1 Y=3; X=2 Y=1; X=2 Y=2; X=2 Y=3; X=3 Y=1; X=3 Y=2; X=3 Y=3;
- X=1 Y=1; X=1 Y=2; X=2 Y=1; X=2 Y=2
Dla następującego programu prologowego: p(N):-N=1; N=2; N=3, !. , które z poniższych odpowiedzi są wszystkimi rozwiązaniami dla zapytania ?- !, p(X), p(Y). :
- X=1 Y=1
- X=1 Y=1; X=1 Y=2; X=1 Y=3
-| X=1 Y=1; X=1 Y=2; X=1 Y=3; X=2 Y=1; X=2 Y=2; X=2 Y=3; X=3 Y=1; X=3 Y=2; X=3 Y=3;
- X=1 Y=1; X=2 Y=2; X=3 Y=3
Dla następującego programu prologowego: p(N):-N=1; N=2, !; N=3, !. , które z poniższych odpowiedzi są wszystkimi rozwiązaniami dla zapytania ?- !, p(X), p(Y). :
- X=1 Y=1
- X=1 Y=1; X=2 Y=2
-| X=1 Y=1; X=1 Y=2; X=2 Y=1; X=2 Y=2
- X=1 Y=1; X=1 Y=2; X=1 Y=3; X=2 Y=1; X=2 Y=2; X=2 Y=3; X=3 Y=1; X=3 Y=2; X=3 Y=3;
Dla następującego programu prologowego: p(1):-!. p(2):-!. p(3). ,które z poniższych odpowiedzi są wszystkimi rozwiązaniami zapytania ?- p(X),!,p(Y).:
- X=1 Y=1; X=2 Y=2
-| X=1 Y=1
- X=1 Y=1; X=1 Y=2
- X=1 Y=1; X=1 Y=2; X=1 Y=3
Biorąc pod uwagę następujące definicje: smutny(X) :- not(szczęśliwy(X)). szczęśliwy(X) :- piękny(X), bogaty(X). bogaty(król). bogaty(książe). piękny(książe). piękny(śnieżka).
-| ?- smutny(król). true
- ?- smutny(król). false
-| ?- smutny(śnieżka). true
- ?- smutny(śnieżka). false
- ?- smutny(książe). true
-| ?- smutny(książe). false
-| ?- smutny(królowa). true
- ?- smutny(królowa). false
- ?- smutny(Ktoś). true
-| ?- smutny(Ktoś). false
-| ?- smutny(ktoś). true
- ?- smutny(ktoś). false
// Docs - "Zadania przepisane z odpowiedziami"
Do ewaluacji wyrażenia będącego terminem złożonym z funktorem arytmetycznym dochodzi kiedy użyjemy operatora:
-=
-|<
-|=\=
-==
-|=:=
-|is
Która z interpretacji deklaratywnych definicji klauzuli p:-!,a,b. p:-!,c,d. p:-e. jest kompletna i poprawna:
-p<=> (a ∧ b) ∨ (~a ∧ ~c ∧ e)
-p<=> (a ∧ b) ∨ (c ∧ d) ∨ e
-p<=> (~a ∧ b) ∨ (~c ∧ d) ∨ e
-|p<=> (a ∧ b)
Dla następującego programu prologowego: p(1). p(2). p(3):-!. , które z poniższych odpowiedzi są wszystkimi rozwiązaniami dla zapytania ?- p(X),!,p(Y).
-|X=1 Y=1; X=1 Y=2; X=1 Y=3
-X=1 Y=1; X=2 Y=2; X=3 Y=3
-X=1 Y=1
-X=2 Y=1; X=2 Y=2; X=2 Y=3;
-X=3 Y=1; X=3 Y=2; X=3 Y=3
Weryfikacja rodzaju termu odbywa się w języku Prolog za pomocą następujących metapredykatów systemowych:
-functor
-|var
-setof
-|atomic
Predykaty użytkownika mogą być argumentami wywołania następujących metapredykatów systemowych:
-repeat
-|call
-|assert
-|bagof
Jakie będą wszystkie możliwe wyniki wykonania zapytania: ?- member(X, [a,A,b,B,c,C]), var(X).
-X=a; False
-|X=A; X=B; X=C; False
-False
-X=a; X=b; X=c; False
Stałe symboliczne w języku Prolog:
-wymagają wcześniejszej deklaracji i określenia zasięgu wartości
-|mają charakter globalny
-mają zasięg lokalny ograniczony do jednej reguły
-mogą występować wyłącznie w klauzulach będących faktami
Jaki będzie wynik wykonania zapytania ?- functor(X,'.',2), arg(1,X,a), arg(2,X,[b]).
-|X=[a,b]
-X=[a,b,[]]
-X=[a|b]
-X=[a,[b]]
Mając na uwadze niedeterminizm predykatu retract należy wskazać, które z poniższych odpowiedzi dla celu ?-g(X). są poprawne, jeżeli wcześniej zostały wydane zapytania: ?- asserta(g(1)),asserta(g(2)),asserta(g(3)). ?- retract(g(X)).
-X=3; X=2; X=1; False
-|X=2; X=1; False
-|X=1; False
-|False
Mając na uwadze niedeterminizm predykatu retract należy wskazać, które z poniższych odpowiedzi dla celu ?-g(X). są poprawne, jeżeli wcześniej zostały wydane zapytania: ?- assertz(g(1)),assertz(g(2)),assertz(g(3)). ?- retract(g(X)).
-X=1; X=2; X=3; False
-|X=2; X=3; False
-|X=3; False
-|False
Która z interpretacji deklaratywnych definicji klauzuli p:-!,a,b,!,c. p:-d jest kompletna i poprawna:
-p<=> (a ∧ b ∧ c) ∨ (~a ∧ ~c ∧ d)
-|p<=> (a ∧ b ∧ c)
-p<=> (a ∧ b ∧ c) ∨ (~a ∧ d) ∨ (~c ∧ d)
-p<=> (~a ∧ ~c) ∨ d
Dla następującego programu prologowego: p(1). p(2). p(3):-!. , które z poniższych odpowiedzi są wszystkimi rozwiązaniami dla zapytania ?- !, p(X), !, p(Y).
-|X=1 Y=1; X=1 Y=2; X=1 Y=3
-X=1 Y=1; X=2 Y=2; X=3 Y=3
-X=1 Y=1
-X=1 Y=1; X=1 Y=2; X=1 Y=3;
-X=2 Y=1; X=2 Y=2; X=2 Y=3;
-X=3 Y=1; X=3 Y=2; X=3 Y=3
Mając na uwadze fakt iż negacja w języku Prolog realizowana jest przez niepowodzenie należy dla reguły postaci: p(A,B) :- not(A=B), f(Z,A), f(Z,B). oraz dwóch faktów: f(a,m). f(a,n). wybrać odpowiedzi będące rezultatem zapytania: ?-p(X,Y).
-X=m Y=n; False
-X=m Y=n; X=n Y=m; False
-X=m Y=m; X=n Y=n; False
-|False
Wartości zmiennych w języku Prolog
-|są ustalane w procesie unifikacji
-muszą być zgodne ze zdefiniowanym wcześniej typem wartości
-mają charakter globalny
-|są lokalne względem jednej instancji klauzuli
Jaki będzie wynik wykonania zapytania ?- functor("f(n,n,n)",F,N).
-F=’f’ N=3
-F=’|’ N=3
-|F=’.’ N=2
-False
Dla następującego programu prologowego: p(N):- N=1; N=2,!; N=3,!. , które z poniższych odpowiedzi są wszystkimi rozwiązaniami dla zapytania ?- p(X),!,p(Y).
-X=1 Y=1; X=1 Y=2; X=2 Y=2
-|X=1 Y=1; X=1 Y=2
-X=1 Y=1; X=1 Y=2; X=1 Y=3;
-X=2 Y=1; X=2 Y=2; X=2 Y=3;
-X=3 Y=1; X=3 Y=2; X=3 Y=3
Które z poniższych zapytań zakończą się spełnieniem celu:
-|?- X=a, Y=a, X==Y.
-|?- X=Z, Y=Z, X==Y.
-|?- _\==_.
-?- X=f(_), Y=f(_), X==Y.
Dla następującego programu prologowego: p(1). p(2):-!. p(3):-!. , które z poniższych odpowiedzi są wszystkimi rozwiązaniami dla zapytania ?- p(X),p(Y),!.
-X=1 Y=1; X=1 Y=2
-|X=1 Y=1
-X=1 Y=1; X=1 Y=2; X=2 Y=1; X=2 Y=2
-X=1 Y=1; X=1 Y=2; X=1 Y=3;
-X=2 Y=1; X=2 Y=2; X=2 Y=3;
-X=3 Y=1; X=3 Y=2; X=3 Y=3
Która z interpretacji deklaratywnych definicji klauzuli p:-a,!,b,!,c. p:-d jest kompletna i poprawna:
-|p<=> (a ∧ b ∧ c) ∨ (~a ∧ d)
-p<=> (a ∧ b ∧ c) ∨ (~a ∧ ~b ∧ d)
-p<=> (a ∧ b ∧ c) ∨ (~a ∧ d) ∨ (~b ∧ d)
-p<=> (a ∧ ~b ∧ ~c) ∨ d
Jaki będzie wynik wykonywania poniższego zapytania: ?- [X|Y] = [a,b,c,d], bagof(X+Z, append(_,[Z|_], Y), W)
-W=[a+b]; W=[b+c]; W=[c+d]; False
-W=[a+b, b+c, c+d]; False
-W=[a+b]; False
-|W=[a+b]; W=[a+c]; W=[a+d]; False
Jakie będą wszystkie możliwe wyniki wykonania zapytania: ?- append([_|_], [X|_], [A,a,B,b,C,c]), var(X).
-X=b; X=c; False
-X=A; X=B; X=C; False
-X=a; X=b; X=c; False
-|X=B; X=C; False
Jaki będzie wynik wykonania zapytania ?- functor(X, '.', 2), arg(1,X,[a]), arg(2,X,[[b]]).
-X=[a,b,[]]
-X=[a,b]
-|X=[[a],[b]]
-X=[a,b]

90
tools/validate_qaml.php Normal file
View File

@@ -0,0 +1,90 @@
<?php
declare(strict_types=1);
$file = $argv[1] ?? 'pytania.txt';
$baseDir = dirname(__DIR__);
$path = $baseDir . '/' . $file;
if (!is_file($path)) {
fwrite(STDERR, "File not found: {$file}\n");
exit(1);
}
$lines = file($path, FILE_IGNORE_NEW_LINES);
$errors = [];
$question = null;
$questionLine = 0;
$answers = 0;
$questionCount = 0;
$finishQuestion = static function () use (&$errors, &$question, &$questionLine, &$answers, &$questionCount): void {
if ($question === null) {
return;
}
if ($answers === 0) {
$errors[] = "Line {$questionLine}: question has no answers.";
}
$questionCount++;
$question = null;
$questionLine = 0;
$answers = 0;
};
foreach ($lines as $i => $rawLine) {
$lineNo = $i + 1;
$line = trim($rawLine);
if ($line === '' || str_starts_with($line, '//')) {
continue;
}
if (!str_starts_with($line, '-')) {
$finishQuestion();
$question = $line;
$questionLine = $lineNo;
continue;
}
if ($question === null) {
$errors[] = "Line {$lineNo}: answer appears before any question.";
continue;
}
if (str_starts_with($line, '-|')) {
$answer = trim(substr($line, 2));
} else {
$answer = trim(substr($line, 1));
}
if ($answer === '') {
$errors[] = "Line {$lineNo}: answer is empty.";
}
$answers++;
}
$finishQuestion();
$content = file_get_contents($path) ?: '';
preg_match_all('/<img\s+[^>]*src=["\']([^"\']+)["\'][^>]*>/i', $content, $matches);
foreach ($matches[1] ?? [] as $src) {
if (str_starts_with($src, 'img/') && !is_file($baseDir . '/' . $src)) {
$errors[] = "Missing image referenced from pytania.txt: {$src}";
}
}
if ($questionCount === 0) {
$errors[] = 'No questions found.';
}
if ($errors !== []) {
foreach ($errors as $error) {
fwrite(STDERR, $error . PHP_EOL);
}
exit(1);
}
echo "OK: {$questionCount} questions validated.\n";